Alc/effects/echo.c

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 2009 by Chris Robinson.
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include <math.h>
  24 #include <stdlib.h>
  25
  26 #include "alMain.h"
  27 #include "alFilter.h"
  28 #include "alAuxEffectSlot.h"
  29 #include "alError.h"
  30 #include "alu.h"
  31
  32
  33 typedef struct ALechoState {
  34     DERIVE_FROM_TYPE(ALeffectState);
  35
  36     ALfloat *SampleBuffer;
  37     ALuint BufferLength;
  38
  39     // The echo is two tap. The delay is the number of samples from before the
  40     // current offset
  41     struct {
  42         ALuint delay;
  43     } Tap[2];
  44     ALuint Offset;
  45     /* The panning gains for the two taps */
  46     ALfloat Gain[2][MAX_OUTPUT_CHANNELS];
  47
  48     ALfloat FeedGain;
  49
  50     ALfilterState Filter;
  51 } ALechoState;
  52
  53 static ALvoid ALechoState_Destruct(ALechoState *state);
  54 static ALboolean ALechoState_deviceUpdate(ALechoState *state, ALCdevice *Device);
  55 static ALvoid ALechoState_update(ALechoState *state, const ALCdevice *Device, const ALeffectslot *Slot, const ALeffectProps *props);
  56 static ALvoid ALechoState_process(ALechoState *state, ALuint SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALuint NumChannels);
  57 DECLARE_DEFAULT_ALLOCATORS(ALechoState)
  58
  59 DEFINE_ALEFFECTSTATE_VTABLE(ALechoState);
  60
  61
  62 static void ALechoState_Construct(ALechoState *state)
  63 {
  64     ALeffectState_Construct(STATIC_CAST(ALeffectState, state));
  65     SET_VTABLE2(ALechoState, ALeffectState, state);
  66
  67     state->BufferLength = 0;
  68     state->SampleBuffer = NULL;
  69
  70     state->Tap[0].delay = 0;
  71     state->Tap[1].delay = 0;
  72     state->Offset = 0;
  73
  74     ALfilterState_clear(&state->Filter);
  75 }
  76
  77 static ALvoid ALechoState_Destruct(ALechoState *state)
  78 {
  79     al_free(state->SampleBuffer);
  80     state->SampleBuffer = NULL;
  81     ALeffectState_Destruct(STATIC_CAST(ALeffectState,state));
  82 }
  83
  84 static ALboolean ALechoState_deviceUpdate(ALechoState *state, ALCdevice *Device)
  85 {
  86     ALuint maxlen, i;
  87
  88     // Use the next power of 2 for the buffer length, so the tap offsets can be
  89     // wrapped using a mask instead of a modulo
  90     maxlen  = fastf2u(AL_ECHO_MAX_DELAY * Device->Frequency) + 1;
  91     maxlen += fastf2u(AL_ECHO_MAX_LRDELAY * Device->Frequency) + 1;
  92     maxlen  = NextPowerOf2(maxlen);
  93
  94     if(maxlen != state->BufferLength)
  95     {
  96         void *temp = al_calloc(16, maxlen * sizeof(ALfloat));
  97         if(!temp) return AL_FALSE;
  98
  99         al_free(state->SampleBuffer);
 100         state->SampleBuffer = temp;
 101         state->BufferLength = maxlen;
 102     }
 103     for(i = 0;i < state->BufferLength;i++)
 104         state->SampleBuffer[i] = 0.0f;
 105
 106     return AL_TRUE;
 107 }
 108
 109 static ALvoid ALechoState_update(ALechoState *state, const ALCdevice *Device, const ALeffectslot *Slot, const ALeffectProps *props)
 110 {
 111     ALuint frequency = Device->Frequency;
 112     ALfloat coeffs[MAX_AMBI_COEFFS];
 113     ALfloat gain, lrpan, spread;
 114
 115     state->Tap[0].delay = fastf2u(props->Echo.Delay * frequency) + 1;
 116     state->Tap[1].delay = fastf2u(props->Echo.LRDelay * frequency);
 117     state->Tap[1].delay += state->Tap[0].delay;
 118
 119     spread = props->Echo.Spread;
 120     if(spread < 0.0f) lrpan = -1.0f;
 121     else lrpan = 1.0f;
 122     /* Convert echo spread (where 0 = omni, +/-1 = directional) to coverage
 123      * spread (where 0 = point, tau = omni).
 124      */
 125     spread = asinf(1.0f - fabsf(spread))*4.0f;
 126
 127     state->FeedGain = props->Echo.Feedback;
 128
 129     gain = minf(1.0f - props->Echo.Damping, 0.0625f); /* Limit -24dB */
 130     ALfilterState_setParams(&state->Filter, ALfilterType_HighShelf,
 131                             gain, LOWPASSFREQREF/frequency,
 132                             calc_rcpQ_from_slope(gain, 1.0f));
 133
 134     gain = Slot->Params.Gain;
 135
 136     /* First tap panning */
 137     CalcAngleCoeffs(-F_PI_2*lrpan, 0.0f, spread, coeffs);
 138     ComputePanningGains(Device->Dry, coeffs, gain, state->Gain[0]);
 139
 140     /* Second tap panning */
 141     CalcAngleCoeffs( F_PI_2*lrpan, 0.0f, spread, coeffs);
 142     ComputePanningGains(Device->Dry, coeffs, gain, state->Gain[1]);
 143 }
 144
 145 static ALvoid ALechoState_process(ALechoState *state, ALuint SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALuint NumChannels)
 146 {
 147     const ALuint mask = state->BufferLength-1;
 148     const ALuint tap1 = state->Tap[0].delay;
 149     const ALuint tap2 = state->Tap[1].delay;
 150     ALuint offset = state->Offset;
 151     ALfloat x[2], y[2], in, out;
 152     ALuint base;
 153     ALuint i, k;
 154
 155     x[0] = state->Filter.x[0];
 156     x[1] = state->Filter.x[1];
 157     y[0] = state->Filter.y[0];
 158     y[1] = state->Filter.y[1];
 159     for(base = 0;base < SamplesToDo;)
 160     {
 161         ALfloat temps[128][2];
 162         ALuint td = minu(128, SamplesToDo-base);
 163
 164         for(i = 0;i < td;i++)
 165         {
 166             /* First tap */
 167             temps[i][0] = state->SampleBuffer[(offset-tap1) & mask];
 168             /* Second tap */
 169             temps[i][1] = state->SampleBuffer[(offset-tap2) & mask];
 170
 171             // Apply damping and feedback gain to the second tap, and mix in the
 172             // new sample
 173             in = temps[i][1] + SamplesIn[0][i+base];
 174             out = in*state->Filter.b0 +
 175                   x[0]*state->Filter.b1 + x[1]*state->Filter.b2 -
 176                   y[0]*state->Filter.a1 - y[1]*state->Filter.a2;
 177             x[1] = x[0]; x[0] = in;
 178             y[1] = y[0]; y[0] = out;
 179
 180             state->SampleBuffer[offset&mask] = out * state->FeedGain;
 181             offset++;
 182         }
 183
 184         for(k = 0;k < NumChannels;k++)
 185         {
 186             ALfloat gain = state->Gain[0][k];
 187             if(fabsf(gain) > GAIN_SILENCE_THRESHOLD)
 188             {
 189                 for(i = 0;i < td;i++)
 190                     SamplesOut[k][i+base] += temps[i][0] * gain;
 191             }
 192
 193             gain = state->Gain[1][k];
 194             if(fabsf(gain) > GAIN_SILENCE_THRESHOLD)
 195             {
 196                 for(i = 0;i < td;i++)
 197                     SamplesOut[k][i+base] += temps[i][1] * gain;
 198             }
 199         }
 200
 201         base += td;
 202     }
 203     state->Filter.x[0] = x[0];
 204     state->Filter.x[1] = x[1];
 205     state->Filter.y[0] = y[0];
 206     state->Filter.y[1] = y[1];
 207
 208     state->Offset = offset;
 209 }
 210
 211
 212 typedef struct ALechoStateFactory {
 213     DERIVE_FROM_TYPE(ALeffectStateFactory);
 214 } ALechoStateFactory;
 215
 216 ALeffectState *ALechoStateFactory_create(ALechoStateFactory *UNUSED(factory))
 217 {
 218     ALechoState *state;
 219
 220     NEW_OBJ0(state, ALechoState)();
 221     if(!state) return NULL;
 222
 223     return STATIC_CAST(ALeffectState, state);
 224 }
 225
 226 DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALechoStateFactory);
 227
 228 ALeffectStateFactory *ALechoStateFactory_getFactory(void)
 229 {
 230     static ALechoStateFactory EchoFactory = { { GET_VTABLE2(ALechoStateFactory, ALeffectStateFactory) } };
 231
 232     return STATIC_CAST(ALeffectStateFactory, &EchoFactory);
 233 }
 234
 235
 236 void ALecho_setParami(ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint UNUSED(val))
 237 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
 238 void ALecho_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
 239 {
 240     ALecho_setParami(effect, context, param, vals[0]);
 241 }
 242 void ALecho_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
 243 {
 244     ALeffectProps *props = &effect->Props;
 245     switch(param)
 246     {
 247         case AL_ECHO_DELAY:
 248             if(!(val >= AL_ECHO_MIN_DELAY && val <= AL_ECHO_MAX_DELAY))
 249                 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
 250             props->Echo.Delay = val;
 251             break;
 252
 253         case AL_ECHO_LRDELAY:
 254             if(!(val >= AL_ECHO_MIN_LRDELAY && val <= AL_ECHO_MAX_LRDELAY))
 255                 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
 256             props->Echo.LRDelay = val;
 257             break;
 258
 259         case AL_ECHO_DAMPING:
 260             if(!(val >= AL_ECHO_MIN_DAMPING && val <= AL_ECHO_MAX_DAMPING))
 261                 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
 262             props->Echo.Damping = val;
 263             break;
 264
 265         case AL_ECHO_FEEDBACK:
 266             if(!(val >= AL_ECHO_MIN_FEEDBACK && val <= AL_ECHO_MAX_FEEDBACK))
 267                 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
 268             props->Echo.Feedback = val;
 269             break;
 270
 271         case AL_ECHO_SPREAD:
 272             if(!(val >= AL_ECHO_MIN_SPREAD && val <= AL_ECHO_MAX_SPREAD))
 273                 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
 274             props->Echo.Spread = val;
 275             break;
 276
 277         default:
 278             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
 279     }
 280 }
 281 void ALecho_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
 282 {
 283     ALecho_setParamf(effect, context, param, vals[0]);
 284 }
 285
 286 void ALecho_getParami(const ALeffect *UNUSED(effect), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val))
 287 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
 288 void ALecho_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
 289 {
 290     ALecho_getParami(effect, context, param, vals);
 291 }
 292 void ALecho_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
 293 {
 294     const ALeffectProps *props = &effect->Props;
 295     switch(param)
 296     {
 297         case AL_ECHO_DELAY:
 298             *val = props->Echo.Delay;
 299             break;
 300
 301         case AL_ECHO_LRDELAY:
 302             *val = props->Echo.LRDelay;
 303             break;
 304
 305         case AL_ECHO_DAMPING:
 306             *val = props->Echo.Damping;
 307             break;
 308
 309         case AL_ECHO_FEEDBACK:
 310             *val = props->Echo.Feedback;
 311             break;
 312
 313         case AL_ECHO_SPREAD:
 314             *val = props->Echo.Spread;
 315             break;
 316
 317         default:
 318             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
 319     }
 320 }
 321 void ALecho_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
 322 {
 323     ALecho_getParamf(effect, context, param, vals);
 324 }
 325
 326 DEFINE_ALEFFECT_VTABLE(ALecho);