kcat/openal-soft
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
openal-soft/Alc/effects/reverb.cpp

1901 lines
73 KiB
C++
Raw Blame History

/**
* Ambisonic reverb engine for the OpenAL cross platform audio library
* Copyright (C) 2008-2017 by Chris Robinson and Christopher Fitzgerald.
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
* Or go to http://www.gnu.org/copyleft/lgpl.html
*/
#include "config.h"
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cmath>
#include <algorithm>
#include "alMain.h"
#include "alcontext.h"
#include "alu.h"
#include "alAuxEffectSlot.h"
#include "alListener.h"
#include "alError.h"
#include "filters/biquad.h"
#include "vector.h"
#include "vecmat.h"
/* This is a user config option for modifying the overall output of the reverb
* effect.
*/
ALfloat ReverbBoost = 1.0f;
namespace {
/* This is the maximum number of samples processed for each inner loop
* iteration.
*/
#define MAX_UPDATE_SAMPLES 256
/* The number of samples used for cross-faded delay lines. This can be used
* to balance the compensation for abrupt line changes and attenuation due to
* minimally lengthed recursive lines. Try to keep this below the device
* update size.
*/
#define FADE_SAMPLES 128
/* The number of spatialized lines or channels to process. Four channels allows
* for a 3D A-Format response. NOTE: This can't be changed without taking care
* of the conversion matrices, and a few places where the length arrays are
* assumed to have 4 elements.
*/
#define NUM_LINES 4
/* The B-Format to A-Format conversion matrix. The arrangement of rows is
* deliberately chosen to align the resulting lines to their spatial opposites
* (0:above front left <-> 3:above back right, 1:below front right <-> 2:below
* back left). It's not quite opposite, since the A-Format results in a
* tetrahedron, but it's close enough. Should the model be extended to 8-lines
* in the future, true opposites can be used.
*/
alignas(16) constexpr ALfloat B2A[NUM_LINES][MAX_AMBI_CHANNELS]{
{ 0.288675134595f, 0.288675134595f, 0.288675134595f, 0.288675134595f },
{ 0.288675134595f, -0.288675134595f, -0.288675134595f, 0.288675134595f },
{ 0.288675134595f, 0.288675134595f, -0.288675134595f, -0.288675134595f },
{ 0.288675134595f, -0.288675134595f, 0.288675134595f, -0.288675134595f }
};
/* Converts A-Format to B-Format. */
constexpr alu::Matrix A2B{
0.866025403785f, 0.866025403785f, 0.866025403785f, 0.866025403785f,
0.866025403785f, -0.866025403785f, 0.866025403785f, -0.866025403785f,
0.866025403785f, -0.866025403785f, -0.866025403785f, 0.866025403785f,
0.866025403785f, 0.866025403785f, -0.866025403785f, -0.866025403785f
};
constexpr ALfloat FadeStep{1.0f / FADE_SAMPLES};
/* The all-pass and delay lines have a variable length dependent on the
* effect's density parameter, which helps alter the perceived environment
* size. The size-to-density conversion is a cubed scale:
*
* density = min(1.0, pow(size, 3.0) / DENSITY_SCALE);
*
* The line lengths scale linearly with room size, so the inverse density
* conversion is needed, taking the cube root of the re-scaled density to
* calculate the line length multiplier:
*
* length_mult = max(5.0, cbrt(density*DENSITY_SCALE));
*
* The density scale below will result in a max line multiplier of 50, for an
* effective size range of 5m to 50m.
*/
constexpr ALfloat DENSITY_SCALE{125000.0f};
/* All delay line lengths are specified in seconds.
*
* To approximate early reflections, we break them up into primary (those
* arriving from the same direction as the source) and secondary (those
* arriving from the opposite direction).
*
* The early taps decorrelate the 4-channel signal to approximate an average
* room response for the primary reflections after the initial early delay.
*
* Given an average room dimension (d_a) and the speed of sound (c) we can
* calculate the average reflection delay (r_a) regardless of listener and
* source positions as:
*
* r_a = d_a / c
* c = 343.3
*
* This can extended to finding the average difference (r_d) between the
* maximum (r_1) and minimum (r_0) reflection delays:
*
* r_0 = 2 / 3 r_a
* = r_a - r_d / 2
* = r_d
* r_1 = 4 / 3 r_a
* = r_a + r_d / 2
* = 2 r_d
* r_d = 2 / 3 r_a
* = r_1 - r_0
*
* As can be determined by integrating the 1D model with a source (s) and
* listener (l) positioned across the dimension of length (d_a):
*
* r_d = int_(l=0)^d_a (int_(s=0)^d_a |2 d_a - 2 (l + s)| ds) dl / c
*
* The initial taps (T_(i=0)^N) are then specified by taking a power series
* that ranges between r_0 and half of r_1 less r_0:
*
* R_i = 2^(i / (2 N - 1)) r_d
* = r_0 + (2^(i / (2 N - 1)) - 1) r_d
* = r_0 + T_i
* T_i = R_i - r_0
* = (2^(i / (2 N - 1)) - 1) r_d
*
* Assuming an average of 1m, we get the following taps:
*/
constexpr ALfloat EARLY_TAP_LENGTHS[NUM_LINES]{
0.0000000e+0f, 2.0213520e-4f, 4.2531060e-4f, 6.7171600e-4f
};
/* The early all-pass filter lengths are based on the early tap lengths:
*
* A_i = R_i / a
*
* Where a is the approximate maximum all-pass cycle limit (20).
*/
const ALfloat EARLY_ALLPASS_LENGTHS[NUM_LINES]{
9.7096800e-5f, 1.0720356e-4f, 1.1836234e-4f, 1.3068260e-4f
};
/* The early delay lines are used to transform the primary reflections into
* the secondary reflections. The A-format is arranged in such a way that
* the channels/lines are spatially opposite:
*
* C_i is opposite C_(N-i-1)
*
* The delays of the two opposing reflections (R_i and O_i) from a source
* anywhere along a particular dimension always sum to twice its full delay:
*
* 2 r_a = R_i + O_i
*
* With that in mind we can determine the delay between the two reflections
* and thus specify our early line lengths (L_(i=0)^N) using:
*
* O_i = 2 r_a - R_(N-i-1)
* L_i = O_i - R_(N-i-1)
* = 2 (r_a - R_(N-i-1))
* = 2 (r_a - T_(N-i-1) - r_0)
* = 2 r_a (1 - (2 / 3) 2^((N - i - 1) / (2 N - 1)))
*
* Using an average dimension of 1m, we get:
*/
constexpr ALfloat EARLY_LINE_LENGTHS[NUM_LINES]{
5.9850400e-4f, 1.0913150e-3f, 1.5376658e-3f, 1.9419362e-3f
};
/* The late all-pass filter lengths are based on the late line lengths:
*
* A_i = (5 / 3) L_i / r_1
*/
constexpr ALfloat LATE_ALLPASS_LENGTHS[NUM_LINES]{
1.6182800e-4f, 2.0389060e-4f, 2.8159360e-4f, 3.2365600e-4f
};
/* The late lines are used to approximate the decaying cycle of recursive
* late reflections.
*
* Splitting the lines in half, we start with the shortest reflection paths
* (L_(i=0)^(N/2)):
*
* L_i = 2^(i / (N - 1)) r_d
*
* Then for the opposite (longest) reflection paths (L_(i=N/2)^N):
*
* L_i = 2 r_a - L_(i-N/2)
* = 2 r_a - 2^((i - N / 2) / (N - 1)) r_d
*
* For our 1m average room, we get:
*/
constexpr ALfloat LATE_LINE_LENGTHS[NUM_LINES]{
1.9419362e-3f, 2.4466860e-3f, 3.3791220e-3f, 3.8838720e-3f
};
struct DelayLineI {
/* The delay lines use interleaved samples, with the lengths being powers
* of 2 to allow the use of bit-masking instead of a modulus for wrapping.
*/
ALsizei Mask{0};
ALfloat (*Line)[NUM_LINES]{nullptr};
};
struct VecAllpass {
DelayLineI Delay;
ALfloat Coeff{0.0f};
ALsizei Offset[NUM_LINES][2]{};
};
struct T60Filter {
/* Two filters are used to adjust the signal. One to control the low
* frequencies, and one to control the high frequencies.
*/
ALfloat MidGain[2]{0.0f, 0.0f};
BiquadFilter HFFilter, LFFilter;
};
struct EarlyReflections {
/* A Gerzon vector all-pass filter is used to simulate initial diffusion.
* The spread from this filter also helps smooth out the reverb tail.
*/
VecAllpass VecAp;
/* An echo line is used to complete the second half of the early
* reflections.
*/
DelayLineI Delay;
ALsizei Offset[NUM_LINES][2]{};
ALfloat Coeff[NUM_LINES][2]{};
/* The gain for each output channel based on 3D panning. */
ALfloat CurrentGain[NUM_LINES][MAX_OUTPUT_CHANNELS]{};
ALfloat PanGain[NUM_LINES][MAX_OUTPUT_CHANNELS]{};
};
struct LateReverb {
/* A recursive delay line is used fill in the reverb tail. */
DelayLineI Delay;
ALsizei Offset[NUM_LINES][2]{};
/* Attenuation to compensate for the modal density and decay rate of the
* late lines.
*/
ALfloat DensityGain[2]{0.0f, 0.0f};
/* T60 decay filters are used to simulate absorption. */
T60Filter T60[NUM_LINES];
/* A Gerzon vector all-pass filter is used to simulate diffusion. */
VecAllpass VecAp;
/* The gain for each output channel based on 3D panning. */
ALfloat CurrentGain[NUM_LINES][MAX_OUTPUT_CHANNELS]{};
ALfloat PanGain[NUM_LINES][MAX_OUTPUT_CHANNELS]{};
};
struct ReverbState final : public EffectState {
/* All delay lines are allocated as a single buffer to reduce memory
* fragmentation and management code.
*/
al::vector<ALfloat,16> mSampleBuffer;
struct {
/* Calculated parameters which indicate if cross-fading is needed after
* an update.
*/
ALfloat Density{AL_EAXREVERB_DEFAULT_DENSITY};
ALfloat Diffusion{AL_EAXREVERB_DEFAULT_DIFFUSION};
ALfloat DecayTime{AL_EAXREVERB_DEFAULT_DECAY_TIME};
ALfloat HFDecayTime{AL_EAXREVERB_DEFAULT_DECAY_HFRATIO * AL_EAXREVERB_DEFAULT_DECAY_TIME};
ALfloat LFDecayTime{AL_EAXREVERB_DEFAULT_DECAY_LFRATIO * AL_EAXREVERB_DEFAULT_DECAY_TIME};
ALfloat HFReference{AL_EAXREVERB_DEFAULT_HFREFERENCE};
ALfloat LFReference{AL_EAXREVERB_DEFAULT_LFREFERENCE};
} mParams;
/* Master effect filters */
struct {
BiquadFilter Lp;
BiquadFilter Hp;
} mFilter[NUM_LINES];
/* Core delay line (early reflections and late reverb tap from this). */
DelayLineI mDelay;
/* Tap points for early reflection delay. */
ALsizei mEarlyDelayTap[NUM_LINES][2]{};
ALfloat mEarlyDelayCoeff[NUM_LINES][2]{};
/* Tap points for late reverb feed and delay. */
ALsizei mLateFeedTap{};
ALsizei mLateDelayTap[NUM_LINES][2]{};
/* Coefficients for the all-pass and line scattering matrices. */
ALfloat mMixX{0.0f};
ALfloat mMixY{0.0f};
EarlyReflections mEarly;
LateReverb mLate;
/* Indicates the cross-fade point for delay line reads [0,FADE_SAMPLES]. */
ALsizei mFadeCount{0};
/* Maximum number of samples to process at once. */
ALsizei mMaxUpdate[2]{MAX_UPDATE_SAMPLES, MAX_UPDATE_SAMPLES};
/* The current write offset for all delay lines. */
ALsizei mOffset{0};
/* Temporary storage used when processing. */
alignas(16) ALfloat mTempSamples[NUM_LINES][MAX_UPDATE_SAMPLES]{};
alignas(16) ALfloat mMixBuffer[NUM_LINES][MAX_UPDATE_SAMPLES]{};
ALboolean deviceUpdate(const ALCdevice *device) override;
void update(const ALCcontext *context, const ALeffectslot *slot, const ALeffectProps *props, const EffectTarget target) override;
void process(ALsizei samplesToDo, const ALfloat (*RESTRICT samplesIn)[BUFFERSIZE], const ALsizei numInput, ALfloat (*RESTRICT samplesOut)[BUFFERSIZE], const ALsizei numOutput) override;
DEF_NEWDEL(ReverbState)
};
/**************************************
* Device Update *
**************************************/
inline ALfloat CalcDelayLengthMult(ALfloat density)
{ return maxf(5.0f, std::cbrt(density*DENSITY_SCALE)); }
/* Given the allocated sample buffer, this function updates each delay line
* offset.
*/
inline ALvoid RealizeLineOffset(ALfloat *sampleBuffer, DelayLineI *Delay)
{
union {
ALfloat *f;
ALfloat (*f4)[NUM_LINES];
} u;
u.f = &sampleBuffer[reinterpret_cast<ptrdiff_t>(Delay->Line) * NUM_LINES];
Delay->Line = u.f4;
}
/* Calculate the length of a delay line and store its mask and offset. */
ALuint CalcLineLength(const ALfloat length, const ptrdiff_t offset, const ALuint frequency,
const ALuint extra, DelayLineI *Delay)
{
ALuint samples;
/* All line lengths are powers of 2, calculated from their lengths in
* seconds, rounded up.
*/
samples = float2int(ceilf(length*frequency));
samples = NextPowerOf2(samples + extra);
/* All lines share a single sample buffer. */
Delay->Mask = samples - 1;
Delay->Line = reinterpret_cast<ALfloat(*)[NUM_LINES]>(offset);
/* Return the sample count for accumulation. */
return samples;
}
/* Calculates the delay line metrics and allocates the shared sample buffer
* for all lines given the sample rate (frequency). If an allocation failure
* occurs, it returns AL_FALSE.
*/
ALboolean AllocLines(const ALuint frequency, ReverbState *State)
{
/* All delay line lengths are calculated to accomodate the full range of
* lengths given their respective paramters.
*/
ALuint totalSamples{0u};
/* Multiplier for the maximum density value, i.e. density=1, which is
* actually the least density...
*/
ALfloat multiplier{CalcDelayLengthMult(AL_EAXREVERB_MAX_DENSITY)};
/* The main delay length includes the maximum early reflection delay, the
* largest early tap width, the maximum late reverb delay, and the
* largest late tap width. Finally, it must also be extended by the
* update size (MAX_UPDATE_SAMPLES) for block processing.
*/
ALfloat length{AL_EAXREVERB_MAX_REFLECTIONS_DELAY + EARLY_TAP_LENGTHS[NUM_LINES-1]*multiplier +
AL_EAXREVERB_MAX_LATE_REVERB_DELAY +
(LATE_LINE_LENGTHS[NUM_LINES-1] - LATE_LINE_LENGTHS[0])*0.25f*multiplier};
totalSamples += CalcLineLength(length, totalSamples, frequency, MAX_UPDATE_SAMPLES,
&State->mDelay);
/* The early vector all-pass line. */
length = EARLY_ALLPASS_LENGTHS[NUM_LINES-1] * multiplier;
totalSamples += CalcLineLength(length, totalSamples, frequency, 0,
&State->mEarly.VecAp.Delay);
/* The early reflection line. */
length = EARLY_LINE_LENGTHS[NUM_LINES-1] * multiplier;
totalSamples += CalcLineLength(length, totalSamples, frequency, 0,
&State->mEarly.Delay);
/* The late vector all-pass line. */
length = LATE_ALLPASS_LENGTHS[NUM_LINES-1] * multiplier;
totalSamples += CalcLineLength(length, totalSamples, frequency, 0,
&State->mLate.VecAp.Delay);
/* The late delay lines are calculated from the largest maximum density
* line length.
*/
length = LATE_LINE_LENGTHS[NUM_LINES-1] * multiplier;
totalSamples += CalcLineLength(length, totalSamples, frequency, 0,
&State->mLate.Delay);
totalSamples *= NUM_LINES;
if(totalSamples != State->mSampleBuffer.size())
{
State->mSampleBuffer.resize(totalSamples);
State->mSampleBuffer.shrink_to_fit();
}
/* Clear the sample buffer. */
std::fill(State->mSampleBuffer.begin(), State->mSampleBuffer.end(), 0.0f);
/* Update all delays to reflect the new sample buffer. */
RealizeLineOffset(State->mSampleBuffer.data(), &State->mDelay);
RealizeLineOffset(State->mSampleBuffer.data(), &State->mEarly.VecAp.Delay);
RealizeLineOffset(State->mSampleBuffer.data(), &State->mEarly.Delay);
RealizeLineOffset(State->mSampleBuffer.data(), &State->mLate.VecAp.Delay);
RealizeLineOffset(State->mSampleBuffer.data(), &State->mLate.Delay);
return AL_TRUE;
}
ALboolean ReverbState::deviceUpdate(const ALCdevice *Device)
{
const ALuint frequency{Device->Frequency};
/* Allocate the delay lines. */
if(!AllocLines(frequency, this))
return AL_FALSE;
const ALfloat multiplier{CalcDelayLengthMult(AL_EAXREVERB_MAX_DENSITY)};
/* The late feed taps are set a fixed position past the latest delay tap. */
mLateFeedTap = float2int((AL_EAXREVERB_MAX_REFLECTIONS_DELAY +
EARLY_TAP_LENGTHS[NUM_LINES-1]*multiplier) *
frequency);
/* Clear filters and gain coefficients since the delay lines were all just
* cleared (if not reallocated).
*/
for(auto &filter : mFilter)
{
filter.Lp.clear();
filter.Hp.clear();
}
for(auto &coeff : mEarlyDelayCoeff)
std::fill(std::begin(coeff), std::end(coeff), 0.0f);
for(auto &coeff : mEarly.Coeff)
std::fill(std::begin(coeff), std::end(coeff), 0.0f);
mLate.DensityGain[0] = 0.0f;
mLate.DensityGain[1] = 0.0f;
for(auto &t60 : mLate.T60)
{
t60.MidGain[0] = 0.0f;
t60.MidGain[1] = 0.0f;
t60.HFFilter.clear();
t60.LFFilter.clear();
}
for(auto &gains : mEarly.CurrentGain)
std::fill(std::begin(gains), std::end(gains), 0.0f);
for(auto &gains : mEarly.PanGain)
std::fill(std::begin(gains), std::end(gains), 0.0f);
for(auto &gains : mLate.CurrentGain)
std::fill(std::begin(gains), std::end(gains), 0.0f);
for(auto &gains : mLate.PanGain)
std::fill(std::begin(gains), std::end(gains), 0.0f);
/* Reset counters and offset base. */
mFadeCount = 0;
std::fill(std::begin(mMaxUpdate), std::end(mMaxUpdate), MAX_UPDATE_SAMPLES);
mOffset = 0;
return AL_TRUE;
}
/**************************************
* Effect Update *
**************************************/
/* Calculate a decay coefficient given the length of each cycle and the time
* until the decay reaches -60 dB.
*/
inline ALfloat CalcDecayCoeff(const ALfloat length, const ALfloat decayTime)
{ return std::pow(REVERB_DECAY_GAIN, length/decayTime); }
/* Calculate a decay length from a coefficient and the time until the decay
* reaches -60 dB.
*/
inline ALfloat CalcDecayLength(const ALfloat coeff, const ALfloat decayTime)
{ return std::log10(coeff) * decayTime / std::log10(REVERB_DECAY_GAIN); }
/* Calculate an attenuation to be applied to the input of any echo models to
* compensate for modal density and decay time.
*/
inline ALfloat CalcDensityGain(const ALfloat a)
{
/* The energy of a signal can be obtained by finding the area under the
* squared signal. This takes the form of Sum(x_n^2), where x is the
* amplitude for the sample n.
*
* Decaying feedback matches exponential decay of the form Sum(a^n),
* where a is the attenuation coefficient, and n is the sample. The area
* under this decay curve can be calculated as: 1 / (1 - a).
*
* Modifying the above equation to find the area under the squared curve
* (for energy) yields: 1 / (1 - a^2). Input attenuation can then be
* calculated by inverting the square root of this approximation,
* yielding: 1 / sqrt(1 / (1 - a^2)), simplified to: sqrt(1 - a^2).
*/
return std::sqrt(1.0f - a*a);
}
/* Calculate the scattering matrix coefficients given a diffusion factor. */
inline ALvoid CalcMatrixCoeffs(const ALfloat diffusion, ALfloat *x, ALfloat *y)
{
/* The matrix is of order 4, so n is sqrt(4 - 1). */
ALfloat n{std::sqrt(3.0f)};
ALfloat t{diffusion * std::atan(n)};
/* Calculate the first mixing matrix coefficient. */
*x = std::cos(t);
/* Calculate the second mixing matrix coefficient. */
*y = std::sin(t) / n;
}
/* Calculate the limited HF ratio for use with the late reverb low-pass
* filters.
*/
ALfloat CalcLimitedHfRatio(const ALfloat hfRatio, const ALfloat airAbsorptionGainHF,
const ALfloat decayTime, const ALfloat SpeedOfSound)
{
/* Find the attenuation due to air absorption in dB (converting delay
* time to meters using the speed of sound). Then reversing the decay
* equation, solve for HF ratio. The delay length is cancelled out of
* the equation, so it can be calculated once for all lines.
*/
ALfloat limitRatio{1.0f / (CalcDecayLength(airAbsorptionGainHF, decayTime) * SpeedOfSound)};
/* Using the limit calculated above, apply the upper bound to the HF ratio.
*/
return minf(limitRatio, hfRatio);
}
/* Calculates the 3-band T60 damping coefficients for a particular delay line
* of specified length, using a combination of two shelf filter sections given
* decay times for each band split at two reference frequencies.
*/
void CalcT60DampingCoeffs(const ALfloat length, const ALfloat lfDecayTime,
const ALfloat mfDecayTime, const ALfloat hfDecayTime,
const ALfloat lf0norm, const ALfloat hf0norm,
T60Filter *filter)
{
ALfloat lfGain{CalcDecayCoeff(length, lfDecayTime)};
ALfloat mfGain{CalcDecayCoeff(length, mfDecayTime)};
ALfloat hfGain{CalcDecayCoeff(length, hfDecayTime)};
filter->MidGain[1] = mfGain;
filter->LFFilter.setParams(BiquadType::LowShelf, lfGain/mfGain, lf0norm,
calc_rcpQ_from_slope(lfGain/mfGain, 1.0f));
filter->HFFilter.setParams(BiquadType::HighShelf, hfGain/mfGain, hf0norm,
calc_rcpQ_from_slope(hfGain/mfGain, 1.0f));
}
/* Update the offsets for the main effect delay line. */
ALvoid UpdateDelayLine(const ALfloat earlyDelay, const ALfloat lateDelay, const ALfloat density, const ALfloat decayTime, const ALuint frequency, ReverbState *State)
{
const ALfloat multiplier{CalcDelayLengthMult(density)};
/* Early reflection taps are decorrelated by means of an average room
* reflection approximation described above the definition of the taps.
* This approximation is linear and so the above density multiplier can
* be applied to adjust the width of the taps. A single-band decay
* coefficient is applied to simulate initial attenuation and absorption.
*
* Late reverb taps are based on the late line lengths to allow a zero-
* delay path and offsets that would continue the propagation naturally
* into the late lines.
*/
for(ALsizei i{0};i < NUM_LINES;i++)
{
ALfloat length{earlyDelay + EARLY_TAP_LENGTHS[i]*multiplier};
State->mEarlyDelayTap[i][1] = float2int(length * frequency);
length = EARLY_TAP_LENGTHS[i]*multiplier;
State->mEarlyDelayCoeff[i][1] = CalcDecayCoeff(length, decayTime);
length = lateDelay + (LATE_LINE_LENGTHS[i] - LATE_LINE_LENGTHS[0])*0.25f*multiplier;
State->mLateDelayTap[i][1] = State->mLateFeedTap + float2int(length * frequency);
}
}
/* Update the early reflection line lengths and gain coefficients. */
ALvoid UpdateEarlyLines(const ALfloat density, const ALfloat diffusion, const ALfloat decayTime, const ALuint frequency, EarlyReflections *Early)
{
const ALfloat multiplier{CalcDelayLengthMult(density)};
/* Calculate the all-pass feed-back/forward coefficient. */
Early->VecAp.Coeff = sqrtf(0.5f) * powf(diffusion, 2.0f);
for(ALsizei i{0};i < NUM_LINES;i++)
{
/* Calculate the length (in seconds) of each all-pass line. */
ALfloat length{EARLY_ALLPASS_LENGTHS[i] * multiplier};
/* Calculate the delay offset for each all-pass line. */
Early->VecAp.Offset[i][1] = float2int(length * frequency);
/* Calculate the length (in seconds) of each delay line. */
length = EARLY_LINE_LENGTHS[i] * multiplier;
/* Calculate the delay offset for each delay line. */
Early->Offset[i][1] = float2int(length * frequency);
/* Calculate the gain (coefficient) for each line. */
Early->Coeff[i][1] = CalcDecayCoeff(length, decayTime);
}
}
/* Update the late reverb line lengths and T60 coefficients. */
ALvoid UpdateLateLines(const ALfloat density, const ALfloat diffusion, const ALfloat lfDecayTime, const ALfloat mfDecayTime, const ALfloat hfDecayTime, const ALfloat lf0norm, const ALfloat hf0norm, const ALuint frequency, LateReverb *Late)
{
/* Scaling factor to convert the normalized reference frequencies from
* representing 0...freq to 0...max_reference.
*/
const ALfloat norm_weight_factor = static_cast<ALfloat>(frequency) / AL_EAXREVERB_MAX_HFREFERENCE;
/* To compensate for changes in modal density and decay time of the late
* reverb signal, the input is attenuated based on the maximal energy of
* the outgoing signal. This approximation is used to keep the apparent
* energy of the signal equal for all ranges of density and decay time.
*
* The average length of the delay lines is used to calculate the
* attenuation coefficient.
*/
const ALfloat multiplier{CalcDelayLengthMult(density)};
ALfloat length{
(LATE_LINE_LENGTHS[0] + LATE_LINE_LENGTHS[1] + LATE_LINE_LENGTHS[2] +
LATE_LINE_LENGTHS[3]) / 4.0f * multiplier};
length += (LATE_ALLPASS_LENGTHS[0] + LATE_ALLPASS_LENGTHS[1] +
LATE_ALLPASS_LENGTHS[2] + LATE_ALLPASS_LENGTHS[3]) / 4.0f * multiplier;
/* The density gain calculation uses an average decay time weighted by
* approximate bandwidth. This attempts to compensate for losses of energy
* that reduce decay time due to scattering into highly attenuated bands.
*/
const ALfloat bandWeights[3]{
lf0norm*norm_weight_factor,
hf0norm*norm_weight_factor - lf0norm*norm_weight_factor,
1.0f - hf0norm*norm_weight_factor};
Late->DensityGain[1] = CalcDensityGain(
CalcDecayCoeff(length,
bandWeights[0]*lfDecayTime + bandWeights[1]*mfDecayTime + bandWeights[2]*hfDecayTime
)
);
/* Calculate the all-pass feed-back/forward coefficient. */
Late->VecAp.Coeff = std::sqrt(0.5f) * std::pow(diffusion, 2.0f);
for(ALsizei i{0};i < NUM_LINES;i++)
{
/* Calculate the length (in seconds) of each all-pass line. */
length = LATE_ALLPASS_LENGTHS[i] * multiplier;
/* Calculate the delay offset for each all-pass line. */
Late->VecAp.Offset[i][1] = float2int(length * frequency);
/* Calculate the length (in seconds) of each delay line. */
length = LATE_LINE_LENGTHS[i] * multiplier;
/* Calculate the delay offset for each delay line. */
Late->Offset[i][1] = float2int(length*frequency + 0.5f);
/* Approximate the absorption that the vector all-pass would exhibit
* given the current diffusion so we don't have to process a full T60
* filter for each of its four lines.
*/
length += lerp(LATE_ALLPASS_LENGTHS[i],
(LATE_ALLPASS_LENGTHS[0] + LATE_ALLPASS_LENGTHS[1] +
LATE_ALLPASS_LENGTHS[2] + LATE_ALLPASS_LENGTHS[3]) / 4.0f,
diffusion) * multiplier;
/* Calculate the T60 damping coefficients for each line. */
CalcT60DampingCoeffs(length, lfDecayTime, mfDecayTime, hfDecayTime,
lf0norm, hf0norm, &Late->T60[i]);
}
}
/* Creates a transform matrix given a reverb vector. The vector pans the reverb
* reflections toward the given direction, using its magnitude (up to 1) as a
* focal strength. This function results in a B-Format transformation matrix
* that spatially focuses the signal in the desired direction.
*/
alu::Matrix GetTransformFromVector(const ALfloat *vec)
{
/* Normalize the panning vector according to the N3D scale, which has an
* extra sqrt(3) term on the directional components. Converting from OpenAL
* to B-Format also requires negating X (ACN 1) and Z (ACN 3). Note however
* that the reverb panning vectors use left-handed coordinates, unlike the
* rest of OpenAL which use right-handed. This is fixed by negating Z,
* which cancels out with the B-Format Z negation.
*/
ALfloat norm[3];
ALfloat mag{std::sqrt(vec[0]*vec[0] + vec[1]*vec[1] + vec[2]*vec[2])};
if(mag > 1.0f)
{
norm[0] = vec[0] / mag * -al::MathDefs<float>::Sqrt3();
norm[1] = vec[1] / mag * al::MathDefs<float>::Sqrt3();
norm[2] = vec[2] / mag * al::MathDefs<float>::Sqrt3();
mag = 1.0f;
}
else
{
/* If the magnitude is less than or equal to 1, just apply the sqrt(3)
* term. There's no need to renormalize the magnitude since it would
* just be reapplied in the matrix.
*/
norm[0] = vec[0] * -al::MathDefs<float>::Sqrt3();
norm[1] = vec[1] * al::MathDefs<float>::Sqrt3();
norm[2] = vec[2] * al::MathDefs<float>::Sqrt3();
}
return alu::Matrix{
1.0f, 0.0f, 0.0f, 0.0f,
norm[0], 1.0f-mag, 0.0f, 0.0f,
norm[1], 0.0f, 1.0f-mag, 0.0f,
norm[2], 0.0f, 0.0f, 1.0f-mag
};
}
/* Update the early and late 3D panning gains. */
ALvoid Update3DPanning(const ALfloat *ReflectionsPan, const ALfloat *LateReverbPan, const ALfloat earlyGain, const ALfloat lateGain, const EffectTarget &target, ReverbState *State)
{
/* Note: ret is transposed. */
auto MatrixMult = [](const alu::Matrix &m1, const alu::Matrix &m2) noexcept -> alu::Matrix
{
alu::Matrix ret;
for(int col{0};col < 4;col++)
{
for(int row{0};row < 4;row++)
ret[col][row] = m1[row][0]*m2[0][col] + m1[row][1]*m2[1][col] +
m1[row][2]*m2[2][col] + m1[row][3]*m2[3][col];
}
return ret;
};
/* Create a matrix that first converts A-Format to B-Format, then
* transforms the B-Format signal according to the panning vector.
*/
alu::Matrix earlymat{MatrixMult(GetTransformFromVector(ReflectionsPan), A2B)};
alu::Matrix latemat{MatrixMult(GetTransformFromVector(LateReverbPan), A2B)};
State->mOutBuffer = target.FOAOut->Buffer;
State->mOutChannels = target.FOAOut->NumChannels;
for(ALsizei i{0};i < NUM_LINES;i++)
ComputePanGains(target.FOAOut, earlymat[i].data(), earlyGain,
State->mEarly.PanGain[i]);
for(ALsizei i{0};i < NUM_LINES;i++)
ComputePanGains(target.FOAOut, latemat[i].data(), lateGain, State->mLate.PanGain[i]);
}
void ReverbState::update(const ALCcontext *Context, const ALeffectslot *Slot, const ALeffectProps *props, const EffectTarget target)
{
const ALCdevice *Device{Context->Device};
const ALlistener &Listener = Context->Listener;
const ALuint frequency{Device->Frequency};
/* Calculate the master filters */
ALfloat hf0norm{minf(props->Reverb.HFReference / frequency, 0.49f)};
/* Restrict the filter gains from going below -60dB to keep the filter from
* killing most of the signal.
*/
ALfloat gainhf{maxf(props->Reverb.GainHF, 0.001f)};
mFilter[0].Lp.setParams(BiquadType::HighShelf, gainhf, hf0norm,
calc_rcpQ_from_slope(gainhf, 1.0f));
ALfloat lf0norm{minf(props->Reverb.LFReference / frequency, 0.49f)};
ALfloat gainlf{maxf(props->Reverb.GainLF, 0.001f)};
mFilter[0].Hp.setParams(BiquadType::LowShelf, gainlf, lf0norm,
calc_rcpQ_from_slope(gainlf, 1.0f));
for(ALsizei i{1};i < NUM_LINES;i++)
{
mFilter[i].Lp.copyParamsFrom(mFilter[0].Lp);
mFilter[i].Hp.copyParamsFrom(mFilter[0].Hp);
}
/* Update the main effect delay and associated taps. */
UpdateDelayLine(props->Reverb.ReflectionsDelay, props->Reverb.LateReverbDelay,
props->Reverb.Density, props->Reverb.DecayTime, frequency,
this);
/* Update the early lines. */
UpdateEarlyLines(props->Reverb.Density, props->Reverb.Diffusion,
props->Reverb.DecayTime, frequency, &mEarly);
/* Get the mixing matrix coefficients. */
CalcMatrixCoeffs(props->Reverb.Diffusion, &mMixX, &mMixY);
/* If the HF limit parameter is flagged, calculate an appropriate limit
* based on the air absorption parameter.
*/
ALfloat hfRatio{props->Reverb.DecayHFRatio};
if(props->Reverb.DecayHFLimit && props->Reverb.AirAbsorptionGainHF < 1.0f)
hfRatio = CalcLimitedHfRatio(hfRatio, props->Reverb.AirAbsorptionGainHF,
props->Reverb.DecayTime, Listener.Params.ReverbSpeedOfSound
);
/* Calculate the LF/HF decay times. */
const ALfloat lfDecayTime{clampf(props->Reverb.DecayTime * props->Reverb.DecayLFRatio,
AL_EAXREVERB_MIN_DECAY_TIME, AL_EAXREVERB_MAX_DECAY_TIME)};
const ALfloat hfDecayTime{clampf(props->Reverb.DecayTime * hfRatio,
AL_EAXREVERB_MIN_DECAY_TIME, AL_EAXREVERB_MAX_DECAY_TIME)};
/* Update the late lines. */
UpdateLateLines(props->Reverb.Density, props->Reverb.Diffusion,
lfDecayTime, props->Reverb.DecayTime, hfDecayTime, lf0norm, hf0norm,
frequency, &mLate
);
/* Update early and late 3D panning. */
const ALfloat gain{props->Reverb.Gain * Slot->Params.Gain * ReverbBoost};
Update3DPanning(props->Reverb.ReflectionsPan, props->Reverb.LateReverbPan,
props->Reverb.ReflectionsGain*gain, props->Reverb.LateReverbGain*gain, target, this);
/* Calculate the max update size from the smallest relevant delay. */
mMaxUpdate[1] = mini(MAX_UPDATE_SAMPLES, mini(mEarly.Offset[0][1], mLate.Offset[0][1]));
/* Determine if delay-line cross-fading is required. Density is essentially
* a master control for the feedback delays, so changes the offsets of many
* delay lines.
*/
if(mParams.Density != props->Reverb.Density ||
/* Diffusion and decay times influences the decay rate (gain) of the
* late reverb T60 filter.
*/
mParams.Diffusion != props->Reverb.Diffusion ||
mParams.DecayTime != props->Reverb.DecayTime ||
mParams.HFDecayTime != hfDecayTime ||
mParams.LFDecayTime != lfDecayTime ||
/* HF/LF References control the weighting used to calculate the density
* gain.
*/
mParams.HFReference != props->Reverb.HFReference ||
mParams.LFReference != props->Reverb.LFReference)
mFadeCount = 0;
mParams.Density = props->Reverb.Density;
mParams.Diffusion = props->Reverb.Diffusion;
mParams.DecayTime = props->Reverb.DecayTime;
mParams.HFDecayTime = hfDecayTime;
mParams.LFDecayTime = lfDecayTime;
mParams.HFReference = props->Reverb.HFReference;
mParams.LFReference = props->Reverb.LFReference;
}
/**************************************
* Effect Processing *
**************************************/
/* Basic delay line input/output routines. */
inline ALfloat DelayLineOut(const DelayLineI *Delay, const ALsizei offset, const ALsizei c)
{ return Delay->Line[offset&Delay->Mask][c]; }
/* Cross-faded delay line output routine. Instead of interpolating the
* offsets, this interpolates (cross-fades) the outputs at each offset.
*/
inline ALfloat FadedDelayLineOut(const DelayLineI *Delay, const ALsizei off0, const ALsizei off1,
const ALsizei c, const ALfloat sc0, const ALfloat sc1)
{
return Delay->Line[off0&Delay->Mask][c]*sc0 +
Delay->Line[off1&Delay->Mask][c]*sc1;
}
inline void DelayLineIn(const DelayLineI *Delay, ALsizei offset, const ALsizei c,
const ALfloat *RESTRICT in, ALsizei count)
{
ASSUME(count > 0);
for(ALsizei i{0};i < count;i++)
Delay->Line[(offset++)&Delay->Mask][c] = *(in++);
}
/* Applies a scattering matrix to the 4-line (vector) input. This is used
* for both the below vector all-pass model and to perform modal feed-back
* delay network (FDN) mixing.
*
* The matrix is derived from a skew-symmetric matrix to form a 4D rotation
* matrix with a single unitary rotational parameter:
*
* [ d, a, b, c ] 1 = a^2 + b^2 + c^2 + d^2
* [ -a, d, c, -b ]
* [ -b, -c, d, a ]
* [ -c, b, -a, d ]
*
* The rotation is constructed from the effect's diffusion parameter,
* yielding:
*
* 1 = x^2 + 3 y^2
*
* Where a, b, and c are the coefficient y with differing signs, and d is the
* coefficient x. The final matrix is thus:
*
* [ x, y, -y, y ] n = sqrt(matrix_order - 1)
* [ -y, x, y, y ] t = diffusion_parameter * atan(n)
* [ y, -y, x, y ] x = cos(t)
* [ -y, -y, -y, x ] y = sin(t) / n
*
* Any square orthogonal matrix with an order that is a power of two will
* work (where ^T is transpose, ^-1 is inverse):
*
* M^T = M^-1
*
* Using that knowledge, finding an appropriate matrix can be accomplished
* naively by searching all combinations of:
*
* M = D + S - S^T
*
* Where D is a diagonal matrix (of x), and S is a triangular matrix (of y)
* whose combination of signs are being iterated.
*/
inline void VectorPartialScatter(ALfloat *RESTRICT out, const ALfloat *RESTRICT in,
const ALfloat xCoeff, const ALfloat yCoeff)
{
out[0] = xCoeff*in[0] + yCoeff*( in[1] + -in[2] + in[3]);
out[1] = xCoeff*in[1] + yCoeff*(-in[0] + in[2] + in[3]);
out[2] = xCoeff*in[2] + yCoeff*( in[0] + -in[1] + in[3]);
out[3] = xCoeff*in[3] + yCoeff*(-in[0] + -in[1] + -in[2] );
}
#define VectorScatterDelayIn(delay, o, in, xcoeff, ycoeff) \
VectorPartialScatter((delay)->Line[(o)&(delay)->Mask], in, xcoeff, ycoeff)
/* Utilizes the above, but reverses the input channels. */
inline void VectorScatterRevDelayIn(const DelayLineI *Delay, ALint offset,
const ALfloat xCoeff, const ALfloat yCoeff,
const ALfloat (*RESTRICT in)[MAX_UPDATE_SAMPLES],
const ALsizei count)
{
const DelayLineI delay{*Delay};
for(ALsizei i{0};i < count;++i)
{
ALfloat f[NUM_LINES];
for(ALsizei j{0};j < NUM_LINES;j++)
f[NUM_LINES-1-j] = in[j][i];
VectorScatterDelayIn(&delay, offset++, f, xCoeff, yCoeff);
}
}
/* This applies a Gerzon multiple-in/multiple-out (MIMO) vector all-pass
* filter to the 4-line input.
*
* It works by vectorizing a regular all-pass filter and replacing the delay
* element with a scattering matrix (like the one above) and a diagonal
* matrix of delay elements.
*
* Two static specializations are used for transitional (cross-faded) delay
* line processing and non-transitional processing.
*/
void VectorAllpass_Unfaded(ALfloat (*RESTRICT samples)[MAX_UPDATE_SAMPLES], ALsizei offset,
const ALfloat xCoeff, const ALfloat yCoeff, ALsizei todo,
VecAllpass *Vap)
{
const DelayLineI delay{Vap->Delay};
const ALfloat feedCoeff{Vap->Coeff};
ASSUME(todo > 0);
ALsizei vap_offset[NUM_LINES];
for(ALsizei j{0};j < NUM_LINES;j++)
vap_offset[j] = offset - Vap->Offset[j][0];
for(ALsizei i{0};i < todo;i++)
{
ALfloat f[NUM_LINES];
for(ALsizei j{0};j < NUM_LINES;j++)
{
ALfloat input = samples[j][i];
ALfloat out = DelayLineOut(&delay, vap_offset[j]++, j) - feedCoeff*input;
f[j] = input + feedCoeff*out;
samples[j][i] = out;
}
VectorScatterDelayIn(&delay, offset, f, xCoeff, yCoeff);
++offset;
}
}
void VectorAllpass_Faded(ALfloat (*RESTRICT samples)[MAX_UPDATE_SAMPLES], ALsizei offset,
const ALfloat xCoeff, const ALfloat yCoeff, ALfloat fade,
ALsizei todo, VecAllpass *Vap)
{
const DelayLineI delay{Vap->Delay};
const ALfloat feedCoeff{Vap->Coeff};
ASSUME(todo > 0);
fade *= 1.0f/FADE_SAMPLES;
ALsizei vap_offset[NUM_LINES][2];
for(ALsizei j{0};j < NUM_LINES;j++)
{
vap_offset[j][0] = offset - Vap->Offset[j][0];
vap_offset[j][1] = offset - Vap->Offset[j][1];
}
for(ALsizei i{0};i < todo;i++)
{
ALfloat f[NUM_LINES];
for(ALsizei j{0};j < NUM_LINES;j++)
{
ALfloat input = samples[j][i];
ALfloat out =
FadedDelayLineOut(&delay, vap_offset[j][0]++, vap_offset[j][1]++, j,
1.0f-fade, fade
) - feedCoeff*input;
f[j] = input + feedCoeff*out;
samples[j][i] = out;
}
fade += FadeStep;
VectorScatterDelayIn(&delay, offset, f, xCoeff, yCoeff);
++offset;
}
}
/* This generates early reflections.
*
* This is done by obtaining the primary reflections (those arriving from the
* same direction as the source) from the main delay line. These are
* attenuated and all-pass filtered (based on the diffusion parameter).
*
* The early lines are then fed in reverse (according to the approximately
* opposite spatial location of the A-Format lines) to create the secondary
* reflections (those arriving from the opposite direction as the source).
*
* The early response is then completed by combining the primary reflections
* with the delayed and attenuated output from the early lines.
*
* Finally, the early response is reversed, scattered (based on diffusion),
* and fed into the late reverb section of the main delay line.
*
* Two static specializations are used for transitional (cross-faded) delay
* line processing and non-transitional processing.
*/
void EarlyReflection_Unfaded(ReverbState *State, ALsizei offset, const ALsizei todo,
ALfloat (*RESTRICT out)[MAX_UPDATE_SAMPLES])
{
ALfloat (*RESTRICT temps)[MAX_UPDATE_SAMPLES]{State->mTempSamples};
const DelayLineI early_delay{State->mEarly.Delay};
const DelayLineI main_delay{State->mDelay};
const ALfloat mixX{State->mMixX};
const ALfloat mixY{State->mMixY};
ASSUME(todo > 0);
/* First, load decorrelated samples from the main delay line as the primary
* reflections.
*/
for(ALsizei j{0};j < NUM_LINES;j++)
{
ALsizei early_delay_tap{offset - State->mEarlyDelayTap[j][0]};
const ALfloat coeff{State->mEarlyDelayCoeff[j][0]};
for(ALsizei i{0};i < todo;i++)
temps[j][i] = DelayLineOut(&main_delay, early_delay_tap++, j) * coeff;
}
/* Apply a vector all-pass, to help color the initial reflections based on
* the diffusion strength.
*/
VectorAllpass_Unfaded(temps, offset, mixX, mixY, todo, &State->mEarly.VecAp);
/* Apply a delay and bounce to generate secondary reflections, combine with
* the primary reflections and write out the result for mixing.
*/
for(ALsizei j{0};j < NUM_LINES;j++)
{
ALint early_feedb_tap{offset - State->mEarly.Offset[j][0]};
const ALfloat early_feedb_coeff{State->mEarly.Coeff[j][0]};
for(ALsizei i{0};i < todo;i++)
out[j][i] = DelayLineOut(&early_delay, early_feedb_tap++, j)*early_feedb_coeff +
temps[j][i];
}
for(ALsizei j{0};j < NUM_LINES;j++)
DelayLineIn(&early_delay, offset, NUM_LINES-1-j, temps[j], todo);
/* Also write the result back to the main delay line for the late reverb
* stage to pick up at the appropriate time, appplying a scatter and
* bounce to improve the initial diffusion in the late reverb.
*/
const ALsizei late_feed_tap{offset - State->mLateFeedTap};
VectorScatterRevDelayIn(&main_delay, late_feed_tap, mixX, mixY, out, todo);
}
void EarlyReflection_Faded(ReverbState *State, ALsizei offset, const ALsizei todo,
const ALfloat fade, ALfloat (*RESTRICT out)[MAX_UPDATE_SAMPLES])
{
ALfloat (*RESTRICT temps)[MAX_UPDATE_SAMPLES]{State->mTempSamples};
const DelayLineI early_delay{State->mEarly.Delay};
const DelayLineI main_delay{State->mDelay};
const ALfloat mixX{State->mMixX};
const ALfloat mixY{State->mMixY};
ASSUME(todo > 0);
for(ALsizei j{0};j < NUM_LINES;j++)
{
ALsizei early_delay_tap0 = offset - State->mEarlyDelayTap[j][0];
ALsizei early_delay_tap1 = offset - State->mEarlyDelayTap[j][1];
ALfloat oldCoeff = State->mEarlyDelayCoeff[j][0];
ALfloat oldCoeffStep = -oldCoeff / FADE_SAMPLES;
ALfloat newCoeffStep = State->mEarlyDelayCoeff[j][1] / FADE_SAMPLES;
ALfloat fadeCount = fade;
for(ALsizei i{0};i < todo;i++)
{
const ALfloat fade0 = oldCoeff + oldCoeffStep*fadeCount;
const ALfloat fade1 = newCoeffStep*fadeCount;
temps[j][i] = FadedDelayLineOut(&main_delay,
early_delay_tap0++, early_delay_tap1++, j, fade0, fade1
);
fadeCount += 1.0f;
}
}
VectorAllpass_Faded(temps, offset, mixX, mixY, fade, todo, &State->mEarly.VecAp);
for(ALsizei j{0};j < NUM_LINES;j++)
{
ALint feedb_tap0{offset - State->mEarly.Offset[j][0]};
ALint feedb_tap1{offset - State->mEarly.Offset[j][1]};
const ALfloat feedb_oldCoeff{State->mEarly.Coeff[j][0]};
const ALfloat feedb_oldCoeffStep{-feedb_oldCoeff / FADE_SAMPLES};
const ALfloat feedb_newCoeffStep{State->mEarly.Coeff[j][1] / FADE_SAMPLES};
ALfloat fadeCount{fade};
for(ALsizei i{0};i < todo;i++)
{
const ALfloat fade0{feedb_oldCoeff + feedb_oldCoeffStep*fadeCount};
const ALfloat fade1{feedb_newCoeffStep*fadeCount};
out[j][i] = FadedDelayLineOut(&early_delay,
feedb_tap0++, feedb_tap1++, j, fade0, fade1
) + temps[j][i];
fadeCount += 1.0f;
}
}
for(ALsizei j{0};j < NUM_LINES;j++)
DelayLineIn(&early_delay, offset, NUM_LINES-1-j, temps[j], todo);
const ALsizei late_feed_tap{offset - State->mLateFeedTap};
VectorScatterRevDelayIn(&main_delay, late_feed_tap, mixX, mixY, out, todo);
}
/* Applies the two T60 damping filter sections. */
inline void LateT60Filter(ALfloat *samples, const ALsizei todo, T60Filter *filter)
{
filter->HFFilter.process(samples, samples, todo);
filter->LFFilter.process(samples, samples, todo);
}
/* This generates the reverb tail using a modified feed-back delay network
* (FDN).
*
* Results from the early reflections are mixed with the output from the late
* delay lines.
*
* The late response is then completed by T60 and all-pass filtering the mix.
*
* Finally, the lines are reversed (so they feed their opposite directions)
* and scattered with the FDN matrix before re-feeding the delay lines.
*
* Two variations are made, one for for transitional (cross-faded) delay line
* processing and one for non-transitional processing.
*/
void LateReverb_Unfaded(ReverbState *State, ALsizei offset, const ALsizei todo,
ALfloat (*RESTRICT out)[MAX_UPDATE_SAMPLES])
{
ALfloat (*RESTRICT temps)[MAX_UPDATE_SAMPLES]{State->mTempSamples};
const DelayLineI late_delay{State->mLate.Delay};
const DelayLineI main_delay{State->mDelay};
const ALfloat mixX{State->mMixX};
const ALfloat mixY{State->mMixY};
ASSUME(todo > 0);
/* First, load decorrelated samples from the main and feedback delay lines.
* Filter the signal to apply its frequency-dependent decay.
*/
for(ALsizei j{0};j < NUM_LINES;j++)
{
ALsizei late_delay_tap{offset - State->mLateDelayTap[j][0]};
ALsizei late_feedb_tap{offset - State->mLate.Offset[j][0]};
const ALfloat midGain{State->mLate.T60[j].MidGain[0]};
const ALfloat densityGain{State->mLate.DensityGain[0] * midGain};
for(ALsizei i{0};i < todo;i++)
temps[j][i] = DelayLineOut(&main_delay, late_delay_tap++, j)*densityGain +
DelayLineOut(&late_delay, late_feedb_tap++, j)*midGain;
LateT60Filter(temps[j], todo, &State->mLate.T60[j]);
}
/* Apply a vector all-pass to improve micro-surface diffusion, and write
* out the results for mixing.
*/
VectorAllpass_Unfaded(temps, offset, mixX, mixY, todo, &State->mLate.VecAp);
for(ALsizei j{0};j < NUM_LINES;j++)
std::copy_n(temps[j], todo, out[j]);
/* Finally, scatter and bounce the results to refeed the feedback buffer. */
VectorScatterRevDelayIn(&late_delay, offset, mixX, mixY, out, todo);
}
void LateReverb_Faded(ReverbState *State, ALsizei offset, const ALsizei todo, const ALfloat fade,
ALfloat (*RESTRICT out)[MAX_UPDATE_SAMPLES])
{
ALfloat (*RESTRICT temps)[MAX_UPDATE_SAMPLES]{State->mTempSamples};
const DelayLineI late_delay{State->mLate.Delay};
const DelayLineI main_delay{State->mDelay};
const ALfloat mixX{State->mMixX};
const ALfloat mixY{State->mMixY};
ASSUME(todo > 0);
for(ALsizei j{0};j < NUM_LINES;j++)
{
const ALfloat oldMidGain{State->mLate.T60[j].MidGain[0]};
const ALfloat midGain{State->mLate.T60[j].MidGain[1]};
const ALfloat oldMidStep{-oldMidGain / FADE_SAMPLES};
const ALfloat midStep{midGain / FADE_SAMPLES};
const ALfloat oldDensityGain{State->mLate.DensityGain[0] * oldMidGain};
const ALfloat densityGain{State->mLate.DensityGain[1] * midGain};
const ALfloat oldDensityStep{-oldDensityGain / FADE_SAMPLES};
const ALfloat densityStep{densityGain / FADE_SAMPLES};
ALsizei late_delay_tap0{offset - State->mLateDelayTap[j][0]};
ALsizei late_delay_tap1{offset - State->mLateDelayTap[j][1]};
ALsizei late_feedb_tap0{offset - State->mLate.Offset[j][0]};
ALsizei late_feedb_tap1{offset - State->mLate.Offset[j][1]};
ALfloat fadeCount{fade};
for(ALsizei i{0};i < todo;i++)
{
const ALfloat fade0 = oldDensityGain + oldDensityStep*fadeCount;
const ALfloat fade1 = densityStep*fadeCount;
const ALfloat gfade0 = oldMidGain + oldMidStep*fadeCount;
const ALfloat gfade1 = midStep*fadeCount;
temps[j][i] =
FadedDelayLineOut(&main_delay, late_delay_tap0++, late_delay_tap1++, j,
fade0, fade1) +
FadedDelayLineOut(&late_delay, late_feedb_tap0++, late_feedb_tap1++, j,
gfade0, gfade1);
fadeCount += 1.0f;
}
LateT60Filter(temps[j], todo, &State->mLate.T60[j]);
}
VectorAllpass_Faded(temps, offset, mixX, mixY, fade, todo, &State->mLate.VecAp);
for(ALsizei j{0};j < NUM_LINES;j++)
std::copy_n(temps[j], todo, out[j]);
VectorScatterRevDelayIn(&late_delay, offset, mixX, mixY, temps, todo);
}
void ReverbState::process(ALsizei samplesToDo, const ALfloat (*RESTRICT samplesIn)[BUFFERSIZE], const ALsizei numInput, ALfloat (*RESTRICT samplesOut)[BUFFERSIZE], const ALsizei numOutput)
{
ALfloat (*RESTRICT afmt)[MAX_UPDATE_SAMPLES]{mTempSamples};
ALfloat (*RESTRICT samples)[MAX_UPDATE_SAMPLES]{mMixBuffer};
ALsizei fadeCount{mFadeCount};
ALsizei offset{mOffset};
ASSUME(samplesToDo > 0);
/* Process reverb for these samples. */
for(ALsizei base{0};base < samplesToDo;)
{
ALsizei todo{samplesToDo - base};
/* If cross-fading, don't do more samples than there are to fade. */
if(FADE_SAMPLES-fadeCount > 0)
{
todo = mini(todo, FADE_SAMPLES-fadeCount);
todo = mini(todo, mMaxUpdate[0]);
}
todo = mini(todo, mMaxUpdate[1]);
/* If this is not the final update, ensure the update size is a
* multiple of 4 for the SIMD mixers.
*/
if(todo < samplesToDo-base)
todo &= ~3;
/* Convert B-Format to A-Format for processing. */
for(ALsizei c{0};c < NUM_LINES;c++)
{
std::fill(std::begin(afmt[c]), std::end(afmt[c]), 0.0f);
MixRowSamples(afmt[c], B2A[c], samplesIn, numInput, base, todo);
}
/* Process the samples for reverb. */
for(ALsizei c{0};c < NUM_LINES;c++)
{
/* Band-pass the incoming samples. */
mFilter[c].Lp.process(samples[0], afmt[c], todo);
mFilter[c].Hp.process(samples[1], samples[0], todo);
/* Feed the initial delay line. */
DelayLineIn(&mDelay, offset, c, samples[1], todo);
}
if(UNLIKELY(fadeCount < FADE_SAMPLES))
{
auto fade = static_cast<ALfloat>(fadeCount);
/* Generate early reflections. */
EarlyReflection_Faded(this, offset, todo, fade, samples);
/* Mix the A-Format results to output, implicitly converting back
* to B-Format.
*/
for(ALsizei c{0};c < NUM_LINES;c++)
MixSamples(samples[c], numOutput, samplesOut, mEarly.CurrentGain[c],
mEarly.PanGain[c], samplesToDo-base, base, todo);
/* Generate and mix late reverb. */
LateReverb_Faded(this, offset, todo, fade, samples);
for(ALsizei c{0};c < NUM_LINES;c++)
MixSamples(samples[c], numOutput, samplesOut, mLate.CurrentGain[c],
mLate.PanGain[c], samplesToDo-base, base, todo);
/* Step fading forward. */
fadeCount += todo;
if(LIKELY(fadeCount >= FADE_SAMPLES))
{
/* Update the cross-fading delay line taps. */
fadeCount = FADE_SAMPLES;
for(ALsizei c{0};c < NUM_LINES;c++)
{
mEarlyDelayTap[c][0] = mEarlyDelayTap[c][1];
mEarlyDelayCoeff[c][0] = mEarlyDelayCoeff[c][1];
mEarly.VecAp.Offset[c][0] = mEarly.VecAp.Offset[c][1];
mEarly.Offset[c][0] = mEarly.Offset[c][1];
mEarly.Coeff[c][0] = mEarly.Coeff[c][1];
mLateDelayTap[c][0] = mLateDelayTap[c][1];
mLate.VecAp.Offset[c][0] = mLate.VecAp.Offset[c][1];
mLate.Offset[c][0] = mLate.Offset[c][1];
mLate.T60[c].MidGain[0] = mLate.T60[c].MidGain[1];
}
mLate.DensityGain[0] = mLate.DensityGain[1];
mMaxUpdate[0] = mMaxUpdate[1];
}
}
else
{
/* Generate and mix early reflections. */
EarlyReflection_Unfaded(this, offset, todo, samples);
for(ALsizei c{0};c < NUM_LINES;c++)
MixSamples(samples[c], numOutput, samplesOut, mEarly.CurrentGain[c],
mEarly.PanGain[c], samplesToDo-base, base, todo);
/* Generate and mix late reverb. */
LateReverb_Unfaded(this, offset, todo, samples);
for(ALsizei c{0};c < NUM_LINES;c++)
MixSamples(samples[c], numOutput, samplesOut, mLate.CurrentGain[c],
mLate.PanGain[c], samplesToDo-base, base, todo);
}
/* Step all delays forward. */
offset += todo;
base += todo;
}
mOffset = offset;
mFadeCount = fadeCount;
}
struct ReverbStateFactory final : public EffectStateFactory {
EffectState *create() override;
};
EffectState *ReverbStateFactory::create()
{ return new ReverbState{}; }
} // namespace
EffectStateFactory *ReverbStateFactory_getFactory()
{
static ReverbStateFactory ReverbFactory{};
return &ReverbFactory;
}
void ALeaxreverb_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
{
ALeffectProps *props = &effect->Props;
switch(param)
{
case AL_EAXREVERB_DECAY_HFLIMIT:
if(!(val >= AL_EAXREVERB_MIN_DECAY_HFLIMIT && val <= AL_EAXREVERB_MAX_DECAY_HFLIMIT))
SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb decay hflimit out of range");
props->Reverb.DecayHFLimit = val;
break;
default:
alSetError(context, AL_INVALID_ENUM, "Invalid EAX reverb integer property 0x%04x",
param);
}
}
void ALeaxreverb_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
{ ALeaxreverb_setParami(effect, context, param, vals[0]); }
void ALeaxreverb_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
{
ALeffectProps *props = &effect->Props;
switch(param)
{
case AL_EAXREVERB_DENSITY:
if(!(val >= AL_EAXREVERB_MIN_DENSITY && val <= AL_EAXREVERB_MAX_DENSITY))
SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb density out of range");
props->Reverb.Density = val;
break;
case AL_EAXREVERB_DIFFUSION:
if(!(val >= AL_EAXREVERB_MIN_DIFFUSION && val <= AL_EAXREVERB_MAX_DIFFUSION))
SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb diffusion out of range");
props->Reverb.Diffusion = val;
break;
case AL_EAXREVERB_GAIN:
if(!(val >= AL_EAXREVERB_MIN_GAIN && val <= AL_EAXREVERB_MAX_GAIN))
SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb gain out of range");
props->Reverb.Gain = val;
break;
case AL_EAXREVERB_GAINHF:
if(!(val >= AL_EAXREVERB_MIN_GAINHF && val <= AL_EAXREVERB_MAX_GAINHF))
SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb gainhf out of range");
props->Reverb.GainHF = val;
break;
case AL_EAXREVERB_GAINLF:
if(!(val >= AL_EAXREVERB_MIN_GAINLF && val <= AL_EAXREVERB_MAX_GAINLF))
SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb gainlf out of range");
props->Reverb.GainLF = val;
break;
case AL_EAXREVERB_DECAY_TIME:
if(!(val >= AL_EAXREVERB_MIN_DECAY_TIME && val <= AL_EAXREVERB_MAX_DECAY_TIME))
SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb decay time out of range");
props->Reverb.DecayTime = val;
break;
case AL_EAXREVERB_DECAY_HFRATIO:
if(!(val >= AL_EAXREVERB_MIN_DECAY_HFRATIO && val <= AL_EAXREVERB_MAX_DECAY_HFRATIO))
SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb decay hfratio out of range");
props->Reverb.DecayHFRatio = val;
break;
case AL_EAXREVERB_DECAY_LFRATIO:
if(!(val >= AL_EAXREVERB_MIN_DECAY_LFRATIO && val <= AL_EAXREVERB_MAX_DECAY_LFRATIO))
SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb decay lfratio out of range");
props->Reverb.DecayLFRatio = val;
break;
case AL_EAXREVERB_REFLECTIONS_GAIN:
if(!(val >= AL_EAXREVERB_MIN_REFLECTIONS_GAIN && val <= AL_EAXREVERB_MAX_REFLECTIONS_GAIN))
SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb reflections gain out of range");
props->Reverb.ReflectionsGain = val;
break;
case AL_EAXREVERB_REFLECTIONS_DELAY:
if(!(val >= AL_EAXREVERB_MIN_REFLECTIONS_DELAY && val <= AL_EAXREVERB_MAX_REFLECTIONS_DELAY))
SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb reflections delay out of range");
props->Reverb.ReflectionsDelay = val;
break;
case AL_EAXREVERB_LATE_REVERB_GAIN:
if(!(val >= AL_EAXREVERB_MIN_LATE_REVERB_GAIN && val <= AL_EAXREVERB_MAX_LATE_REVERB_GAIN))
SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb late reverb gain out of range");
props->Reverb.LateReverbGain = val;
break;
case AL_EAXREVERB_LATE_REVERB_DELAY:
if(!(val >= AL_EAXREVERB_MIN_LATE_REVERB_DELAY && val <= AL_EAXREVERB_MAX_LATE_REVERB_DELAY))
SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb late reverb delay out of range");
props->Reverb.LateReverbDelay = val;
break;
case AL_EAXREVERB_AIR_ABSORPTION_GAINHF:
if(!(val >= AL_EAXREVERB_MIN_AIR_ABSORPTION_GAINHF && val <= AL_EAXREVERB_MAX_AIR_ABSORPTION_GAINHF))
SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb air absorption gainhf out of range");
props->Reverb.AirAbsorptionGainHF = val;
break;
case AL_EAXREVERB_ECHO_TIME:
if(!(val >= AL_EAXREVERB_MIN_ECHO_TIME && val <= AL_EAXREVERB_MAX_ECHO_TIME))
SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb echo time out of range");
props->Reverb.EchoTime = val;
break;
case AL_EAXREVERB_ECHO_DEPTH:
if(!(val >= AL_EAXREVERB_MIN_ECHO_DEPTH && val <= AL_EAXREVERB_MAX_ECHO_DEPTH))
SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb echo depth out of range");
props->Reverb.EchoDepth = val;
break;
case AL_EAXREVERB_MODULATION_TIME:
if(!(val >= AL_EAXREVERB_MIN_MODULATION_TIME && val <= AL_EAXREVERB_MAX_MODULATION_TIME))
SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb modulation time out of range");
props->Reverb.ModulationTime = val;
break;
case AL_EAXREVERB_MODULATION_DEPTH:
if(!(val >= AL_EAXREVERB_MIN_MODULATION_DEPTH && val <= AL_EAXREVERB_MAX_MODULATION_DEPTH))
SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb modulation depth out of range");
props->Reverb.ModulationDepth = val;
break;
case AL_EAXREVERB_HFREFERENCE:
if(!(val >= AL_EAXREVERB_MIN_HFREFERENCE && val <= AL_EAXREVERB_MAX_HFREFERENCE))
SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb hfreference out of range");
props->Reverb.HFReference = val;
break;
case AL_EAXREVERB_LFREFERENCE:
if(!(val >= AL_EAXREVERB_MIN_LFREFERENCE && val <= AL_EAXREVERB_MAX_LFREFERENCE))
SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb lfreference out of range");
props->Reverb.LFReference = val;
break;
case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR:
if(!(val >= AL_EAXREVERB_MIN_ROOM_ROLLOFF_FACTOR && val <= AL_EAXREVERB_MAX_ROOM_ROLLOFF_FACTOR))
SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb room rolloff factor out of range");
props->Reverb.RoomRolloffFactor = val;
break;
default:
alSetError(context, AL_INVALID_ENUM, "Invalid EAX reverb float property 0x%04x",
param);
}
}
void ALeaxreverb_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
{
ALeffectProps *props = &effect->Props;
switch(param)
{
case AL_EAXREVERB_REFLECTIONS_PAN:
if(!(std::isfinite(vals[0]) && std::isfinite(vals[1]) && std::isfinite(vals[2])))
SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb reflections pan out of range");
props->Reverb.ReflectionsPan[0] = vals[0];
props->Reverb.ReflectionsPan[1] = vals[1];
props->Reverb.ReflectionsPan[2] = vals[2];
break;
case AL_EAXREVERB_LATE_REVERB_PAN:
if(!(std::isfinite(vals[0]) && std::isfinite(vals[1]) && std::isfinite(vals[2])))
SETERR_RETURN(context, AL_INVALID_VALUE,, "EAX Reverb late reverb pan out of range");
props->Reverb.LateReverbPan[0] = vals[0];
props->Reverb.LateReverbPan[1] = vals[1];
props->Reverb.LateReverbPan[2] = vals[2];
break;
default:
ALeaxreverb_setParamf(effect, context, param, vals[0]);
break;
}
}
void ALeaxreverb_getParami(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
{
const ALeffectProps *props = &effect->Props;
switch(param)
{
case AL_EAXREVERB_DECAY_HFLIMIT:
*val = props->Reverb.DecayHFLimit;
break;
default:
alSetError(context, AL_INVALID_ENUM, "Invalid EAX reverb integer property 0x%04x",
param);
}
}
void ALeaxreverb_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
{ ALeaxreverb_getParami(effect, context, param, vals); }
void ALeaxreverb_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
{
const ALeffectProps *props = &effect->Props;
switch(param)
{
case AL_EAXREVERB_DENSITY:
*val = props->Reverb.Density;
break;
case AL_EAXREVERB_DIFFUSION:
*val = props->Reverb.Diffusion;
break;
case AL_EAXREVERB_GAIN:
*val = props->Reverb.Gain;
break;
case AL_EAXREVERB_GAINHF:
*val = props->Reverb.GainHF;
break;
case AL_EAXREVERB_GAINLF:
*val = props->Reverb.GainLF;
break;
case AL_EAXREVERB_DECAY_TIME:
*val = props->Reverb.DecayTime;
break;
case AL_EAXREVERB_DECAY_HFRATIO:
*val = props->Reverb.DecayHFRatio;
break;
case AL_EAXREVERB_DECAY_LFRATIO:
*val = props->Reverb.DecayLFRatio;
break;
case AL_EAXREVERB_REFLECTIONS_GAIN:
*val = props->Reverb.ReflectionsGain;
break;
case AL_EAXREVERB_REFLECTIONS_DELAY:
*val = props->Reverb.ReflectionsDelay;
break;
case AL_EAXREVERB_LATE_REVERB_GAIN:
*val = props->Reverb.LateReverbGain;
break;
case AL_EAXREVERB_LATE_REVERB_DELAY:
*val = props->Reverb.LateReverbDelay;
break;
case AL_EAXREVERB_AIR_ABSORPTION_GAINHF:
*val = props->Reverb.AirAbsorptionGainHF;
break;
case AL_EAXREVERB_ECHO_TIME:
*val = props->Reverb.EchoTime;
break;
case AL_EAXREVERB_ECHO_DEPTH:
*val = props->Reverb.EchoDepth;
break;
case AL_EAXREVERB_MODULATION_TIME:
*val = props->Reverb.ModulationTime;
break;
case AL_EAXREVERB_MODULATION_DEPTH:
*val = props->Reverb.ModulationDepth;
break;
case AL_EAXREVERB_HFREFERENCE:
*val = props->Reverb.HFReference;
break;
case AL_EAXREVERB_LFREFERENCE:
*val = props->Reverb.LFReference;
break;
case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR:
*val = props->Reverb.RoomRolloffFactor;
break;
default:
alSetError(context, AL_INVALID_ENUM, "Invalid EAX reverb float property 0x%04x",
param);
}
}
void ALeaxreverb_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
{
const ALeffectProps *props = &effect->Props;
switch(param)
{
case AL_EAXREVERB_REFLECTIONS_PAN:
vals[0] = props->Reverb.ReflectionsPan[0];
vals[1] = props->Reverb.ReflectionsPan[1];
vals[2] = props->Reverb.ReflectionsPan[2];
break;
case AL_EAXREVERB_LATE_REVERB_PAN:
vals[0] = props->Reverb.LateReverbPan[0];
vals[1] = props->Reverb.LateReverbPan[1];
vals[2] = props->Reverb.LateReverbPan[2];
break;
default:
ALeaxreverb_getParamf(effect, context, param, vals);
break;
}
}
DEFINE_ALEFFECT_VTABLE(ALeaxreverb);
void ALreverb_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
{
ALeffectProps *props = &effect->Props;
switch(param)
{
case AL_REVERB_DECAY_HFLIMIT:
if(!(val >= AL_REVERB_MIN_DECAY_HFLIMIT && val <= AL_REVERB_MAX_DECAY_HFLIMIT))
SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb decay hflimit out of range");
props->Reverb.DecayHFLimit = val;
break;
default:
alSetError(context, AL_INVALID_ENUM, "Invalid reverb integer property 0x%04x", param);
}
}
void ALreverb_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
{ ALreverb_setParami(effect, context, param, vals[0]); }
void ALreverb_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
{
ALeffectProps *props = &effect->Props;
switch(param)
{
case AL_REVERB_DENSITY:
if(!(val >= AL_REVERB_MIN_DENSITY && val <= AL_REVERB_MAX_DENSITY))
SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb density out of range");
props->Reverb.Density = val;
break;
case AL_REVERB_DIFFUSION:
if(!(val >= AL_REVERB_MIN_DIFFUSION && val <= AL_REVERB_MAX_DIFFUSION))
SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb diffusion out of range");
props->Reverb.Diffusion = val;
break;
case AL_REVERB_GAIN:
if(!(val >= AL_REVERB_MIN_GAIN && val <= AL_REVERB_MAX_GAIN))
SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb gain out of range");
props->Reverb.Gain = val;
break;
case AL_REVERB_GAINHF:
if(!(val >= AL_REVERB_MIN_GAINHF && val <= AL_REVERB_MAX_GAINHF))
SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb gainhf out of range");
props->Reverb.GainHF = val;
break;
case AL_REVERB_DECAY_TIME:
if(!(val >= AL_REVERB_MIN_DECAY_TIME && val <= AL_REVERB_MAX_DECAY_TIME))
SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb decay time out of range");
props->Reverb.DecayTime = val;
break;
case AL_REVERB_DECAY_HFRATIO:
if(!(val >= AL_REVERB_MIN_DECAY_HFRATIO && val <= AL_REVERB_MAX_DECAY_HFRATIO))
SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb decay hfratio out of range");
props->Reverb.DecayHFRatio = val;
break;
case AL_REVERB_REFLECTIONS_GAIN:
if(!(val >= AL_REVERB_MIN_REFLECTIONS_GAIN && val <= AL_REVERB_MAX_REFLECTIONS_GAIN))
SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb reflections gain out of range");
props->Reverb.ReflectionsGain = val;
break;
case AL_REVERB_REFLECTIONS_DELAY:
if(!(val >= AL_REVERB_MIN_REFLECTIONS_DELAY && val <= AL_REVERB_MAX_REFLECTIONS_DELAY))
SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb reflections delay out of range");
props->Reverb.ReflectionsDelay = val;
break;
case AL_REVERB_LATE_REVERB_GAIN:
if(!(val >= AL_REVERB_MIN_LATE_REVERB_GAIN && val <= AL_REVERB_MAX_LATE_REVERB_GAIN))
SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb late reverb gain out of range");
props->Reverb.LateReverbGain = val;
break;
case AL_REVERB_LATE_REVERB_DELAY:
if(!(val >= AL_REVERB_MIN_LATE_REVERB_DELAY && val <= AL_REVERB_MAX_LATE_REVERB_DELAY))
SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb late reverb delay out of range");
props->Reverb.LateReverbDelay = val;
break;
case AL_REVERB_AIR_ABSORPTION_GAINHF:
if(!(val >= AL_REVERB_MIN_AIR_ABSORPTION_GAINHF && val <= AL_REVERB_MAX_AIR_ABSORPTION_GAINHF))
SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb air absorption gainhf out of range");
props->Reverb.AirAbsorptionGainHF = val;
break;
case AL_REVERB_ROOM_ROLLOFF_FACTOR:
if(!(val >= AL_REVERB_MIN_ROOM_ROLLOFF_FACTOR && val <= AL_REVERB_MAX_ROOM_ROLLOFF_FACTOR))
SETERR_RETURN(context, AL_INVALID_VALUE,, "Reverb room rolloff factor out of range");
props->Reverb.RoomRolloffFactor = val;
break;
default:
alSetError(context, AL_INVALID_ENUM, "Invalid reverb float property 0x%04x", param);
}
}
void ALreverb_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
{ ALreverb_setParamf(effect, context, param, vals[0]); }
void ALreverb_getParami(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
{
const ALeffectProps *props = &effect->Props;
switch(param)
{
case AL_REVERB_DECAY_HFLIMIT:
*val = props->Reverb.DecayHFLimit;
break;
default:
alSetError(context, AL_INVALID_ENUM, "Invalid reverb integer property 0x%04x", param);
}
}
void ALreverb_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
{ ALreverb_getParami(effect, context, param, vals); }
void ALreverb_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
{
const ALeffectProps *props = &effect->Props;
switch(param)
{
case AL_REVERB_DENSITY:
*val = props->Reverb.Density;
break;
case AL_REVERB_DIFFUSION:
*val = props->Reverb.Diffusion;
break;
case AL_REVERB_GAIN:
*val = props->Reverb.Gain;
break;
case AL_REVERB_GAINHF:
*val = props->Reverb.GainHF;
break;
case AL_REVERB_DECAY_TIME:
*val = props->Reverb.DecayTime;
break;
case AL_REVERB_DECAY_HFRATIO:
*val = props->Reverb.DecayHFRatio;
break;
case AL_REVERB_REFLECTIONS_GAIN:
*val = props->Reverb.ReflectionsGain;
break;
case AL_REVERB_REFLECTIONS_DELAY:
*val = props->Reverb.ReflectionsDelay;
break;
case AL_REVERB_LATE_REVERB_GAIN:
*val = props->Reverb.LateReverbGain;
break;
case AL_REVERB_LATE_REVERB_DELAY:
*val = props->Reverb.LateReverbDelay;
break;
case AL_REVERB_AIR_ABSORPTION_GAINHF:
*val = props->Reverb.AirAbsorptionGainHF;
break;
case AL_REVERB_ROOM_ROLLOFF_FACTOR:
*val = props->Reverb.RoomRolloffFactor;
break;
default:
alSetError(context, AL_INVALID_ENUM, "Invalid reverb float property 0x%04x", param);
}
}
void ALreverb_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
{ ALreverb_getParamf(effect, context, param, vals); }
DEFINE_ALEFFECT_VTABLE(ALreverb);
Reference in New Issue View Git Blame Copy Permalink