spessasynth_core 4.3.5 → 4.3.7

package/dist/index.js

@@ -1124,7 +1124,11 @@ const NonRegisteredLSB = {
 };
 //#endregion
 //#region src/midi/midi_message.ts
-var MIDIMessage = class {
+/**
+* Midi_message.ts
+* purpose: contains enums for midi events and controllers and functions to parse them
+*/
+var MIDIMessage = class MIDIMessage {
 	/**
 	* Absolute number of MIDI ticks from the start of the track.
 	*/
@@ -1148,6 +1152,68 @@ var MIDIMessage = class {
 		this.statusByte = byte;
 		this.data = data;
 	}
+	/**
+	* Returns a new MIDI Pitch Wheel message.
+	* @param ticks time of this message in absolute MIDI ticks.
+	* @param channel the channel number of this message.
+	* @param value the new value, between 0 and 16383, where 8192 is the center (no pitch change).
+	*/
+	static pitchWheel(ticks, channel, value) {
+		return new MIDIMessage(ticks, MIDIMessageTypes.pitchWheel | channel % 16, new Uint8Array([value & 127, value >> 7 & 127]));
+	}
+	/**
+	* Returns a new MIDI Channel Pressure message.
+	* @param ticks time of this message in absolute MIDI ticks.
+	* @param channel the channel number of this message.
+	* @param value the new value, between 0 and 127.
+	*/
+	static channelPressure(ticks, channel, value) {
+		return new MIDIMessage(ticks, MIDIMessageTypes.channelPressure | channel % 16, new Uint8Array([value]));
+	}
+	/**
+	* Returns a new MIDI Program Change message.
+	* @param ticks time of this message in absolute MIDI ticks.
+	* @param channel the channel number of this message.
+	* @param program the new MIDI program number, between 0 and 127.
+	*/
+	static programChange(ticks, channel, program) {
+		return new MIDIMessage(ticks, MIDIMessageTypes.programChange | channel % 16, new Uint8Array([program]));
+	}
+	/**
+	* Returns a new MIDI Controller Change message.
+	* @param ticks time of this message in absolute MIDI ticks.
+	* @param channel the channel number of this message.
+	* @param controller the MIDI controller.
+	* @param value the new value.
+	*/
+	static controllerChange(ticks, channel, controller, value) {
+		return new MIDIMessage(ticks, MIDIMessageTypes.controllerChange | channel % 16, new Uint8Array([controller, value]));
+	}
+	/**
+	* Returns a new MIDI System Exclusive message.
+	* @param ticks time of this message in absolute MIDI ticks.
+	* @param data the data of the system exclusive message,
+	* excluding the starting 0xF0 byte.
+	*/
+	static systemExclusive(ticks, data) {
+		return new MIDIMessage(ticks, MIDIMessageTypes.systemExclusive, new Uint8Array(data));
+	}
+	/**
+	* Returns a new MIDI Registered Parameter message. Sends both data MSB and LSB.
+	* @param ticks time of this message in absolute MIDI ticks.
+	* @param channel the channel number of this message.
+	* @param parameter the 14-bit MIDI registered parameter number.
+	* @param value the 14-bit new value.
+	*/
+	static registeredParameter(ticks, channel, parameter, value) {
+		if (parameter > 16383 || parameter < 0 || value > 16383 || value < 0) throw new Error("Parameter and value must be between 0 and 16383.");
+		return [
+			MIDIMessage.controllerChange(ticks, channel, MIDIControllers.registeredParameterMSB, parameter >> 7),
+			MIDIMessage.controllerChange(ticks, channel, MIDIControllers.registeredParameterLSB, parameter & 127),
+			MIDIMessage.controllerChange(ticks, channel, MIDIControllers.dataEntryMSB, value >> 7),
+			MIDIMessage.controllerChange(ticks, channel, MIDIControllers.dataEntryLSB, value & 127)
+		];
+	}
 };
 //#endregion
 //#region src/midi/write/midi.ts
@@ -1494,16 +1560,30 @@ var MIDIUtils = class MIDIUtils {
 	static analyzeRPN(channel, rpn, value) {
 		switch (rpn) {
 			default: return OTHER;
+			case RegisteredParameterTypes.pitchWheelRange: return {
+				type: "Channel MIDI Param",
+				channel,
+				parameter: "pitchWheelRange",
+				value: value / 128
+			};
 			case RegisteredParameterTypes.fineTuning: return {
-				type: "Fine Tune",
+				type: "Channel MIDI Param",
 				channel,
+				parameter: "fineTune",
 				value: (value - 8192) / 81.92
 			};
 			case RegisteredParameterTypes.coarseTuning: return {
-				type: "Key Shift",
+				type: "Channel MIDI Param",
 				channel,
+				parameter: "keyShift",
 				value: (value >> 7) - 64
 			};
+			case RegisteredParameterTypes.modulationDepth: return {
+				type: "Channel MIDI Param",
+				channel,
+				parameter: "modulationDepth",
+				value: value / 1.28
+			};
 		}
 	}
 	/**
@@ -1579,6 +1659,104 @@ var MIDIUtils = class MIDIUtils {
 		}
 	}
 	/**
+	* Returns a list of MIDI events needed to set the given parameter.
+	* @param ticks The ticks for all events.
+	* @param system If the message has multiple ways of setting it,
+	* this selects the preferred way. Otherwise, it prefers Universal (GM).
+	* @param parameter The parameter to set.
+	* @param value The value to set it to.
+	*/
+	static setGlobalMIDIParameter(ticks, system, parameter, value) {
+		switch (parameter) {
+			case "system": return [MIDIUtils.reset(ticks, value)];
+			case "keyShift": switch (system) {
+				default: return [MIDIUtils.deviceControlMessage(ticks, 4, [0, value + 64])];
+				case "xg": return [MIDIUtils.xgMessage(ticks, 0, 0, 6, [value + 64])];
+				case "gs": return [MIDIUtils.gsMessage(ticks, 64, 0, 5, [value + 64])];
+			}
+			case "fineTune": switch (system) {
+				default: {
+					const tuneValue = Math.floor(value * 81.92 + 8192);
+					return [MIDIUtils.deviceControlMessage(ticks, 3, [tuneValue & 127, tuneValue >> 7 & 127])];
+				}
+				case "xg": {
+					const tuneValue = Math.floor(value * 10 + 1024);
+					return [MIDIUtils.xgMessage(ticks, 0, 0, 0, [
+						tuneValue >> 12 & 15,
+						tuneValue >> 8 & 15,
+						tuneValue >> 4 & 15,
+						tuneValue & 15
+					])];
+				}
+				case "gs": {
+					const tuneValue = Math.floor(value * 10 + 1024);
+					return [MIDIUtils.gsMessage(ticks, 64, 0, 0, [
+						tuneValue >> 12 & 15,
+						tuneValue >> 8 & 15,
+						tuneValue >> 4 & 15,
+						tuneValue & 15
+					])];
+				}
+			}
+			case "gain": switch (system) {
+				default: {
+					const gainValue = Math.floor(Math.sqrt(value) * 16383);
+					return [MIDIUtils.deviceControlMessage(ticks, 1, [gainValue & 127, gainValue >> 7 & 127])];
+				}
+				case "xg": {
+					const gainValue = Math.floor(value * 127);
+					return [MIDIUtils.xgMessage(ticks, 0, 0, 4, [gainValue])];
+				}
+				case "gs": {
+					const gainValue = Math.floor(value * 127);
+					return [MIDIUtils.gsMessage(ticks, 64, 0, 4, [gainValue])];
+				}
+			}
+			case "pan": switch (system) {
+				default: {
+					const balance = Math.floor(value * 8192) + 8192;
+					return [MIDIUtils.deviceControlMessage(ticks, 2, [balance & 127, balance >> 7 & 127])];
+				}
+				case "gs": {
+					const balance = Math.floor(value * 63) + 64;
+					return [MIDIUtils.gsMessage(ticks, 64, 0, 6, [balance])];
+				}
+			}
+		}
+	}
+	/**
+	* Returns a list of MIDI events needed to set the given parameter.
+	* @param ticks The ticks for all events.
+	* @param channel The channel number.
+	* @param system If the message has multiple ways of setting it,
+	* this selects the preferred way. Otherwise, it prefers Universal (GM).
+	* @param parameter The parameter to set.
+	* @param value The value to set it to.
+	* @returns The list of `MIDIMessage`s that set the parameter.
+	*/
+	static setChannelMIDIParameter(ticks, channel, system, parameter, value) {
+		channel %= 16;
+		const gsChannel = MIDIUtils.channelToSyx(channel);
+		switch (parameter) {
+			case "pressure": return [MIDIMessage.channelPressure(ticks, channel, value)];
+			case "pitchWheel": return [MIDIMessage.pitchWheel(ticks, channel, value)];
+			case "pitchWheelRange": return MIDIMessage.registeredParameter(ticks, channel, RegisteredParameterTypes.pitchWheelRange, Math.floor(value * 128));
+			case "modulationDepth": return MIDIMessage.registeredParameter(ticks, channel, RegisteredParameterTypes.modulationDepth, Math.floor(value * 1.28));
+			case "rxChannel": return system === "xg" ? [MIDIUtils.xgMessage(ticks, 8, channel, 4, [value])] : [MIDIUtils.gsMessage(ticks, 64, 16 | gsChannel, 2, [value])];
+			case "polyMode": return value ? [MIDIMessage.controllerChange(ticks, channel, MIDIControllers.polyModeOn, 0)] : [MIDIMessage.controllerChange(ticks, channel, MIDIControllers.monoModeOn, 0)];
+			case "keyShift": return MIDIMessage.registeredParameter(ticks, channel, RegisteredParameterTypes.coarseTuning, value + 64 << 7);
+			case "fineTune": return MIDIMessage.registeredParameter(ticks, channel, RegisteredParameterTypes.fineTuning, Math.floor(value * 81.92 + 8192));
+			case "randomPan": return system === "xg" ? [MIDIUtils.xgMessage(ticks, 8, channel, 14, [0])] : [MIDIUtils.gsMessage(ticks, 64, 16 | gsChannel, 28, [0])];
+			case "assignMode": return [MIDIUtils.gsMessage(ticks, 64, 16 | gsChannel, 20, [value])];
+			case "efxAssign": return [MIDIUtils.gsMessage(ticks, 64, 16 | gsChannel, 34, [value])];
+			case "cc1": return [MIDIUtils.gsMessage(ticks, 64, 16 | gsChannel, 31, [value])];
+			case "cc2": return [MIDIUtils.gsMessage(ticks, 64, 16 | gsChannel, 32, [value])];
+			case "drumMap": return [MIDIUtils.gsMessage(ticks, 64, 16 | gsChannel, 21, [value])];
+			case "velocitySenseDepth": return system === "xg" ? [MIDIUtils.xgMessage(ticks, 8, channel, 12, [value])] : [MIDIUtils.gsMessage(ticks, 64, 16 | gsChannel, 26, [value])];
+			case "velocitySenseOffset": return system === "xg" ? [MIDIUtils.xgMessage(ticks, 8, channel, 13, [value])] : [MIDIUtils.gsMessage(ticks, 64, 16 | gsChannel, 27, [value])];
+		}
+	}
+	/**
 	* Converts GS/XG "part number" to MIDI channel number.
 	* @param part The part number.
 	*/
@@ -1633,7 +1811,7 @@ var MIDIUtils = class MIDIUtils {
 	* @param a3 Address 3
 	* @param data Data, can be multiple bytes.
 	*/
-	static gsData(a1, a2, a3, data) {
+	static gs(a1, a2, a3, data) {
 		const checksum = 128 - (a1 + a2 + a3 + data.reduce((sum, cur) => sum + cur, 0)) % 128 & 127;
 		return [
 			65,
@@ -1657,36 +1835,112 @@ var MIDIUtils = class MIDIUtils {
 	* @param data Data, can be multiple bytes.
 	*/
 	static gsMessage(ticks, a1, a2, a3, data) {
-		return new MIDIMessage(ticks, MIDIMessageTypes.systemExclusive, new Uint8Array(this.gsData(a1, a2, a3, data)));
+		return MIDIMessage.systemExclusive(ticks, this.gs(a1, a2, a3, data));
 	}
 	/**
-	* Gets a GS reset message System Exclusive MIDI message.
+	* Gets raw XG System Exclusive message bytes, without the 0xF0 status byte.
+	* @param a1 Address 1
+	* @param a2 Address 2
+	* @param a3 Address 3
+	* @param data Data, can be multiple bytes.
+	*/
+	static xg(a1, a2, a3, data) {
+		return [
+			67,
+			16,
+			76,
+			a1,
+			a2,
+			a3,
+			...data,
+			247
+		];
+	}
+	/**
+	* Gets a XG System Exclusive MIDI message.
 	* @param ticks The tick time of the message.
-	* @param channel The MIDI channel number.
-	* @param drumMap The drum map to use. 0 turns the channel into a melodic channel,
-	* while other values turn it into a drum channel.
+	* @param a1 Address 1
+	* @param a2 Address 2
+	* @param a3 Address 3
+	* @param data Data, can be multiple bytes.
+	*/
+	static xgMessage(ticks, a1, a2, a3, data) {
+		return MIDIMessage.systemExclusive(ticks, this.xg(a1, a2, a3, data));
+	}
+	/**
+	* Gets a raw Device Control System Exclusive message bytes, without the 0xF0 status byte.
+	* @param subID The sub ID.
+	* @param data Data, can be multiple bytes.
 	*/
-	static gsDrumChange(ticks, channel, drumMap) {
-		const chanAddress = 16 | this.channelToSyx(channel);
-		return this.gsMessage(ticks, 40, chanAddress, 21, [drumMap]);
+	static deviceControl(subID, data) {
+		return [
+			127,
+			127,
+			4,
+			subID,
+			...data,
+			247
+		];
 	}
 	/**
-	* Gets a GS reset message System Exclusive MIDI message.
+	* Gets a Device Control System Exclusive MIDI message.
 	* @param ticks The tick time of the message.
+	* @param subID The sub ID.
+	* @param data Data, can be multiple bytes.
 	*/
-	static gsReset(ticks) {
-		return this.gsMessage(ticks, 64, 0, 127, [0]);
+	static deviceControlMessage(ticks, subID, data) {
+		return MIDIMessage.systemExclusive(ticks, this.deviceControl(subID, data));
+	}
+	/**
+	* Gets a selected reset System Exclusive MIDI message.
+	* @param ticks The tick time of the message.
+	* @param system The system to reset into.
+	*/
+	static reset(ticks, system) {
+		switch (system) {
+			case "gs": return this.gsMessage(ticks, 64, 0, 127, [0]);
+			case "xg": return this.xgMessage(ticks, 0, 0, 126, [0]);
+			case "gm": return MIDIMessage.systemExclusive(ticks, [
+				126,
+				127,
+				9,
+				1,
+				127
+			]);
+			case "gm2": return MIDIMessage.systemExclusive(ticks, [
+				126,
+				127,
+				9,
+				3,
+				127
+			]);
+		}
 	}
 	static analyzeGM(syx) {
 		if (syx.length < 4) return OTHER;
 		if (syx[2] === 4) switch (syx[3]) {
 			default: return OTHER;
+			case 1: {
+				const value = (syx[5] << 7 | syx[4]) / 16383;
+				return {
+					type: "Global MIDI Param",
+					parameter: "gain",
+					value: Math.pow(value, 2)
+				};
+			}
+			case 2: return {
+				type: "Global MIDI Param",
+				parameter: "pan",
+				value: ((syx[5] << 7 | syx[4]) - 8192) / 8192
+			};
 			case 3: return {
-				type: "Master Fine Tune",
-				value: ((syx[5] << 7 | syx[6]) - 8192) / 81.92
+				type: "Global MIDI Param",
+				parameter: "fineTune",
+				value: ((syx[5] << 7 | syx[4]) - 8192) / 81.92
 			};
 			case 4: return {
-				type: "Master Key Shift",
+				type: "Global MIDI Param",
+				parameter: "keyShift",
 				value: syx[5] - 64
 			};
 			case 5:
@@ -1710,9 +1964,21 @@ var MIDIUtils = class MIDIUtils {
 		if (syx[2] !== 9) return OTHER;
 		switch (syx[3]) {
 			default: return OTHER;
-			case 1: return { type: "GM On" };
-			case 2: return { type: "GM Off" };
-			case 3: return { type: "GM2 On" };
+			case 1: return {
+				type: "Global MIDI Param",
+				parameter: "system",
+				value: "gm"
+			};
+			case 2: return {
+				type: "Global MIDI Param",
+				parameter: "system",
+				value: "gm"
+			};
+			case 3: return {
+				type: "Global MIDI Param",
+				parameter: "system",
+				value: "gm2"
+			};
 		}
 	}
 	static analyzeXG(syx) {
@@ -1721,18 +1987,25 @@ var MIDIUtils = class MIDIUtils {
 		const a2 = syx[4];
 		const a3 = syx[5];
 		const data = syx[6];
+		if (a1 === 6 || a1 === 7) return { type: "Display Data" };
 		if (a1 === 0 && a2 === 0) switch (a3) {
 			default: return OTHER;
 			case 0: return {
-				type: "Master Fine Tune",
+				type: "Global MIDI Param",
+				parameter: "fineTune",
 				value: (((syx[6] & 15) << 12 | (syx[7] & 15) << 8 | (syx[8] & 15) << 4 | syx[9] & 15) - 1024) / 10
 			};
 			case 6: return {
-				type: "Master Key Shift",
+				type: "Global MIDI Param",
+				parameter: "keyShift",
 				value: data - 64
 			};
 			case 126:
-			case 127: return { type: "XG Reset" };
+			case 127: return {
+				type: "Global MIDI Param",
+				parameter: "system",
+				value: "xg"
+			};
 		}
 		if (a1 === 2 && a2 === 1) {
 			if (a3 <= 21) return { type: "Reverb Param" };
@@ -1774,8 +2047,9 @@ var MIDIUtils = class MIDIUtils {
 					isDrum: data > 0
 				};
 				case 8: return {
-					type: "Key Shift",
+					type: "Channel MIDI Param",
 					channel,
+					parameter: "keyShift",
 					value: data - 64
 				};
 				case 11: return {
@@ -1856,27 +2130,54 @@ var MIDIUtils = class MIDIUtils {
 		return OTHER;
 	}
 	static analyzeGS(syx) {
-		if (syx.length < 10 || syx[2] !== 66 || syx[3] !== 18) return OTHER;
+		if (syx.length < 10 || syx[3] !== 18) return OTHER;
+		if (syx[2] === 69) return { type: "Display Data" };
+		if (syx[2] !== 66) return OTHER;
 		const a1 = syx[4];
 		const a2 = syx[5];
 		const a3 = syx[6];
 		const data = syx[7];
 		if ((a1 === 0 || a1 === 64) && a2 === 0) switch (a3) {
+			case 0: return {
+				type: "Global MIDI Param",
+				parameter: "fineTune",
+				value: ((data << 12 | syx[8] << 8 | syx[9] << 4 | syx[10]) - 1024) / 10
+			};
+			case 4: return {
+				type: "Global MIDI Param",
+				parameter: "gain",
+				value: data / 127
+			};
+			case 5: return {
+				type: "Global MIDI Param",
+				parameter: "keyShift",
+				value: data - 64
+			};
+			case 6: return {
+				type: "Global MIDI Param",
+				parameter: "pan",
+				value: (data - 64) / 63
+			};
 			case 127:
 				switch (data) {
-					case 0: return { type: "GS Reset" };
-					case 127: return { type: "GM On" };
+					case 0: return {
+						type: "Global MIDI Param",
+						parameter: "system",
+						value: "gs"
+					};
+					case 127: return {
+						type: "Global MIDI Param",
+						parameter: "system",
+						value: "gm"
+					};
 				}
 				return OTHER;
-			case 0: return {
-				type: "Master Fine Tune",
-				value: ((data << 12 | syx[8] << 8 | syx[9] << 4 | syx[10]) - 1024) / 10
-			};
 		}
 		if (a1 === 65) return { type: "Drum Setup" };
 		if (a1 !== 64) return OTHER;
 		if (a2 === 0 && a3 === 5) return {
-			type: "Master Key Shift",
+			type: "Global MIDI Param",
+			parameter: "keyShift",
 			value: data - 64
 		};
 		if (a2 === 1) {
@@ -1895,10 +2196,16 @@ var MIDIUtils = class MIDIUtils {
 					value: data
 				};
 				case 19: return {
-					type: "Controller Change",
+					type: "Channel MIDI Param",
 					channel,
-					controller: data === 1 ? MIDIControllers.polyModeOn : MIDIControllers.monoModeOn,
-					value: 0
+					parameter: "polyMode",
+					value: data === 1
+				};
+				case 20: return {
+					type: "Channel MIDI Param",
+					channel,
+					parameter: "assignMode",
+					value: data
 				};
 				case 21: return {
 					type: "Drums On",
@@ -1906,8 +2213,9 @@ var MIDIUtils = class MIDIUtils {
 					isDrum: data > 0
 				};
 				case 22: return {
-					type: "Key Shift",
+					type: "Channel MIDI Param",
 					channel,
+					parameter: "keyShift",
 					value: data - 64
 				};
 				case 25: return {
@@ -1916,12 +2224,36 @@ var MIDIUtils = class MIDIUtils {
 					controller: MIDIControllers.mainVolume,
 					value: data
 				};
+				case 26: return {
+					type: "Channel MIDI Param",
+					channel,
+					parameter: "velocitySenseDepth",
+					value: data
+				};
+				case 27: return {
+					type: "Channel MIDI Param",
+					channel,
+					parameter: "velocitySenseOffset",
+					value: data
+				};
 				case 28: return {
 					type: "Controller Change",
 					channel,
 					controller: MIDIControllers.pan,
 					value: data
 				};
+				case 31: return {
+					type: "Channel MIDI Param",
+					channel,
+					parameter: "cc1",
+					value: data
+				};
+				case 32: return {
+					type: "Channel MIDI Param",
+					channel,
+					parameter: "cc2",
+					value: data
+				};
 				case 33: return {
 					type: "Controller Change",
 					channel,
@@ -1935,8 +2267,9 @@ var MIDIUtils = class MIDIUtils {
 					value: data
 				};
 				case 42: return {
-					type: "Fine Tune",
+					type: "Channel MIDI Param",
 					channel,
+					parameter: "fineTune",
 					value: ((data << 7 | syx[8]) - 8192) / 81.92
 				};
 				case 44: return {
@@ -2006,7 +2339,12 @@ var MIDIUtils = class MIDIUtils {
 					controller: MIDIControllers.bankSelectLSB,
 					value: data
 				};
-				case 34: return { type: "Insertion Param" };
+				case 34: return {
+					type: "Channel MIDI Param",
+					channel,
+					parameter: "efxAssign",
+					value: data === 1
+				};
 			}
 		}
 		return OTHER;
@@ -2054,26 +2392,18 @@ function correctBankOffsetInternal(mid, bankOffset, soundBank) {
 					channels[sysexChannel].isDrum = syx.isDrum;
 					return;
 				}
-				case "XG Reset":
-					system = "xg";
-					return;
-				case "GS Reset":
-					system = "gs";
-					return;
-				case "GM Off":
-				case "GM On":
-					system = "gm";
-					unwantedSystems.push({
-						tNum: trackNum,
-						e
-					});
-					return;
-				case "GM2 On":
-					system = "gm2";
-					return;
+				case "Global MIDI Param":
+					if (syx.parameter === "system") {
+						system = syx.value;
+						if (syx.value === "gm") unwantedSystems.push({
+							tNum: trackNum,
+							e
+						});
+					}
+					break;
 				case "Controller Change": {
 					const t = mid.tracks[trackNum];
-					const newEvent = new MIDIMessage(e.ticks, MIDIMessageTypes.controllerChange | syx.channel, new Uint8Array([syx.controller, syx.value]));
+					const newEvent = MIDIMessage.controllerChange(e.ticks, syx.channel, syx.controller, syx.value);
 					t.events[eventIndexes[trackNum]] = newEvent;
 					e = newEvent;
 					SpessaLog.info("%cReplaced a system exclusive with controller change!", ConsoleColors.info);
@@ -2081,7 +2411,7 @@ function correctBankOffsetInternal(mid, bankOffset, soundBank) {
 				}
 				case "Program Change": {
 					const t = mid.tracks[trackNum];
-					const newEvent = new MIDIMessage(e.ticks, MIDIMessageTypes.programChange | syx.channel, new Uint8Array([syx.value]));
+					const newEvent = MIDIMessage.programChange(e.ticks, syx.channel, syx.value);
 					t.events[eventIndexes[trackNum]] = newEvent;
 					e = newEvent;
 					SpessaLog.info("%cReplaced a system exclusive with program change!", ConsoleColors.info);
@@ -2134,7 +2464,7 @@ function correctBankOffsetInternal(mid, bankOffset, soundBank) {
 				program: 0,
 				isGMGSDrum: false
 			}, system).program;
-			track.addEvents(programIndex, new MIDIMessage(programTicks, MIDIMessageTypes.programChange | midiChannel, new IndexedByteArray([targetProgram])));
+			track.addEvents(programIndex, MIDIMessage.programChange(programTicks, midiChannel, targetProgram));
 			indexToAdd = programIndex;
 		}
 		SpessaLog.info(`%cAdding bank select for %c${chNum}`, ConsoleColors.info, ConsoleColors.recognized);
@@ -2146,7 +2476,7 @@ function correctBankOffsetInternal(mid, bankOffset, soundBank) {
 			isGMGSDrum: ch.isDrum
 		}, system);
 		const targetBank = BankSelectHacks.addBankOffset(targetPreset.bankMSB, bankOffset, system === "xg");
-		track.addEvents(indexToAdd, new MIDIMessage(ticks, MIDIMessageTypes.controllerChange | midiChannel, new IndexedByteArray([MIDIControllers.bankSelect, targetBank])));
+		track.addEvents(indexToAdd, MIDIMessage.controllerChange(ticks, midiChannel, MIDIControllers.bankSelect, targetBank));
 	}
 	if (system === "gm" && !BankSelectHacks.isSystemXG(system)) {
 		for (const m of unwantedSystems) {
@@ -2155,7 +2485,7 @@ function correctBankOffsetInternal(mid, bankOffset, soundBank) {
 		}
 		let index = 0;
 		if (mid.tracks[0].events[0].statusByte === MIDIMessageTypes.trackName) index++;
-		mid.tracks[0].addEvents(index, MIDIUtils.gsReset(0));
+		mid.tracks[0].addEvents(index, MIDIUtils.reset(0, "gs"));
 	}
 	mid.flush();
 }
@@ -2461,7 +2791,7 @@ function getUsedProgramsAndKeys(mid, soundBank) {
 					case MIDIControllers.dataEntryMSB:
 					case MIDIControllers.dataEntryLSB: {
 						const analyzed = ch.param.controllerChange(cc, value, trackNum, event);
-						if (analyzed?.type === "Key Shift") ch.keyShift = ch.isDrum ? 0 : analyzed.value;
+						if (analyzed?.type === "Channel MIDI Param" && analyzed.parameter === "keyShift") ch.keyShift = ch.isDrum ? 0 : analyzed.value;
 						break;
 					}
 					case MIDIControllers.resetAllControllers:
@@ -2498,31 +2828,19 @@ function getUsedProgramsAndKeys(mid, soundBank) {
 				const syx = MIDIUtils.analyzeSysEx(e.data);
 				switch (syx.type) {
 					default: break;
-					case "XG Reset":
-						reset("xg");
-						SpessaLog.info("%cXG on detected!", ConsoleColors.recognized);
-						break;
-					case "GM2 On":
-						reset("gm2");
-						SpessaLog.info("%cGM2 on detected!", ConsoleColors.recognized);
-						break;
-					case "GM On":
-						reset("gm");
-						SpessaLog.info("%cGM on detected!", ConsoleColors.recognized);
-						break;
-					case "GM Off":
-					case "GS Reset":
-						reset("gs");
-						SpessaLog.info("%cGS on detected!", ConsoleColors.recognized);
-						break;
-					case "Master Key Shift":
-						masterKeyShift = syx.value;
+					case "Global MIDI Param":
+						if (syx.parameter === "keyShift") masterKeyShift = syx.value;
+						else if (syx.parameter === "system") {
+							reset(syx.value);
+							SpessaLog.info(`%c${syx.value.toUpperCase()} on detected!`, ConsoleColors.recognized);
+						}
 						break;
-					case "Key Shift": {
-						const ch = channels[syx.channel];
-						ch.keyShift = ch.isDrum ? 0 : syx.value;
+					case "Channel MIDI Param":
+						if (syx.parameter === "keyShift") {
+							const ch = channels[syx.channel];
+							ch.keyShift = ch.isDrum ? 0 : syx.value;
+						}
 						break;
-					}
 					case "Drums On": {
 						const sysexChannel = syx.channel + channelOffset;
 						channels[sysexChannel].isDrum = syx.isDrum;
@@ -2585,13 +2903,13 @@ function getNoteTimesInternal(midi, minDrumLength = 0) {
 	const unfinishedNotes = [];
 	for (let i = 0; i < 16; i++) unfinishedNotes.push(/* @__PURE__ */ new Map());
 	const noteOff = (midiNote, channel) => {
-		const ch = unfinishedNotes[channel];
-		const noteIndex = ch.get(midiNote);
+		const noteIndexes = unfinishedNotes[channel].get(midiNote);
+		if (noteIndexes === void 0) return;
+		const noteIndex = noteIndexes.shift();
 		if (noteIndex === void 0) return;
 		const note = noteTimes[channel][noteIndex];
 		const time = elapsedTime - note.start;
 		note.length = channel === 9 ? Math.max(time, minDrumLength) : time;
-		ch.delete(midiNote);
 		unfinished--;
 	};
 	const { timeline, tracks } = midi;
@@ -2606,7 +2924,6 @@ function getNoteTimesInternal(midi, minDrumLength = 0) {
 			const velocity = event.data[1];
 			if (velocity === 0) noteOff(midiNote, channel);
 			else {
-				noteOff(midiNote, channel);
 				const noteTime = {
 					midiNote,
 					start: elapsedTime,
@@ -2615,14 +2932,17 @@ function getNoteTimesInternal(midi, minDrumLength = 0) {
 				};
 				const times = noteTimes[channel];
 				times.push(noteTime);
-				unfinishedNotes[channel].set(midiNote, times.length - 1);
+				const unfinishedChannel = unfinishedNotes[channel];
+				if (!unfinishedChannel.has(midiNote)) unfinishedChannel.set(midiNote, []);
+				unfinishedNotes[channel].get(midiNote)?.push(times.length - 1);
 				unfinished++;
 			}
 		} else if (event.statusByte === 81) oneTickToSeconds = 60 / (getTempo(event) * midi.timeDivision);
 		if (++i >= timeline.length) break;
-		elapsedTime += oneTickToSeconds * (tracks[timeline[i].tr].events[timeline[i].ev].ticks - event.ticks);
+		const nextTimeline = timeline[i];
+		elapsedTime += oneTickToSeconds * (tracks[nextTimeline.tr].events[nextTimeline.ev].ticks - event.ticks);
 	}
-	if (unfinished > 0) for (let channel = 0; channel < unfinishedNotes.length; channel++) for (const noteIndex of unfinishedNotes[channel].values()) {
+	if (unfinished > 0) for (let channel = 0; channel < unfinishedNotes.length; channel++) for (const noteIndexes of unfinishedNotes[channel].values()) for (const noteIndex of noteIndexes) {
 		const note = noteTimes[channel][noteIndex];
 		note.length = elapsedTime - note.start;
 	}
@@ -2660,9 +2980,6 @@ const delayAddressMap = {
 	feedback: 89,
 	sendLevelToReverb: 90
 };
-function getControllerChange(channel, cc, value, ticks) {
-	return new MIDIMessage(ticks, MIDIMessageTypes.controllerChange | channel % 16, new IndexedByteArray([cc, value]));
-}
 /**
 * Allows easy editing of the file by removing channels, changing programs,
 * changing controllers and transposing channels. Note that this modifies the MIDI in-place.
@@ -2681,8 +2998,8 @@ function modifyMIDIInternal(midi, opts) {
 	const channelChanges = /* @__PURE__ */ new Map();
 	if (channels) for (const [channel, ch] of channels) if (ch === "clear") clearedChannels.add(channel);
 	else channelChanges.set(channel, ch);
-	let system = "gs";
-	let addedGs = false;
+	let system = (opts.midiParams?.system === "clear" ? void 0 : opts.midiParams?.system) ?? "gs";
+	let addedReset = false;
 	let resetTrack = 0;
 	let resetIndex = 0;
 	/**
@@ -2718,7 +3035,9 @@ function modifyMIDIInternal(midi, opts) {
 			data: true
 		},
 		keyShift: channelChanges.get(i)?.keyShift ?? 0,
-		fineTune: channelChanges.get(i)?.fineTune ?? 0
+		fineTune: channelChanges.get(i)?.fineTune ?? 0,
+		currentFineTune: 0,
+		currentKeyShift: 0
 	});
 	midi.iterate((e, trackNum, eventIndexes) => {
 		const track = midi.tracks[trackNum];
@@ -2751,10 +3070,18 @@ function modifyMIDIInternal(midi, opts) {
 				ch.clearedParams.pLSB = true;
 			}
 		};
-		const addEventBefore = (e, offset = 0) => {
-			track.addEvents(index + offset, e);
+		const addEventBefore = (e) => {
+			track.addEvents(index, e);
 			eventIndexes[trackNum]++;
 		};
+		/**
+		* This function adds the events IN ORDER they are in the array,
+		* So the first event in the array will end up as the first one before the current event.
+		* @param events
+		*/
+		const addEventsBefore = (...events) => {
+			for (let i = events.length - 1; i >= 0; i--) addEventBefore(events[i]);
+		};
 		const portOffset = midiPortChannelOffsets[midiPorts[trackNum]] || 0;
 		if (e.statusByte === MIDIMessageTypes.midiPort) {
 			assignMIDIPort(trackNum, e.data[0]);
@@ -2777,17 +3104,17 @@ function modifyMIDIInternal(midi, opts) {
 					channelStatus.isFirstNoteOn = false;
 					if (channelChange.controllers) for (const [cc, value] of channelChange.controllers) {
 						if (value === "clear") continue;
-						addEventBefore(getControllerChange(midiChannel, cc, value, e.ticks));
+						addEventBefore(MIDIMessage.controllerChange(e.ticks, midiChannel, cc, value));
 					}
-					if (channelStatus.fineTune !== 0) {
-						const data = Math.floor(channelStatus.fineTune * 81.92) + 8192;
-						const rpnCoarse = getControllerChange(midiChannel, MIDIControllers.registeredParameterMSB, 0, e.ticks);
-						const rpnFine = getControllerChange(midiChannel, MIDIControllers.registeredParameterLSB, 1, e.ticks);
-						const dataEntryCoarse = getControllerChange(channel, MIDIControllers.dataEntryMSB, data >> 7 & 127, e.ticks);
-						addEventBefore(getControllerChange(midiChannel, MIDIControllers.dataEntryLSB, data & 127, e.ticks));
-						addEventBefore(dataEntryCoarse);
-						addEventBefore(rpnFine);
-						addEventBefore(rpnCoarse);
+					if (channelChange.midiParams?.fineTune !== void 0 && channelChange.midiParams.fineTune !== "clear") {
+						const newTune = channelStatus.fineTune + channelChange.midiParams.fineTune;
+						channelStatus.currentKeyShift = Math.trunc(newTune / 100);
+						channelChange.midiParams.fineTune = newTune % 100;
+					} else {
+						const newTune = channelStatus.fineTune + channelStatus.currentFineTune;
+						channelStatus.currentKeyShift = Math.trunc(newTune / 100);
+						channelChange.midiParams ??= {};
+						channelChange.midiParams.fineTune = newTune % 100;
 					}
 					const patch = channelChange.patch;
 					if (patch && patch !== "clear") {
@@ -2795,9 +3122,9 @@ function modifyMIDIInternal(midi, opts) {
 						let desiredBankMSB = patch.bankMSB;
 						let desiredBankLSB = patch.bankLSB;
 						const desiredProgram = patch.program;
-						addEventBefore(new MIDIMessage(e.ticks, MIDIMessageTypes.programChange | midiChannel, new IndexedByteArray([desiredProgram])));
+						addEventBefore(MIDIMessage.programChange(e.ticks, midiChannel, desiredProgram));
 						const addBank = (isLSB, v) => {
-							addEventBefore(getControllerChange(midiChannel, isLSB ? MIDIControllers.bankSelectLSB : MIDIControllers.bankSelect, v, e.ticks));
+							addEventBefore(MIDIMessage.controllerChange(e.ticks, midiChannel, isLSB ? MIDIControllers.bankSelectLSB : MIDIControllers.bankSelect, v));
 						};
 						if (BankSelectHacks.isSystemXG(system) && patch.isGMGSDrum) {
 							SpessaLog.info(`%cAdding XG Drum change on track %c${trackNum}`, ConsoleColors.recognized, ConsoleColors.value);
@@ -2808,15 +3135,20 @@ function modifyMIDIInternal(midi, opts) {
 						addBank(true, desiredBankLSB);
 						if (patch.isGMGSDrum && !BankSelectHacks.isSystemXG(system) && midiChannel !== 9) {
 							SpessaLog.info(`%cAdding GS Drum change on track %c${trackNum}`, ConsoleColors.recognized, ConsoleColors.value);
-							addEventBefore(MIDIUtils.gsDrumChange(e.ticks, midiChannel, 1));
+							const chanAddress = 16 | MIDIUtils.channelToSyx(midiChannel);
+							addEventBefore(MIDIUtils.gsMessage(e.ticks, 40, chanAddress, 21, [1]));
 						}
 					}
+					if (channelChange.midiParams) for (const [param, value] of Object.entries(channelChange.midiParams)) {
+						if (value === "clear") continue;
+						addEventsBefore(...MIDIUtils.setChannelMIDIParameter(e.ticks, midiChannel, system, param, value));
+					}
 				}
-				e.data[0] += channelStatus.keyShift;
+				e.data[0] += channelStatus.keyShift + channelStatus.currentKeyShift;
 				break;
 			case MIDIMessageTypes.noteOff:
 				if (!channelChange) break;
-				e.data[0] += channelStatus.keyShift;
+				e.data[0] += channelStatus.keyShift + channelStatus.currentKeyShift;
 				break;
 			case MIDIMessageTypes.programChange:
 				if (channelChange?.patch) {
@@ -2824,6 +3156,12 @@ function modifyMIDIInternal(midi, opts) {
 					return;
 				}
 				break;
+			case MIDIMessageTypes.pitchWheel:
+				if (channelChange?.midiParams?.pitchWheel) deleteThisEvent();
+				break;
+			case MIDIMessageTypes.channelPressure:
+				if (channelChange?.midiParams?.pressure) deleteThisEvent();
+				break;
 			case MIDIMessageTypes.controllerChange: {
 				const ccNum = e.data[0];
 				const value = e.data[1];
@@ -2863,17 +3201,17 @@ function modifyMIDIInternal(midi, opts) {
 								if ((ccNum === MIDIControllers.bankSelect || ccNum === MIDIControllers.bankSelectLSB) && channelChange?.patch) deleteParameter(channel);
 								break;
 							}
-							case "Fine Tune":
-								if (channelStatus.fineTune) {
-									if (channelStatus.isFirstNoteOn) {
-										const newTune = channelStatus.fineTune + data.value;
-										channelStatus.keyShift += Math.trunc(newTune / 100);
-										channelStatus.fineTune = newTune % 100;
-										SpessaLog.info(`%cFine tuning already present on ${channel}, new relative tune: %c${newTune} cents`, ConsoleColors.info, ConsoleColors.recognized);
-									}
-									deleteParameter(channel);
-								}
-								return;
+							case "Channel MIDI Param":
+								if (data.parameter === "fineTune" && channelStatus.fineTune) {
+									channelStatus.currentFineTune = data.value;
+									const newTune = channelStatus.fineTune + data.value;
+									channelStatus.currentKeyShift = Math.trunc(newTune / 100);
+									const targetTune = newTune % 100;
+									SpessaLog.info(`%cFine tuning already present on ${channel}%c (${data.value})%c, new relative tune: %c${newTune}%c cents. Key shift: %c${channelStatus.currentKeyShift}%c semitones. Actual RPN value to set: %c${targetTune} cents.`, ConsoleColors.info, ConsoleColors.recognized, ConsoleColors.info, ConsoleColors.value, ConsoleColors.info, ConsoleColors.value, ConsoleColors.info, ConsoleColors.value);
+									const updatedData = Math.floor(targetTune * 81.92) + 8192;
+									e.data[1] = ccNum === MIDIControllers.dataEntryMSB ? updatedData >> 7 : updatedData & 127;
+								} else if (channelChange?.midiParams?.[data.parameter]) deleteParameter(channel);
+								break;
 						}
 						channelStatus.clearedParams.pLSB = true;
 						channelStatus.clearedParams.pMSB = true;
@@ -2886,56 +3224,6 @@ function modifyMIDIInternal(midi, opts) {
 				const syx = MIDIUtils.analyzeSysEx(e.data);
 				switch (syx.type) {
 					default: return;
-					case "XG Reset":
-						SpessaLog.info("%cXG system on detected", ConsoleColors.info);
-						system = "xg";
-						addedGs = true;
-						resetTrack = trackNum;
-						resetIndex = index;
-						for (const ch of channelStatuses) {
-							ch.param.reset();
-							ch.clearedParams = {
-								pLSB: true,
-								pMSB: true,
-								data: true
-							};
-						}
-						return;
-					case "GM2 On":
-						SpessaLog.info("%cGM2 system on detected", ConsoleColors.info);
-						system = "gm2";
-						addedGs = true;
-						resetTrack = trackNum;
-						resetIndex = index;
-						for (const ch of channelStatuses) {
-							ch.param.reset();
-							ch.clearedParams = {
-								pLSB: true,
-								pMSB: true,
-								data: true
-							};
-						}
-						return;
-					case "GS Reset":
-						SpessaLog.info("%cGS on detected!", ConsoleColors.recognized);
-						addedGs = true;
-						resetTrack = trackNum;
-						resetIndex = index;
-						for (const ch of channelStatuses) {
-							ch.param.reset();
-							ch.clearedParams = {
-								pLSB: true,
-								pMSB: true,
-								data: true
-							};
-						}
-						return;
-					case "GM Off":
-					case "GM On":
-						SpessaLog.info("%cGM on detected, removing!", ConsoleColors.info);
-						deleteThisEvent();
-						addedGs = false;
-						return;
 					case "Drum Setup":
 						if (clearDrumParams) deleteThisEvent();
 						return;
@@ -2954,15 +3242,79 @@ function modifyMIDIInternal(midi, opts) {
 					case "Program Change":
 						if (channelChanges.get(syx.channel + portOffset)?.patch) deleteThisEvent();
 						return;
-					case "Fine Tune": {
+					case "Global MIDI Param":
+						if (opts.midiParams?.[syx.parameter]) {
+							deleteThisEvent();
+							return;
+						}
+						if (syx.parameter === "system") switch (syx.value) {
+							case "xg":
+								SpessaLog.info("%cXG system on detected", ConsoleColors.info);
+								system = "xg";
+								addedReset = true;
+								resetTrack = trackNum;
+								resetIndex = index;
+								for (const ch of channelStatuses) {
+									ch.param.reset();
+									ch.clearedParams = {
+										pLSB: true,
+										pMSB: true,
+										data: true
+									};
+								}
+								return;
+							case "gm2":
+								SpessaLog.info("%cGM2 system on detected", ConsoleColors.info);
+								system = "gm2";
+								addedReset = true;
+								resetTrack = trackNum;
+								resetIndex = index;
+								for (const ch of channelStatuses) {
+									ch.param.reset();
+									ch.clearedParams = {
+										pLSB: true,
+										pMSB: true,
+										data: true
+									};
+								}
+								return;
+							case "gs":
+								SpessaLog.info("%cGS on detected!", ConsoleColors.recognized);
+								addedReset = true;
+								resetTrack = trackNum;
+								resetIndex = index;
+								for (const ch of channelStatuses) {
+									ch.param.reset();
+									ch.clearedParams = {
+										pLSB: true,
+										pMSB: true,
+										data: true
+									};
+								}
+								return;
+							case "gm":
+								SpessaLog.info("%cGM on detected, removing!", ConsoleColors.info);
+								deleteThisEvent();
+								addedReset = false;
+								return;
+						}
+						break;
+					case "Channel MIDI Param": {
 						const syxChannel = channelChanges.get(syx.channel + portOffset);
-						const syxStatus = channelStatuses[syx.channel + portOffset];
-						if (syxStatus.isFirstNoteOn && syxChannel) {
-							const newTune = syxStatus.fineTune + syx.value;
-							syxStatus.keyShift += Math.trunc(newTune / 100);
-							syxStatus.fineTune = newTune % 100;
-							SpessaLog.info(`%cFine tuning already present on ${syx.channel + portOffset}, new relative tune: %c${newTune} cents`, ConsoleColors.info, ConsoleColors.recognized);
+						if (syxChannel?.midiParams?.[syx.parameter]) {
 							deleteThisEvent();
+							return;
+						}
+						if (syx.parameter === "fineTune") {
+							const syxStatus = channelStatuses[syx.channel + portOffset];
+							if (syxStatus.isFirstNoteOn && syxChannel) {
+								const newTune = syxStatus.fineTune + syx.value;
+								syxStatus.currentKeyShift = Math.trunc(newTune / 100);
+								syxStatus.fineTune = newTune % 100;
+								SpessaLog.info(`%cFine tuning already present on ${syx.channel + portOffset}, new relative tune: %c${newTune} cents`, ConsoleColors.info, ConsoleColors.recognized);
+								deleteThisEvent();
+							}
+							break;
 						}
 						break;
 					}
@@ -2980,17 +3332,25 @@ function modifyMIDIInternal(midi, opts) {
 			}
 		}
 	});
-	if (!addedGs && [...channelChanges.values()].some((c) => c.patch && c.patch !== "clear")) {
+	if (!addedReset && [...channelChanges.values()].some((c) => c.patch && c.patch !== "clear")) {
 		let index = 0;
 		if (midi.tracks[0].events[0].statusByte === MIDIMessageTypes.trackName) index++;
-		midi.tracks[0].addEvents(index, MIDIUtils.gsReset(0));
+		const targetSystem = (opts.midiParams?.system === "clear" ? void 0 : opts.midiParams?.system) ?? "gs";
+		midi.tracks[0].addEvents(index, MIDIUtils.reset(0, targetSystem));
 		resetTrack = 0;
 		resetIndex = index;
-		SpessaLog.info("%cGS on not detected. Adding it.", ConsoleColors.info);
+		system = targetSystem;
+		SpessaLog.info(`%c${targetSystem} reset on not detected. Adding it.`, ConsoleColors.info);
 	}
 	const targetTicks = Math.max(0, midi.firstNoteOn);
 	const targetTrack = midi.tracks[resetTrack];
 	const targetIndex = resetIndex + 1;
+	for (const param of Object.keys(opts.midiParams ?? {})) {
+		if (param === "system") continue;
+		const value = opts.midiParams?.[param];
+		if (!value || value === "clear") continue;
+		targetTrack.addEvents(targetIndex, ...MIDIUtils.setGlobalMIDIParameter(targetTicks, system, param, value));
+	}
 	if (reverbParams && reverbParams !== "clear") {
 		const m = reverbAddressMap;
 		const p = reverbParams;
@@ -3008,7 +3368,6 @@ function modifyMIDIInternal(midi, opts) {
 	}
 	if (insertionParams && insertionParams !== "clear") {
 		const p = insertionParams;
-		for (let channel = 0; channel < p.channels.length; channel++) if (p.channels[channel]) targetTrack.addEvents(targetTicks, MIDIUtils.gsMessage(targetTicks, 64, 64 | MIDIUtils.channelToSyx(channel), 34, [1]));
 		for (let param = 0; param < p.params.length; param++) {
 			const value = p.params[param];
 			if (value === 255) continue;
@@ -3612,8 +3971,10 @@ function loadXMF(midi, binaryData, fileName) {
 //#endregion
 //#region src/midi/midi_tools/apply_snapshot.ts
 /**
-* Modifies the sequence according to the locked presets and controllers in the given snapshot.
-* Note that this ignores the MIDI parameters and only applies system parameter tuning.
+* Modifies the sequence *in-place* according to the locked presets and controllers in the given snapshot.
+*
+* Note that System Parameters `fineTune` and `keyShift` are passed to the relative tuning parameters of the channels.
+* Only locked MIDI parameters and controllers are applied.
 */
 function applySnapshotInternal(midi, snapshot) {
 	const channels = /* @__PURE__ */ new Map();
@@ -3635,20 +3996,26 @@ function applySnapshotInternal(midi, snapshot) {
 			const targetValue = channelSnapshot.midiControllers[ccNumber] >> 7;
 			controllers.set(ccNumber, targetValue);
 		}
+		const midiParams = {};
+		for (const [parameter, value] of Object.entries(channelSnapshot.midiParameters)) if (channelSnapshot.lockedMIDIParameters[parameter]) midiParams[parameter] = value;
 		channels.set(channelNumber, {
 			keyShift,
 			fineTune,
 			patch,
-			controllers
+			controllers,
+			midiParams
 		});
 	}
+	const midiParams = {};
+	for (const [parameter, value] of Object.entries(snapshot.midiParameters)) if (snapshot.lockedMIDIParameters[parameter]) midiParams[parameter] = value;
 	midi.modify({
 		channels,
 		drumSetupParams: snapshot.systemParameters.drumLock ? "clear" : void 0,
 		reverbParams: snapshot.systemParameters.reverbLock ? snapshot.reverbProcessor : void 0,
 		chorusParams: snapshot.systemParameters.chorusLock ? snapshot.chorusProcessor : void 0,
 		delayParams: snapshot.systemParameters.delayLock ? snapshot.delayProcessor : void 0,
-		insertionParams: snapshot.systemParameters.insertionEffectLock ? snapshot.insertionProcessor : void 0
+		insertionParams: snapshot.systemParameters.insertionEffectLock ? snapshot.insertionProcessor : void 0,
+		midiParams
 	});
 }
 //#endregion
@@ -3785,7 +4152,7 @@ var BasicMIDI = class BasicMIDI {
 	* It supports Standard MIDI Files (SMF), RIFF MIDI (RMIDI), and Extensible Music Format (XMF).
 	* It also handles embedded soundbanks in RMIDI files.
 	* If the file is an RMIDI file, it will extract the embedded soundbank and store
-	* it in the `embeddedSoundFont` property of the BasicMIDI instance.
+	* it in the `embeddedSoundBank` property of the BasicMIDI instance.
 	* If the file is an XMF file, it will parse the XMF structure and extract the MIDI data.
 	*/
 	static fromArrayBuffer(arrayBuffer, fileName = "") {
@@ -3945,7 +4312,9 @@ var BasicMIDI = class BasicMIDI {
 	}
 	/**
 	* Modifies the sequence *in-place* according to the locked presets and controllers in the given snapshot.
-	* Note that this ignores the MIDI parameters and only applies system parameter tuning.
+	*
+	* Note that System Parameters `fineTune` and `keyShift` are passed to the relative tuning parameters of the channels.
+	* Only locked MIDI parameters and controllers are applied.
 	* @param snapshot the snapshot to apply.
 	*/
 	applySnapshot(snapshot) {
@@ -4130,15 +4499,15 @@ var BasicMIDI = class BasicMIDI {
 					switch (e.statusByte & 240) {
 						case MIDIMessageTypes.controllerChange:
 							switch (e.data[0]) {
-								case 2:
-								case 111:
+								case MIDIControllers.breathController:
+								case MIDIControllers.undefinedCC111LSB:
 									if (e.data[1] === 0) loopStart = e.ticks;
 									break;
-								case 116:
+								case MIDIControllers.undefinedCC116LSB:
 									loopStart = e.ticks;
 									break;
-								case 4:
-								case 117:
+								case MIDIControllers.footController:
+								case MIDIControllers.undefinedCC117LSB:
 									if (loopEnd === null && (e.data[0] !== 4 || e.data[0] === 4 && e.data[1] === 0)) {
 										loopType = "soft";
 										loopEnd = e.ticks;
@@ -4147,7 +4516,7 @@ var BasicMIDI = class BasicMIDI {
 										loopType = "hard";
 									}
 									break;
-								case 0: if (this.isDLSRMIDI && e.data[1] !== 0 && e.data[1] !== 127) {
+								case MIDIControllers.bankSelect: if (this.isDLSRMIDI && e.data[1] !== 0 && e.data[1] !== 127) {
 									SpessaLog.info("%cDLS RMIDI with offset 1 detected!", ConsoleColors.recognized);
 									this.bankOffset = 1;
 								}
@@ -4664,9 +5033,6 @@ function loadNewSequenceInternal(parsedMIDI) {
 }
 //#endregion
 //#region src/synthesizer/audio_engine/channel/reset.ts
-function resetPortamento() {
-	this.lastNote = this.channelSystem === "xg" ? 60 : -1;
-}
 /**
 * An array with the default MIDI controller values.
 * Note that these are 14-bit, requiring a 7-bit shift to the right for 7-bit values!
@@ -4712,27 +5078,30 @@ function resetChannelInternal(sendCCEvents = true) {
 		const resetValue = DEFAULT_MIDI_CONTROLLERS[cc];
 		if (this._midiControllers[cc] !== resetValue && cc !== MIDIControllers.portamentoControl && cc !== MIDIControllers.dataEntryMSB && cc !== MIDIControllers.registeredParameterMSB && cc !== MIDIControllers.registeredParameterLSB && cc !== MIDIControllers.nonRegisteredParameterMSB && cc !== MIDIControllers.nonRegisteredParameterLSB) this.controllerChange(cc, resetValue >> 7, sendCCEvents);
 	}
-	if (!this.synthCore.systemParameters.insertionEffectLock) this.setMIDIParameter("efxAssign", false);
+	this.setMIDIParameter("pressure", 0);
+	this.setMIDIParameter("pitchWheelRange", 2);
+	this.setMIDIParameter("modulationDepth", 50);
 	this.setMIDIParameter("rxChannel", this.channel);
+	this.setMIDIParameter("efxAssign", false);
+	this.setMIDIParameter("polyMode", true);
+	this.setMIDIParameter("keyShift", 0);
+	this.setMIDIParameter("fineTune", 0);
 	this.setMIDIParameter("assignMode", 2);
 	this.setMIDIParameter("randomPan", false);
 	this.setMIDIParameter("cc1", 16);
 	this.setMIDIParameter("cc2", 17);
 	this.setMIDIParameter("drumMap", this.channel % 16 === 9 ? 1 : 0);
+	this.setMIDIParameter("velocitySenseOffset", 64);
+	this.setMIDIParameter("velocitySenseDepth", 64);
 	this.pitchWheel(8192);
-	this.pitchWheelRange(2, false);
-	this.keyShift(0, false);
-	this.fineTune(0, false);
-	this.setMIDIParameter("pressure", 0);
-	this.modulationDepth(50, false);
-	if (!this.lockedControllers[MIDIControllers.monoModeOn] && !this.lockedControllers[MIDIControllers.polyModeOn]) this.setMIDIParameter("polyMode", true);
 	this.octaveTuning.fill(0);
-	resetPortamento.call(this);
+	this.lastPortamentoNote = this.channelSystem === "xg" ? 60 : -1;
 	this.resetDrumParams();
 	this.resetGeneratorOverrides();
 	this.resetGeneratorOffsets();
 	this.dynamicModulators.resetModulators();
 	this.sf2NRPNGeneratorLSB = 0;
+	this.playingNotes.fill(false);
 	this.lastParameterIsRegistered = true;
 	this._midiControllers[MIDIControllers.nonRegisteredParameterLSB] = 0;
 	this._midiControllers[MIDIControllers.nonRegisteredParameterMSB] = 0;
@@ -5265,7 +5634,7 @@ var SpessaSynthSequencer = class {
 			this.synth.reset();
 			return;
 		}
-		this.sendMIDISysEx(MIDIUtils.gsData(64, 0, 127, [0]));
+		this.sendMIDISysEx(MIDIUtils.gs(64, 0, 127, [0]));
 	}
 	loadCurrentSong() {
 		let index = this._songIndex;
@@ -6014,15 +6383,16 @@ function applySnapshot$1(snapshot) {
 	for (const [key, value] of Object.entries(this.chorusProcessor)) this.chorusProcessor[key] = value;
 	for (const [key, value] of Object.entries(this.delayProcessor)) this.delayProcessor[key] = value;
 	const is = snapshot.insertionProcessor;
-	this.systemExclusive(MIDIUtils.gsData(64, 3, 0, [is.type >> 8, is.type & 127]));
-	for (let i = 0; i < is.params.length; i++) if (is.params[i] !== 255) this.systemExclusive(MIDIUtils.gsData(64, 3, 3 + i, [is.params[i]]));
-	for (let channel = 0; channel < is.channels.length; channel++) this.systemExclusive(MIDIUtils.gsData(64, 64 | MIDIUtils.channelToSyx(channel), 34, [is.channels[channel] ? 1 : 0]));
+	this.systemExclusive(MIDIUtils.gs(64, 3, 0, [is.type >> 8, is.type & 127]));
+	for (let i = 0; i < is.params.length; i++) if (is.params[i] !== 255) this.systemExclusive(MIDIUtils.gs(64, 3, 3 + i, [is.params[i]]));
 	for (const [parameter, value] of Object.entries(snapshot.midiParameters)) this.setMIDIParameter(parameter, value);
+	for (const [parameter, isLocked] of Object.entries(snapshot.lockedMIDIParameters)) this.lockMIDIParameter(parameter, isLocked);
 	for (const [parameter, value] of Object.entries(snapshot.systemParameters)) this.setSystemParameter(parameter, value);
 }
 function getSynthesizerSnapshot() {
 	return {
 		midiParameters: { ...this.midiParameters },
+		lockedMIDIParameters: { ...this.lockedMIDIParameters },
 		systemParameters: { ...this.systemParameters },
 		midiChannels: this.midiChannels.map((c) => c.getSnapshot()),
 		keyMappings: this.keyModifierManager.getMappings(),
@@ -6229,7 +6599,7 @@ var LowpassFilter = class LowpassFilter {
 		LowpassFilter.smoothingConstant = FILTER_SMOOTHING_FACTOR * (44100 / sampleRate);
 		const dummy = new LowpassFilter(sampleRate);
 		dummy.resonanceCb = 0;
-		for (let i = 1500; i < 13500; i++) {
+		for (let i = 8e3; i < 13500; i++) {
 			dummy.currentInitialFc = i;
 			dummy.calculateCoefficients(i);
 		}
@@ -7389,6 +7759,11 @@ var Voice = class {
 	*/
 	channel = 0;
 	/**
+	* Grouping voices for specific Note On messages.
+	* Used for overlapping Note Ons.
+	*/
+	noteID = 0;
+	/**
 	* MIDI note number of the voice.
 	* Direct number from the Note On message and is
 	* used for Note Off and external parameters:
@@ -7511,7 +7886,7 @@ var Voice = class {
 		this.releaseStartTime = currentTime;
 		if (this.releaseStartTime - this.startTime < minNoteLength) this.releaseStartTime = this.startTime + minNoteLength;
 	}
-	setup(currentTime, channel, midiNote) {
+	setup(currentTime, channel, midiNote, noteID) {
 		this.isActive = true;
 		this.isInRelease = false;
 		this.hasRendered = false;
@@ -7526,6 +7901,7 @@ var Voice = class {
 		this.startTime = currentTime;
 		this.channel = channel;
 		this.midiNote = midiNote;
+		this.noteID = noteID;
 	}
 };
 //#endregion
@@ -7548,7 +7924,7 @@ var ModulatorSource = class ModulatorSource {
 	* If this field is set to false, the controller should be mapped with a minimum value of 0 and a maximum value of 1. This is also
 	* called Unipolar. Thus, it behaves similar to the Modulation Wheel controller of the MIDI specification.
 	*
-	* If this field is set to true, the controller sound be mapped with a minimum value of -1 and a maximum value of 1. This is also
+	* If this field is set to true, the controller should be mapped with a minimum value of -1 and a maximum value of 1. This is also
 	* called Bipolar. Thus, it behaves similar to the Pitch Wheel controller of the MIDI specification.
 	*/
 	isBipolar;
@@ -8879,7 +9255,8 @@ var SoundFontSample = class extends BasicSample {
 		}
 		const audioData = new Float32Array(byteLength / 2);
 		const convertedSigned16 = new Int16Array(this.s16leData.buffer);
-		for (const [i, element] of convertedSigned16.entries()) audioData[i] = element / 32768;
+		const l = convertedSigned16.length;
+		for (let i = 0; i < l; i++) audioData[i] = convertedSigned16[i] / 32768;
 		this.audioData = audioData;
 		return audioData;
 	}
@@ -9421,7 +9798,8 @@ function readPCM(data, bytesPerSample) {
 	const sampleData = new Float32Array(sampleLength);
 	if (bytesPerSample === 2) {
 		const s16 = new Int16Array(data.buffer);
-		for (const [i, element] of s16.entries()) sampleData[i] = element / 32768;
+		const s16l = s16.length;
+		for (let i = 0; i < s16l; i++) sampleData[i] = s16[i] / 32768;
 	} else for (let i = 0; i < sampleData.length; i++) {
 		let sample = readLittleEndianIndexed(data, bytesPerSample);
 		if (isUnsigned) sampleData[i] = sample / normalizationFactor - .5;
@@ -12170,7 +12548,7 @@ function controllerChange(controller, value, sendEvent = true) {
 			}
 			break;
 		case MIDIControllers.portamentoControl:
-			this.lastNote = value;
+			this.lastPortamentoNote = value;
 			this.portamentoForce = true;
 			break;
 		default:
@@ -12329,22 +12707,30 @@ function dataEntry() {
 			default:
 				SpessaLog.info(`%cUnrecognized RPN for %c${this.channel}%c: %c(0x${rpnValue.toString(16)})%c data value: %c${dataValue}`, ConsoleColors.warn, ConsoleColors.recognized, ConsoleColors.warn, ConsoleColors.unrecognized, ConsoleColors.warn, ConsoleColors.value);
 				break;
-			case RegisteredParameterTypes.pitchWheelRange:
-				this.pitchWheelRange(dataValue / 128);
+			case RegisteredParameterTypes.pitchWheelRange: {
+				const range = dataValue / 128;
+				this.setMIDIParameter("pitchWheelRange", range);
+				SpessaLog.coolInfo(`Pitch Wheel Range for ${this.channel}`, range, "semitones");
 				break;
+			}
 			case RegisteredParameterTypes.coarseTuning: {
 				const semitones = (dataValue >> 7) - 64;
-				this.keyShift(semitones);
+				this.setMIDIParameter("keyShift", semitones);
+				SpessaLog.coolInfo(`Key shift for ${this.channel}`, semitones);
 				break;
 			}
 			case RegisteredParameterTypes.fineTuning: {
-				const finalTuning = dataValue - 8192;
-				this.fineTune(finalTuning / 81.92);
+				const cents = (dataValue - 8192) / 81.92;
+				this.setMIDIParameter("fineTune", cents);
+				SpessaLog.coolInfo(`Fine tuning for ${this.channel}`, Math.round(cents), "cents");
 				break;
 			}
-			case RegisteredParameterTypes.modulationDepth:
-				this.modulationDepth(dataValue / 1.28);
+			case RegisteredParameterTypes.modulationDepth: {
+				const cents = dataValue / 1.28;
+				this.setMIDIParameter("modulationDepth", cents);
+				SpessaLog.coolInfo(`Modulation depth for ${this.channel}`, Math.round(cents), "cents");
 				break;
+			}
 			case RegisteredParameterTypes.resetParameters: break;
 		}
 		return;
@@ -12583,15 +12969,16 @@ const clamp = (num, min, max) => Math.max(min, Math.min(max, num));
 * Sends a "MIDI Note on" message and starts a note.
 * @param midiNote The MIDI note number (0-127).
 * @param velocity The velocity of the note (0-127). If less than 1, it will send a note off instead.
+* @param emit If the note on should be updated and emitted (non-internal)
 */
-function noteOn(midiNote, velocity) {
+function noteOn(midiNote, velocity, emit = true) {
 	if (velocity < 1) {
 		this.noteOff(midiNote);
 		return;
 	}
-	velocity = clamp(velocity, 0, 127);
 	const black = this.synthCore.systemParameters.blackMIDIMode;
 	if (black && this.synthCore.voiceCount > 200 && velocity < 40 || black && velocity < 10 || this._systemParameters.isMuted || !this.preset) return;
+	let realVelocity = clamp(velocity * (this._midiParameters.velocitySenseDepth / 64) + (this._midiParameters.velocitySenseOffset - 64) * 2, 0, 127);
 	let soundBankNote = midiNote + this.currentKeyShift;
 	if (midiNote > 127 || midiNote < 0) return;
 	const program = this.preset.program;
@@ -12599,9 +12986,9 @@ function noteOn(midiNote, velocity) {
 	if (tune >= 0) soundBankNote = Math.trunc(tune);
 	if ((this._systemParameters.monophonicRetrigger ?? this.synthCore.systemParameters.monophonicRetrigger) || this._midiParameters.assignMode === 0) this.killNote(midiNote);
 	const keyVel = this.synthCore.keyModifierManager.getVelocity(this.channel, midiNote);
-	if (keyVel > -1) velocity = keyVel;
+	if (keyVel > -1) realVelocity = keyVel;
 	let voiceGain = this.synthCore.keyModifierManager.getGain(this.channel, midiNote);
-	const previousNote = this.lastNote;
+	const previousNote = this.lastPortamentoNote;
 	const portamentoEnabled = this.portamentoForce || this._midiControllers[MIDIControllers.portamentoOnOff] >= 8192;
 	const portamentoTime = this._midiControllers[MIDIControllers.portamentoTime] >> 7;
 	const canApplyPortamento = portamentoEnabled && !this._drumChannel && previousNote >= 0 && previousNote !== midiNote && portamentoTime > 0;
@@ -12613,17 +13000,14 @@ function noteOn(midiNote, velocity) {
 		portaTime = portamentoTimeToSeconds(portamentoTime, keyDistance);
 		this.portamentoForce = false;
 	}
-	this.lastNote = midiNote;
+	this.lastPortamentoNote = midiNote;
+	this.playingNotes[midiNote] = true;
 	if (!this._midiParameters.polyMode) {
-		let vc = 0;
-		if (this._voiceCount > 0) {
-			for (const v of this.synthCore.voices) if (v.isActive && v.channel === this.channel) {
-				v.exclusiveRelease(this.synthCore.currentTime, 0);
-				if (++vc >= this._voiceCount) break;
-			}
-		}
+		if (this.lastMonoNote >= 0 && this.lastMonoNote !== midiNote) this.killNote(this.lastMonoNote);
+		this.lastMonoNote = midiNote;
+		this.lastMonoVelocity = velocity;
 	}
-	const voices = this.synthCore.getVoices(this.channel, soundBankNote, velocity);
+	const voices = this.synthCore.getVoices(this.channel, soundBankNote, realVelocity);
 	let panOverride = 0;
 	let exclusiveOverride = 0;
 	let pitchOffset = 0;
@@ -12647,10 +13031,11 @@ function noteOn(midiNote, velocity) {
 		delaySend = p.delayGain;
 		if (voiceGain === 1) voiceGain = p.gain;
 	}
+	const noteID = emit ? this.noteOnID[midiNote]++ : this.noteOnID[midiNote];
 	for (const cached of voices) {
 		const voice = this.synthCore.assignVoice();
 		const now = this.synthCore.currentTime;
-		voice.setup(now, this.channel, midiNote);
+		voice.setup(now, this.channel, midiNote, noteID);
 		voice.wavetable = voice.oscillators[this._systemParameters.interpolationType ?? this.synthCore.systemParameters.interpolationType];
 		voice.targetKey = cached.targetKey;
 		voice.velocity = cached.velocity;
@@ -12723,7 +13108,7 @@ function noteOn(midiNote, velocity) {
 		voice.currentPan = Math.max(-500, Math.min(500, panOverride || voice.modulatedGenerators[GeneratorTypes.pan]));
 	}
 	this._voiceCount += voices.length;
-	this.synthCore.callEvent("noteOn", {
+	if (emit) this.synthCore.callEvent("noteOn", {
 		midiNote,
 		channel: this.channel,
 		velocity
@@ -12747,10 +13132,14 @@ function noteOff(midiNote) {
 		});
 		return;
 	}
-	const sustain = this._midiControllers[MIDIControllers.sustainPedal] >= 8192;
+	this.playingNotes[midiNote] = false;
+	const mono = !this._midiParameters.polyMode;
+	const sustain = this._midiControllers[MIDIControllers.sustainPedal] >= 8192 && !mono;
 	let vc = 0;
+	const noteID = this.noteOffID[midiNote];
+	if (noteID < this.noteOnID[midiNote]) this.noteOffID[midiNote]++;
 	if (this._voiceCount > 0) {
-		for (const v of this.synthCore.voices) if (v.channel === this.channel && v.isActive && v.midiNote === midiNote && !v.isInRelease) {
+		for (const v of this.synthCore.voices) if (v.channel === this.channel && v.isActive && v.midiNote === midiNote && v.noteID === noteID && !v.isInRelease) {
 			if (sustain) v.isHeld = true;
 			else v.releaseVoice(this.synthCore.currentTime);
 			if (++vc >= this._voiceCount) break;
@@ -12760,6 +13149,11 @@ function noteOff(midiNote) {
 		midiNote,
 		channel: this.channel
 	});
+	if (mono) {
+		const highest = this.playingNotes.lastIndexOf(true);
+		if (highest === -1) this.lastMonoNote = -1;
+		else if (this.lastMonoNote === midiNote) this.noteOn(highest, this.lastMonoVelocity, false);
+	}
 }
 //#endregion
 //#region src/synthesizer/audio_engine/channel/program_change.ts
@@ -12924,7 +13318,7 @@ function computeModulator(voice, pitchWheel, modulatorIndex) {
 	let computedValue = sourceValue * secondSrcValue * transformAmount;
 	if (modulator.transformType === 2) computedValue = Math.abs(computedValue);
 	if (modulator.isDefaultResonantModulator) voice.resonanceOffset = Math.max(0, computedValue / 2);
-	if (modulator.isModWheelModulator) computedValue *= this._midiParameters.modulationDepth;
+	if (modulator.isModWheelModulator) computedValue *= this._midiParameters.modulationDepth / 50;
 	voice.modulatorValues[modulatorIndex] = computedValue;
 	return computedValue;
 }
@@ -13047,12 +13441,13 @@ function getChannelSnapshot() {
 			overrides: this.generators.overrides.slice()
 		},
 		midiParameters: { ...this._midiParameters },
+		lockedMIDIParameters: { ...this.lockedMIDIParameters },
 		systemParameters: { ...this._systemParameters },
 		octaveTuning: this.octaveTuning.slice(),
 		perNotePitch: this.perNotePitch,
 		drumParams: this.drumParams.map((d) => ({ ...d })),
 		drumChannel: this._drumChannel,
-		channelNumber: this.channel
+		channel: this.channel
 	};
 }
 function applySnapshot(snapshot) {
@@ -13071,6 +13466,7 @@ function applySnapshot(snapshot) {
 	if (snapshot.patch) this.setPatch(snapshot.patch);
 	this.lockedSystem = snapshot.lockedSystem;
 	for (const [parameter, value] of Object.entries(snapshot.midiParameters)) this.setMIDIParameter(parameter, value);
+	for (const [parameter, isLocked] of Object.entries(snapshot.lockedMIDIParameters)) this.lockMIDIParameter(parameter, isLocked);
 	for (const [parameter, value] of Object.entries(snapshot.systemParameters)) this.setSystemParameter(parameter, value);
 }
 //#endregion
@@ -13079,18 +13475,53 @@ const DEFAULT_CHANNEL_MIDI_PARAMETERS = {
 	pitchWheel: 8192,
 	pitchWheelRange: 2,
 	pressure: 0,
-	modulationDepth: 1,
+	modulationDepth: 50,
 	rxChannel: 0,
 	polyMode: true,
 	keyShift: 0,
+	fineTune: 0,
 	randomPan: false,
 	assignMode: 2,
 	efxAssign: false,
 	cc1: 16,
 	cc2: 17,
 	drumMap: 0,
-	fineTune: 0
+	velocitySenseDepth: 64,
+	velocitySenseOffset: 64
 };
+/**
+* Sets a channel MIDI parameter of the synthesizer.
+* @param parameter The type of the channel MIDI parameter to set.
+* @param value The value to set for the channel MIDI parameter.
+* @internal
+*/
+function setMIDIParameterInternal$1(parameter, value) {
+	if (this.lockedMIDIParameters[parameter]) return;
+	this._midiParameters[parameter] = value;
+	switch (parameter) {
+		case "pitchWheel":
+			this.computeModulatorsAll(0, ModulatorControllerSources.pitchWheel);
+			break;
+		case "pressure":
+			this.computeModulatorsAll(0, ModulatorControllerSources.channelPressure);
+			break;
+	}
+	this.updateInternalParams();
+	this.synthCore.callEvent("channelParamChange", {
+		channel: this.channel,
+		parameter,
+		value
+	});
+}
+/**
+* Locks or unlocks a given Channel MIDI Parameter.
+* This prevents any changes to it until it's unlocked.
+* @param parameter The Channel MIDI Parameter to lock.
+* @param isLocked If the parameter should be locked.
+*/
+function lockMIDIParameterInternal$1(parameter, isLocked) {
+	this.lockedMIDIParameters[parameter] = isLocked;
+}
 //#endregion
 //#region src/synthesizer/audio_engine/channel/parameters/system.ts
 const DEFAULT_CHANNEL_SYSTEM_PARAMETERS = {
@@ -13137,13 +13568,6 @@ var MIDIChannel = class {
 	*/
 	pitchWheels = new Int16Array(128).fill(8192);
 	/**
-	* An array indicating if a controller, at the equivalent index in the midiControllers array, is locked
-	* (i.e., not allowed changing).
-	* A locked controller cannot be modified.
-	* @internal
-	*/
-	lockedControllers = new Array(128).fill(false);
-	/**
 	* Parameters for each drum instrument.
 	* @internal
 	*/
@@ -13194,6 +13618,13 @@ var MIDIChannel = class {
 	*/
 	setSystemParameter = setSystemParameterInternal.bind(this);
 	/**
+	* Locks or unlocks a given Channel MIDI Parameter.
+	* This prevents any changes to it until it's unlocked.
+	* @param parameter The Channel MIDI Parameter to lock.
+	* @param isLocked If the parameter should be locked.
+	*/
+	lockMIDIParameter = lockMIDIParameterInternal$1.bind(this);
+	/**
 	* Sends a "MIDI Note on" message and starts a note.
 	* @param midiNote The MIDI note number (0-127).
 	* @param velocity The velocity of the note (0-127). If less than 1, it will send a note off instead.
@@ -13246,6 +13677,20 @@ var MIDIChannel = class {
 	*/
 	renderVoice = renderVoice.bind(this);
 	/**
+	* Sets a channel MIDI parameter of the synthesizer.
+	* @param parameter The type of the channel MIDI parameter to set.
+	* @param value The value to set for the channel MIDI parameter.
+	* @internal
+	*/
+	setMIDIParameter = setMIDIParameterInternal$1.bind(this);
+	/**
+	* An array indicating if a controller, at the equivalent index in the midiControllers array, is locked
+	* (i.e., not allowed changing).
+	* A locked controller cannot be modified.
+	* @internal
+	*/
+	lockedControllers = new Array(128).fill(false);
+	/**
 	* 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.
@@ -13274,6 +13719,13 @@ var MIDIChannel = class {
 	* @internal
 	*/
 	dataEntry = dataEntry.bind(this);
+	/**
+	* An object indicating if a Channel MIDI parameter, at the equivalent key, is locked
+	* (i.e., not allowed changing).
+	* A locked parameter cannot be modified.
+	* @internal
+	*/
+	lockedMIDIParameters = Object.fromEntries(Object.keys(DEFAULT_CHANNEL_MIDI_PARAMETERS).map((key) => [key, false]));
 	_midiParameters = { ...DEFAULT_CHANNEL_MIDI_PARAMETERS };
 	/**
 	* All system parameters of this channel.
@@ -13281,6 +13733,20 @@ var MIDIChannel = class {
 	*/
 	_systemParameters = { ...DEFAULT_CHANNEL_SYSTEM_PARAMETERS };
 	/**
+	* Note On message tracking, for grouping voices for specific Note On messages.
+	* Used for overlapping Note Ons.
+	* MIDI note: current note on ID
+	* @protected
+	*/
+	noteOnID = new Array(128).fill(0);
+	/**
+	* Note Off message tracking, for grouping voices for specific Note On messages.
+	* Used for overlapping Note Ons.
+	* MIDI note: current note on ID
+	* @protected
+	*/
+	noteOffID = new Array(128).fill(0);
+	/**
 	* If the last Parameter was RPN.
 	* If false then the last parameter was NRPN.
 	* @protected
@@ -13315,21 +13781,39 @@ var MIDIChannel = class {
 	*/
 	currentGain = 0;
 	/**
-	* The last pressed note on this channel.
+	* The last pressed note on this channel for portamento tracking.
 	* -1 means none.
 	* This is not a `ChannelMIDIParameter` and is strictly internal,
 	* mostly because we don't want to send events for every note on message.
 	* It can be set with Portamento Control CC anyway.
 	* @protected
 	*/
-	lastNote = -1;
+	lastPortamentoNote = -1;
 	/**
 	* If the portamento should be executed once regardless of Portamento on/off.
 	* Adhering to the MIDI spec, CC#84 ignores on/off.
-	* This is also not a `ChannelMIDIParameter` for the same reason as `lastNote`
+	* This is also not a `ChannelMIDIParameter` for the same reason as `lastPortamentoNote`
 	* @protected
 	*/
 	portamentoForce = false;
+	/**
+	* The last pressed note on this channel in mono mode.
+	* Used for tracking and releasing this note on a new Note On event.
+	* -1 means none.
+	* @protected
+	*/
+	lastMonoNote = -1;
+	/**
+	* The last pressed note's velocity on this channel in mono mode.
+	* @protected
+	*/
+	lastMonoVelocity = 0;
+	/**
+	* For Mono Mode restoring notes.
+	* playingNotes[midiNote]
+	* @protected
+	*/
+	playingNotes = new Array(128).fill(false);
 	generators = {
 		offsets: new Int16Array(GENERATORS_AMOUNT),
 		offsetsEnabled: false,
@@ -13442,6 +13926,9 @@ var MIDIChannel = class {
 	* @param force If true, stops all notes immediately, otherwise applies release time.
 	*/
 	stopAllNotes(force = false) {
+		this.noteOnID.fill(0);
+		this.noteOffID.fill(0);
+		this.playingNotes.fill(false);
 		if (force) {
 			let vc = 0;
 			if (this._voiceCount > 0) {
@@ -13466,29 +13953,6 @@ var MIDIChannel = class {
 		});
 	}
 	/**
-	* Sets a channel MIDI parameter of the synthesizer.
-	* @param parameter The type of the channel MIDI parameter to set.
-	* @param value The value to set for the channel MIDI parameter.
-	* @internal
-	*/
-	setMIDIParameter(parameter, value) {
-		this._midiParameters[parameter] = value;
-		switch (parameter) {
-			case "pitchWheel":
-				this.computeModulatorsAll(0, ModulatorControllerSources.pitchWheel);
-				break;
-			case "pressure":
-				this.computeModulatorsAll(0, ModulatorControllerSources.channelPressure);
-				break;
-		}
-		this.updateInternalParams();
-		this.synthCore.callEvent("channelParamChange", {
-			channel: this.channel,
-			parameter,
-			value
-		});
-	}
-	/**
 	* @internal
 	*/
 	clearVoiceCount() {
@@ -13506,49 +13970,6 @@ var MIDIChannel = class {
 		for (let i = 0; i < 128; i++) this.octaveTuning[i] = tuning[i % 12];
 	}
 	/**
-	* Sets the modulation depth for the channel.
-	* @param cents The modulation depth in cents to set.
-	* @param log If true, logs the change to the console.
-	* @remarks
-	* This method sets the modulation depth for the channel by converting the given cents value into a
-	* multiplier. The MIDI specification assumes the default modulation depth is 50 cents,
-	* but it may vary for different sound banks.
-	* For example, if you want a modulation depth of 100 cents,
-	* the multiplier will be 2,
-	* which, for a preset with a depth of 50,
-	* will create a total modulation depth of 100 cents.
-	* @internal
-	*/
-	modulationDepth(cents, log = true) {
-		this.setMIDIParameter("modulationDepth", cents / 50);
-		if (!log) return;
-		SpessaLog.info(`%cChannel ${this.channel} modulation depth. Cents: %c${Math.round(cents)}`, ConsoleColors.info, ConsoleColors.value);
-	}
-	/**
-	* Sets the channel's key shift (MIDI).
-	* @param shift the key shift.
-	* @param log If true, logs the change to the console.
-	* @internal
-	*/
-	keyShift(shift, log = true) {
-		if (this._drumChannel) shift = 0;
-		if (this._midiParameters.keyShift === shift) return;
-		this.setMIDIParameter("keyShift", shift);
-		if (!log) return;
-		SpessaLog.info(`%cKey shift for %c${this.channel}%c is now set to %c${shift}.`, ConsoleColors.info, ConsoleColors.recognized, ConsoleColors.info, ConsoleColors.value);
-	}
-	/**
-	* Sets the channel's tuning.
-	* @param cents The tuning in cents to set.
-	* @param log If true, logs the change to the console.
-	* @internal
-	*/
-	fineTune(cents, log = true) {
-		this.setMIDIParameter("fineTune", cents);
-		if (!log) return;
-		SpessaLog.info(`%cFine tuning for %c${this.channel}%c is now set to %c${Math.round(cents)}%c cents.`, ConsoleColors.info, ConsoleColors.recognized, ConsoleColors.info, ConsoleColors.value, ConsoleColors.info);
-	}
-	/**
 	* Sets the pitch of the given channel.
 	* @param pitch The pitch (0 - 16383)
 	* @param midiNote The MIDI note number, pass -1 for the regular pitch wheel
@@ -13588,17 +14009,6 @@ var MIDIChannel = class {
 		});
 	}
 	/**
-	* Sets the pitch wheel range for this channel.
-	* @param range range in semitones.
-	* @param log If true, logs the change to the console.
-	* @internal
-	*/
-	pitchWheelRange(range, log = true) {
-		this.setMIDIParameter("pitchWheelRange", range);
-		if (!log) return;
-		SpessaLog.coolInfo(`Pitch Wheel Range for ${this.channel}`, range, "semitones");
-	}
-	/**
 	* @internal
 	*/
 	updateInternalParams() {
@@ -13644,6 +14054,8 @@ var MIDIChannel = class {
 	*/
 	killNote(midiNote, releaseTime = -12e3) {
 		let vc = 0;
+		this.noteOffID[midiNote] = 0;
+		this.noteOnID[midiNote] = 0;
 		if (this._voiceCount > 0) {
 			for (const v of this.synthCore.voices) if (v.channel === this.channel && v.isActive && v.midiNote === midiNote) {
 				v.overrideReleaseVolEnv = releaseTime;
@@ -13674,7 +14086,7 @@ var MIDIChannel = class {
 	* @param midiNote
 	*/
 	setLastNote(midiNote) {
-		this.lastNote = midiNote;
+		this.lastPortamentoNote = midiNote;
 	}
 	/**
 	* @internal
@@ -13757,7 +14169,7 @@ var MIDIChannel = class {
 	setDrumFlag(isDrum) {
 		if (this._systemParameters.presetLock || !this.preset || this._drumChannel === isDrum) return;
 		this._drumChannel = isDrum;
-		this.keyShift(this._midiParameters.keyShift, false);
+		this.updateInternalParams();
 	}
 };
 //#endregion
@@ -13918,7 +14330,8 @@ function universalSystemExclusive(syx, channelOffset = 0) {
 					break;
 				case 1: {
 					const vol = syx[5] << 7 | syx[4];
-					this.setMIDIParameter("gain", vol / 16384);
+					const gain = Math.pow(vol / 16383, 2);
+					this.setMIDIParameter("gain", gain);
 					SpessaLog.gmInfo("Master Volume", vol);
 					break;
 				}
@@ -13929,7 +14342,7 @@ function universalSystemExclusive(syx, channelOffset = 0) {
 					break;
 				}
 				case 3: {
-					const cents = ((syx[5] << 7 | syx[6]) - 8192) / 81.92;
+					const cents = ((syx[5] << 7 | syx[4]) - 8192) / 81.92;
 					this.setMIDIParameter("fineTune", cents);
 					SpessaLog.gmInfo("Master Fine Tuning", cents, "cents");
 					break;
@@ -14100,6 +14513,7 @@ function rolandSystemExclusive(syx, channelOffset = 0) {
 						}
 						case 4:
 							SpessaLog.gsInfo("Master Volume", data);
+							this.setMIDIParameter("gain", data / 127);
 							break;
 						case 5: {
 							const transpose = data - 64;
@@ -14107,10 +14521,12 @@ function rolandSystemExclusive(syx, channelOffset = 0) {
 							this.setMIDIParameter("keyShift", transpose);
 							break;
 						}
-						case 6:
-							SpessaLog.gsInfo("Master Pan", data);
-							this.setMIDIParameter("pan", (data - 64) / 64);
+						case 6: {
+							const pan = (data - 64) / 63;
+							SpessaLog.gsInfo("Master Pan", pan);
+							this.setMIDIParameter("pan", pan);
 							break;
+						}
 						case 127:
 							if (data === 0) {
 								SpessaLog.coolInfo("MIDI System", "Roland GS");
@@ -14141,6 +14557,7 @@ function rolandSystemExclusive(syx, channelOffset = 0) {
 						case 0: {
 							const patchName = readBinaryString(syx, 16, 7);
 							SpessaLog.gsInfo("Patch name", patchName);
+							this.callEvent("displayMessage", [...syx]);
 							break;
 						}
 						case 48:
@@ -14476,12 +14893,21 @@ function rolandSystemExclusive(syx, channelOffset = 0) {
 						}
 						case 22: {
 							const keyShift = data - 64;
-							ch.keyShift(keyShift);
+							ch.setMIDIParameter("keyShift", keyShift);
+							SpessaLog.gsInfo(`Key Shift for ${channel}`, keyShift);
 							return;
 						}
 						case 25:
 							ch.controllerChange(MIDIControllers.mainVolume, data);
 							return;
+						case 26:
+							ch.setMIDIParameter("velocitySenseDepth", data);
+							SpessaLog.gsInfo(`Velocity Sense Depth for ${channel}`, data);
+							return;
+						case 27:
+							ch.setMIDIParameter("velocitySenseOffset", data);
+							SpessaLog.gsInfo(`Velocity Sense Offset for ${channel}`, data);
+							return;
 						case 28: {
 							const panPosition = data;
 							const randomPan = panPosition === 0;
@@ -14492,11 +14918,11 @@ function rolandSystemExclusive(syx, channelOffset = 0) {
 						}
 						case 31:
 							ch.setMIDIParameter("cc1", data);
-							SpessaLog.gsInfo("CC1 Controller Number", data);
+							SpessaLog.gsInfo(`CC1 Controller Number for ${channel}`, data);
 							break;
 						case 32:
 							ch.setMIDIParameter("cc2", data);
-							SpessaLog.gsInfo("CC2 Controller Number", data);
+							SpessaLog.gsInfo(`CC2 Controller Number for ${channel}`, data);
 							break;
 						case 33:
 							ch.controllerChange(MIDIControllers.chorusDepth, data);
@@ -14505,8 +14931,9 @@ function rolandSystemExclusive(syx, channelOffset = 0) {
 							ch.controllerChange(MIDIControllers.reverbDepth, data);
 							break;
 						case 42: {
-							const tuneCents = ((data << 7 | syx[8]) - 8192) / 81.92;
-							ch.fineTune(tuneCents);
+							const cents = ((data << 7 | syx[8]) - 8192) / 81.92;
+							ch.setMIDIParameter("fineTune", cents);
+							SpessaLog.gsInfo(`Fine tuning for ${channel}`, Math.round(cents), "cents");
 							break;
 						}
 						case 44:
@@ -14541,7 +14968,7 @@ function rolandSystemExclusive(syx, channelOffset = 0) {
 							const newTuning = new Int8Array(12);
 							for (let i = 0; i < tuningBytes; i++) newTuning[i] = syx[i + 7] - 64;
 							ch.setOctaveTuning(newTuning);
-							SpessaLog.gsInfo(`Octave Scale Tuning on ${channel}`, newTuning.join(", "));
+							SpessaLog.gsInfo(`Octave Scale Tuning for ${channel}`, newTuning.join(", "));
 							break;
 						}
 					}
@@ -14557,7 +14984,8 @@ function rolandSystemExclusive(syx, channelOffset = 0) {
 						case 0:
 							if ((a3 & 15) === 4) {
 								const cents = data / 127 * 600;
-								ch.modulationDepth(cents);
+								ch.setMIDIParameter("modulationDepth", cents);
+								SpessaLog.gsInfo(`Modulation depth for ${channel}`, Math.round(cents), "cents");
 								break;
 							}
 							ch.dynamicModulators.setupReceiver(a3, data, MIDIControllers.modulationWheel, true, "mod wheel");
@@ -14565,7 +14993,8 @@ function rolandSystemExclusive(syx, channelOffset = 0) {
 						case 16:
 							if ((a3 & 15) === 0) {
 								const centeredValue = data - 64;
-								ch.pitchWheelRange(centeredValue);
+								ch.setMIDIParameter("pitchWheelRange", centeredValue);
+								SpessaLog.gsInfo(`Pitch Wheel Range for ${channel}`, centeredValue, "semitones");
 								break;
 							}
 							ch.dynamicModulators.setupReceiver(a3, data, ModulatorControllerSources.pitchWheel, false, "pitch wheel", true);
@@ -14595,7 +15024,6 @@ function rolandSystemExclusive(syx, channelOffset = 0) {
 							ch.controllerChange(MIDIControllers.bankSelectLSB, data);
 							break;
 						case 34: {
-							if (this.systemParameters.insertionEffectLock) return;
 							const efx = data === 1;
 							ch.setMIDIParameter("efxAssign", efx);
 							this.insertionActive ||= efx;
@@ -14805,12 +15233,21 @@ function yamahaSystemExclusive(syx, channelOffset = 0) {
 				}
 				case 8: {
 					const keyShift = data - 64;
-					ch.keyShift(keyShift);
+					ch.setMIDIParameter("keyShift", keyShift);
+					SpessaLog.xgInfo(`Key Shift on ${channel}`, keyShift);
 					break;
 				}
 				case 11:
 					ch.controllerChange(MIDIControllers.mainVolume, data);
 					break;
+				case 12:
+					ch.setMIDIParameter("velocitySenseDepth", data);
+					SpessaLog.xgInfo(`Velocity Sense Depth on ${channel}`, data);
+					return;
+				case 13:
+					ch.setMIDIParameter("velocitySenseOffset", data);
+					SpessaLog.xgInfo(`Velocity Sense Offset on ${channel}`, data);
+					return;
 				case 14: {
 					const pan = data;
 					const randomPan = pan === 0;
@@ -14851,7 +15288,8 @@ function yamahaSystemExclusive(syx, channelOffset = 0) {
 					break;
 				case 35: {
 					const centeredValue = data - 64;
-					ch.pitchWheelRange(centeredValue);
+					ch.setMIDIParameter("pitchWheelRange", centeredValue);
+					SpessaLog.xgInfo(`Pitch Wheel Range for ${channel}`, centeredValue, "semitones");
 				}
 			}
 			return;
@@ -19314,6 +19752,7 @@ const DEFAULT_GLOBAL_MIDI_PARAMETERS = {
 * @param value The value to set for the global MIDI parameter.
 */
 function setMIDIParameterInternal(parameter, value) {
+	if (this.lockedMIDIParameters[parameter]) return;
 	this.midiParameters[parameter] = value;
 	for (const ch of this.midiChannels) ch.updateInternalParams();
 	this.callEvent("globalParamChange", {
@@ -19322,15 +19761,13 @@ function setMIDIParameterInternal(parameter, value) {
 	});
 }
 /**
-* Resets all global MIDI parameters to their default values.
-* @param system the MIDI system to set when resetting.
+* Locks or unlocks a given Global MIDI Parameter.
+* This prevents any changes to it until it's unlocked.
+* @param parameter The Global MIDI Parameter to lock.
+* @param isLocked If the parameter should be locked.
 */
-function resetMIDIParametersInternal(system) {
-	this.setMIDIParameter("gain", 1);
-	this.setMIDIParameter("pan", 0);
-	this.setMIDIParameter("keyShift", 0);
-	this.setMIDIParameter("fineTune", 0);
-	this.setMIDIParameter("system", system);
+function lockMIDIParameterInternal(parameter, isLocked) {
+	this.lockedMIDIParameters[parameter] = isLocked;
 }
 //#endregion
 //#region src/synthesizer/audio_engine/synthesizer_core.ts
@@ -19396,6 +19833,13 @@ var SynthesizerCore = class {
 	*/
 	tunings = new Float32Array(16384).fill(-1);
 	/**
+	* An object indicating if a Global MIDI parameter, at the equivalent key, is locked
+	* (i.e., not allowed changing).
+	* A locked parameter cannot be modified.
+	* @internal
+	*/
+	lockedMIDIParameters = Object.fromEntries(Object.keys(DEFAULT_GLOBAL_MIDI_PARAMETERS).map((key) => [key, false]));
+	/**
 	* The global MIDI parameters of the synthesizer.
 	*/
 	midiParameters = { ...DEFAULT_GLOBAL_MIDI_PARAMETERS };
@@ -19436,6 +19880,13 @@ var SynthesizerCore = class {
 	*/
 	cachedVoices = /* @__PURE__ */ new Map();
 	/**
+	* Locks or unlocks a given Global MIDI Parameter.
+	* This prevents any changes to it until it's unlocked.
+	* @param parameter The Global MIDI Parameter to lock.
+	* @param isLocked If the parameter should be locked.
+	*/
+	lockMIDIParameter = lockMIDIParameterInternal.bind(this);
+	/**
 	* Sets a system parameter of the synthesizer.
 	* @param type The type of the system parameter to set.
 	* @param value The value to set for the system parameter.
@@ -19465,7 +19916,6 @@ var SynthesizerCore = class {
 	* @param value The value to set for the global MIDI parameter.
 	*/
 	setMIDIParameter = setMIDIParameterInternal.bind(this);
-	resetMIDIParameters = resetMIDIParametersInternal.bind(this);
 	/**
 	* The fallback processor when the requested insertion is not available.
 	*/
@@ -19683,10 +20133,15 @@ var SynthesizerCore = class {
 	* Executes a full system reset of the synthesizer.
 	* This will reset all controllers to their default values,
 	* except for the locked controllers.
+	* @param system The MIDI system to reset the synthesizer to. Defaults to `gs`.
 	*/
 	reset(system = "gs") {
 		this.callEvent("reset", system);
-		this.resetMIDIParameters(system);
+		this.setMIDIParameter("system", system);
+		this.setMIDIParameter("gain", 1);
+		this.setMIDIParameter("pan", 0);
+		this.setMIDIParameter("keyShift", 0);
+		this.setMIDIParameter("fineTune", 0);
 		this.tunings.fill(-1);
 		this.portSelectChannelOffset = 0;
 		this.customChannelNumbers = false;
@@ -19702,7 +20157,7 @@ var SynthesizerCore = class {
 		this.processSplit([[left, right]], left, right, startIndex, sampleCount);
 	}
 	/**
-	* The main rendering pipeline, renders all voices the processes the effects:
+	* The main rendering pipeline, renders all voices and processes the effects:
 	* ```
 	*                   ┌────────────────────────────────┐
 	*                   │        Voice Processor         │
@@ -19820,8 +20275,7 @@ var SynthesizerCore = class {
 	getInsertionSnapshot() {
 		return {
 			type: this.insertionProcessor.type,
-			params: this.insertionParams.slice(),
-			channels: this.midiChannels.map((c) => c.midiParameters.efxAssign)
+			params: this.insertionParams.slice()
 		};
 	}
 	resetInsertionParams() {
@@ -20353,7 +20807,7 @@ var SpessaSynthProcessor = class {
 	*/
 	synthCore;
 	/**
-	* Tor applying the snapshot after an override sound bank too.
+	* For applying the snapshot after an override sound bank too.
 	*/
 	savedSnapshot;
 	/**
@@ -20456,12 +20910,21 @@ var SpessaSynthProcessor = class {
 		SpessaLog.warn(`No preset found for ${MIDIPatchTools.toMIDIString(patch)}! Did you forget to add a sound bank?`);
 	};
 	/**
+	* Locks or unlocks a given Global MIDI Parameter.
+	* This prevents any changes to it until it's unlocked.
+	* @param parameter The Global MIDI Parameter to lock.
+	* @param isLocked If the parameter should be locked.
+	*/
+	lockMIDIParameter(parameter, isLocked) {
+		this.synthCore.lockMIDIParameter(parameter, isLocked);
+	}
+	/**
 	* Sets a system parameter of the synthesizer.
-	* @param type The type of the system parameter to set.
+	* @param parameter The type of the system parameter to set.
 	* @param value The value to set for the system parameter.
 	*/
-	setSystemParameter(type, value) {
-		this.synthCore.setSystemParameter(type, value);
+	setSystemParameter(parameter, value) {
+		this.synthCore.setSystemParameter(parameter, value);
 	}
 	/**
 	* Executes a full synthesizer reset.