chorus.c

linux下录音程序

/*
 * 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 */
#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 */
	}
}