Merge pull request #215 from TwilitRealm/reverb-wip

Audio FX reverb proof of concept

CMakeLists.txt

@@ -17,6 +17,8 @@ set(AURORA_ENABLE_DVD ON CACHE BOOL "Enable DVD API support" FORCE)
 set(AURORA_ENABLE_CARD ON CACHE BOOL "Enable CARD API support" FORCE)
 add_subdirectory(extern/aurora EXCLUDE_FROM_ALL)
 
+add_subdirectory(libs/freeverb)
+
 option(DUSK_BUILD_WARNINGS "If off, compiler warnings will be suppressed")
 option(DUSK_SELECTED_OPT "If on, selected parts of the project will be compiled with optimizations on Debug, intending to make the game run at 30 FPS. Note for MSVC: you will need to remove '/RTC1' from your debug flags in CMake.")
 option(DUSK_MOVIE_SUPPORT "If on, compile against libjpeg-turbo to enable THP file decoding" ON)
@@ -108,14 +110,14 @@ target_include_directories(game_debug PUBLIC
         extern
         ${CMAKE_SOURCE_DIR}/build/${DUSK_TP_VERSION}/include
         build/${DUSK_TP_VERSION}/include)
-target_link_libraries(game_debug PUBLIC aurora::core aurora::gx aurora::gd aurora::si aurora::vi aurora::pad aurora::mtx aurora::os aurora::dvd aurora::card)
+target_link_libraries(game_debug PUBLIC aurora::core aurora::gx aurora::gd aurora::si aurora::vi aurora::pad aurora::mtx aurora::os aurora::dvd aurora::card freeverb)
 
 set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
 add_library(game SHARED ${DOLZEL_FILES} ${Z2AUDIOLIB_FILES} ${SSYSTEM_FILES} ${JSYSTEM_FILES} ${REL_FILES} ${DUSK_FILES} ${DOLPHIN_FILES}
         src/dusk/imgui/ImGuiStubLog.cpp
         src/dusk/imgui/ImGuiAudio.cpp)
 
-target_link_libraries(game PRIVATE game_debug cxxopts::cxxopts absl::flat_hash_map)
+target_link_libraries(game PRIVATE game_debug cxxopts::cxxopts absl::flat_hash_map freeverb)
 if (DUSK_MOVIE_SUPPORT_REAL)
     if (TARGET libjpeg-turbo::turbojpeg-static)
         message(STATUS "dusk: Linking against libjpeg-turbo static library")
@@ -132,7 +134,7 @@ target_precompile_headers(game PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:${CMAKE_SOURCE
 add_executable(dusk src/dusk/main.cpp)
 target_compile_definitions(dusk PRIVATE TARGET_PC AVOID_UB=1 VERSION=0)
 target_include_directories(dusk PRIVATE include)
-target_link_libraries(dusk PRIVATE game aurora::main)
+target_link_libraries(dusk PRIVATE game aurora::main freeverb)
 
 add_custom_command(TARGET dusk POST_BUILD
     COMMAND ${CMAKE_COMMAND} -E copy_directory

include/dusk/settings.h

@@ -20,6 +20,7 @@ struct UserSettings {
         float subMusicVolume;
         float soundEffectsVolume;
         float fanfareVolume;
+        bool enableReverb;
     } audio;
 
     // Game settings
@@ -83,4 +84,3 @@ TransientSettings& getTransientSettings();
 }
 
 #endif // DUSK_CONFIG_H
-

libs/freeverb/CMakeLists.txt

@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 3.10)
+
+project(freeverb LANGUAGES CXX)
+
+add_library(freeverb
+    comb.cpp
+    allpass.cpp
+    revmodel.cpp
+)
+
+target_include_directories(freeverb PUBLIC
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)

libs/freeverb/allpass.cpp

@@ -0,0 +1,36 @@
+// Allpass filter implementation
+//
+// Written by Jezar at Dreampoint, June 2000
+// http://www.dreampoint.co.uk
+// This code is public domain
+
+#include "allpass.hpp"
+
+allpass::allpass()
+{
+	bufidx = 0;
+}
+
+void allpass::setbuffer(float *buf, int size) 
+{
+	buffer = buf; 
+	bufsize = size;
+}
+
+void allpass::mute()
+{
+	for (int i=0; i<bufsize; i++)
+		buffer[i]=0;
+}
+
+void allpass::setfeedback(float val) 
+{
+	feedback = val;
+}
+
+float allpass::getfeedback() 
+{
+	return feedback;
+}
+
+//ends

libs/freeverb/allpass.hpp

@@ -0,0 +1,48 @@
+// Allpass filter declaration
+//
+// Written by Jezar at Dreampoint, June 2000
+// http://www.dreampoint.co.uk
+// This code is public domain
+
+#ifndef _allpass_
+#define _allpass_
+#include "denormals.h"
+
+class allpass
+{
+public:
+					allpass();
+			void	setbuffer(float *buf, int size);
+	inline  float	process(float inp);
+			void	mute();
+			void	setfeedback(float val);
+			float	getfeedback();
+// private:
+	float	feedback;
+	float	*buffer;
+	int		bufsize;
+	int		bufidx;
+};
+
+
+// Big to inline - but crucial for speed
+
+inline float allpass::process(float input)
+{
+	float output;
+	float bufout;
+	
+	bufout = buffer[bufidx];
+	undenormalise(bufout);
+	
+	output = -input + bufout;
+	buffer[bufidx] = input + (bufout*feedback);
+
+	if(++bufidx>=bufsize) bufidx = 0;
+
+	return output;
+}
+
+#endif//_allpass
+
+//ends

libs/freeverb/comb.cpp

@@ -0,0 +1,48 @@
+// Comb filter implementation
+//
+// Written by Jezar at Dreampoint, June 2000
+// http://www.dreampoint.co.uk
+// This code is public domain
+
+#include "comb.hpp"
+
+comb::comb()
+{
+	filterstore = 0;
+	bufidx = 0;
+}
+
+void comb::setbuffer(float *buf, int size) 
+{
+	buffer = buf; 
+	bufsize = size;
+}
+
+void comb::mute()
+{
+	for (int i=0; i<bufsize; i++)
+		buffer[i]=0;
+}
+
+void comb::setdamp(float val) 
+{
+	damp1 = val; 
+	damp2 = 1-val;
+}
+
+float comb::getdamp() 
+{
+	return damp1;
+}
+
+void comb::setfeedback(float val) 
+{
+	feedback = val;
+}
+
+float comb::getfeedback() 
+{
+	return feedback;
+}
+
+// ends

libs/freeverb/comb.hpp

@@ -0,0 +1,55 @@
+// Comb filter class declaration
+//
+// Written by Jezar at Dreampoint, June 2000
+// http://www.dreampoint.co.uk
+// This code is public domain
+
+#ifndef _comb_
+#define _comb_
+
+#include "denormals.h"
+
+class comb
+{
+public:
+					comb();
+			void	setbuffer(float *buf, int size);
+	inline  float	process(float inp);
+			void	mute();
+			void	setdamp(float val);
+			float	getdamp();
+			void	setfeedback(float val);
+			float	getfeedback();
+private:
+	float	feedback;
+	float	filterstore;
+	float	damp1;
+	float	damp2;
+	float	*buffer;
+	int		bufsize;
+	int		bufidx;
+};
+
+
+// Big to inline - but crucial for speed
+
+inline float comb::process(float input)
+{
+	float output;
+
+	output = buffer[bufidx];
+	undenormalise(output);
+
+	filterstore = (output*damp2) + (filterstore*damp1);
+	undenormalise(filterstore);
+
+	buffer[bufidx] = input + (filterstore*feedback);
+
+	if(++bufidx>=bufsize) bufidx = 0;
+
+	return output;
+}
+
+#endif //_comb_
+
+//ends

libs/freeverb/denormals.h

@@ -0,0 +1,15 @@
+// Macro for killing denormalled numbers
+//
+// Written by Jezar at Dreampoint, June 2000
+// http://www.dreampoint.co.uk
+// Based on IS_DENORMAL macro by Jon Watte
+// This code is public domain
+
+#ifndef _denormals_
+#define _denormals_
+
+#define undenormalise(sample) if(((*(unsigned int*)&sample)&0x7f800000)==0) sample=0.0f
+
+#endif//_denormals_
+
+//ends

libs/freeverb/revmodel.cpp

@@ -0,0 +1,252 @@
+// Reverb model implementation
+//
+// Written by Jezar at Dreampoint, June 2000
+// http://www.dreampoint.co.uk
+// This code is public domain
+
+#include "revmodel.hpp"
+
+revmodel::revmodel()
+{
+	// Tie the components to their buffers
+	combL[0].setbuffer(bufcombL1,combtuningL1);
+	combR[0].setbuffer(bufcombR1,combtuningR1);
+	combL[1].setbuffer(bufcombL2,combtuningL2);
+	combR[1].setbuffer(bufcombR2,combtuningR2);
+	combL[2].setbuffer(bufcombL3,combtuningL3);
+	combR[2].setbuffer(bufcombR3,combtuningR3);
+	combL[3].setbuffer(bufcombL4,combtuningL4);
+	combR[3].setbuffer(bufcombR4,combtuningR4);
+	combL[4].setbuffer(bufcombL5,combtuningL5);
+	combR[4].setbuffer(bufcombR5,combtuningR5);
+	combL[5].setbuffer(bufcombL6,combtuningL6);
+	combR[5].setbuffer(bufcombR6,combtuningR6);
+	combL[6].setbuffer(bufcombL7,combtuningL7);
+	combR[6].setbuffer(bufcombR7,combtuningR7);
+	combL[7].setbuffer(bufcombL8,combtuningL8);
+	combR[7].setbuffer(bufcombR8,combtuningR8);
+	allpassL[0].setbuffer(bufallpassL1,allpasstuningL1);
+	allpassR[0].setbuffer(bufallpassR1,allpasstuningR1);
+	allpassL[1].setbuffer(bufallpassL2,allpasstuningL2);
+	allpassR[1].setbuffer(bufallpassR2,allpasstuningR2);
+	allpassL[2].setbuffer(bufallpassL3,allpasstuningL3);
+	allpassR[2].setbuffer(bufallpassR3,allpasstuningR3);
+	allpassL[3].setbuffer(bufallpassL4,allpasstuningL4);
+	allpassR[3].setbuffer(bufallpassR4,allpasstuningR4);
+
+	// Set default values
+	allpassL[0].setfeedback(0.5f);
+	allpassR[0].setfeedback(0.5f);
+	allpassL[1].setfeedback(0.5f);
+	allpassR[1].setfeedback(0.5f);
+	allpassL[2].setfeedback(0.5f);
+	allpassR[2].setfeedback(0.5f);
+	allpassL[3].setfeedback(0.5f);
+	allpassR[3].setfeedback(0.5f);
+	setwet(initialwet);
+	setroomsize(initialroom);
+	setdry(initialdry);
+	setdamp(initialdamp);
+	setwidth(initialwidth);
+	setmode(initialmode);
+
+	// Buffer will be full of rubbish - so we MUST mute them
+	mute();
+}
+
+void revmodel::mute()
+{
+	if (getmode() >= freezemode)
+		return;
+
+	for (int i=0;i<numcombs;i++)
+	{
+		combL[i].mute();
+		combR[i].mute();
+	}
+	for (int i=0;i<numallpasses;i++)
+	{
+		allpassL[i].mute();
+		allpassR[i].mute();
+	}
+}
+
+void revmodel::processreplace(float *inputL, float *inputR, float *outputL, float *outputR, long numsamples, int skip)
+{
+	float outL,outR,input;
+
+	while(numsamples-- > 0)
+	{
+		outL = outR = 0;
+		input = (*inputL + *inputR) * gain;
+
+		// Accumulate comb filters in parallel
+		for(int i=0; i<numcombs; i++)
+		{
+			outL += combL[i].process(input);
+			outR += combR[i].process(input);
+		}
+
+		// Feed through allpasses in series
+		for(int i=0; i<numallpasses; i++)
+		{
+			outL = allpassL[i].process(outL);
+			outR = allpassR[i].process(outR);
+		}
+
+		// Calculate output REPLACING anything already there
+		*outputL = outL*wet1 + outR*wet2 + *inputL*dry;
+		*outputR = outR*wet1 + outL*wet2 + *inputR*dry;
+
+		// Increment sample pointers, allowing for interleave (if any)
+		inputL += skip;
+		inputR += skip;
+		outputL += skip;
+		outputR += skip;
+	}
+}
+
+void revmodel::processmix(float *inputL, float *inputR, float *outputL, float *outputR, long numsamples, int skip)
+{
+	float outL,outR,input;
+
+	while(numsamples-- > 0)
+	{
+		outL = outR = 0;
+		input = (*inputL + *inputR) * gain;
+
+		// Accumulate comb filters in parallel
+		for(int i=0; i<numcombs; i++)
+		{
+			outL += combL[i].process(input);
+			outR += combR[i].process(input);
+		}
+
+		// Feed through allpasses in series
+		for(int i=0; i<numallpasses; i++)
+		{
+			outL = allpassL[i].process(outL);
+			outR = allpassR[i].process(outR);
+		}
+
+		// Calculate output MIXING with anything already there
+		*outputL += outL*wet1 + outR*wet2 + *inputL*dry;
+		*outputR += outR*wet1 + outL*wet2 + *inputR*dry;
+
+		// Increment sample pointers, allowing for interleave (if any)
+		inputL += skip;
+		inputR += skip;
+		outputL += skip;
+		outputR += skip;
+	}
+}
+
+void revmodel::update()
+{
+// Recalculate internal values after parameter change
+
+	int i;
+
+	wet1 = wet*(width/2 + 0.5f);
+	wet2 = wet*((1-width)/2);
+
+	if (mode >= freezemode)
+	{
+		roomsize1 = 1;
+		damp1 = 0;
+		gain = muted;
+	}
+	else
+	{
+		roomsize1 = roomsize;
+		damp1 = damp;
+		gain = fixedgain;
+	}
+
+	for(i=0; i<numcombs; i++)
+	{
+		combL[i].setfeedback(roomsize1);
+		combR[i].setfeedback(roomsize1);
+	}
+
+	for(i=0; i<numcombs; i++)
+	{
+		combL[i].setdamp(damp1);
+		combR[i].setdamp(damp1);
+	}
+}
+
+// The following get/set functions are not inlined, because
+// speed is never an issue when calling them, and also
+// because as you develop the reverb model, you may
+// wish to take dynamic action when they are called.
+
+void revmodel::setroomsize(float value)
+{
+	roomsize = (value*scaleroom) + offsetroom;
+	update();
+}
+
+float revmodel::getroomsize()
+{
+	return (roomsize-offsetroom)/scaleroom;
+}
+
+void revmodel::setdamp(float value)
+{
+	damp = value*scaledamp;
+	update();
+}
+
+float revmodel::getdamp()
+{
+	return damp/scaledamp;
+}
+
+void revmodel::setwet(float value)
+{
+	wet = value*scalewet;
+	update();
+}
+
+float revmodel::getwet()
+{
+	return wet/scalewet;
+}
+
+void revmodel::setdry(float value)
+{
+	dry = value*scaledry;
+}
+
+float revmodel::getdry()
+{
+	return dry/scaledry;
+}
+
+void revmodel::setwidth(float value)
+{
+	width = value;
+	update();
+}
+
+float revmodel::getwidth()
+{
+	return width;
+}
+
+void revmodel::setmode(float value)
+{
+	mode = value;
+	update();
+}
+
+float revmodel::getmode()
+{
+	if (mode >= freezemode)
+		return 1;
+	else
+		return 0;
+}
+
+//ends

libs/freeverb/revmodel.hpp

@@ -0,0 +1,87 @@
+// Reverb model declaration
+//
+// Written by Jezar at Dreampoint, June 2000
+// http://www.dreampoint.co.uk
+// This code is public domain
+
+#ifndef _revmodel_
+#define _revmodel_
+
+#include "comb.hpp"
+#include "allpass.hpp"
+#include "tuning.h"
+
+class revmodel
+{
+public:
+					revmodel();
+			void	mute();
+			void	processmix(float *inputL, float *inputR, float *outputL, float *outputR, long numsamples, int skip);
+			void	processreplace(float *inputL, float *inputR, float *outputL, float *outputR, long numsamples, int skip);
+			void	setroomsize(float value);
+			float	getroomsize();
+			void	setdamp(float value);
+			float	getdamp();
+			void	setwet(float value);
+			float	getwet();
+			void	setdry(float value);
+			float	getdry();
+			void	setwidth(float value);
+			float	getwidth();
+			void	setmode(float value);
+			float	getmode();
+private:
+			void	update();
+private:
+	float	gain;
+	float	roomsize,roomsize1;
+	float	damp,damp1;
+	float	wet,wet1,wet2;
+	float	dry;
+	float	width;
+	float	mode;
+
+	// The following are all declared inline 
+	// to remove the need for dynamic allocation
+	// with its subsequent error-checking messiness
+
+	// Comb filters
+	comb	combL[numcombs];
+	comb	combR[numcombs];
+
+	// Allpass filters
+	allpass	allpassL[numallpasses];
+	allpass	allpassR[numallpasses];
+
+	// Buffers for the combs
+	float	bufcombL1[combtuningL1];
+	float	bufcombR1[combtuningR1];
+	float	bufcombL2[combtuningL2];
+	float	bufcombR2[combtuningR2];
+	float	bufcombL3[combtuningL3];
+	float	bufcombR3[combtuningR3];
+	float	bufcombL4[combtuningL4];
+	float	bufcombR4[combtuningR4];
+	float	bufcombL5[combtuningL5];
+	float	bufcombR5[combtuningR5];
+	float	bufcombL6[combtuningL6];
+	float	bufcombR6[combtuningR6];
+	float	bufcombL7[combtuningL7];
+	float	bufcombR7[combtuningR7];
+	float	bufcombL8[combtuningL8];
+	float	bufcombR8[combtuningR8];
+
+	// Buffers for the allpasses
+	float	bufallpassL1[allpasstuningL1];
+	float	bufallpassR1[allpasstuningR1];
+	float	bufallpassL2[allpasstuningL2];
+	float	bufallpassR2[allpasstuningR2];
+	float	bufallpassL3[allpasstuningL3];
+	float	bufallpassR3[allpasstuningR3];
+	float	bufallpassL4[allpasstuningL4];
+	float	bufallpassR4[allpasstuningR4];
+};
+
+#endif//_revmodel_
+
+//ends

libs/freeverb/tuning.h

@@ -0,0 +1,60 @@
+// Reverb model tuning values
+//
+// Written by Jezar at Dreampoint, June 2000
+// http://www.dreampoint.co.uk
+// This code is public domain
+
+#ifndef _tuning_
+#define _tuning_
+
+const int	numcombs		= 8;
+const int	numallpasses	= 4;
+const float	muted			= 0;
+const float	fixedgain		= 0.015f;
+const float scalewet		= 3;
+const float scaledry		= 2;
+const float scaledamp		= 0.4f;
+const float scaleroom		= 0.28f;
+const float offsetroom		= 0.7f;
+const float initialroom		= 0.5f;
+const float initialdamp		= 0.5f;
+const float initialwet		= 1/scalewet;
+const float initialdry		= 0;
+const float initialwidth	= 1;
+const float initialmode		= 0;
+const float freezemode		= 0.5f;
+const int	stereospread	= 23;
+
+// These values assume 44.1KHz sample rate
+// they will probably be OK for 48KHz sample rate
+// but would need scaling for 96KHz (or other) sample rates.
+// The values were obtained by listening tests.
+const int combtuningL1		= 1116;
+const int combtuningR1		= 1116+stereospread;
+const int combtuningL2		= 1188;
+const int combtuningR2		= 1188+stereospread;
+const int combtuningL3		= 1277;
+const int combtuningR3		= 1277+stereospread;
+const int combtuningL4		= 1356;
+const int combtuningR4		= 1356+stereospread;
+const int combtuningL5		= 1422;
+const int combtuningR5		= 1422+stereospread;
+const int combtuningL6		= 1491;
+const int combtuningR6		= 1491+stereospread;
+const int combtuningL7		= 1557;
+const int combtuningR7		= 1557+stereospread;
+const int combtuningL8		= 1617;
+const int combtuningR8		= 1617+stereospread;
+const int allpasstuningL1	= 556;
+const int allpasstuningR1	= 556+stereospread;
+const int allpasstuningL2	= 441;
+const int allpasstuningR2	= 441+stereospread;
+const int allpasstuningL3	= 341;
+const int allpasstuningR3	= 341+stereospread;
+const int allpasstuningL4	= 225;
+const int allpasstuningR4	= 225+stereospread;
+
+#endif//_tuning_
+
+//ends
+

src/dusk/audio/DuskAudioSystem.cpp

@@ -3,8 +3,6 @@
 #include <SDL3/SDL_init.h>
 #include <array>
 #include <cassert>
-#include <fstream>
-#include <ios>
 #include <span>
 
 #include "JSystem/JAudio2/JASAiCtrl.h"
@@ -17,8 +15,6 @@
 #include "JSystem/JAudio2/JASAudioThread.h"
 #include "JSystem/JAudio2/JASDriverIF.h"
 
-// #define DUSK_DUMP_AUDIO
-
 using namespace dusk::audio;
 
 static OutputSubframe OutBuffer;
@@ -91,10 +87,6 @@ void SDLCALL GetNewAudio(
     }
 }
 
-#if defined(DUSK_DUMP_AUDIO)
-static std::ofstream outRaw("guh.raw", std::ios_base::out | std::ios_base::binary);
-#endif
-
 int RenderNewAudioFrame() {
     JASCriticalSection section;
     const u32 countSubframes = JASDriver::getSubFrames();
@@ -107,10 +99,6 @@ int RenderNewAudioFrame() {
         JASAudioThread::snIntCount -= 1;
     }
 
-#if defined(DUSK_DUMP_AUDIO)
-    outRaw.flush();
-#endif
-
     return static_cast<u16>(countSubframes) * DSP_SUBFRAME_SIZE;
 }
 
@@ -147,10 +135,6 @@ void RenderAudioSubframe() {
         }
     }
 
-#if defined(DUSK_DUMP_AUDIO)
-    outRaw.write((const char*)OutInterleaveBuffer.data(), sizeof(OutInterleaveBuffer));
-#endif
-
     SDL_PutAudioStreamData(PlaybackStream, &OutInterleaveBuffer, sizeof(OutInterleaveBuffer));
 }
 

src/dusk/audio/DuskDsp.cpp

@@ -5,6 +5,7 @@
 
 #include <algorithm>
 #include <cassert>
+#include <cstdio>
 #include <span>
 
 #include "Adpcm.hpp"
@@ -17,8 +18,30 @@ using namespace dusk::audio;
 
 ChannelAuxData dusk::audio::ChannelAux[DSP_CHANNELS] = {};
 
+static bool sDumpWasActive = false;
+static FILE* sChannelDumpFiles[DSP_CHANNELS] = {};
+
+static void OpenChannelDumpFiles() {
+    char name[32];
+    for (int i = 0; i < DSP_CHANNELS; i++) {
+        snprintf(name, sizeof(name), "channel_%02d.raw", i);
+        sChannelDumpFiles[i] = fopen(name, "wb");
+    }
+}
+
+static void CloseChannelDumpFiles() {
+    for (int i = 0; i < DSP_CHANNELS; i++) {
+        if (sChannelDumpFiles[i]) {
+            fclose(sChannelDumpFiles[i]);
+            sChannelDumpFiles[i] = nullptr;
+        }
+    }
+}
+
 f32 dusk::audio::MasterVolume = 1.0f;
 f32 dusk::audio::PrevMasterVolume = 1.0f;
+bool dusk::audio::EnableReverb = true;
+bool dusk::audio::DumpAudio = false;
 
 /**
  * Validate that a DSP channel's format is actually something we know how to play.
@@ -106,38 +129,81 @@ static void MixSubframe(DspSubframe& dst, const DspSubframe& src) {
 }
 
 void dusk::audio::DspRender(OutputSubframe& subframe) {
+    if (DumpAudio != sDumpWasActive) {
+        sDumpWasActive = DumpAudio;
+        if (DumpAudio) {
+            OpenChannelDumpFiles();
+        } else {
+            CloseChannelDumpFiles();
+        }
+    }
+
     std::span channels(JASDsp::CH_BUF, DSP_CHANNELS);
 
     for (int i = 0; i < channels.size(); i++) {
         auto& channel = channels[i];
         auto& channelAux = ChannelAux[i];
 
-        if (!channel.mIsActive) {
-            continue;
-        }
+        bool skipRender = false;
 
-        if (channel.mPauseFlag) {
+        if (!channel.mIsActive) {
+            skipRender = true;
+        }
+        else if (channel.mPauseFlag) {
             // Not really sure what the practical difference between pause and
             // deactivation is. Either avoids clearing state or allows the DSP to avoid popping?
-            continue;
+            skipRender = true;
         }
-
-        if (channel.mForcedStop) {
+        else if (channel.mForcedStop) {
             channel.mIsFinished = true;
-            continue;
+            skipRender = true;
         }
-
-        if (channel.mWaveAramAddress == 0) {
+        else if (channel.mWaveAramAddress == 0) {
             // I think these are oscillator channels? Not backed by audio.
             // No idea how to implement these yet, so skip them.
             channel.mIsFinished = true;
-            continue;
+            skipRender = true;
         }
 
-        ValidateChannel(channel);
-
         OutputSubframe channelSubframe = {};
-        RenderChannel(channel, channelAux, channelSubframe);
+
+        if (!skipRender) {
+            ValidateChannel(channel);
+            RenderChannel(channel, channelAux, channelSubframe);
+        }
+
+        if (EnableReverb) {
+            // scale the input to the reverb rather than using wet/dry on the output.
+            // this way the reverb's internal buffers accumulate energy proportional to mAutoMixerFxMix,
+            // so any tail always decays at the correct level regardless of mAutoMixerFxMix changes
+            // prevents transients when the next sound starts playing with a different reverb level
+            // 700.0f was pulled out of my ass and just sounds good enough for console
+            f32 inputGain = (!skipRender) ? (channel.mAutoMixerFxMix >> 8) / 700.0f : 0.0f;
+
+            OutputSubframe reverbSubframe = {};
+            for (int j = 0; j < DSP_SUBFRAME_SIZE; j++) {
+                reverbSubframe.channels[0][j] = channelSubframe.channels[0][j] * inputGain;
+                reverbSubframe.channels[1][j] = channelSubframe.channels[1][j] * inputGain;
+            }
+
+            channelAux.reverb.processreplace(
+                reverbSubframe.channels[0].data(), reverbSubframe.channels[1].data(),
+                reverbSubframe.channels[0].data(), reverbSubframe.channels[1].data(),
+                DSP_SUBFRAME_SIZE, 1
+            );
+
+            for (int j = 0; j < DSP_SUBFRAME_SIZE; j++) {
+                channelSubframe.channels[0][j] += reverbSubframe.channels[0][j];
+                channelSubframe.channels[1][j] += reverbSubframe.channels[1][j];
+            }
+        }
+
+        if (DumpAudio && sChannelDumpFiles[i]) {
+            for (int j = 0; j < DSP_SUBFRAME_SIZE; j++) {
+                fwrite(&channelSubframe.channels[0][j], sizeof(f32), 1, sChannelDumpFiles[i]);
+                fwrite(&channelSubframe.channels[1][j], sizeof(f32), 1, sChannelDumpFiles[i]);
+            }
+        }
 
         for (int o = 0; o < subframe.channels.size(); o++) {
             MixSubframe(subframe.channels[o], channelSubframe.channels[o]);
@@ -463,6 +529,16 @@ static void RenderChannel(
 }
 
 void dusk::audio::DspInit() {
+    for (int i = 0; i < DSP_CHANNELS; i++) {
+        auto& channelAux = ChannelAux[i];
+        channelAux.reverb.setwet(1.0f);
+        channelAux.reverb.setdry(0.0f);
+        channelAux.reverb.setroomsize(0.4f);
+        channelAux.reverb.setdamp(0.7f);
+        channelAux.reverb.setwidth(1.0f);
+        channelAux.reverb.setmode(0.0f);
+        channelAux.reverb.mute();
+    }
 }
 
 void dusk::audio::ApplyVolume(

src/dusk/audio/DuskDsp.hpp

@@ -8,6 +8,8 @@
 #include "SDL3/SDL_audio.h"
 #include <span>
 
+#include "revmodel.hpp"
+
 // ReSharper disable once CppUnusedIncludeDirective
 #include "global.h"
 
@@ -29,6 +31,7 @@ namespace dusk::audio {
 
         // Used for debugging tools.
         u32 resetCount;
+        revmodel reverb;
 
         /**
          * Previous volume values, per output channel.
@@ -51,7 +54,7 @@ namespace dusk::audio {
         // basically stores our position between resamplePrev and decodeBuf[0] so we don't lose that fractional resampler position next subframe
         f32 resamplePos;
         // last consumed sample from decodeBuf
-        s16 resamplePrev;     
+        s16 resamplePrev;
     };
 
     extern ChannelAuxData ChannelAux[DSP_CHANNELS];
@@ -118,4 +121,6 @@ namespace dusk::audio {
 
     extern f32 MasterVolume;
     extern f32 PrevMasterVolume;
+    extern bool EnableReverb;
+    extern bool DumpAudio;
 }

src/dusk/imgui/ImGuiAudio.cpp

@@ -8,6 +8,7 @@
 #include "JSystem/JAudio2/JASDSPInterface.h"
 #include "JSystem/JAudio2/JASTrack.h"
 #include "dusk/audio/DuskAudioSystem.h"
+#include "dusk/audio/DuskDsp.hpp"
 
 static std::array<u8, DSP_CHANNELS> channelSortIndices = {};
 static std::array<u32, DSP_CHANNELS> lastResetCounts = {};
@@ -102,6 +103,7 @@ static void ShowAllDspChannels() {
     }
 
     ImGui::Text("Active channels: %d", activeChannels);
+    ImGui::Checkbox("Dump channels to disk", &dusk::audio::DumpAudio);
     ImGui::Checkbox("Sort by update count", &sortUpdateCount);
 
     if (sortUpdateCount) {

src/dusk/imgui/ImGuiMenuGame.cpp

@@ -6,6 +6,7 @@
 #include <imgui_internal.h>
 
 #include "JSystem/JUtility/JUTGamePad.h"
+#include "dusk/audio/DuskDsp.hpp"
 #include "dusk/audio/DuskAudioSystem.h"
 #include "dusk/hotkeys.h"
 #include "dusk/settings.h"
@@ -34,7 +35,7 @@ namespace dusk {
             if (ImGui::BeginMenu("Audio")) {
                 ImGui::Text("Master Volume");
                 ImGui::SliderFloat("##masterVolume", &getSettings().audio.masterVolume, 0.0f, 1.0f, "");
-
+                ImGui::Checkbox("Enable Reverb", &getSettings().audio.enableReverb);
                 /*
                 // TODO: implement additional settings
                 ImGui::Text("Main Music Volume");
@@ -55,6 +56,7 @@ namespace dusk {
                 */
 
                 audio::SetMasterVolume(getSettings().audio.masterVolume);
+                audio::EnableReverb = getSettings().audio.enableReverb;
 
                 ImGui::EndMenu();
             }

src/dusk/settings.cpp

@@ -12,11 +12,12 @@ UserSettings g_userSettings = {
 
     // Audio
     .audio = {
-        .masterVolume = 1.0f,
+        .masterVolume = 0.8f,
         .mainMusicVolume = 1.0f,
         .subMusicVolume = 1.0f,
         .soundEffectsVolume = 1.0f,
         .fanfareVolume = 1.0f,
+        .enableReverb = true
     },
 
     // Game settings