ss_eff.c

   1 /*
   2
   3     Ann Hell Ex Machina - Music Software
   4     Copyright (C) 2003/2008 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 "ahxm.h"
  34
  35
  36 /** helping functions **/
  37
  38 static struct ss_eff *ss_eff_add(struct ss_eff **ec, double size,
  39                                  sample_t gain,
  40                                  sample_t(*func) (struct ss_eff *,
  41                                                   sample_t))
  42 /* adds an effect to the ec chain */
  43 {
  44     struct ss_eff *e;
  45
  46     /* convert to frames */
  47     size = MS2F(size);
  48
  49     /* create new structure and reset */
  50     if ((e = malloc(sizeof(struct ss_eff))) == NULL)
  51         return NULL;
  52
  53     memset(e, '\0', sizeof(struct ss_eff));
  54
  55     /* enqueue */
  56     if (*ec == NULL)
  57         *ec = e;
  58     else {
  59         struct ss_eff *t;
  60
  61         /* loop to add e to the end */
  62         for (t = *ec; t->next != NULL; t = t->next);
  63
  64         t->next = e;
  65     }
  66
  67     /* add buffer */
  68     if (size > 0) {
  69         e->wave = ss_alloc_wave((int) size, 1, ss_frequency, -1);
  70         ss_prepare_wave(e->wave);
  71     }
  72
  73     e->gain = gain;
  74     e->func = func;
  75
  76     return e;
  77 }
  78
  79
  80 static void ss_eff_set_lfo(struct ss_eff *e, double freq, double phase,
  81                            double depth)
  82 /* sets an alfo */
  83 {
  84     e->lfo = phase * 6.28;
  85     e->lfo_inc = (freq * 6.28) / (double) ss_frequency;
  86     e->lfo_depth = MS2F(depth);
  87 }
  88
  89
  90 static double ss_eff_lfo(struct ss_eff *e)
  91 /* processes an lfo */
  92 {
  93     double r = sin(e->lfo);
  94     e->lfo += e->lfo_inc;
  95
  96     return r;
  97 }
  98
  99
 100 /**
 101  * ss_eff_process - Processes a chain of digital effects
 102  * @e: the effect chain
 103  * @s: input sample
 104  *
 105  * Processes a chain of digital effects, taking each one as input
 106  * the output of the previous one.
 107  */
 108 sample_t ss_eff_process(struct ss_eff * e, sample_t s)
 109 {
 110     while (e != NULL) {
 111         /* filter */
 112         s = e->func(e, s);
 113
 114         /* increment cursor */
 115         if (e->wave != NULL) {
 116             if (++e->cursor >= e->wave->size)
 117                 e->cursor = 0;
 118         }
 119
 120         /* move to next */
 121         e = e->next;
 122     }
 123
 124     return s;
 125 }
 126
 127
 128 /**
 129  * ss_eff_off - Destroys a chain of digital effects
 130  * @ec: the effect chain
 131  *
 132  * Destroys a chain of digital effects.
 133  */
 134 void ss_eff_off(struct ss_eff **ec)
 135 {
 136     while (*ec != NULL) {
 137         struct ss_eff *e = (*ec)->next;
 138
 139         /* free the buffer, if any */
 140         if ((*ec)->wave != NULL)
 141             ss_free_wave((*ec)->wave);
 142
 143         /* free the effect itself */
 144         free(*ec);
 145
 146         /* move to next */
 147         *ec = e;
 148     }
 149 }
 150
 151
 152 static sample_t *eff_cursor_ptr(struct ss_eff *e)
 153 /* returns a pointer to the current sample */
 154 {
 155     sample_t *wave = e->wave->wave[0];
 156     return wave + (int) e->cursor;
 157 }
 158
 159
 160 /** Effect: delay **/
 161
 162 static sample_t func_delay(struct ss_eff *e, sample_t input)
 163 {
 164     sample_t *p;
 165     sample_t s;
 166
 167     p = eff_cursor_ptr(e);
 168     s = *p;
 169     *p = input;
 170
 171     return s;
 172 }
 173
 174
 175 /**
 176  * ss_eff_delay - Adds a delay effect.
 177  * @ec: the effect chain
 178  * @size: delay in milliseconds
 179  *
 180  * Adds a delay effect. On output, this effect will simply
 181  * delay the output of the samples fed to it in @size
 182  * frames. No further filtering is done.
 183  */
 184 void ss_eff_delay(struct ss_eff **ec, double size)
 185 {
 186     ss_eff_add(ec, size, 0, func_delay);
 187 }
 188
 189
 190 /** Effect: echo **/
 191
 192 static sample_t func_echo(struct ss_eff *e, sample_t input)
 193 {
 194     sample_t *p;
 195     sample_t s;
 196
 197     p = eff_cursor_ptr(e);
 198     s = *p * e->gain;
 199     *p = input;
 200
 201     return input + s;
 202 }
 203
 204
 205 /**
 206  * ss_eff_echo - Adds an echo effect.
 207  * @ec: the effect chain
 208  * @size: delay in milliseconds
 209  * @gain: echo gain
 210  *
 211  * Adds an echo effect. Outputs the current sample mixed
 212  * with the product of the sample sent @size frames ago
 213  * multiplied by the specified @gain.
 214  */
 215 void ss_eff_echo(struct ss_eff **ec, double size, sample_t gain)
 216 {
 217     ss_eff_add(ec, size, gain, func_echo);
 218 }
 219
 220
 221 /** Effect: comb **/
 222
 223 static sample_t func_comb(struct ss_eff *e, sample_t input)
 224 {
 225     sample_t *p;
 226     sample_t s;
 227
 228     p = eff_cursor_ptr(e);
 229     s = *p;
 230     *p = input + (s * e->gain);
 231
 232     return input + s;
 233 }
 234
 235
 236 /**
 237  * ss_effect_comb - Adds a comb filter.
 238  * @ec: the effect chain
 239  * @size: delay in milliseconds
 240  * @gain: filter gain
 241  *
 242  * Adds a comb filter, being @size the number of samples to
 243  * delay and @gain the feedback output. Comb filters are
 244  * used in reverbs.
 245  */
 246 void ss_eff_comb(struct ss_eff **ec, double size, sample_t gain)
 247 {
 248     ss_eff_add(ec, size, gain, func_comb);
 249 }
 250
 251
 252 /** Effect: allpass **/
 253
 254 static sample_t func_allpass(struct ss_eff *e, sample_t input)
 255 {
 256     sample_t *p;
 257     sample_t s, t, u;
 258
 259     p = eff_cursor_ptr(e);
 260     t = *p;
 261
 262     u = input + (t * e->gain);
 263     s = t - (e->gain * u);
 264
 265     *p = u;
 266
 267     return s;
 268 }
 269
 270
 271 /**
 272  * ss_eff_allpass - Adds an allpass filter.
 273  * @ec: the effect chain
 274  * @size: delay in milliseconds
 275  * @gain: filter gain
 276  *
 277  * Adds an allpass filter, being @size the number of samples to
 278  * delay and @gain the feedback output. Allpass filters are
 279  * used in reverbs.
 280  */
 281 void ss_eff_allpass(struct ss_eff **ec, double size, sample_t gain)
 282 {
 283     ss_eff_add(ec, size, gain, func_allpass);
 284 }
 285
 286
 287 /** Effect: flanger **/
 288
 289 static sample_t func_flanger(struct ss_eff *e, sample_t input)
 290 {
 291     double c;
 292     sample_t s;
 293     sample_t *p;
 294
 295     c = e->cursor - e->lfo_depth - (e->lfo_depth * ss_eff_lfo(e));
 296
 297     s = ss_get_sample(e->wave, 0, c) * e->gain;
 298
 299     p = eff_cursor_ptr(e);
 300     *p = input;
 301
 302     return input + s;
 303 }
 304
 305
 306
 307 /**
 308  * ss_eff_flanger - Adds a flanger effect.
 309  * @ec: the effect chain
 310  * @size: delay in milliseconds
 311  * @gain: output gain
 312  * @depth: flanger depth in milliseconds
 313  * @freq: LFO frequency [0..1]
 314  * @phase: initial phase [0..1]
 315  *
 316  * Adds a flanger effect, being @size the number of samples
 317  * to delay, @gain the output gain, @depth the number of samples
 318  * the output will be 'flanged' (bigger values mean bigger
 319  * fluctuations in the final frequency), @freq the frequency of
 320  * the LFO in Hz and @phase the initial LFO value as a
 321  * fractional part of a period, being 0 the start of the period,
 322  * 0.5 half a period and so on. The LFO is sinusoidal.
 323  */
 324 void ss_eff_flanger(struct ss_eff **ec, double size, sample_t gain,
 325                     double depth, double freq, double phase)
 326 {
 327     struct ss_eff *e;
 328
 329     e = ss_eff_add(ec, size, gain, func_flanger);
 330     ss_eff_set_lfo(e, freq, phase, depth);
 331 }
 332
 333
 334 /** Effect: wobble **/
 335
 336 static sample_t func_wobble(struct ss_eff *e, sample_t input)
 337 {
 338     sample_t s;
 339
 340     s = (input * fabs(ss_eff_lfo(e)) * e->gain) +
 341         (input * (1.0 - e->gain));
 342
 343     return s;
 344 }
 345
 346
 347 /**
 348  * ss_effect_wobble - Adds a wobble effect.
 349  * @ec: the effect chain
 350  * @freq: frequency [0..1]
 351  * @phase: initial phase [0..1]
 352  * @gain: ammount of effect [0..1]
 353  *
 354  * Adds a wobble effect, where the sample amplitudes are
 355  * multiplied by an LFO, so sound volume wobbles from full
 356  * volume to silence twice a period. @freq is the LFO frequency
 357  * in Hz and @phase the initial LFO value as a
 358  * fractional part of a period, being 0 the start of the period,
 359  * 0.5 half a period and so on. The LFO is sinusoidal.
 360  */
 361 void ss_eff_wobble(struct ss_eff **ec, double freq, double phase,
 362                    sample_t gain)
 363 {
 364     struct ss_eff *e;
 365
 366     e = ss_eff_add(ec, 0, gain, func_wobble);
 367     ss_eff_set_lfo(e, freq, phase, 0);
 368 }
 369
 370
 371 /** Effect: square wave wobble **/
 372
 373 static sample_t func_square_wobble(struct ss_eff *e, sample_t input)
 374 {
 375     return ss_eff_lfo(e) > 0 ? input : 0;
 376 }
 377
 378
 379 /**
 380  * ss_eff_square_wobble - Adds a square wave wobble effect.
 381  * @ec: the effect chain
 382  * @freq: frequency [0..1]
 383  * @phase: initial phase [0..1]
 384  *
 385  * Adds an effect like the wobble one (see documentation for
 386  * effect_wobble()), but using a square wave, meaning that input
 387  * goes unfiltered (full amplitude) for half the period and
 388  * complete silence the other half.
 389  */
 390 void ss_eff_square_wobble(struct ss_eff **ec, double freq, double phase)
 391 {
 392     struct ss_eff *e;
 393
 394     e = ss_eff_add(ec, 0, 0, func_square_wobble);
 395     ss_eff_set_lfo(e, freq, phase, 0);
 396 }
 397
 398
 399 /** Effect: half wobble **/
 400
 401 static sample_t func_half_wobble(struct ss_eff *e, sample_t input)
 402 {
 403     sample_t s;
 404
 405     s = ss_eff_lfo(e);
 406
 407     return s > 0.0 ? s * input : 0.0;
 408 }
 409
 410
 411 /**
 412  * ss_eff_half_wobble - Adds a half wave wobble effect.
 413  * @ec: the effect chain
 414  * @freq: frequency [0..1]
 415  * @phase: initial phase [0..1]
 416  *
 417  * Adds an effect like the wobble one (see documentation for
 418  * effect_wobble()), but returning only the first half of the
 419  * full period as a wobble and the second as silence.
 420  */
 421 void ss_eff_half_wobble(struct ss_eff **ec, double freq, double phase)
 422 {
 423     struct ss_eff *e;
 424
 425     e = ss_eff_add(ec, 0, 0, func_half_wobble);
 426     ss_eff_set_lfo(e, freq, phase, 0);
 427 }
 428
 429
 430 /** Effect: fader **/
 431
 432 static sample_t func_fader(struct ss_eff *e, sample_t input)
 433 {
 434     sample_t s;
 435
 436     s = input * e->gain;
 437     e->gain += e->igain;
 438
 439     if (e->cursor == e->wave->size - 1)
 440         e->igain = 0;
 441
 442     return s;
 443 }
 444
 445
 446 /**
 447  * ss_eff_fader - Adds a fader effect.
 448  * @ec: the effect chain
 449  * @size: number of milliseconds the fader will last
 450  * @initial: initial volume
 451  * @final: final volume
 452  *
 453  * Adds a fader effect. The effect will fade in or out the input
 454  * volume from @initial to @final during @size samples.
 455  */
 456 void ss_eff_fader(struct ss_eff **ec, double size, sample_t initial,
 457                   sample_t final)
 458 {
 459     struct ss_eff *e;
 460
 461     e = ss_eff_add(ec, size, initial, func_fader);
 462
 463     e->igain = (final - initial) / (sample_t) MS2F(size);
 464 }
 465
 466
 467 /** Effect: reverb **/
 468
 469 /**
 470  * ss_eff_reverb - Adds a simple reverb effect.
 471  * @ec: the effect chain
 472  *
 473  * Adds a simple reverb effect, using a chain of allpass filters.
 474  */
 475 void ss_eff_reverb(struct ss_eff **ec)
 476 {
 477     ss_eff_allpass(ec, 20.0, 0.9);
 478     ss_eff_allpass(ec, 36.0, 0.9);
 479     ss_eff_allpass(ec, 39.0, 0.9);
 480 }
 481
 482
 483 /** Effect: foldback distortion **/
 484
 485 static sample_t func_foldback(struct ss_eff *e, sample_t input)
 486 {
 487     sample_t s = input;
 488
 489     /* http://www.musicdsp.org/archive.php?classid=4#203 */
 490     if (input > e->gain)
 491         s = e->gain - (input - e->gain);
 492     else
 493     if (input < -e->gain)
 494         s = -e->gain + (-e->gain - input);
 495
 496     return s;
 497 }
 498
 499
 500 /**
 501  * ss_eff_foldback - Adds a foldback distortion effect.
 502  * @ec: the effect chain
 503  * @threshold: threshold to apply the folding
 504  *
 505  * Adds a foldback distortion effect. All aplitudes above the
 506  * threshold are folded back.
 507  */
 508 void ss_eff_foldback(struct ss_eff **ec, sample_t threshold)
 509 {
 510     ss_eff_add(ec, 0, threshold, func_foldback);
 511 }
 512
 513
 514 /** Effect: atan distortion **/
 515
 516 static sample_t func_atan(struct ss_eff *e, sample_t input)
 517 {
 518     sample_t s = input;
 519
 520     /* atan */
 521     /* http://www.musicdsp.org/showArchiveComment.php?ArchiveID=104 */
 522     s = atan(s * e->gain) / e->gain;
 523
 524     return s;
 525 }
 526
 527
 528 /**
 529  * ss_eff_atan - Adds an 'atan' distortion effect.
 530  * @ec: the effect chain
 531  * @gain: amount of effect
 532  *
 533  * Adds an 'atan' distortion effect.
 534  */
 535 void ss_eff_atan(struct ss_eff **ec, sample_t gain)
 536 {
 537     ss_eff_add(ec, 0, gain, func_atan);
 538 }
 539
 540
 541 /** Effect: distort distortion **/
 542
 543 static sample_t func_distort(struct ss_eff *e, sample_t input)
 544 {
 545     sample_t s = input;
 546
 547     /* distort */
 548     /* http://www.musicdsp.org/showArchiveComment.php?ArchiveID=86 */
 549     s = s - e->gain * s * s * s;
 550
 551     return s;
 552 }
 553
 554
 555 /**
 556  * ss_eff_distort - Adds a 'distort' distortion effect.
 557  * @ec: the effect chain
 558  * @gain: amount of effect
 559  *
 560  * Adds a 'distort' distortion effect.
 561  */
 562 void ss_eff_distort(struct ss_eff **ec, sample_t gain)
 563 {
 564     ss_eff_add(ec, 0, gain, func_distort);
 565 }
 566
 567
 568 /** Effect: overdrive distortion **/
 569
 570 static sample_t func_overdrive(struct ss_eff *e, sample_t input)
 571 {
 572     sample_t s = input;
 573
 574     /* overdrive */
 575     /* http://www.musicdsp.org/archive.php?classid=4#41 */
 576     s = s * (fabs(s) + e->gain) / (s * s + (e->gain - 1) * fabs(s) + 1);
 577
 578     return s;
 579 }
 580
 581
 582 /**
 583  * ss_eff_overdrive - Adds an 'overdrive' distortion effect.
 584  * @ec: the effect chain
 585  * @gain: amount of effect
 586  *
 587  * Adds an 'overdrive' distortion effect.
 588  */
 589 void ss_eff_overdrive(struct ss_eff **ec, sample_t gain)
 590 {
 591     ss_eff_add(ec, 0, gain, func_overdrive);
 592 }