spessasynth_core 4.2.9 → 4.2.11

package/dist/index.d.ts

@@ -362,6 +362,10 @@ declare class VolumeEnvelope {
    * The sample rate in Hz.
    */
   readonly sampleRate: number;
+  /**
+   * The target gain for the current rendering block.
+   */
+  outputGain: number;
   /**
    * The current attenuation of the envelope in cB.
    */
@@ -425,21 +429,10 @@ declare class VolumeEnvelope {
    * We can't do that with modulated as it can silence the volume and then raise it again, and the voice must keep playing.
    */
   private canEndOnSilentSustain;
-  private readonly gainSmoothing;
-  private currentGain;
   /**
    * @param sampleRate Hz
    */
   constructor(sampleRate: number);
-  /**
-   * Applies volume envelope gain to the given output buffer.
-   * Essentially we use approach of 100dB is silence, 0dB is peak.
-   * @param sampleCount the amount of samples to write
-   * @param buffer the audio buffer to modify
-   * @param gainTarget the gain target to smooth.
-   * @returns if the voice is still active
-   */
-  process(sampleCount: number, buffer: Float32Array, gainTarget: number): boolean;
   /**
    * Starts the release phase in the envelope.
    * @param voice the voice this envelope belongs to.
@@ -450,13 +443,15 @@ declare class VolumeEnvelope {
    * @param voice The voice this envelope belongs to
    */
   init(voice: Voice): void;
+  /**
+   * Calculates the gain value for the last sample in the block and writes it to `outputGain`.
+   * Essentially we use approach of 100dB is silence, 0dB is peak.
+   * @param sampleCount the amount of samples to write
+   * @param gainTarget the gain to apply.
+   * @returns if the voice has finished.
+   */
+  process(sampleCount: number, gainTarget: number): boolean;
   private timecentsToSamples;
-  private releasePhase;
-  private delayPhase;
-  private attackPhase;
-  private holdPhase;
-  private decayPhase;
-  private sustainPhase;
 }
 //#endregion
 //#region src/synthesizer/audio_engine/engine_components/dsp_chain/modulation_envelope.d.ts

package/dist/index.js

@@ -1650,8 +1650,13 @@ function getUsedProgramsAndKeys(mid, soundBank) {
 	const usedProgramsAndKeys = /* @__PURE__ */ new Map();
 	const ports = mid.tracks.map((t) => t.port);
 	mid.iterate((event, trackNum) => {
-		if (event.statusByte === midiMessageTypes.midiPort) {
-			ports[trackNum] = event.data[0];
+		if (event.statusByte === midiMessageTypes.midiPort && mid.tracks[trackNum].channels.size > 0) {
+			let port = event.data[0];
+			if (mid.portChannelOffsetMap[port] === void 0) {
+				SpessaSynthWarn(`Invalid port ${port} on track ${trackNum}. (No offset found in the MIDI map.`);
+				port = 0;
+			}
+			ports[trackNum] = port;
 			return;
 		}
 		const status = event.statusByte & 240;
@@ -3599,13 +3604,15 @@ function processEventInternal(event, trackIndex) {
 		case midiMessageTypes.systemExclusive:
 			this.synth.systemExclusive(event.data, offset);
 			break;
-		case midiMessageTypes.setTempo:
-			this.oneTickToSeconds = 60 / (6e7 / readBigEndian(event.data, 3) * this._midiData.timeDivision);
+		case midiMessageTypes.setTempo: {
+			const tempoBPM = 6e7 / readBigEndian(event.data, 3);
+			this.oneTickToSeconds = 60 / (tempoBPM * this._midiData.timeDivision);
 			if (this.oneTickToSeconds === 0) {
 				this.oneTickToSeconds = 60 / (120 * this._midiData.timeDivision);
 				SpessaSynthInfo("invalid tempo! falling back to 120 BPM");
 			}
 			break;
+		}
 		case midiMessageTypes.timeSignature:
 		case midiMessageTypes.endOfTrack:
 		case midiMessageTypes.midiChannelPrefix:
@@ -4455,11 +4462,13 @@ function setTimeToInternal(time, ticks = void 0) {
 				}
 				break;
 			}
-			case midiMessageTypes.setTempo:
-				this.oneTickToSeconds = 60 / (6e7 / readBigEndian(event.data, 3) * this._midiData.timeDivision);
+			case midiMessageTypes.setTempo: {
+				const tempoBPM = 6e7 / readBigEndian(event.data, 3);
+				this.oneTickToSeconds = 60 / (tempoBPM * this._midiData.timeDivision);
 				savedTempo = event;
 				savedTempoTrack = trackIndex;
 				break;
+			}
 			default:
 				this.processEvent(event, trackIndex);
 				break;
@@ -4875,7 +4884,8 @@ var SpessaSynthSequencer = class {
 			const idx = track.events.findIndex((e) => e.ticks >= targetTicks);
 			this.eventIndexes.push(idx === -1 ? track.events.length : idx);
 		}
-		this.oneTickToSeconds = 60 / (this._midiData.tempoChanges.find((t) => t.ticks <= targetTicks).tempo * this._midiData.timeDivision);
+		const targetTempo = this._midiData.tempoChanges.find((t) => t.ticks <= targetTicks);
+		this.oneTickToSeconds = 60 / (targetTempo.tempo * this._midiData.timeDivision);
 	}
 	sendMIDINoteOn(channel, midiNote, velocity) {
 		if (!this.externalMIDIPlayback) {
@@ -6043,13 +6053,16 @@ var LowpassFilter = class LowpassFilter {
 */
 const CB_SILENCE = 960;
 const PERCEIVED_CB_SILENCE = 900;
-const GAIN_SMOOTHING_FACTOR$1 = .01;
 var VolumeEnvelope = class {
 	/**
 	* The sample rate in Hz.
 	*/
 	sampleRate;
 	/**
+	* The target gain for the current rendering block.
+	*/
+	outputGain = 0;
+	/**
 	* The current attenuation of the envelope in cB.
 	*/
 	attenuationCb = CB_SILENCE;
@@ -6112,32 +6125,11 @@ var VolumeEnvelope = class {
 	* We can't do that with modulated as it can silence the volume and then raise it again, and the voice must keep playing.
 	*/
 	canEndOnSilentSustain = false;
-	gainSmoothing;
-	currentGain = 0;
 	/**
 	* @param sampleRate Hz
 	*/
 	constructor(sampleRate) {
 		this.sampleRate = sampleRate;
-		this.gainSmoothing = GAIN_SMOOTHING_FACTOR$1 * (44100 / sampleRate);
-	}
-	/**
-	* Applies volume envelope gain to the given output buffer.
-	* Essentially we use approach of 100dB is silence, 0dB is peak.
-	* @param sampleCount the amount of samples to write
-	* @param buffer the audio buffer to modify
-	* @param gainTarget the gain target to smooth.
-	* @returns if the voice is still active
-	*/
-	process(sampleCount, buffer, gainTarget) {
-		if (this.enteredRelease) return this.releasePhase(sampleCount, buffer, gainTarget);
-		switch (this.state) {
-			case 0: return this.delayPhase(sampleCount, buffer, gainTarget, 0);
-			case 1: return this.attackPhase(sampleCount, buffer, gainTarget, 0);
-			case 2: return this.holdPhase(sampleCount, buffer, gainTarget, 0);
-			case 3: return this.decayPhase(sampleCount, buffer, gainTarget, 0);
-			case 4: return this.sustainPhase(sampleCount, buffer, gainTarget, 0);
-		}
 	}
 	/**
 	* Starts the release phase in the envelope.
@@ -6189,7 +6181,7 @@ var VolumeEnvelope = class {
 		this.state = 0;
 		this.sampleTime = 0;
 		this.canEndOnSilentSustain = voice.modulatedGenerators[generatorTypes.sustainVolEnv] >= PERCEIVED_CB_SILENCE;
-		this.currentGain = CENTIBEL_LOOKUP_TABLE[voice.modulatedGenerators[generatorTypes.initialAttenuation] - MIN_CENTIBELS | 0];
+		this.outputGain = 0;
 		this.sustainCb = Math.min(CB_SILENCE, voice.modulatedGenerators[generatorTypes.sustainVolEnv]);
 		this.attackDuration = this.timecentsToSamples(voice.modulatedGenerators[generatorTypes.attackVolEnv]);
 		const keyNumAddition = (60 - voice.targetKey) * voice.modulatedGenerators[generatorTypes.keyNumToVolEnvDecay];
@@ -6202,132 +6194,66 @@ var VolumeEnvelope = class {
 		this.decayEnd = this.decayDuration + this.holdEnd;
 		if (this.attackEnd === 0) this.state = 2;
 	}
-	timecentsToSamples(tc) {
-		return Math.max(0, Math.floor(timecentsToSeconds(tc) * this.sampleRate));
-	}
-	releasePhase(sampleCount, buffer, gainTarget) {
-		let { sampleTime, currentGain, attenuationCb } = this;
-		const { releaseStartTimeSamples, releaseStartCb, releaseDuration, gainSmoothing } = this;
-		let elapsedRelease = sampleTime - releaseStartTimeSamples;
-		const cbDifference = CB_SILENCE - releaseStartCb;
-		const smooth = currentGain !== gainTarget;
-		for (let i = 0; i < sampleCount; i++) {
-			if (smooth) currentGain += (gainTarget - currentGain) * gainSmoothing;
-			attenuationCb = elapsedRelease / releaseDuration * cbDifference + releaseStartCb;
-			buffer[i] *= CENTIBEL_LOOKUP_TABLE[attenuationCb - MIN_CENTIBELS | 0] * currentGain;
-			sampleTime++;
-			elapsedRelease++;
-		}
-		this.sampleTime = sampleTime;
-		this.currentGain = currentGain;
-		this.attenuationCb = attenuationCb;
-		return attenuationCb < PERCEIVED_CB_SILENCE;
-	}
-	delayPhase(sampleCount, buffer, gainTarget, filledBuffer) {
-		const { delayEnd } = this;
-		let { sampleTime } = this;
-		if (sampleTime < delayEnd) {
-			this.attenuationCb = CB_SILENCE;
-			const delaySamples = Math.min(delayEnd - sampleTime, sampleCount);
-			buffer.fill(0, filledBuffer, filledBuffer + delaySamples);
-			filledBuffer += delaySamples;
-			sampleTime += delaySamples;
-			if (filledBuffer >= sampleCount) {
-				this.sampleTime = sampleTime;
-				return true;
-			}
+	/**
+	* Calculates the gain value for the last sample in the block and writes it to `outputGain`.
+	* Essentially we use approach of 100dB is silence, 0dB is peak.
+	* @param sampleCount the amount of samples to write
+	* @param gainTarget the gain to apply.
+	* @returns if the voice has finished.
+	*/
+	process(sampleCount, gainTarget) {
+		const { releaseStartTimeSamples, releaseStartCb, releaseDuration, delayEnd, attackEnd, attackDuration, holdEnd, decayEnd, decayDuration, sustainCb } = this;
+		const sampleTime = this.sampleTime += sampleCount;
+		if (this.enteredRelease) {
+			const elapsedRelease = sampleTime - releaseStartTimeSamples;
+			const cbDifference = CB_SILENCE - releaseStartCb;
+			this.attenuationCb = elapsedRelease / releaseDuration * cbDifference + releaseStartCb;
+			this.outputGain = CENTIBEL_LOOKUP_TABLE[this.attenuationCb - MIN_CENTIBELS | 0] * gainTarget;
+			return this.attenuationCb < PERCEIVED_CB_SILENCE;
 		}
-		this.sampleTime = sampleTime;
-		this.state++;
-		return this.attackPhase(sampleCount, buffer, gainTarget, filledBuffer);
-	}
-	attackPhase(sampleCount, buffer, gainTarget, filledBuffer) {
-		const { attackEnd, attackDuration, gainSmoothing } = this;
-		let { sampleTime, currentGain } = this;
-		const smooth = currentGain !== gainTarget;
-		if (sampleTime < attackEnd) {
-			this.attenuationCb = 0;
-			while (sampleTime < attackEnd) {
-				if (smooth) currentGain += (gainTarget - currentGain) * gainSmoothing;
-				const linearGain = 1 - (attackEnd - sampleTime) / attackDuration;
-				buffer[filledBuffer] *= linearGain * currentGain;
-				sampleTime++;
-				if (++filledBuffer >= sampleCount) {
-					this.sampleTime = sampleTime;
-					this.currentGain = currentGain;
+		switch (this.state) {
+			case 0:
+				if (sampleTime < delayEnd) {
+					this.attenuationCb = CB_SILENCE;
+					this.outputGain = 0;
 					return true;
 				}
-			}
-		}
-		this.sampleTime = sampleTime;
-		this.currentGain = currentGain;
-		this.state++;
-		return this.holdPhase(sampleCount, buffer, gainTarget, filledBuffer);
-	}
-	holdPhase(sampleCount, buffer, gainTarget, filledBuffer) {
-		const { holdEnd, gainSmoothing } = this;
-		let { sampleTime, currentGain } = this;
-		const smooth = currentGain !== gainTarget;
-		if (sampleTime < holdEnd) {
-			this.attenuationCb = 0;
-			while (sampleTime < holdEnd) {
-				if (smooth) currentGain += (gainTarget - currentGain) * gainSmoothing;
-				buffer[filledBuffer] *= currentGain;
-				sampleTime++;
-				if (++filledBuffer >= sampleCount) {
-					this.sampleTime = sampleTime;
-					this.currentGain = currentGain;
+				this.state++;
+			case 1:
+				if (sampleTime < attackEnd) {
+					this.attenuationCb = 0;
+					const linearGain = 1 - (attackEnd - sampleTime) / attackDuration;
+					this.outputGain = linearGain * gainTarget;
 					return true;
 				}
-			}
-		}
-		this.sampleTime = sampleTime;
-		this.currentGain = currentGain;
-		this.state++;
-		return this.decayPhase(sampleCount, buffer, gainTarget, filledBuffer);
-	}
-	decayPhase(sampleCount, buffer, gainTarget, filledBuffer) {
-		const { decayDuration, decayEnd, gainSmoothing, sustainCb } = this;
-		let { sampleTime, currentGain, attenuationCb } = this;
-		const smooth = currentGain !== gainTarget;
-		if (sampleTime < decayEnd) while (sampleTime < decayEnd) {
-			if (smooth) currentGain += (gainTarget - currentGain) * gainSmoothing;
-			attenuationCb = (1 - (decayEnd - sampleTime) / decayDuration) * sustainCb;
-			buffer[filledBuffer] *= currentGain * CENTIBEL_LOOKUP_TABLE[attenuationCb - MIN_CENTIBELS | 0];
-			sampleTime++;
-			if (++filledBuffer >= sampleCount) {
-				this.sampleTime = sampleTime;
-				this.currentGain = currentGain;
-				this.attenuationCb = attenuationCb;
+				this.state++;
+			case 2:
+				if (sampleTime < holdEnd) {
+					this.attenuationCb = 0;
+					this.outputGain = gainTarget;
+					return true;
+				}
+				this.state++;
+			case 3:
+				if (sampleTime < decayEnd) {
+					this.attenuationCb = (1 - (decayEnd - sampleTime) / decayDuration) * sustainCb;
+					this.outputGain = gainTarget * CENTIBEL_LOOKUP_TABLE[this.attenuationCb - MIN_CENTIBELS | 0];
+					return true;
+				}
+				this.state++;
+			case 4:
+				if (this.canEndOnSilentSustain && sustainCb >= PERCEIVED_CB_SILENCE) {
+					this.attenuationCb = CB_SILENCE;
+					this.outputGain = 0;
+					return false;
+				}
+				this.attenuationCb = sustainCb;
+				this.outputGain = gainTarget * CENTIBEL_LOOKUP_TABLE[sustainCb - MIN_CENTIBELS | 0];
 				return true;
-			}
 		}
-		this.sampleTime = sampleTime;
-		this.currentGain = currentGain;
-		this.attenuationCb = attenuationCb;
-		this.state++;
-		return this.sustainPhase(sampleCount, buffer, gainTarget, filledBuffer);
-	}
-	sustainPhase(sampleCount, buffer, gainTarget, filledBuffer) {
-		const { sustainCb, gainSmoothing } = this;
-		if (this.canEndOnSilentSustain && sustainCb >= PERCEIVED_CB_SILENCE) {
-			buffer.fill(0, filledBuffer, sampleCount);
-			return false;
-		}
-		let { sampleTime, currentGain } = this;
-		const smooth = currentGain !== gainTarget;
-		if (filledBuffer < sampleCount) {
-			this.attenuationCb = sustainCb;
-			while (filledBuffer < sampleCount) {
-				if (smooth) currentGain += (gainTarget - currentGain) * gainSmoothing;
-				buffer[filledBuffer] *= currentGain * CENTIBEL_LOOKUP_TABLE[sustainCb - MIN_CENTIBELS | 0];
-				sampleTime++;
-				filledBuffer++;
-			}
-		}
-		this.sampleTime = sampleTime;
-		this.currentGain = currentGain;
-		return true;
+	}
+	timecentsToSamples(tc) {
+		return Math.max(0, Math.floor(timecentsToSeconds(tc) * this.sampleRate));
 	}
 };
 //#endregion
@@ -6466,7 +6392,8 @@ var ModulationEnvelope = class {
 	startRelease(voice) {
 		this.releaseStartLevel = this.currentValue;
 		this.enteredRelease = true;
-		this.releaseDuration = this.tc2Sec(Math.max(voice.modulatedGenerators[generatorTypes.releaseModEnv], -7200)) * this.releaseStartLevel;
+		const releaseTime = this.tc2Sec(Math.max(voice.modulatedGenerators[generatorTypes.releaseModEnv], -7200));
+		this.releaseDuration = releaseTime * this.releaseStartLevel;
 	}
 	/**
 	* Initializes the modulation envelope.
@@ -6477,7 +6404,8 @@ var ModulationEnvelope = class {
 		this.sustainLevel = 1 - voice.modulatedGenerators[generatorTypes.sustainModEnv] / 1e3;
 		this.attackDuration = this.tc2Sec(voice.modulatedGenerators[generatorTypes.attackModEnv]);
 		const decayKeyExcursionCents = (60 - voice.midiNote) * voice.modulatedGenerators[generatorTypes.keyNumToModEnvDecay];
-		this.decayDuration = this.tc2Sec(voice.modulatedGenerators[generatorTypes.decayModEnv] + decayKeyExcursionCents) * (1 - this.sustainLevel);
+		const decayTime = this.tc2Sec(voice.modulatedGenerators[generatorTypes.decayModEnv] + decayKeyExcursionCents);
+		this.decayDuration = decayTime * (1 - this.sustainLevel);
 		const holdKeyExcursionCents = (60 - voice.midiNote) * voice.modulatedGenerators[generatorTypes.keyNumToModEnvHold];
 		this.holdDuration = this.tc2Sec(holdKeyExcursionCents + voice.modulatedGenerators[generatorTypes.holdModEnv]);
 		this.delayEnd = voice.startTime + this.tc2Sec(voice.modulatedGenerators[generatorTypes.delayModEnv]);
@@ -11386,12 +11314,15 @@ function renderVoice(voice, timeNow, outputL, outputR, startIndex, sampleCount)
 		voice.tuningRatio = Math.pow(2, centsTotal / 1200);
 	}
 	const gainTarget = cbAttenuationToGain(modulated[generatorTypes.initialAttenuation]) * cbAttenuationToGain(volumeExcursionCentibels);
-	const buffer = core.voiceBuffer;
 	if (voice.loopingMode === 2 && !voice.isInRelease) {
-		voice.isActive = voice.volEnv.process(sampleCount, buffer, gainTarget);
+		voice.isActive = voice.volEnv.process(sampleCount, gainTarget);
 		return;
 	}
+	const buffer = core.voiceBuffer;
 	voice.isActive = voice.wavetable.process(sampleCount, voice.tuningRatio, buffer);
+	let gain = voice.volEnv.outputGain;
+	const envActive = voice.volEnv.process(sampleCount, gainTarget);
+	const gainInc = (voice.volEnv.outputGain - gain) / sampleCount;
 	{
 		const f = voice.filter;
 		const initialFc = modulated[generatorTypes.initialFilterFc];
@@ -11402,8 +11333,13 @@ function renderVoice(voice, timeNow, outputL, outputR, startIndex, sampleCount)
 		}
 		const targetCutoff = f.currentInitialFc + lowpassExcursion;
 		const modulatedResonance = modulated[generatorTypes.initialFilterQ];
-		if (f.currentInitialFc > 13499 && targetCutoff > 13499 && modulatedResonance === 0) f.currentInitialFc = 13500;
-		else {
+		if (f.currentInitialFc > 13499 && targetCutoff > 13499 && modulatedResonance === 0) {
+			f.currentInitialFc = 13500;
+			for (let i = 0; i < sampleCount; i++) {
+				buffer[i] *= gain;
+				gain += gainInc;
+			}
+		} else {
 			if (Math.abs(f.lastTargetCutoff - targetCutoff) > 1 || f.resonanceCb !== modulatedResonance) {
 				f.lastTargetCutoff = targetCutoff;
 				f.resonanceCb = modulatedResonance;
@@ -11418,7 +11354,8 @@ function renderVoice(voice, timeNow, outputL, outputR, startIndex, sampleCount)
 				x1 = input;
 				y2 = y1;
 				y1 = filtered;
-				buffer[i] = filtered;
+				buffer[i] = filtered * gain;
+				gain += gainInc;
 			}
 			f.x1 = x1;
 			f.x2 = x2;
@@ -11426,7 +11363,6 @@ function renderVoice(voice, timeNow, outputL, outputR, startIndex, sampleCount)
 			f.y2 = y2;
 		}
 	}
-	const envActive = voice.volEnv.process(sampleCount, buffer, gainTarget);
 	voice.isActive = voice.isActive && envActive;
 	let pan;
 	if (voice.overridePan) pan = voice.overridePan;
@@ -11434,10 +11370,10 @@ function renderVoice(voice, timeNow, outputL, outputR, startIndex, sampleCount)
 		voice.currentPan += (modulated[generatorTypes.pan] - voice.currentPan) * core.panSmoothingFactor;
 		pan = voice.currentPan;
 	}
-	const gain = core.masterParameters.masterGain * core.midiVolume * voiceGain;
+	const outputGain = core.masterParameters.masterGain * core.midiVolume * voiceGain;
 	const index = pan + 500 | 0;
-	const gainLeft = panTableLeft$1[index] * gain * core.panLeft;
-	const gainRight = panTableRight$1[index] * gain * core.panRight;
+	const gainLeft = panTableLeft$1[index] * outputGain * core.panLeft;
+	const gainRight = panTableRight$1[index] * outputGain * core.panRight;
 	if (this.insertionEnabled) {
 		const insertionL = core.insertionInputL;
 		const insertionR = core.insertionInputR;
@@ -11457,20 +11393,20 @@ function renderVoice(voice, timeNow, outputL, outputR, startIndex, sampleCount)
 	if (!core.enableEffects) return;
 	const reverbSend = modulated[generatorTypes.reverbEffectsSend] * voice.reverbSend;
 	if (reverbSend > 0) {
-		const reverbGain = core.masterParameters.reverbGain * gain * (reverbSend / 1e3);
+		const reverbGain = core.masterParameters.reverbGain * outputGain * (reverbSend / 1e3);
 		const reverb = core.reverbInput;
 		for (let i = 0; i < sampleCount; i++) reverb[i] += reverbGain * buffer[i];
 	}
 	const chorusSend = modulated[generatorTypes.chorusEffectsSend] * voice.chorusSend;
 	if (chorusSend > 0) {
-		const chorusGain = core.masterParameters.chorusGain * (chorusSend / 1e3) * gain;
+		const chorusGain = core.masterParameters.chorusGain * (chorusSend / 1e3) * outputGain;
 		const chorus = core.chorusInput;
 		for (let i = 0; i < sampleCount; i++) chorus[i] += chorusGain * buffer[i];
 	}
 	if (core.delayActive) {
 		const delaySend = this.midiControllers[midiControllers.variationDepth] * voice.delaySend;
 		if (delaySend > 0) {
-			const delayGain = gain * core.masterParameters.delayGain * ((delaySend >> 7) / 127);
+			const delayGain = outputGain * core.masterParameters.delayGain * ((delaySend >> 7) / 127);
 			const delay = core.delayInput;
 			for (let i = 0; i < sampleCount; i++) delay[i] += delayGain * buffer[i];
 		}
@@ -11542,7 +11478,7 @@ function dataEntryCoarse(dataCoarse) {
 			switch (paramCoarse) {
 				default:
 					if (dataCoarse === 64) return;
-					SpessaSynthInfo(`%cUnrecognized NRPN for %c${this.channel}%c: %c(0x${paramFine.toString(16).toUpperCase()} 0x${paramFine.toString(16).toUpperCase()})%c data value: %c${dataCoarse}`, consoleColors.warn, consoleColors.recognized, consoleColors.warn, consoleColors.unrecognized, consoleColors.warn, consoleColors.value);
+					SpessaSynthInfo(`%cUnrecognized NRPN for %c${this.channel}%c: %c(0x${paramCoarse.toString(16).toUpperCase()} 0x${paramFine.toString(16).toUpperCase()})%c data value: %c${dataCoarse}`, consoleColors.warn, consoleColors.recognized, consoleColors.warn, consoleColors.unrecognized, consoleColors.warn, consoleColors.value);
 					break;
 				case nonRegisteredMSB.partParameter: {
 					const paramLock = this.synthCore.masterParameters.nprnParamLock;
@@ -11821,9 +11757,12 @@ function dataEntryFine(dataValue) {
 	switch (this.dataEntryState) {
 		default: break;
 		case dataEntryStates.RPCoarse:
-		case dataEntryStates.RPFine:
-			switch (this.midiControllers[midiControllers.registeredParameterMSB] | this.midiControllers[midiControllers.registeredParameterLSB] >> 7) {
-				default: break;
+		case dataEntryStates.RPFine: {
+			const rpnValue = this.midiControllers[midiControllers.registeredParameterMSB] | this.midiControllers[midiControllers.registeredParameterLSB] >> 7;
+			switch (rpnValue) {
+				default:
+					SpessaSynthInfo(`%cUnrecognized RPN LSB 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: {
 					if (dataValue === 0) break;
 					this.midiControllers[128 + modulatorSources.pitchWheelRange] |= dataValue;
@@ -11846,16 +11785,17 @@ function dataEntryFine(dataValue) {
 					break;
 			}
 			break;
+		}
 		case dataEntryStates.NRPFine: {
-			const NRPNCoarse = this.midiControllers[midiControllers.nonRegisteredParameterMSB] >> 7;
-			const NRPNFine = this.midiControllers[midiControllers.nonRegisteredParameterLSB] >> 7;
-			if (NRPNCoarse === nonRegisteredMSB.SF2) return;
-			switch (NRPNCoarse) {
+			const paramCoarse = this.midiControllers[midiControllers.nonRegisteredParameterMSB] >> 7;
+			const paramFine = this.midiControllers[midiControllers.nonRegisteredParameterLSB] >> 7;
+			if (paramCoarse === nonRegisteredMSB.SF2 || paramCoarse >= nonRegisteredMSB.drumPitch && paramFine <= nonRegisteredMSB.drumDelay || paramCoarse === nonRegisteredMSB.partParameter) return;
+			switch (paramCoarse) {
 				default:
-					SpessaSynthInfo(`%cUnrecognized NRPN LSB for %c${this.channel}%c: %c(0x${NRPNFine.toString(16).toUpperCase()} 0x${NRPNFine.toString(16).toUpperCase()})%c data value: %c${dataValue}`, consoleColors.warn, consoleColors.recognized, consoleColors.warn, consoleColors.unrecognized, consoleColors.warn, consoleColors.value);
+					SpessaSynthInfo(`%cUnrecognized NRPN LSB for %c${this.channel}%c: %c(0x${paramCoarse.toString(16).toUpperCase()} 0x${paramFine.toString(16).toUpperCase()})%c data value: %c${dataValue}`, consoleColors.warn, consoleColors.recognized, consoleColors.warn, consoleColors.unrecognized, consoleColors.warn, consoleColors.value);
 					break;
 				case nonRegisteredMSB.awe32:
-					handleAWE32NRPN.call(this, NRPNFine, dataValue, this.midiControllers[midiControllers.dataEntryMSB] >> 7);
+					handleAWE32NRPN.call(this, paramFine, dataValue, this.midiControllers[midiControllers.dataEntryMSB] >> 7);
 					break;
 			}
 		}
@@ -18121,7 +18061,8 @@ var SpessaSynthReverb = class {
 	set preLowpass(value) {
 		this._preLowpass = value;
 		this.preLPFfc = 8e3 * .63 ** this._preLowpass;
-		this.preLPFa = 1 - Math.exp(-2 * Math.PI * this.preLPFfc / this.sampleRate);
+		const decay = Math.exp(-2 * Math.PI * this.preLPFfc / this.sampleRate);
+		this.preLPFa = 1 - decay;
 		this.updateLowpass();
 	}
 	/**
@@ -18282,7 +18223,8 @@ var SpessaSynthChorus = class {
 	set preLowpass(value) {
 		this._preLowpass = value;
 		this.preLPFfc = 8e3 * .63 ** this._preLowpass;
-		this.preLPFa = 1 - Math.exp(-2 * Math.PI * this.preLPFfc / this.sampleRate);
+		const decay = Math.exp(-2 * Math.PI * this.preLPFfc / this.sampleRate);
+		this.preLPFa = 1 - decay;
 	}
 	_depth = 0;
 	get depth() {
@@ -18314,7 +18256,8 @@ var SpessaSynthChorus = class {
 	}
 	set rate(value) {
 		this._rate = value;
-		this.rateInc = 15.5 * (value / 127) / this.sampleRate;
+		const rate = 15.5 * (value / 127);
+		this.rateInc = rate / this.sampleRate;
 	}
 	_level = 64;
 	get level() {
@@ -18501,7 +18444,8 @@ var SpessaSynthDelay = class {
 	set preLowpass(value) {
 		this._preLowpass = value;
 		this.preLPFfc = 8e3 * .63 ** this._preLowpass;
-		this.preLPFa = 1 - Math.exp(-2 * Math.PI * this.preLPFfc / this.sampleRate);
+		const decay = Math.exp(-2 * Math.PI * this.preLPFfc / this.sampleRate);
+		this.preLPFa = 1 - decay;
 	}
 	_levelRight = 0;
 	get levelRight() {
@@ -19218,6 +19162,25 @@ var SynthesizerCore = class {
 		rev.preDelayTime = 0;
 		rev.character = macro;
 		switch (macro) {
+			/**
+			* REVERB MACRO is a macro parameter that allows global setting of reverb parameters.
+			* When you select the reverb type with REVERB MACRO, each reverb parameter will be set to their most
+			* suitable value.
+			*
+			* Room1, Room2, Room3
+			* These reverbs simulate the reverberation of a room. They provide a well-defined
+			* spacious reverberation.
+			* Hall1, Hall2
+			* These reverbs simulate the reverberation of a concert hall. They provide a deeper
+			* reverberation than the Room reverbs.
+			* Plate
+			* This simulates a plate reverb (a studio device using a metal plate).
+			* Delay
+			* This is a conventional delay that produces echo effects.
+			* Panning Delay
+			* This is a special delay in which the delayed sounds move left and right.
+			* It is effective when you are listening in stereo.
+			*/
 			case 0:
 				rev.character = 0;
 				rev.preLowpass = 3;
@@ -19279,6 +19242,23 @@ var SynthesizerCore = class {
 		chr.sendLevelToDelay = 0;
 		chr.sendLevelToReverb = 0;
 		switch (macro) {
+			/**
+			* CHORUS MACRO is a macro parameter that allows global setting of chorus parameters.
+			* When you select the chorus type with CHORUS MACRO, each chorus parameter will be set to their
+			* most suitable value.
+			*
+			* Chorus1, Chorus2, Chorus3, Chorus4
+			* These are conventional chorus effects that add spaciousness and depth to the
+			* sound.
+			* Feedback Chorus
+			* This is a chorus with a flanger-like effect and a soft sound.
+			* Flanger
+			* This is an effect sounding somewhat like a jet airplane taking off and landing.
+			* Short Delay
+			* This is a delay with a short delay time.
+			* Short Delay (FB)
+			* This is a short delay with many repeats.
+			*/
 			case 0:
 				chr.feedback = 0;
 				chr.delay = 112;
@@ -19346,6 +19326,29 @@ var SynthesizerCore = class {
 		dly.levelRight = dly.levelLeft = 0;
 		dly.levelCenter = 127;
 		switch (macro) {
+			/**
+			* DELAY MACRO is a macro parameter that allows global setting of delay parameters. When you select the delay type with DELAY MACRO, each delay parameter will be set to their most
+			* suitable value.
+			*
+			* Delay1, Delay2, Delay3
+			* These are conventional delays. 1, 2 and 3 have progressively longer delay times.
+			* Delay4
+			* This is a delay with a rather short delay time.
+			* Pan Delay1. Pan Delay2. Pan Delay3
+			* The delay sound moves between left and right. This is effective when listening in
+			* stereo. 1, 2 and 3 have progressively longer delay times.
+			* Pan Delay4
+			* This is a rather short delay with the delayed sound moving between left and
+			* right.
+			* It is effective when listening in stereo.
+			* Dly To Rev
+			* Reverb is added to the delay sound, which moves between left and right.
+			* It is effective when listening in stereo.
+			* PanRepeat
+			* The delay sound moves between left and right,
+			* but the pan positioning is different from the effects listed above.
+			* It is effective when listening in stereo.
+			*/
 			case 0:
 				dly.timeCenter = 97;
 				dly.timeRatioRight = dly.timeRatioLeft = 1;