/* libSoX Echo effect 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. * * * Flow diagram scheme for n delays ( 1 <= n <= MAX_ECHOS ): * * * gain-in ___ * ibuff --+--------------------------------------------------->| | * | * decay 1 | | * | +----------------------------------->| | * | | * decay 2 | + | * | | +--------------------->| | * | | | * decay n | | * | _________ | _________ | _________ +--->|___| * | | | | | | | | | | | * +-->| delay 1 |-+-| delay 2 |-+...-| delay n |--+ | * gain-out * |_________| |_________| |_________| | * +----->obuff * Usage: * echos gain-in gain-out delay-1 decay-1 [delay-2 decay-2 ... delay-n decay-n] * * Where: * gain-in, decay-1 ... decay-n : 0.0 ... 1.0 volume * gain-out : 0.0 ... volume * delay-1 ... delay-n : > 0.0 msec * * 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 ) * */ #include "sox_i.h" #include /* Harmless, and prototypes atof() etc. --dgc */ #define DELAY_BUFSIZ ( 50 * 50U * 1024 ) #define MAX_ECHOS 7 /* 24 bit x ( 1 + MAX_ECHOS ) = */ /* 24 bit x 8 = 32 bit !!! */ /* Private data for SKEL file */ typedef struct { int counter[MAX_ECHOS]; int num_delays; double *delay_buf; float in_gain, out_gain; float delay[MAX_ECHOS], decay[MAX_ECHOS]; ptrdiff_t samples[MAX_ECHOS], pointer[MAX_ECHOS]; size_t sumsamples; } priv_t; /* Private data for SKEL file */ /* * Process options */ static int sox_echos_getopts(sox_effect_t * effp, int argc, char **argv) { priv_t * echos = (priv_t *) effp->priv; int i; echos->num_delays = 0; --argc, ++argv; if ((argc < 4) || (argc % 2)) return lsx_usage(effp); i = 0; sscanf(argv[i++], "%f", &echos->in_gain); sscanf(argv[i++], "%f", &echos->out_gain); while (i < argc) { /* Linux bug and it's cleaner. */ sscanf(argv[i++], "%f", &echos->delay[echos->num_delays]); sscanf(argv[i++], "%f", &echos->decay[echos->num_delays]); echos->num_delays++; if ( echos->num_delays > MAX_ECHOS ) { lsx_fail("echos: to many delays, use less than %i delays", MAX_ECHOS); return (SOX_EOF); } } echos->sumsamples = 0; return (SOX_SUCCESS); } /* * Prepare for processing. */ static int sox_echos_start(sox_effect_t * effp) { priv_t * echos = (priv_t *) effp->priv; int i; float sum_in_volume; unsigned long j; if ( echos->in_gain < 0.0 ) { lsx_fail("echos: gain-in must be positive!"); return (SOX_EOF); } if ( echos->in_gain > 1.0 ) { lsx_fail("echos: gain-in must be less than 1.0!"); return (SOX_EOF); } if ( echos->out_gain < 0.0 ) { lsx_fail("echos: gain-in must be positive!"); return (SOX_EOF); } for ( i = 0; i < echos->num_delays; i++ ) { echos->samples[i] = echos->delay[i] * effp->in_signal.rate / 1000.0; if ( echos->samples[i] < 1 ) { lsx_fail("echos: delay must be positive!"); return (SOX_EOF); } if ( echos->samples[i] > (ptrdiff_t)DELAY_BUFSIZ ) { lsx_fail("echos: delay must be less than %g seconds!", DELAY_BUFSIZ / effp->in_signal.rate ); return (SOX_EOF); } if ( echos->decay[i] < 0.0 ) { lsx_fail("echos: decay must be positive!" ); return (SOX_EOF); } if ( echos->decay[i] > 1.0 ) { lsx_fail("echos: decay must be less than 1.0!" ); return (SOX_EOF); } echos->counter[i] = 0; echos->pointer[i] = echos->sumsamples; echos->sumsamples += echos->samples[i]; } echos->delay_buf = lsx_malloc(sizeof (double) * echos->sumsamples); for ( j = 0; j < echos->sumsamples; ++j ) echos->delay_buf[j] = 0.0; /* Be nice and check the hint with warning, if... */ sum_in_volume = 1.0; for ( i = 0; i < echos->num_delays; i++ ) sum_in_volume += echos->decay[i]; if ( sum_in_volume * echos->in_gain > 1.0 / echos->out_gain ) lsx_warn("echos: warning >>> gain-out can cause saturation of output <<<"); effp->out_signal.length = SOX_UNKNOWN_LEN; /* TODO: calculate actual length */ return (SOX_SUCCESS); } /* * Processed signed long samples from ibuf to obuf. * Return number of samples processed. */ static int sox_echos_flow(sox_effect_t * effp, const sox_sample_t *ibuf, sox_sample_t *obuf, size_t *isamp, size_t *osamp) { priv_t * echos = (priv_t *) effp->priv; int j; double d_in, d_out; sox_sample_t out; size_t len = min(*isamp, *osamp); *isamp = *osamp = len; while (len--) { /* Store delays as 24-bit signed longs */ d_in = (double) *ibuf++ / 256; /* Compute output first */ d_out = d_in * echos->in_gain; for ( j = 0; j < echos->num_delays; j++ ) { d_out += echos->delay_buf[echos->counter[j] + echos->pointer[j]] * echos->decay[j]; } /* Adjust the output volume and size to 24 bit */ d_out = d_out * echos->out_gain; out = SOX_24BIT_CLIP_COUNT((sox_sample_t) d_out, effp->clips); *obuf++ = out * 256; /* Mix decay of delays and input */ for ( j = 0; j < echos->num_delays; j++ ) { if ( j == 0 ) echos->delay_buf[echos->counter[j] + echos->pointer[j]] = d_in; else echos->delay_buf[echos->counter[j] + echos->pointer[j]] = echos->delay_buf[echos->counter[j-1] + echos->pointer[j-1]] + d_in; } /* Adjust the counters */ for ( j = 0; j < echos->num_delays; j++ ) echos->counter[j] = ( echos->counter[j] + 1 ) % echos->samples[j]; } /* processed all samples */ return (SOX_SUCCESS); } /* * Drain out reverb lines. */ static int sox_echos_drain(sox_effect_t * effp, sox_sample_t *obuf, size_t *osamp) { priv_t * echos = (priv_t *) effp->priv; double d_in, d_out; sox_sample_t out; int j; size_t done; done = 0; /* drain out delay samples */ while ( ( done < *osamp ) && ( done < echos->sumsamples ) ) { d_in = 0; d_out = 0; for ( j = 0; j < echos->num_delays; j++ ) { d_out += echos->delay_buf[echos->counter[j] + echos->pointer[j]] * echos->decay[j]; } /* Adjust the output volume and size to 24 bit */ d_out = d_out * echos->out_gain; out = SOX_24BIT_CLIP_COUNT((sox_sample_t) d_out, effp->clips); *obuf++ = out * 256; /* Mix decay of delays and input */ for ( j = 0; j < echos->num_delays; j++ ) { if ( j == 0 ) echos->delay_buf[echos->counter[j] + echos->pointer[j]] = d_in; else echos->delay_buf[echos->counter[j] + echos->pointer[j]] = echos->delay_buf[echos->counter[j-1] + echos->pointer[j-1]]; } /* Adjust the counters */ for ( j = 0; j < echos->num_delays; j++ ) echos->counter[j] = ( echos->counter[j] + 1 ) % echos->samples[j]; done++; echos->sumsamples--; }; /* samples played, it remains */ *osamp = done; if (echos->sumsamples == 0) return SOX_EOF; else return SOX_SUCCESS; } /* * Clean up echos effect. */ static int sox_echos_stop(sox_effect_t * effp) { priv_t * echos = (priv_t *) effp->priv; free(echos->delay_buf); echos->delay_buf = NULL; return (SOX_SUCCESS); } static sox_effect_handler_t sox_echos_effect = { "echos", "gain-in gain-out delay decay [ delay decay ... ]", SOX_EFF_LENGTH | SOX_EFF_GAIN, sox_echos_getopts, sox_echos_start, sox_echos_flow, sox_echos_drain, sox_echos_stop, NULL, sizeof(priv_t) }; const sox_effect_handler_t *lsx_echos_effect_fn(void) { return &sox_echos_effect; }