Alc/effects/chorus.c

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 2013 by Mike Gorchak
   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 enum ChorusWaveForm {
  34     CWF_Triangle = AL_CHORUS_WAVEFORM_TRIANGLE,
  35     CWF_Sinusoid = AL_CHORUS_WAVEFORM_SINUSOID
  36 };
  37
  38 typedef struct ALchorusState {
  39     DERIVE_FROM_TYPE(ALeffectState);
  40
  41     ALfloat *SampleBuffer[2];
  42     ALuint BufferLength;
  43     ALuint offset;
  44     ALuint lfo_range;
  45     ALfloat lfo_scale;
  46     ALint lfo_disp;
  47
  48     /* Gains for left and right sides */
  49     ALfloat Gain[2][MAX_OUTPUT_CHANNELS];
  50
  51     /* effect parameters */
  52     enum ChorusWaveForm waveform;
  53     ALint delay;
  54     ALfloat depth;
  55     ALfloat feedback;
  56 } ALchorusState;
  57
  58 static ALvoid ALchorusState_Destruct(ALchorusState *state);
  59 static ALboolean ALchorusState_deviceUpdate(ALchorusState *state, ALCdevice *Device);
  60 static ALvoid ALchorusState_update(ALchorusState *state, const ALCdevice *Device, const ALeffectslot *Slot, const ALeffectProps *props);
  61 static ALvoid ALchorusState_process(ALchorusState *state, ALuint SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALuint NumChannels);
  62 DECLARE_DEFAULT_ALLOCATORS(ALchorusState)
  63
  64 DEFINE_ALEFFECTSTATE_VTABLE(ALchorusState);
  65
  66
  67 static void ALchorusState_Construct(ALchorusState *state)
  68 {
  69     ALeffectState_Construct(STATIC_CAST(ALeffectState, state));
  70     SET_VTABLE2(ALchorusState, ALeffectState, state);
  71
  72     state->BufferLength = 0;
  73     state->SampleBuffer[0] = NULL;
  74     state->SampleBuffer[1] = NULL;
  75     state->offset = 0;
  76     state->lfo_range = 1;
  77     state->waveform = CWF_Triangle;
  78 }
  79
  80 static ALvoid ALchorusState_Destruct(ALchorusState *state)
  81 {
  82     al_free(state->SampleBuffer[0]);
  83     state->SampleBuffer[0] = NULL;
  84     state->SampleBuffer[1] = NULL;
  85
  86     ALeffectState_Destruct(STATIC_CAST(ALeffectState,state));
  87 }
  88
  89 static ALboolean ALchorusState_deviceUpdate(ALchorusState *state, ALCdevice *Device)
  90 {
  91     ALuint maxlen;
  92     ALuint it;
  93
  94     maxlen = fastf2u(AL_CHORUS_MAX_DELAY * 3.0f * Device->Frequency) + 1;
  95     maxlen = NextPowerOf2(maxlen);
  96
  97     if(maxlen != state->BufferLength)
  98     {
  99         void *temp = al_calloc(16, maxlen * sizeof(ALfloat) * 2);
 100         if(!temp) return AL_FALSE;
 101
 102         al_free(state->SampleBuffer[0]);
 103         state->SampleBuffer[0] = temp;
 104         state->SampleBuffer[1] = state->SampleBuffer[0] + maxlen;
 105
 106         state->BufferLength = maxlen;
 107     }
 108
 109     for(it = 0;it < state->BufferLength;it++)
 110     {
 111         state->SampleBuffer[0][it] = 0.0f;
 112         state->SampleBuffer[1][it] = 0.0f;
 113     }
 114
 115     return AL_TRUE;
 116 }
 117
 118 static ALvoid ALchorusState_update(ALchorusState *state, const ALCdevice *Device, const ALeffectslot *Slot, const ALeffectProps *props)
 119 {
 120     ALfloat frequency = (ALfloat)Device->Frequency;
 121     ALfloat coeffs[MAX_AMBI_COEFFS];
 122     ALfloat rate;
 123     ALint phase;
 124
 125     switch(props->Chorus.Waveform)
 126     {
 127         case AL_CHORUS_WAVEFORM_TRIANGLE:
 128             state->waveform = CWF_Triangle;
 129             break;
 130         case AL_CHORUS_WAVEFORM_SINUSOID:
 131             state->waveform = CWF_Sinusoid;
 132             break;
 133     }
 134     state->depth = props->Chorus.Depth;
 135     state->feedback = props->Chorus.Feedback;
 136     state->delay = fastf2i(props->Chorus.Delay * frequency);
 137
 138     /* Gains for left and right sides */
 139     CalcXYZCoeffs(-1.0f, 0.0f, 0.0f, 0.0f, coeffs);
 140     ComputePanningGains(Device->Dry, coeffs, Slot->Params.Gain, state->Gain[0]);
 141     CalcXYZCoeffs( 1.0f, 0.0f, 0.0f, 0.0f, coeffs);
 142     ComputePanningGains(Device->Dry, coeffs, Slot->Params.Gain, state->Gain[1]);
 143
 144     phase = props->Chorus.Phase;
 145     rate = props->Chorus.Rate;
 146     if(!(rate > 0.0f))
 147     {
 148         state->lfo_scale = 0.0f;
 149         state->lfo_range = 1;
 150         state->lfo_disp = 0;
 151     }
 152     else
 153     {
 154         /* Calculate LFO coefficient */
 155         state->lfo_range = fastf2u(frequency/rate + 0.5f);
 156         switch(state->waveform)
 157         {
 158             case CWF_Triangle:
 159                 state->lfo_scale = 4.0f / state->lfo_range;
 160                 break;
 161             case CWF_Sinusoid:
 162                 state->lfo_scale = F_TAU / state->lfo_range;
 163                 break;
 164         }
 165
 166         /* Calculate lfo phase displacement */
 167         state->lfo_disp = fastf2i(state->lfo_range * (phase/360.0f));
 168     }
 169 }
 170
 171 static inline void Triangle(ALint *delay_left, ALint *delay_right, ALuint offset, const ALchorusState *state)
 172 {
 173     ALfloat lfo_value;
 174
 175     lfo_value = 2.0f - fabsf(2.0f - state->lfo_scale*(offset%state->lfo_range));
 176     lfo_value *= state->depth * state->delay;
 177     *delay_left = fastf2i(lfo_value) + state->delay;
 178
 179     offset += state->lfo_disp;
 180     lfo_value = 2.0f - fabsf(2.0f - state->lfo_scale*(offset%state->lfo_range));
 181     lfo_value *= state->depth * state->delay;
 182     *delay_right = fastf2i(lfo_value) + state->delay;
 183 }
 184
 185 static inline void Sinusoid(ALint *delay_left, ALint *delay_right, ALuint offset, const ALchorusState *state)
 186 {
 187     ALfloat lfo_value;
 188
 189     lfo_value = 1.0f + sinf(state->lfo_scale*(offset%state->lfo_range));
 190     lfo_value *= state->depth * state->delay;
 191     *delay_left = fastf2i(lfo_value) + state->delay;
 192
 193     offset += state->lfo_disp;
 194     lfo_value = 1.0f + sinf(state->lfo_scale*(offset%state->lfo_range));
 195     lfo_value *= state->depth * state->delay;
 196     *delay_right = fastf2i(lfo_value) + state->delay;
 197 }
 198
 199 #define DECL_TEMPLATE(Func)                                                   \
 200 static void Process##Func(ALchorusState *state, const ALuint SamplesToDo,     \
 201   const ALfloat *restrict SamplesIn, ALfloat (*restrict out)[2])              \
 202 {                                                                             \
 203     const ALuint bufmask = state->BufferLength-1;                             \
 204     ALfloat *restrict leftbuf = state->SampleBuffer[0];                       \
 205     ALfloat *restrict rightbuf = state->SampleBuffer[1];                      \
 206     ALuint offset = state->offset;                                            \
 207     const ALfloat feedback = state->feedback;                                 \
 208     ALuint it;                                                                \
 209                                                                               \
 210     for(it = 0;it < SamplesToDo;it++)                                         \
 211     {                                                                         \
 212         ALint delay_left, delay_right;                                        \
 213         Func(&delay_left, &delay_right, offset, state);                       \
 214                                                                               \
 215         out[it][0] = leftbuf[(offset-delay_left)&bufmask];                    \
 216         leftbuf[offset&bufmask] = (out[it][0]+SamplesIn[it]) * feedback;      \
 217                                                                               \
 218         out[it][1] = rightbuf[(offset-delay_right)&bufmask];                  \
 219         rightbuf[offset&bufmask] = (out[it][1]+SamplesIn[it]) * feedback;     \
 220                                                                               \
 221         offset++;                                                             \
 222     }                                                                         \
 223     state->offset = offset;                                                   \
 224 }
 225
 226 DECL_TEMPLATE(Triangle)
 227 DECL_TEMPLATE(Sinusoid)
 228
 229 #undef DECL_TEMPLATE
 230
 231 static ALvoid ALchorusState_process(ALchorusState *state, ALuint SamplesToDo, const ALfloat (*restrict SamplesIn)[BUFFERSIZE], ALfloat (*restrict SamplesOut)[BUFFERSIZE], ALuint NumChannels)
 232 {
 233     ALuint it, kt;
 234     ALuint base;
 235
 236     for(base = 0;base < SamplesToDo;)
 237     {
 238         ALfloat temps[128][2];
 239         ALuint td = minu(128, SamplesToDo-base);
 240
 241         switch(state->waveform)
 242         {
 243             case CWF_Triangle:
 244                 ProcessTriangle(state, td, SamplesIn[0]+base, temps);
 245                 break;
 246             case CWF_Sinusoid:
 247                 ProcessSinusoid(state, td, SamplesIn[0]+base, temps);
 248                 break;
 249         }
 250
 251         for(kt = 0;kt < NumChannels;kt++)
 252         {
 253             ALfloat gain = state->Gain[0][kt];
 254             if(fabsf(gain) > GAIN_SILENCE_THRESHOLD)
 255             {
 256                 for(it = 0;it < td;it++)
 257                     SamplesOut[kt][it+base] += temps[it][0] * gain;
 258             }
 259
 260             gain = state->Gain[1][kt];
 261             if(fabsf(gain) > GAIN_SILENCE_THRESHOLD)
 262             {
 263                 for(it = 0;it < td;it++)
 264                     SamplesOut[kt][it+base] += temps[it][1] * gain;
 265             }
 266         }
 267
 268         base += td;
 269     }
 270 }
 271
 272
 273 typedef struct ALchorusStateFactory {
 274     DERIVE_FROM_TYPE(ALeffectStateFactory);
 275 } ALchorusStateFactory;
 276
 277 static ALeffectState *ALchorusStateFactory_create(ALchorusStateFactory *UNUSED(factory))
 278 {
 279     ALchorusState *state;
 280
 281     NEW_OBJ0(state, ALchorusState)();
 282     if(!state) return NULL;
 283
 284     return STATIC_CAST(ALeffectState, state);
 285 }
 286
 287 DEFINE_ALEFFECTSTATEFACTORY_VTABLE(ALchorusStateFactory);
 288
 289
 290 ALeffectStateFactory *ALchorusStateFactory_getFactory(void)
 291 {
 292     static ALchorusStateFactory ChorusFactory = { { GET_VTABLE2(ALchorusStateFactory, ALeffectStateFactory) } };
 293
 294     return STATIC_CAST(ALeffectStateFactory, &ChorusFactory);
 295 }
 296
 297
 298 void ALchorus_setParami(ALeffect *effect, ALCcontext *context, ALenum param, ALint val)
 299 {
 300     ALeffectProps *props = &effect->Props;
 301     switch(param)
 302     {
 303         case AL_CHORUS_WAVEFORM:
 304             if(!(val >= AL_CHORUS_MIN_WAVEFORM && val <= AL_CHORUS_MAX_WAVEFORM))
 305                 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
 306             props->Chorus.Waveform = val;
 307             break;
 308
 309         case AL_CHORUS_PHASE:
 310             if(!(val >= AL_CHORUS_MIN_PHASE && val <= AL_CHORUS_MAX_PHASE))
 311                 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
 312             props->Chorus.Phase = val;
 313             break;
 314
 315         default:
 316             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
 317     }
 318 }
 319 void ALchorus_setParamiv(ALeffect *effect, ALCcontext *context, ALenum param, const ALint *vals)
 320 {
 321     ALchorus_setParami(effect, context, param, vals[0]);
 322 }
 323 void ALchorus_setParamf(ALeffect *effect, ALCcontext *context, ALenum param, ALfloat val)
 324 {
 325     ALeffectProps *props = &effect->Props;
 326     switch(param)
 327     {
 328         case AL_CHORUS_RATE:
 329             if(!(val >= AL_CHORUS_MIN_RATE && val <= AL_CHORUS_MAX_RATE))
 330                 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
 331             props->Chorus.Rate = val;
 332             break;
 333
 334         case AL_CHORUS_DEPTH:
 335             if(!(val >= AL_CHORUS_MIN_DEPTH && val <= AL_CHORUS_MAX_DEPTH))
 336                 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
 337             props->Chorus.Depth = val;
 338             break;
 339
 340         case AL_CHORUS_FEEDBACK:
 341             if(!(val >= AL_CHORUS_MIN_FEEDBACK && val <= AL_CHORUS_MAX_FEEDBACK))
 342                 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
 343             props->Chorus.Feedback = val;
 344             break;
 345
 346         case AL_CHORUS_DELAY:
 347             if(!(val >= AL_CHORUS_MIN_DELAY && val <= AL_CHORUS_MAX_DELAY))
 348                 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
 349             props->Chorus.Delay = val;
 350             break;
 351
 352         default:
 353             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
 354     }
 355 }
 356 void ALchorus_setParamfv(ALeffect *effect, ALCcontext *context, ALenum param, const ALfloat *vals)
 357 {
 358     ALchorus_setParamf(effect, context, param, vals[0]);
 359 }
 360
 361 void ALchorus_getParami(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *val)
 362 {
 363     const ALeffectProps *props = &effect->Props;
 364     switch(param)
 365     {
 366         case AL_CHORUS_WAVEFORM:
 367             *val = props->Chorus.Waveform;
 368             break;
 369
 370         case AL_CHORUS_PHASE:
 371             *val = props->Chorus.Phase;
 372             break;
 373
 374         default:
 375             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
 376     }
 377 }
 378 void ALchorus_getParamiv(const ALeffect *effect, ALCcontext *context, ALenum param, ALint *vals)
 379 {
 380     ALchorus_getParami(effect, context, param, vals);
 381 }
 382 void ALchorus_getParamf(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *val)
 383 {
 384     const ALeffectProps *props = &effect->Props;
 385     switch(param)
 386     {
 387         case AL_CHORUS_RATE:
 388             *val = props->Chorus.Rate;
 389             break;
 390
 391         case AL_CHORUS_DEPTH:
 392             *val = props->Chorus.Depth;
 393             break;
 394
 395         case AL_CHORUS_FEEDBACK:
 396             *val = props->Chorus.Feedback;
 397             break;
 398
 399         case AL_CHORUS_DELAY:
 400             *val = props->Chorus.Delay;
 401             break;
 402
 403         default:
 404             SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
 405     }
 406 }
 407 void ALchorus_getParamfv(const ALeffect *effect, ALCcontext *context, ALenum param, ALfloat *vals)
 408 {
 409     ALchorus_getParamf(effect, context, param, vals);
 410 }
 411
 412 DEFINE_ALEFFECT_VTABLE(ALchorus);