/* 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 <stdlib.h> /* 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;}