effect.c

   1 /*
   2
   3     Ann Hell Ex Machina - Music Software
   4     Copyright (C) 2003 Angel Ortega <angel@triptico.com>
   5
   6     effect.c - Digital audio filters and effects
   7
   8     This program is free software; you can redistribute it and/or
   9     modify it under the terms of the GNU General Public License
  10     as published by the Free Software Foundation; either version 2
  11     of the License, or (at your option) any later version.
  12
  13     This program is distributed in the hope that it will be useful,
  14     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16     GNU General Public License for more details.
  17
  18     You should have received a copy of the GNU General Public License
  19     along with this program; if not, write to the Free Software
  20     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21
  22     http://www.triptico.com
  23
  24 */
  25
  26 #include "config.h"
  27
  28 #include <stdlib.h>
  29 #include <math.h>
  30
  31 #include "core.h"
  32 #include "effect.h"
  33
  34 /*******************
  35         Data
  36 ********************/
  37
  38 /*******************
  39         Code
  40 ********************/
  41
  42 static void _init_effect(struct effect * e, double size,
  43         float (* func)(struct effect *, float))
  44 {
  45         if(size)
  46         {
  47                 int n;
  48
  49                 e->wave=(float *) malloc((int)size * sizeof(float));
  50
  51                 for(n=0;n < (int)size;n++)
  52                         e->wave[n]=0;
  53         }
  54         else
  55                 e->wave=NULL;
  56
  57         e->size=size;
  58         e->func=func;
  59
  60         e->cursor=0;
  61 }
  62
  63
  64 static void _set_effect_lfo(struct effect * e, double freq, double phase)
  65 {
  66         e->lfo=phase * 6.28;
  67         e->lfo_inc=(freq * 6.28) / (double) _frequency;
  68 }
  69
  70
  71 /**
  72  * process_effect - Processes an effect.
  73  * @e: the effect
  74  * input: an input sample
  75  *
  76  * Processes an effect. @input is the input sample.
  77  *
  78  * Returns the filtered sample.
  79  */
  80 float process_effect(struct effect * e, float input)
  81 {
  82         float output;
  83
  84         if(e->func == NULL)
  85                 return(0);
  86
  87         output=e->func(e, input);
  88
  89         if(++e->cursor == e->size)
  90                 e->cursor=0;
  91
  92         return(output);
  93 }
  94
  95
  96 /**
  97  * effect_off - Switches off an effect.
  98  * @e: the effect
  99  *
 100  * Switches off an effect.
 101  */
 102 void effect_off(struct effect * e)
 103 {
 104         if(e->wave != NULL)
 105         {
 106                 free(e->wave);
 107                 e->wave=NULL;
 108         }
 109
 110         e->func=NULL;
 111 }
 112
 113
 114 /* effects */
 115
 116 /* delay */
 117
 118 static float _process_delay(struct effect * e, float input)
 119 {
 120         float s;
 121
 122         s=get_sample(e->wave, e->size, e->cursor);
 123         e->wave[(int) e->cursor]=input;
 124
 125         return(s);
 126 }
 127
 128
 129 /**
 130  * effect_delay - Sets a delay effect.
 131  * @e: the effect structure
 132  * @size: delay in samples
 133  *
 134  * Sets a delay effect. On output, this effect will simply
 135  * delay the output of the samples fed to it in @size
 136  * frames. No further filtering is done.
 137  */
 138 int effect_delay(struct effect * e, double size)
 139 {
 140         if(size == 0)
 141                 return(0);
 142
 143         _init_effect(e, size, _process_delay);
 144         return(1);
 145 }
 146
 147
 148 /* echo */
 149
 150 static float _process_echo(struct effect * e, float input)
 151 {
 152         float s;
 153
 154         s=get_sample(e->wave, e->size, e->cursor) * e->gain;
 155         e->wave[(int) e->cursor]=input;
 156
 157         return(input + s);
 158 }
 159
 160
 161 /**
 162  * effect_echo - Sets an echo effect.
 163  * @e: the effect structure
 164  * @size: delay in sample
 165  * @gain: echo gain
 166  *
 167  * Sets an echo effect. Outputs the current sample mixed
 168  * with the product of the sample sent @size frames ago
 169  * multiplied by the specified @gain.
 170  */
 171 int effect_echo(struct effect * e, double size, float gain)
 172 {
 173         if(size == 0)
 174                 return(0);
 175
 176         _init_effect(e, size, _process_echo);
 177         e->gain=gain;
 178
 179         return(1);
 180 }
 181
 182
 183 /* comb */
 184
 185 static float _process_comb(struct effect * e, float input)
 186 {
 187         float s;
 188
 189         s=get_sample(e->wave, e->size, e->cursor);
 190         e->wave[(int) e->cursor]=input + (s * e->gain);
 191
 192         return(input + s);
 193 }
 194
 195
 196 /**
 197  * effect_comb - Sets a comb filter.
 198  * @e: the effect structure
 199  * @size: delay in samples
 200  * @gain: filter gain
 201  *
 202  * Sets a comb filter, being @size the number of samples to
 203  * delay and @gain the feedback output. Comb filters are
 204  * used in reverbs.
 205  */
 206 int effect_comb(struct effect * e, double size, float gain)
 207 {
 208         if(size == 0)
 209                 return(0);
 210
 211         _init_effect(e, size, _process_comb);
 212         e->gain=gain;
 213
 214         return(1);
 215 }
 216
 217
 218 static float _process_allpass(struct effect * e, float input)
 219 {
 220         float s,t;
 221
 222         if(e->wave == NULL) return(0);
 223
 224         t=get_sample(e->wave, e->size, e->cursor);
 225         e->wave[(int) e->cursor]=input + (t * e->gain);
 226         s=t - (e->gain * e->wave[(int) e->cursor]);
 227
 228         return(s);
 229 }
 230
 231
 232 /**
 233  * effect_allpass - Sets an allpass filter.
 234  * @e: the effect structure
 235  * @size: delay in samples
 236  * @gain: filter gain
 237  *
 238  * Sets an allpass filter, being @size the number of samples to
 239  * delay and @gain the feedback output. Allpass filters are
 240  * used in reverbs.
 241  */
 242 int effect_allpass(struct effect * e, double size, float gain)
 243 {
 244         if(size == 0)
 245                 return(0);
 246
 247         _init_effect(e, size, _process_allpass);
 248         e->gain=gain;
 249
 250         return(1);
 251 }
 252
 253
 254 /* flanger */
 255
 256 static float _process_flanger(struct effect * e, float input)
 257 {
 258         double c;
 259         float s;
 260
 261         c=e->cursor - e->lfo_depth - (e->lfo_depth * sin(e->lfo));
 262         e->lfo += e->lfo_inc;
 263         if(c < 0) c += e->size;
 264
 265         s=get_sample(e->wave, e->size, c) * e->gain;
 266
 267         e->wave[(int) e->cursor]=input;
 268
 269         return(input + s);
 270 }
 271
 272
 273
 274 /**
 275  * effect_flanger: Sets a flanger effect.
 276  * @e: the effect structure
 277  * @size: delay in samples
 278  * @gain: output gain
 279  * @depth: flanger depth
 280  * @freq: LFO frequency in Hz
 281  * @phase: initial phase
 282  *
 283  * Sets a flanger effect, being @size the number of samples
 284  * to delay, @gain the output gain, @depth the number of samples
 285  * the output will be 'flanged' (bigger values mean bigger
 286  * fluctuations in the final frequency), @freq the frequency of
 287  * the LFO in Hz and @phase the initial LFO value as a
 288  * fractional part of a period, being 0 the start of the period,
 289  * 0.5 half a period and so on. The LFO is sinusoidal.
 290  */
 291 int effect_flanger(struct effect * e, double size, float gain,
 292         double depth, double freq, double phase)
 293 {
 294         if(size == 0)
 295                 return(0);
 296
 297         _init_effect(e, size, _process_flanger);
 298
 299         e->gain=gain;
 300         e->lfo_depth=depth;
 301
 302         _set_effect_lfo(e, freq, phase);
 303
 304         return(1);
 305 }
 306
 307
 308 /* wobble */
 309
 310 static float _process_wobble(struct effect * e, float input)
 311 {
 312         float s;
 313
 314         s=input * sin(e->lfo);
 315         e->lfo += e->lfo_inc;
 316
 317         return(s);
 318 }
 319
 320
 321 /**
 322  * effect_wobble - Sets a wobble effect.
 323  * @e: the effect structure
 324  * @freq: frequency in Hz
 325  * @phase: initial phase
 326  *
 327  * Sets a wobble effect, where the sample amplitudes are
 328  * multiplied by an LFO, so sound volume wobbles from full
 329  * volume to silence twice a period. @freq is the LFO frequency
 330  * in Hz and @phase the initial LFO value as a
 331  * fractional part of a period, being 0 the start of the period,
 332  * 0.5 half a period and so on. The LFO is sinusoidal.
 333  */
 334 int effect_wobble(struct effect * e, double freq, double phase)
 335 {
 336         _init_effect(e, 0, _process_wobble);
 337         _set_effect_lfo(e, freq, phase);
 338
 339         return(1);
 340 }
 341
 342
 343 /* square wave wobble */
 344
 345 static float _process_square_wobble(struct effect * e, float input)
 346 {
 347         float s;
 348
 349         s=sin(e->lfo) > 0 ? input : 0;
 350         e->lfo += e->lfo_inc;
 351
 352         return(s);
 353 }
 354
 355
 356 /**
 357  * effect_square_wobble - Sets a square wave wobble effect.
 358  * @e: the effect structure
 359  * @freq: frequency in Hz
 360  * @phase: initial phase
 361  *
 362  * Sets an effect like the wobble one (see documentation for
 363  * effect_wobble()), but using a square wave, meaning that input
 364  * goes unfiltered (full amplitude) for half the period and
 365  * complete silence the other half.
 366  */
 367 int effect_square_wobble(struct effect * e, double freq, double phase)
 368 {
 369         _init_effect(e, 0, _process_square_wobble);
 370         _set_effect_lfo(e, freq, phase);
 371
 372         return(1);
 373 }
 374
 375
 376 /* fader */
 377
 378 static float _process_fader(struct effect * e, float input)
 379 {
 380         float s;
 381
 382         s=input * e->gain;
 383
 384         if(e->size)
 385         {
 386                 e->size--;
 387                 e->gain += e->igain;
 388         }
 389
 390         return(s);
 391 }
 392
 393
 394 /**
 395  * effect_fader - Sets a fader effect.
 396  * @e: the effect structure
 397  * @size: number of samples the fader will last
 398  * @initial: initial volume
 399  * @final: final volume
 400  *
 401  * Sets a fader effect. The effect will fade in or out the input
 402  * volume from @initial to @final during @size samples.
 403  */
 404 int effect_fader(struct effect * e, double size, float initial, float final)
 405 {
 406         _init_effect(e, 0, _process_fader);
 407
 408         /* size is used as the number of samples,
 409            though this effect has no buffer */
 410         e->size=size;
 411
 412         e->gain=initial;
 413         e->igain=(final - initial) / (float) size;
 414
 415         return(1);
 416 }