Listener-centric reverb;

bjornbytes · bjornbytes · commit 2fd63e641558 · 2026-02-18T12:02:11.000-08:00
Not sure about final API yet
diff --git a/etc/boot.lua b/etc/boot.lua
@@ -23,7 +23,7 @@ local conf = {
     reverb = {
       mode = 'convolution',
       rays = 4096,
-      bounces = 4,
+      bounces = 16,
       duration = 2,
       rate = .1
     }
diff --git a/src/api/l_audio.c b/src/api/l_audio.c
@@ -10,7 +10,6 @@ StringEntry lovrEffect[] = {
   [EFFECT_ABSORPTION] = ENTRY("absorption"),
   [EFFECT_ATTENUATION] = ENTRY("attenuation"),
   [EFFECT_OCCLUSION] = ENTRY("occlusion"),
-  [EFFECT_REVERB] = ENTRY("reverb"),
   [EFFECT_SPATIALIZATION] = ENTRY("spatialization"),
   [EFFECT_TRANSMISSION] = ENTRY("transmission"),
   { 0 }
@@ -229,6 +228,18 @@ static int l_lovrAudioSetAbsorption(lua_State* L) {
   return 0;
 }
 
+static int l_lovrAudioGetReverb(lua_State* L) {
+  float reverb = lovrAudioGetReverb();
+  lua_pushnumber(L, reverb);
+  return 1;
+}
+
+static int l_lovrAudioSetReverb(lua_State* L) {
+  float reverb = luax_optfloat(L, 1, 0.f);
+  lovrAudioSetReverb(reverb);
+  return 0;
+}
+
 static int l_lovrAudioNewSource(lua_State* L) {
   Sound* sound = luax_totype(L, 1, Sound);
 
@@ -336,6 +347,8 @@ static const luaL_Reg lovrAudio[] = {
   { "getSampleRate", l_lovrAudioGetSampleRate },
   { "getAbsorption", l_lovrAudioGetAbsorption },
   { "setAbsorption", l_lovrAudioSetAbsorption },
+  { "getReverb", l_lovrAudioGetReverb },
+  { "setReverb", l_lovrAudioSetReverb },
   { "newSource", l_lovrAudioNewSource },
   { "newAudioMesh", l_lovrAudioNewAudioMesh },
   { NULL, NULL }
diff --git a/src/api/l_audio_source.c b/src/api/l_audio_source.c
@@ -83,6 +83,20 @@ static int l_lovrSourceSetVolume(lua_State* L) {
   return 0;
 }
 
+static int l_lovrSourceGetReverb(lua_State* L) {
+  Source* source = luax_checktype(L, 1, Source);
+  float reverb = lovrSourceGetReverb(source);
+  lua_pushnumber(L, reverb);
+  return 1;
+}
+
+static int l_lovrSourceSetReverb(lua_State* L) {
+  Source* source = luax_checktype(L, 1, Source);
+  float reverb = luax_optfloat(L, 2, 0.f);
+  lovrSourceSetReverb(source, reverb);
+  return 0;
+}
+
 static int l_lovrSourceSeek(lua_State* L) {
   Source* source = luax_checktype(L, 1, Source);
   double seconds = luaL_checknumber(L, 2);
@@ -237,6 +251,8 @@ const luaL_Reg lovrSource[] = {
   { "setPitch", l_lovrSourceSetPitch },
   { "getVolume", l_lovrSourceGetVolume },
   { "setVolume", l_lovrSourceSetVolume },
+  { "getReverb", l_lovrSourceGetReverb },
+  { "setReverb", l_lovrSourceSetReverb },
   { "seek", l_lovrSourceSeek },
   { "tell", l_lovrSourceTell },
   { "getDuration", l_lovrSourceGetDuration },
diff --git a/src/core/job.c b/src/core/job.c
@@ -70,7 +70,9 @@ bool job_init(uint32_t count, void (*setupWorker)(uint32_t id)) {
 }
 
 void job_destroy(void) {
+  mtx_lock(&state.lock);
   state.quit = true;
+  mtx_unlock(&state.lock);
   cnd_broadcast(&state.hasJob);
   for (uint32_t i = 0; i < state.workerCount; i++) {
     thrd_join(state.workers[i], NULL);
diff --git a/src/modules/audio/audio.c b/src/modules/audio/audio.c
@@ -30,8 +30,9 @@ struct Source {
   uint32_t slot;
   Sound* sound;
   ma_data_converter* converter;
-  float volume;
   float pitch;
+  float volume;
+  float reverb;
   float position[3];
   float radius;
   float orientation[4];
@@ -87,6 +88,7 @@ static struct {
   float position[3];
   float orientation[4];
   float absorption[3];
+  float reverb;
 #ifdef LOVR_USE_PHONON
   IPLContext phonon;
   IPLAudioSettings audioSettings;
@@ -96,9 +98,13 @@ static struct {
   IPLScene scene;
   bool sceneDirty;
   IPLHRTF hrtf;
+  IPLSource listener;
+  bool listenerAdded;
   IPLCoordinateSpace3 listenerBasis[2];
+  IPLReflectionEffect reflectionEffect;
   IPLReflectionMixer reflectionMixer;
   IPLAudioBuffer reflectionBuffer;
+  IPLAudioBuffer listenerReverbInput;
   IPLAmbisonicsDecodeEffect ambisonicsDecodeEffect;
   atomic_bool reverbFinished;
   float reverbTimer;
@@ -287,6 +293,8 @@ bool lovrAudioInit(AudioConfig* config) {
   state.absorption[1] = .0017f;
   state.absorption[2] = .0182f;
 
+  state.reverb = 1.f;
+
   quat_identity(state.orientation);
   return true;
 }
@@ -486,6 +494,14 @@ void lovrAudioSetAbsorption(float absorption[3]) {
   memcpy(state.absorption, absorption, 3 * sizeof(float));
 }
 
+float lovrAudioGetReverb(void) {
+  return state.reverb;
+}
+
+void lovrAudioSetReverb(float reverb) {
+  state.reverb = reverb;
+}
+
 // Source
 
 Source* lovrSourceCreate(Sound* sound, bool pitchable, bool spatial, uint32_t effects) {
@@ -494,8 +510,9 @@ Source* lovrSourceCreate(Sound* sound, bool pitchable, bool spatial, uint32_t ef
   Source* source = lovrCalloc(sizeof(Source));
   source->ref = 1;
   source->slot = ~0u;
-  source->pitch = 1.f;
   source->volume = 1.f;
+  source->pitch = 1.f;
+  source->reverb = 0.f;
   source->pitchable = pitchable;
   source->spatial = spatial;
   source->effects = spatial ? effects : 0;
@@ -658,6 +675,14 @@ void lovrSourceSetVolume(Source* source, float volume, VolumeUnit units) {
   source->volume = CLAMP(volume, 0.f, 1.f);
 }
 
+float lovrSourceGetReverb(Source* source) {
+  return source->reverb;
+}
+
+void lovrSourceSetReverb(Source* source, float reverb) {
+  source->reverb = reverb;
+}
+
 void lovrSourceSeek(Source* source, double time, TimeUnit units) {
   source->seekRequest = units == UNIT_SECONDS ? (uint32_t) (time * lovrSoundGetSampleRate(source->sound) + .5) : (uint32_t) time;
 }
@@ -855,6 +880,18 @@ static bool phonon_init(void) {
 
   iplSimulatorSetScene(state.simulator, state.scene);
 
+  IPLSourceSettings sourceSettings = {
+    .flags = IPL_SIMULATIONFLAGS_REFLECTIONS
+  };
+
+  if (iplSourceCreate(state.simulator, &sourceSettings, &state.listener)) {
+    return phonon_destroy(), lovrSetError("Failed to create listener source");
+  }
+
+  if (iplReflectionEffectCreate(state.phonon, &state.audioSettings, &state.reflectionSettings, &state.reflectionEffect)) {
+    return phonon_destroy(), lovrSetError("Failed to create reflection effect");
+  }
+
   if (state.config.reverb.mode == REVERB_CONVOLUTION) {
     if (iplReflectionMixerCreate(state.phonon, &state.audioSettings, &state.reflectionSettings, &state.reflectionMixer)) {
       return phonon_destroy(), lovrSetError("Failed to create reverb mixer");
@@ -875,15 +912,26 @@ static bool phonon_init(void) {
     return phonon_destroy(), lovrSetError("Failed to create reverb buffer");
   }
 
+  if (iplAudioBufferAllocate(state.phonon, 1, BUFFER_SIZE, &state.listenerReverbInput)) {
+    return phonon_destroy(), lovrSetError("Failed to create reverb buffer");
+  }
+
   atomic_store(&state.reverbFinished, true);
 
   return true;
 }
 
 static void phonon_destroy(void) {
+  while (!atomic_load(&state.reverbFinished)) {
+    job_spin();
+  }
+
   iplAmbisonicsDecodeEffectRelease(&state.ambisonicsDecodeEffect), state.ambisonicsDecodeEffect = NULL;
+  iplAudioBufferFree(state.phonon, &state.listenerReverbInput), state.listenerReverbInput.data = NULL;
   iplAudioBufferFree(state.phonon, &state.reflectionBuffer), state.reflectionBuffer.data = NULL;
   iplReflectionMixerRelease(&state.reflectionMixer), state.reflectionMixer = NULL;
+  iplReflectionEffectRelease(&state.reflectionEffect), state.reflectionEffect = NULL;
+  iplSourceRelease(&state.listener), state.listener = NULL;
   iplHRTFRelease(&state.hrtf), state.hrtf = NULL;
   iplSceneRelease(&state.scene), state.scene = NULL;
   iplSimulatorRelease(&state.simulator), state.simulator = NULL;
@@ -898,6 +946,14 @@ static void phonon_update(float dt) {
 
   // TODO maybe split into 2 simulators so we can have less latency on direct simulation commits
   if (atomic_load(&state.reverbFinished)) {
+    if (!state.listenerAdded && state.reverb > 0.f) {
+      iplSourceAdd(state.listener, state.simulator);
+      state.listenerAdded = true;
+    } else if (state.listenerAdded && state.reverb <= 0.f) {
+      iplSourceRemove(state.listener, state.simulator);
+      state.listenerAdded = false;
+    }
+
     iplSimulatorCommit(state.simulator);
   }
 
@@ -927,7 +983,6 @@ static void phonon_update(float dt) {
       [EFFECT_ABSORPTION] = IPL_DIRECTSIMULATIONFLAGS_AIRABSORPTION,
       [EFFECT_ATTENUATION] = IPL_DIRECTSIMULATIONFLAGS_DISTANCEATTENUATION,
       [EFFECT_OCCLUSION] = IPL_DIRECTSIMULATIONFLAGS_OCCLUSION,
-      [EFFECT_REVERB] = 0,
       [EFFECT_SPATIALIZATION] = 0,
       [EFFECT_TRANSMISSION] = IPL_DIRECTSIMULATIONFLAGS_TRANSMISSION
     };
@@ -940,7 +995,7 @@ static void phonon_update(float dt) {
       }
     }
 
-    hasReverb |= !!(source->effects & (1 << EFFECT_REVERB));
+    hasReverb |= source->reverb > 0.f;
 
     source->inputs.directivity.dipoleWeight = source->dipoleWeight;
     source->inputs.directivity.dipolePower = source->dipolePower;
@@ -960,13 +1015,23 @@ static void phonon_update(float dt) {
 
   atomic_fetch_xor(&state.backbuffer, 0x1);
 
-  if (hasReverb) {
+  if (hasReverb || state.reverb > 0.f) {
     state.reverbTimer -= dt;
 
     if (state.reverbTimer <= 0.f && atomic_load(&state.reverbFinished)) {
       atomic_store(&state.reverbFinished, false);
       state.reverbTimer = state.config.reverb.rate;
 
+      if (state.reverb > 0.f) {
+        IPLSimulationInputs inputs = { 0 };
+        inputs.flags = IPL_SIMULATIONFLAGS_REFLECTIONS;
+        inputs.source = sharedInputs.listener;
+        inputs.reverbScale[0] = 1.f;
+        inputs.reverbScale[1] = 1.f;
+        inputs.reverbScale[2] = 1.f;
+        iplSourceSetInputs(state.listener, IPL_SIMULATIONFLAGS_REFLECTIONS, &inputs);
+      }
+
       Source* source;
       FOREACH_SOURCE(mask, source) {
         iplSourceSetInputs(source->handle, IPL_SIMULATIONFLAGS_REFLECTIONS, &source->inputs);
@@ -1008,6 +1073,10 @@ static void phonon_mix_begin(void) {
   if (state.config.reverb.mode == REVERB_PARAMETRIC) {
     memset(state.reflectionBuffer.data[0], 0, BUFFER_SIZE * sizeof(float));
   }
+
+  if (state.reverb > 0.f) {
+    memset(state.listenerReverbInput.data[0], 0, BUFFER_SIZE * sizeof(float));
+  }
 }
 
 static bool phonon_mix_source(Source* source, float* _src, float* dst, float* _tmp) {
@@ -1026,9 +1095,9 @@ static bool phonon_mix_source(Source* source, float* _src, float* dst, float* _t
       memset(dst, 0, 2 * BUFFER_SIZE * sizeof(float));
     }
 
-    if ((source->effects & (1 << EFFECT_REVERB)) && iplReflectionEffectGetTailSize(source->reflectionEffect) > 0) {
+    if (source->reverb > 0.f && iplReflectionEffectGetTailSize(source->reflectionEffect) > 0) {
       if (state.config.reverb.mode == REVERB_CONVOLUTION) {
-        tail |= !iplReflectionEffectGetTail(source->reflectionEffect, NULL, state.reflectionMixer);
+        tail |= !iplReflectionEffectGetTail(source->reflectionEffect, &tmp1, state.reflectionMixer);
       } else {
         tail |= !iplReflectionEffectGetTail(source->reflectionEffect, &tmp1, NULL);
         iplAudioBufferMix(state.phonon, &tmp1, &state.reflectionBuffer);
@@ -1040,7 +1109,7 @@ static bool phonon_mix_source(Source* source, float* _src, float* dst, float* _t
 
   // Feed raw audio to reflection effect (use reflection mixer for convolution, or mix mono reverb
   // into reflectionBuffer for parametric)
-  if (source->effects & (1 << EFFECT_REVERB)) {
+  if (source->reverb > 0.f) {
     IPLSimulationOutputs outputs = { 0 };
     iplSourceGetOutputs(source->handle, IPL_SIMULATIONFLAGS_REFLECTIONS, &outputs);
 
@@ -1058,6 +1127,13 @@ static bool phonon_mix_source(Source* source, float* _src, float* dst, float* _t
     tail |= !iplDirectEffectApply(source->directEffect, params, &src, &src);
   }
 
+  // Accumulate post-direct-effect mono audio for listener-centric reverb
+  if (state.reverb > 0.f && source->reverb <= 0.f) {
+    for (uint32_t i = 0; i < BUFFER_SIZE; i++) {
+      state.listenerReverbInput.data[0][i] += _src[i];
+    }
+  }
+
   // Spatialize to stereo (either binaural, panning, or upmix)
   if (source->effects & (1 << EFFECT_SPATIALIZATION)) {
     if (source->hrtf) {
@@ -1089,18 +1165,43 @@ static bool phonon_mix_source(Source* source, float* _src, float* dst, float* _t
 }
 
 static void phonon_mix_tail(float* dst, float* _tmp) {
-  IPLAudioBuffer tmp = { 2, BUFFER_SIZE, .data = (float*[2]) { _tmp, _tmp + BUFFER_SIZE } };
+  IPLAudioBuffer tmp1 = { .numChannels = 1, .numSamples = BUFFER_SIZE, .data = &_tmp };
+  IPLAudioBuffer tmp2 = { .numChannels = 2, .numSamples = BUFFER_SIZE, .data = (float*[2]) { _tmp, _tmp + BUFFER_SIZE } };
 
-  // TODO?
   Source* source;
   bool hasReverb = false;
   FOREACH_SOURCE(state.activeSourceMask, source) {
-    if (source->effects & (1 << EFFECT_REVERB)) {
+    if (source->reverb > 0.f || iplReflectionEffectGetTailSize(source->reflectionEffect) > 0) {
       hasReverb = true;
       break;
     }
   }
 
+  // Listener-centric reverb
+  if (state.reverb > 0.f) {
+    IPLSimulationOutputs outputs = { 0 };
+    iplSourceGetOutputs(state.listener, IPL_SIMULATIONFLAGS_REFLECTIONS, &outputs);
+
+    if (state.config.reverb.mode == REVERB_CONVOLUTION) {
+      iplReflectionEffectApply(state.reflectionEffect, &outputs.reflections, &state.listenerReverbInput, &tmp1, state.reflectionMixer);
+    } else {
+      iplReflectionEffectApply(state.reflectionEffect, &outputs.reflections, &state.listenerReverbInput, &tmp1, NULL);
+      iplAudioBufferMix(state.phonon, &tmp1, &state.reflectionBuffer);
+    }
+
+    hasReverb = true;
+  } else if (iplReflectionEffectGetTailSize(state.reflectionEffect) > 0) {
+    if (state.config.reverb.mode == REVERB_CONVOLUTION) {
+      iplReflectionEffectGetTail(state.reflectionEffect, &tmp1, state.reflectionMixer);
+    } else {
+      iplReflectionEffectGetTail(state.reflectionEffect, &tmp1, NULL);
+      iplAudioBufferMix(state.phonon, &tmp1, &state.reflectionBuffer);
+    }
+
+    hasReverb = true;
+  }
+
+  // Final reverb mix
   if (state.config.reverb.mode == REVERB_CONVOLUTION) {
     if (hasReverb) {
       IPLReflectionEffectParams reflectionMixerParams = {
@@ -1116,15 +1217,15 @@ static void phonon_mix_tail(float* dst, float* _tmp) {
         .binaural = !!state.hrtf
       };
 
-      iplAmbisonicsDecodeEffectApply(state.ambisonicsDecodeEffect, &ambisonicsDecodeParams, &state.reflectionBuffer, &tmp);
+      iplAmbisonicsDecodeEffectApply(state.ambisonicsDecodeEffect, &ambisonicsDecodeParams, &state.reflectionBuffer, &tmp2);
     } else if (iplAmbisonicsDecodeEffectGetTailSize(state.ambisonicsDecodeEffect) > 0) {
-      iplAmbisonicsDecodeEffectGetTail(state.ambisonicsDecodeEffect, &tmp);
+      iplAmbisonicsDecodeEffectGetTail(state.ambisonicsDecodeEffect, &tmp2);
     }
 
     // Interleave and mix
     for (uint32_t i = 0; i < BUFFER_SIZE; i++) {
-      dst[2 * i + 0] += tmp.data[0][i];
-      dst[2 * i + 1] += tmp.data[1][i];
+      dst[2 * i + 0] += tmp2.data[0][i];
+      dst[2 * i + 1] += tmp2.data[1][i];
     }
   } else if (hasReverb) {
     // Parametric reverb: just upmix mono reflection buffer to stereo and mix into dst
@@ -1333,7 +1434,7 @@ static void phonon_mesh_destroy(AudioMesh* mesh) {
 }
 
 static void phonon_mesh_set_enabled(AudioMesh* mesh, bool enable) {
-  if (mesh->enabled == enable) {
+  if (mesh->enabled != enable) {
     if (enable) {
       iplInstancedMeshAdd(mesh->instancedMesh, state.scene);
     } else {
diff --git a/src/modules/audio/audio.h b/src/modules/audio/audio.h

Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ local conf = {`
`23`	`23`	`reverb = {`
`24`	`24`	`mode = 'convolution',`
`25`	`25`	`rays = 4096,`
`26`		`- bounces = 4,`
	`26`	`+ bounces = 16,`
`27`	`27`	`duration = 2,`
`28`	`28`	`rate = .1`
`29`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,9 @@ bool job_init(uint32_t count, void (*setupWorker)(uint32_t id)) {`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`void job_destroy(void) {`
	`73`	`+ mtx_lock(&state.lock);`
`73`	`74`	`state.quit = true;`
	`75`	`+ mtx_unlock(&state.lock);`
`74`	`76`	`cnd_broadcast(&state.hasJob);`
`75`	`77`	`for (uint32_t i = 0; i < state.workerCount; i++) {`
`76`	`78`	`thrd_join(state.workers[i], NULL);`