ref: eb34a52b9b0c0b82b889cbef287c174a1344df36
dir: /src/chorus.c/
/*
* August 24, 1998
* Copyright (C) 1998 Juergen Mueller And Sundry Contributors
* This source code is freely redistributable and may be used for
* any purpose. This copyright notice must be maintained.
* Juergen Mueller And Sundry Contributors are not responsible for
* the consequences of using this software.
*/
/*
* Chorus effect.
*
* Flow diagram scheme for n delays ( 1 <= n <= MAX_CHORUS ):
*
* * gain-in ___
* ibuff -----+--------------------------------------------->| |
* | _________ | |
* | | | * decay 1 | |
* +---->| delay 1 |----------------------------->| |
* | |_________| | |
* | /|\ | |
* : | | |
* : +-----------------+ +--------------+ | + |
* : | Delay control 1 |<--| mod. speed 1 | | |
* : +-----------------+ +--------------+ | |
* | _________ | |
* | | | * decay n | |
* +---->| delay n |----------------------------->| |
* |_________| | |
* /|\ |___|
* | |
* +-----------------+ +--------------+ | * gain-out
* | Delay control n |<--| mod. speed n | |
* +-----------------+ +--------------+ +----->obuff
*
*
* The delay i is controled by a sine or triangle modulation i ( 1 <= i <= n).
*
* Usage:
* chorus gain-in gain-out delay-1 decay-1 speed-1 depth-1 -s1|t1 [
* delay-2 decay-2 speed-2 depth-2 -s2|-t2 ... ]
*
* Where:
* gain-in, decay-1 ... decay-n : 0.0 ... 1.0 volume
* gain-out : 0.0 ... volume
* delay-1 ... delay-n : 20.0 ... 100.0 msec
* speed-1 ... speed-n : 0.1 ... 5.0 Hz modulation 1 ... n
* depth-1 ... depth-n : 0.0 ... 10.0 msec modulated delay 1 ... n
* -s1 ... -sn : modulation by sine 1 ... n
* -t1 ... -tn : modulation by triangle 1 ... n
*
* Note:
* when decay is close to 1.0, the samples can begin clipping and the output
* can saturate!
*
* Hint:
* 1 / out-gain < gain-in ( 1 + decay-1 + ... + decay-n )
*
*/
/*
* Sound Tools chorus effect file.
*/
#include <stdlib.h> /* Harmless, and prototypes atof() etc. --dgc */
#ifdef HAVE_MALLOC_H
#include <malloc.h>
#endif
#include <math.h>
#include <string.h>
#include "st.h"
#define MOD_SINE 0
#define MOD_TRIANGLE 1
#define MAX_CHORUS 7
/* Private data for SKEL file */
typedef struct chorusstuff {
int num_chorus;
int modulation[MAX_CHORUS];
int counter;
long phase[MAX_CHORUS];
float *chorusbuf;
float in_gain, out_gain;
float delay[MAX_CHORUS], decay[MAX_CHORUS];
float speed[MAX_CHORUS], depth[MAX_CHORUS];
long length[MAX_CHORUS];
int *lookup_tab[MAX_CHORUS];
int depth_samples[MAX_CHORUS], samples[MAX_CHORUS];
int maxsamples, fade_out;
} *chorus_t;
/* Private data for SKEL file */
LONG chorus_clip24(l)
LONG l;
{
if (l >= ((LONG)1 << 24))
return ((LONG)1 << 24) - 1;
else if (l <= -((LONG)1 << 24))
return -((LONG)1 << 24) + 1;
else
return l;
}
/* This was very painful. We need a sine library. */
void chorus_sine(buf, len, max, depth)
int *buf;
long len;
int max;
int depth;
{
long i;
int offset;
double val;
offset = max - depth;
for (i = 0; i < len; i++) {
val = sin((double)i/(double)len * 2.0 * M_PI);
buf[i] = offset + (int) (val * (double)depth);
}
}
void chorus_triangle(buf, len, max, depth)
int *buf;
long len;
int max;
int depth;
{
long i;
int offset;
double val;
offset = max - 2 * depth;
for (i = 0; i < len / 2; i++) {
val = i * 2.0 / len;
buf[i] = offset + (int) (val * 2.0 * (double)depth);
}
for (i = len / 2; i < len ; i++) {
val = (len - i) * 2.0 / len;
buf[i] = offset + (int) (val * 2.0 * (double)depth);
}
}
/*
* Process options
*/
void chorus_getopts(effp, n, argv)
eff_t effp;
int n;
char **argv;
{
chorus_t chorus = (chorus_t) effp->priv;
int i;
chorus->num_chorus = 0;
i = 0;
if ( ( n < 7 ) || (( n - 2 ) % 5 ) )
fail("Usage: chorus gain-in gain-out delay decay speed depth [ -s | -t ]");
sscanf(argv[i++], "%f", &chorus->in_gain);
sscanf(argv[i++], "%f", &chorus->out_gain);
while ( i < n ) {
if ( chorus->num_chorus > MAX_CHORUS )
fail("chorus: to many delays, use less than %i delays", MAX_CHORUS);
sscanf(argv[i++], "%f", &chorus->delay[chorus->num_chorus]);
sscanf(argv[i++], "%f", &chorus->decay[chorus->num_chorus]);
sscanf(argv[i++], "%f", &chorus->speed[chorus->num_chorus]);
sscanf(argv[i++], "%f", &chorus->depth[chorus->num_chorus]);
if ( !strcmp(argv[i], "-s"))
chorus->modulation[chorus->num_chorus] = MOD_SINE;
else if ( ! strcmp(argv[i], "-t"))
chorus->modulation[chorus->num_chorus] = MOD_TRIANGLE;
else
fail("Usage: chorus gain-in gain-out delay decay speed [ -s | -t ]");
i++;
chorus->num_chorus++;
}
}
/*
* Prepare for processing.
*/
void chorus_start(effp)
eff_t effp;
{
chorus_t chorus = (chorus_t) effp->priv;
int i;
float sum_in_volume;
chorus->maxsamples = 0;
if ( chorus->in_gain < 0.0 )
fail("chorus: gain-in must be positive!\n");
if ( chorus->in_gain > 1.0 )
fail("chorus: gain-in must be less than 1.0!\n");
if ( chorus->out_gain < 0.0 )
fail("chorus: gain-out must be positive!\n");
for ( i = 0; i < chorus->num_chorus; i++ ) {
chorus->samples[i] = (int) ( ( chorus->delay[i] +
chorus->depth[i] ) * effp->ininfo.rate / 1000.0);
chorus->depth_samples[i] = (int) (chorus->depth[i] *
effp->ininfo.rate / 1000.0);
if ( chorus->delay[i] < 20.0 )
fail("chorus: delay must be more than 20.0 msec!\n");
if ( chorus->delay[i] > 100.0 )
fail("chorus: delay must be less than 100.0 msec!\n");
if ( chorus->speed[i] < 0.1 )
fail("chorus: speed must be more than 0.1 Hz!\n");
if ( chorus->speed[i] > 5.0 )
fail("chorus: speed must be less than 5.0 Hz!\n");
if ( chorus->depth[i] < 0.0 )
fail("chorus: delay must be more positive!\n");
if ( chorus->depth[i] > 10.0 )
fail("chorus: delay must be less than 10.0 msec!\n");
if ( chorus->decay[i] < 0.0 )
fail("chorus: decay must be positive!\n" );
if ( chorus->decay[i] > 1.0 )
fail("chorus: decay must be less that 1.0!\n" );
chorus->length[i] = effp->ininfo.rate / chorus->speed[i];
if (! (chorus->lookup_tab[i] =
(int *) malloc(sizeof (int) * chorus->length[i])))
fail("chorus: Cannot malloc %d bytes!\n",
sizeof(int) * chorus->length[i]);
if ( chorus->modulation[i] == MOD_SINE )
chorus_sine(chorus->lookup_tab[i], chorus->length[i],
chorus->samples[i] - 1, chorus->depth_samples[i]);
else
chorus_triangle(chorus->lookup_tab[i], chorus->length[i],
chorus->samples[i] - 1, chorus->depth_samples[i]);
chorus->phase[i] = 0;
if ( chorus->samples[i] > chorus->maxsamples )
chorus->maxsamples = chorus->samples[i];
}
/* Be nice and check the hint with warning, if... */
sum_in_volume = 1.0;
for ( i = 0; i < chorus->num_chorus; i++ )
sum_in_volume += chorus->decay[i];
if ( chorus->in_gain * ( sum_in_volume ) > 1.0 / chorus->out_gain )
warn("chorus: warning >>> gain-out can cause saturation or clipping of output <<<");
if (! (chorus->chorusbuf =
(float *) malloc(sizeof (float) * chorus->maxsamples)))
fail("chorus: Cannot malloc %d bytes!\n",
sizeof(float) * chorus->maxsamples);
for ( i = 0; i < chorus->maxsamples; i++ )
chorus->chorusbuf[i] = 0.0;
chorus->counter = 0;
chorus->fade_out = chorus->maxsamples;
}
/*
* Processed signed long samples from ibuf to obuf.
* Return number of samples processed.
*/
void chorus_flow(effp, ibuf, obuf, isamp, osamp)
eff_t effp;
LONG *ibuf, *obuf;
int *isamp, *osamp;
{
chorus_t chorus = (chorus_t) effp->priv;
int len, done;
int i;
float d_in, d_out;
LONG out;
len = ((*isamp > *osamp) ? *osamp : *isamp);
for(done = 0; done < len; done++) {
/* Store delays as 24-bit signed longs */
d_in = (float) *ibuf++ / 256;
/* Compute output first */
d_out = d_in * chorus->in_gain;
for ( i = 0; i < chorus->num_chorus; i++ )
d_out += chorus->chorusbuf[(chorus->maxsamples +
chorus->counter - chorus->lookup_tab[i][chorus->phase[i]]) %
chorus->maxsamples] * chorus->decay[i];
/* Adjust the output volume and size to 24 bit */
d_out = d_out * chorus->out_gain;
out = chorus_clip24((LONG) d_out);
*obuf++ = out * 256;
/* Mix decay of delay and input */
chorus->chorusbuf[chorus->counter] = d_in;
chorus->counter =
( chorus->counter + 1 ) % chorus->maxsamples;
for ( i = 0; i < chorus->num_chorus; i++ )
chorus->phase[i] =
( chorus->phase[i] + 1 ) % chorus->length[i];
}
/* processed all samples */
}
/*
* Drain out reverb lines.
*/
void chorus_drain(effp, obuf, osamp)
eff_t effp;
LONG *obuf;
int *osamp;
{
chorus_t chorus = (chorus_t) effp->priv;
int done;
int i;
float d_in, d_out;
LONG out;
done = 0;
while ( ( done < *osamp ) && ( done < chorus->fade_out ) ) {
d_in = 0;
d_out = 0;
/* Compute output first */
for ( i = 0; i < chorus->num_chorus; i++ )
d_out += chorus->chorusbuf[(chorus->maxsamples +
chorus->counter - chorus->lookup_tab[i][chorus->phase[i]]) %
chorus->maxsamples] * chorus->decay[i];
/* Adjust the output volume and size to 24 bit */
d_out = d_out * chorus->out_gain;
out = chorus_clip24((LONG) d_out);
*obuf++ = out * 256;
/* Mix decay of delay and input */
chorus->chorusbuf[chorus->counter] = d_in;
chorus->counter =
( chorus->counter + 1 ) % chorus->maxsamples;
for ( i = 0; i < chorus->num_chorus; i++ )
chorus->phase[i] =
( chorus->phase[i] + 1 ) % chorus->length[i];
done++;
chorus->fade_out--;
}
/* samples played, it remains */
*osamp = done;
}
/*
* Clean up chorus effect.
*/
void chorus_stop(effp)
eff_t effp;
{
chorus_t chorus = (chorus_t) effp->priv;
int i;
free((char *) chorus->chorusbuf);
chorus->chorusbuf = (float *) -1; /* guaranteed core dump */
for ( i = 0; i < chorus->num_chorus; i++ ) {
free((char *) chorus->lookup_tab[i]);
chorus->lookup_tab[i] = (int *) -1; /* guaranteed core dump */
}
}