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