ss_eff.c

   1 /*
   2
   3     Ann Hell Ex Machina - Music Software
   4     Copyright (C) 2003/2005 Angel Ortega <angel@triptico.com>
   5
   6     ss_eff.c - Software syntesizer's digital 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 <stdio.h>
  29 #include <string.h>
  30 #include <stdlib.h>
  31 #include <math.h>
  32
  33 #include "ss_core.h"
  34 #include "ss_eff.h"
  35
  36 /*******************
  37         Data
  38 ********************/
  39
  40 /*******************
  41         Code
  42 ********************/
  43
  44 struct ss_eff * ss_eff_add(struct ss_eff ** ec, double size,
  45         float gain, float (* func)(struct ss_eff *, float))
  46 /* adds an effect to the ec chain */
  47 {
  48         struct ss_eff * e;
  49
  50         /* convert to frames */
  51         size=MS2F(size);
  52
  53         /* create new structure and reset */
  54         if((e=malloc(sizeof(struct ss_eff))) == NULL)
  55                 return(NULL);
  56
  57         memset(e, '\0', sizeof(struct ss_eff));
  58
  59         /* enqueue */
  60         if(*ec == NULL)
  61                 *ec=e;
  62         else
  63         {
  64                 struct ss_eff * t;
  65
  66                 /* loop to add e to the end */
  67                 for(t=*ec;t->next != NULL;t=t->next);
  68
  69                 t->next=e;
  70         }
  71
  72         /* add buffer */
  73         if(size > 0)
  74         {
  75                 e->wave=(float *) malloc(((int) size) * sizeof(float));
  76                 memset(e->wave, '\0', ((int) size) * sizeof(float));
  77         }
  78
  79         e->size=size;
  80         e->gain=gain;
  81         e->func=func;
  82
  83         return(e);
  84 }
  85
  86
  87 void ss_eff_set_lfo(struct ss_eff * e, double freq, double phase, double depth)
  88 /* sets an alfo */
  89 {
  90         e->lfo=phase * 6.28;
  91         e->lfo_inc=(freq * 6.28) / (double) ss_frequency;
  92         e->lfo_depth=MS2F(depth);
  93 }
  94
  95
  96 double ss_eff_lfo(struct ss_eff * e)
  97 /* processes an lfo */
  98 {
  99         double r=sin(e->lfo);
 100         e->lfo += e->lfo_inc;
 101
 102         return(r);
 103 }
 104
 105
 106 /**
 107  * ss_eff_process - Processes a chain of digital effects
 108  * @e: the effect chain
 109  * @s: input sample
 110  *
 111  * Processes a chain of digital effects, taking each one as input
 112  * the output of the previous one.
 113  */
 114 float ss_eff_process(struct ss_eff * e, float s)
 115 {
 116         while(e != NULL)
 117         {
 118                 /* filter */
 119                 s=e->func(e, s);
 120
 121                 /* increment cursor */
 122                 if(++e->cursor >= e->size)
 123                         e->cursor=0;
 124
 125                 /* move to next */
 126                 e=e->next;
 127         }
 128
 129         return(s);
 130 }
 131
 132
 133 /**
 134  * ss_eff_off - Destroys a chain of digital effects
 135  * @ec: the effect chain
 136  *
 137  * Destroys a chain of digital effects.
 138  */
 139 void ss_eff_off(struct ss_eff ** ec)
 140 {
 141         while(*ec != NULL)
 142         {
 143                 struct ss_eff * e=(*ec)->next;
 144
 145                 /* free the buffer, if any */
 146                 if((*ec)->wave != NULL)
 147                         free((*ec)->wave);
 148
 149                 /* free the effect itself */
 150                 free(*ec);
 151
 152                 /* move to next */
 153                 *ec=e;
 154         }
 155 }
 156
 157
 158 /* effects */
 159
 160 /* delay */
 161
 162 static float func_delay(struct ss_eff * e, float input)
 163 {
 164         float s;
 165
 166         s=e->wave[(int) e->cursor];
 167         e->wave[(int) e->cursor]=input;
 168
 169         return(s);
 170 }
 171
 172
 173 /**
 174  * ss_eff_delay - Adds a delay effect.
 175  * @ec: the effect chain
 176  * @size: delay in milliseconds
 177  *
 178  * Adds a delay effect. On output, this effect will simply
 179  * delay the output of the samples fed to it in @size
 180  * frames. No further filtering is done.
 181  */
 182 void ss_eff_delay(struct ss_eff ** ec, double size)
 183 {
 184         ss_eff_add(ec, size, 0, func_delay);
 185 }
 186
 187
 188 /* echo */
 189
 190 static float func_echo(struct ss_eff * e, float input)
 191 {
 192         float s;
 193
 194         s=e->wave[(int) e->cursor] * e->gain;
 195         e->wave[(int) e->cursor]=input;
 196
 197         return(input + s);
 198 }
 199
 200
 201 /**
 202  * ss_eff_echo - Adds an echo effect.
 203  * @ec: the effect chain
 204  * @size: delay in milliseconds
 205  * @gain: echo gain
 206  *
 207  * Adds an echo effect. Outputs the current sample mixed
 208  * with the product of the sample sent @size frames ago
 209  * multiplied by the specified @gain.
 210  */
 211 void ss_eff_echo(struct ss_eff ** ec, double size, float gain)
 212 {
 213         ss_eff_add(ec, size, gain, func_echo);
 214 }
 215
 216
 217 /* comb */
 218
 219 static float func_comb(struct ss_eff * e, float input)
 220 {
 221         float s;
 222
 223         s=e->wave[(int) e->cursor];
 224         e->wave[(int) e->cursor]=input + (s * e->gain);
 225
 226         return(input + s);
 227 }
 228
 229
 230 /**
 231  * effect_comb - Adds a comb filter.
 232  * @ec: the effect chain
 233  * @size: delay in milliseconds
 234  * @gain: filter gain
 235  *
 236  * Adds a comb filter, being @size the number of samples to
 237  * delay and @gain the feedback output. Comb filters are
 238  * used in reverbs.
 239  */
 240 void ss_eff_comb(struct ss_eff ** ec, double size, float gain)
 241 {
 242         ss_eff_add(ec, size, gain, func_comb);
 243 }
 244
 245
 246 /* allpass */
 247
 248 static float func_allpass(struct ss_eff * e, float input)
 249 {
 250         float s, t, u;
 251
 252         t=e->wave[(int)e->cursor];
 253
 254         u=input + (t * e->gain);
 255         s=t - (e->gain * u);
 256
 257         e->wave[(int) e->cursor]=u;
 258
 259         return(s);
 260 }
 261
 262
 263 /**
 264  * ss_eff_allpass - Adds an allpass filter.
 265  * @ec: the effect chain
 266  * @size: delay in milliseconds
 267  * @gain: filter gain
 268  *
 269  * Adds an allpass filter, being @size the number of samples to
 270  * delay and @gain the feedback output. Allpass filters are
 271  * used in reverbs.
 272  */
 273 void ss_eff_allpass(struct ss_eff ** ec, double size, float gain)
 274 {
 275         ss_eff_add(ec, size, gain, func_allpass);
 276 }
 277
 278
 279 /* flanger */
 280
 281 static float func_flanger(struct ss_eff * e, float input)
 282 {
 283         double c;
 284         float s;
 285
 286         c=e->cursor - e->lfo_depth - (e->lfo_depth * ss_eff_lfo(e));
 287
 288         s=ss_get_sample(e->wave, e->size, c) * e->gain;
 289
 290         e->wave[(int) e->cursor]=input;
 291
 292         return(input + s);
 293 }
 294
 295
 296
 297 /**
 298  * ss_eff_flanger: Adds a flanger effect.
 299  * @ec: the effect chain
 300  * @size: delay in milliseconds
 301  * @gain: output gain
 302  * @depth: flanger depth in milliseconds
 303  * @freq: LFO frequency [0..1]
 304  * @phase: initial phase [0..1]
 305  *
 306  * Adds a flanger effect, being @size the number of samples
 307  * to delay, @gain the output gain, @depth the number of samples
 308  * the output will be 'flanged' (bigger values mean bigger
 309  * fluctuations in the final frequency), @freq the frequency of
 310  * the LFO in Hz and @phase the initial LFO value as a
 311  * fractional part of a period, being 0 the start of the period,
 312  * 0.5 half a period and so on. The LFO is sinusoidal.
 313  */
 314 void ss_eff_flanger(struct ss_eff ** ec, double size, float gain,
 315         double depth, double freq, double phase)
 316 {
 317         struct ss_eff * e;
 318
 319         e=ss_eff_add(ec, size, gain, func_flanger);
 320         ss_eff_set_lfo(e, freq, phase, depth);
 321 }
 322
 323
 324 /* wobble */
 325
 326 static float func_wobble(struct ss_eff * e, float input)
 327 {
 328         float s;
 329
 330         s=input * ss_eff_lfo(e);
 331
 332         return(s);
 333 }
 334
 335
 336 /**
 337  * effect_wobble - Adds a wobble effect.
 338  * @ec: the effect chain
 339  * @freq: frequency [0..1]
 340  * @phase: initial phase [0..1]
 341  *
 342  * Adds a wobble effect, where the sample amplitudes are
 343  * multiplied by an LFO, so sound volume wobbles from full
 344  * volume to silence twice a period. @freq is the LFO frequency
 345  * in Hz and @phase the initial LFO value as a
 346  * fractional part of a period, being 0 the start of the period,
 347  * 0.5 half a period and so on. The LFO is sinusoidal.
 348  */
 349 void ss_eff_wobble(struct ss_eff ** ec, double freq, double phase)
 350 {
 351         struct ss_eff * e;
 352
 353         e=ss_eff_add(ec, 0, 0, func_wobble);
 354         ss_eff_set_lfo(e, freq, phase, 0);
 355 }
 356
 357
 358 /* square wave wobble */
 359
 360 static float func_square_wobble(struct ss_eff * e, float input)
 361 {
 362         return(ss_eff_lfo(e) > 0 ? input : 0);
 363 }
 364
 365
 366 /**
 367  * ss_eff_square_wobble - Adds a square wave wobble effect.
 368  * @ec: the effect chain
 369  * @freq: frequency [0..1]
 370  * @phase: initial phase [0..1]
 371  *
 372  * Adds an effect like the wobble one (see documentation for
 373  * effect_wobble()), but using a square wave, meaning that input
 374  * goes unfiltered (full amplitude) for half the period and
 375  * complete silence the other half.
 376  */
 377 void ss_eff_square_wobble(struct ss_eff ** ec, double freq, double phase)
 378 {
 379         struct ss_eff * e;
 380
 381         e=ss_eff_add(ec, 0, 0, func_square_wobble);
 382         ss_eff_set_lfo(e, freq, phase, 0);
 383 }
 384
 385
 386 /* fader */
 387
 388 static float func_fader(struct ss_eff * e, float input)
 389 {
 390         float s;
 391
 392         s=input * e->gain;
 393
 394         if(e->size)
 395         {
 396                 e->size--;
 397                 e->gain += e->igain;
 398         }
 399
 400         return(s);
 401 }
 402
 403
 404 /**
 405  * ss_eff_fader - Adds a fader effect.
 406  * @ec: the effect chain
 407  * @size: number of milliseconds the fader will last
 408  * @initial: initial volume
 409  * @final: final volume
 410  *
 411  * Adds a fader effect. The effect will fade in or out the input
 412  * volume from @initial to @final during @size samples.
 413  */
 414 void ss_eff_fader(struct ss_eff ** ec, double size, float initial, float final)
 415 {
 416         struct ss_eff * e;
 417
 418         e=ss_eff_add(ec, size, initial, func_fader);
 419
 420         e->igain=(final - initial) / (float) MS2F(size);
 421 }
 422
 423
 424 /**
 425  * ss_eff_reverb - Adds a simple reverb effect.
 426  * @ec: the effect chain
 427  *
 428  * Adds a simple reverb effect, using a chain of allpass filters.
 429  */
 430 void ss_eff_reverb(struct ss_eff ** ec)
 431 {
 432         ss_eff_allpass(ec, 20.0, 0.9);
 433         ss_eff_allpass(ec, 36.0, 0.9);
 434         ss_eff_allpass(ec, 39.0, 0.9);
 435 }