// Update the echo gain, line offset, line coefficients, and mixing
// coefficients.
static ALvoid UpdateEchoLine(ALfloat reverbGain, ALfloat lateGain, ALfloat echoTime, ALfloat decayTime, ALfloat diffusion, ALfloat echoDepth, ALfloat hfRatio, ALfloat cw, ALuint frequency, ALverbState *State)
{
// Update the offset and coefficient for the echo delay line.
State->Echo.Offset = (ALuint)(echoTime * frequency);
// Calculate the decay coefficient for the echo line.
State->Echo.Coeff = CalcDecayCoeff(echoTime, decayTime);
// Calculate the energy-based attenuation coefficient for the echo delay
// line.
State->Echo.DensityGain = CalcDensityGain(State->Echo.Coeff);
// Calculate the echo all-pass feed coefficient.
State->Echo.ApFeedCoeff = 0.5f * aluPow(diffusion, 2.0f);
// Calculate the echo all-pass attenuation coefficient.
State->Echo.ApCoeff = CalcDecayCoeff(ECHO_ALLPASS_LENGTH, decayTime);
// Calculate the damping coefficient for each low-pass filter.
State->Echo.LpCoeff = CalcDampingCoeff(hfRatio, echoTime, decayTime,
State->Echo.Coeff, cw);
/* Calculate the echo mixing coefficients. The first is applied to the
* echo itself. The second is used to attenuate the late reverb when
* echo depth is high and diffusion is low, so the echo is slightly
* stronger than the decorrelated echos in the reverb tail.
*/
State->Echo.MixCoeff[0] = reverbGain * lateGain * echoDepth;
State->Echo.MixCoeff[1] = 1.0f - (echoDepth * 0.5f * (1.0f - diffusion));
}
// Update the late reverb gains, line lengths, and line coefficients.
static ALvoid UpdateLateLines(ALfloat reverbGain, ALfloat lateGain, ALfloat xMix, ALfloat density, ALfloat decayTime, ALfloat diffusion, ALfloat hfRatio, ALfloat cw, ALuint frequency, ALverbState *State)
{
ALfloat length;
ALuint index;
/* Calculate the late reverb gain (from the master effect gain, and late
* reverb gain parameters). Since the output is tapped prior to the
* application of the next delay line coefficients, this gain needs to be
* attenuated by the 'x' mixing matrix coefficient as well.
*/
State->Late.Gain = reverbGain * lateGain * xMix;
/* 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 cyclcical delay lines is used to calculate
* the attenuation coefficient.
*/
length = (LATE_LINE_LENGTH[0] + LATE_LINE_LENGTH[1] +
LATE_LINE_LENGTH[2] + LATE_LINE_LENGTH[3]) / 4.0f;
length *= 1.0f + (density * LATE_LINE_MULTIPLIER);
State->Late.DensityGain = CalcDensityGain(CalcDecayCoeff(length,
decayTime));
// Calculate the all-pass feed-back and feed-forward coefficient.
State->Late.ApFeedCoeff = 0.5f * aluPow(diffusion, 2.0f);
for(index = 0;index < 4;index++)
{
// Calculate the gain (coefficient) for each all-pass line.
State->Late.ApCoeff[index] = CalcDecayCoeff(ALLPASS_LINE_LENGTH[index],
decayTime);
// Calculate the length (in seconds) of each cyclical delay line.
length = LATE_LINE_LENGTH[index] * (1.0f + (density *
LATE_LINE_MULTIPLIER));
// Calculate the delay offset for each cyclical delay line.
State->Late.Offset[index] = (ALuint)(length * frequency);
// Calculate the gain (coefficient) for each cyclical line.
State->Late.Coeff[index] = CalcDecayCoeff(length, decayTime);
// Calculate the damping coefficient for each low-pass filter.
State->Late.LpCoeff[index] =
CalcDampingCoeff(hfRatio, length, decayTime,
State->Late.Coeff[index], cw);
// Attenuate the cyclical line coefficients by the mixing coefficient
// (x).
State->Late.Coeff[index] *= xMix;
}
}
// Calculate the coefficient for a HF (and eventually LF) decay damping
// filter.
static __inline ALfloat CalcDampingCoeff( ALfloat hfRatio, ALfloat length, ALfloat decayTime, ALfloat decayCoeff, ALfloat cw )
{
ALfloat coeff, g;
// Eventually this should boost the high frequencies when the ratio
// exceeds 1.
coeff = 0.0f;
if ( hfRatio < 1.0f )
{
// Calculate the low-pass coefficient by dividing the HF decay
// coefficient by the full decay coefficient.
g = CalcDecayCoeff( length, decayTime * hfRatio ) / decayCoeff;
// Damping is done with a 1-pole filter, so g needs to be squared.
g *= g;
coeff = lpCoeffCalc( g, cw );
// Very low decay times will produce minimal output, so apply an
// upper bound to the coefficient.
coeff = __min( coeff, 0.98f );
}
return coeff;
}
static void UpdateEarlyLines(float reverbGain, float earlyGain, float lateDelay, eax_buffer_info *State)
{
unsigned int index;
/* Calculate the early reflections gain (from the master effect gain, and
* reflections gain parameters) with a constant attenuation of 0.5. */
State->Early.Gain = 0.5f * reverbGain * earlyGain;
/* Calculate the gain (coefficient) for each early delay line using the
* late delay time. This expands the early reflections to the start of
* the late reverb. */
for(index = 0; index < 4; index++)
State->Early.Coeff[index] = CalcDecayCoeff(EARLY_LINE_LENGTH[index],
lateDelay);
}
// Update the early reflections gain and line coefficients.
static ALvoid UpdateEarlyLines(ALfloat reverbGain, ALfloat earlyGain, ALfloat lateDelay, ALverbState *State)
{
ALuint index;
// Calculate the early reflections gain (from the master effect gain, and
// reflections gain parameters) with a constant attenuation of 0.5.
State->Early.Gain = 0.5f * reverbGain * earlyGain;
// Calculate the gain (coefficient) for each early delay line using the
// late delay time. This expands the early reflections to the start of
// the late reverb.
for(index = 0;index < 4;index++)
State->Early.Coeff[index] = CalcDecayCoeff(EARLY_LINE_LENGTH[index],
lateDelay);
}
static float CalcDampingCoeff(float hfRatio, float length, float decayTime, float decayCoeff, float cw)
{
float coeff, g;
coeff = 0.0f;
if (hfRatio < 1.0f)
{
/* Calculate the low-pass coefficient by dividing the HF decay
* coefficient by the full decay coefficient. */
g = CalcDecayCoeff(length, decayTime * hfRatio) / decayCoeff;
/* Damping is done with a 1-pole filter, so g needs to be squared. */
g *= g;
coeff = lpCoeffCalc(g, cw);
/* Very low decay times will produce minimal output, so apply an
* upper bound to the coefficient. */
if (coeff > 0.98f) coeff = 0.98f;
}
return coeff;
}
