kcat/openal-soft
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Share the interpolation functions and use them in the reverb effect

Browse Source
This commit is contained in:
Chris Robinson 2010-11-26 01:07:54 -08:00
parent 98d78f7ff9
commit de8b7fbc5f
3 changed files with 39 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
Alc/alcReverb.c
View File

@ -700,8 +700,8 @@ static __inline ALfloat EAXModulation(ALverbState *State, ALfloat in)
// The depth determines the range over which to read the input samples
// from, so it must be filtered to reduce the distortion caused by even
// small parameter changes.
State->Mod.Filter += (State->Mod.Depth - State->Mod.Filter) *
State->Mod.Coeff;
State->Mod.Filter = lerp(State->Mod.Filter, State->Mod.Depth,
State->Mod.Coeff);
// Calculate the read offset and fraction between it and the next sample.
frac = (1.0f + (State->Mod.Filter * sinus));
@ -719,7 +719,7 @@ static __inline ALfloat EAXModulation(ALverbState *State, ALfloat in)
// The output is obtained by linearly interpolating the two samples that
// were acquired above.
return out0 + ((out1 - out0) * frac);
return lerp(out0, out1, frac);
}
// Delay line output routine for early reflections.
@ -796,9 +796,9 @@ static __inline ALfloat LateDelayLineOut(ALverbState *State, ALuint index)
// Low-pass filter input/output routine for late reverb.
static __inline ALfloat LateLowPassInOut(ALverbState *State, ALuint index, ALfloat in)
{
State->Late.LpSample[index] = in +
((State->Late.LpSample[index] - in) * State->Late.LpCoeff[index]);
return State->Late.LpSample[index];
in = lerp(in, State->Late.LpSample[index], State->Late.LpCoeff[index]);
State->Late.LpSample[index] = in;
return in;
}
// Given four decorrelated input samples, this function produces four-channel
@ -853,10 +853,10 @@ static __inline ALvoid LateReverb(ALverbState *State, ALfloat *in, ALfloat *out)
* the cyclical delay line coefficients. Thus only the y coefficient is
* applied when mixing, and is modified to be: y / x.
*/
f[0] = d[0] + (State->Late.MixCoeff * ( d[1] - d[2] + d[3]));
f[0] = d[0] + (State->Late.MixCoeff * ( d[1] + -d[2] + d[3]));
f[1] = d[1] + (State->Late.MixCoeff * (-d[0] + d[2] + d[3]));
f[2] = d[2] + (State->Late.MixCoeff * ( d[0] - d[1] + d[3]));
f[3] = d[3] + (State->Late.MixCoeff * (-d[0] - d[1] - d[2]));
f[2] = d[2] + (State->Late.MixCoeff * ( d[0] + -d[1] + d[3]));
f[3] = d[3] + (State->Late.MixCoeff * (-d[0] + -d[1] + -d[2] ));
// Output the results of the matrix for all four channels, attenuated by
// the late reverb gain (which is attenuated by the 'x' mix coefficient).
@ -893,7 +893,7 @@ static __inline ALvoid EAXEcho(ALverbState *State, ALfloat in, ALfloat *late)
// Mix the energy-attenuated input with the output and pass it through
// the echo low-pass filter.
feed += State->Echo.DensityGain * in;
feed += ((State->Echo.LpSample - feed) * State->Echo.LpCoeff);
feed = lerp(feed, State->Echo.LpSample, State->Echo.LpCoeff);
State->Echo.LpSample = feed;
// Then the echo all-pass filter.

32
Alc/mixer.c
View File

@ -37,43 +37,29 @@
#include "bs2b.h"
static __inline ALdouble lerp(ALdouble val1, ALdouble val2, ALint frac)
{
val1 += ((val2-val1) * (frac * (1.0/(1<<FRACTIONBITS))));
return val1;
}
static __inline ALdouble cubic(ALdouble val0, ALdouble val1, ALdouble val2, ALdouble val3, ALint frac)
{
ALdouble mu = frac * (1.0/(1<<FRACTIONBITS));
ALdouble mu2 = mu*mu;
ALdouble a0 = -0.5*val0 + 1.5*val1 + -1.5*val2 + 0.5*val3;
ALdouble a1 = val0 + -2.5*val1 + 2.0*val2 + -0.5*val3;
ALdouble a2 = -0.5*val0 + 0.5*val2;
ALdouble a3 = val1;
return a0*mu*mu2 + a1*mu2 + a2*mu + a3;
}
static __inline ALdouble point32(const ALfloat *vals, ALint step, ALint frac)
{ return vals[0]; (void)step; (void)frac; }
static __inline ALdouble lerp32(const ALfloat *vals, ALint step, ALint frac)
{ return lerp(vals[0], vals[step], frac); }
{ return lerp(vals[0], vals[step], frac * (1.0/(1<<FRACTIONBITS))); }
static __inline ALdouble cubic32(const ALfloat *vals, ALint step, ALint frac)
{ return cubic(vals[-step], vals[0], vals[step], vals[step+step], frac); }
{ return cubic(vals[-step], vals[0], vals[step], vals[step+step],
frac * (1.0/(1<<FRACTIONBITS))); }
static __inline ALdouble point16(const ALshort *vals, ALint step, ALint frac)
{ return vals[0] / 32767.0; (void)step; (void)frac; }
static __inline ALdouble lerp16(const ALshort *vals, ALint step, ALint frac)
{ return lerp(vals[0], vals[step], frac) / 32767.0; }
{ return lerp(vals[0], vals[step], frac * (1.0/(1<<FRACTIONBITS))) / 32767.0; }
static __inline ALdouble cubic16(const ALshort *vals, ALint step, ALint frac)
{ return cubic(vals[-step], vals[0], vals[step], vals[step+step], frac) / 32767.0; }
{ return cubic(vals[-step], vals[0], vals[step], vals[step+step],
frac * (1.0/(1<<FRACTIONBITS))) / 32767.0; }
static __inline ALdouble point8(const ALubyte *vals, ALint step, ALint frac)
{ return (vals[0]-128.0) / 127.0; (void)step; (void)frac; }
static __inline ALdouble lerp8(const ALubyte *vals, ALint step, ALint frac)
{ return (lerp(vals[0], vals[step], frac)-128.0) / 127.0; }
{ return (lerp(vals[0], vals[step], frac * (1.0/(1<<FRACTIONBITS)))-128.0) / 127.0; }
static __inline ALdouble cubic8(const ALubyte *vals, ALint step, ALint frac)
{ return (cubic(vals[-step], vals[0], vals[step], vals[step+step], frac)-128.0) / 127.0; }
{ return (cubic(vals[-step], vals[0], vals[step], vals[step+step],
frac * (1.0/(1<<FRACTIONBITS)))-128.0) / 127.0; }
#define DECL_TEMPLATE(T, sampler) \

16
OpenAL32/Include/alu.h
View File

@ -182,6 +182,22 @@ static __inline ALint aluCart2LUTpos(ALfloat re, ALfloat im)
return pos%LUT_NUM;
}
static __inline ALdouble lerp(ALdouble val1, ALdouble val2, ALdouble mu)
{
val1 += (val2-val1) * mu;
return val1;
}
static __inline ALdouble cubic(ALdouble val0, ALdouble val1, ALdouble val2, ALdouble val3, ALdouble mu)
{
ALdouble mu2 = mu*mu;
ALdouble a0 = -0.5*val0 + 1.5*val1 + -1.5*val2 + 0.5*val3;
ALdouble a1 = val0 + -2.5*val1 + 2.0*val2 + -0.5*val3;
ALdouble a2 = -0.5*val0 + 0.5*val2;
ALdouble a3 = val1;
return a0*mu*mu2 + a1*mu2 + a2*mu + a3;
}
struct ALsource;
ALvoid aluInitPanning(ALCdevice *Device);