/* 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 )
 *
*/

/*
 * libSoX chorus effect file.
 */

#include "sox_i.h"

#include <stdlib.h> /* Harmless, and prototypes atof() etc. --dgc */
#include <string.h>

#define MOD_SINE        0
#define MOD_TRIANGLE    1
#define MAX_CHORUS      7

typedef struct {
        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;
        unsigned int fade_out;
} priv_t;

/*
 * Process options
 */
static int sox_chorus_getopts(sox_effect_t * effp, int argc, char **argv)
{
        priv_t * chorus = (priv_t *) effp->priv;
        int i;
  --argc, ++argv;

        chorus->num_chorus = 0;
        i = 0;

        if ( ( argc < 7 ) || (( argc - 2 ) % 5 ) )
          return lsx_usage(effp);

        sscanf(argv[i++], "%f", &chorus->in_gain);
        sscanf(argv[i++], "%f", &chorus->out_gain);
        while ( i < argc ) {
                if ( chorus->num_chorus > MAX_CHORUS )
                {
                        lsx_fail("chorus: to many delays, use less than %i delays", MAX_CHORUS);
                        return (SOX_EOF);
                }
                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
                  return lsx_usage(effp);
                i++;
                chorus->num_chorus++;
        }
        return (SOX_SUCCESS);
}

/*
 * Prepare for processing.
 */
static int sox_chorus_start(sox_effect_t * effp)
{
        priv_t * chorus = (priv_t *) effp->priv;
        int i;
        float sum_in_volume;

        chorus->maxsamples = 0;

        if ( chorus->in_gain < 0.0 )
        {
                lsx_fail("chorus: gain-in must be positive!");
                return (SOX_EOF);
        }
        if ( chorus->in_gain > 1.0 )
        {
                lsx_fail("chorus: gain-in must be less than 1.0!");
                return (SOX_EOF);
        }
        if ( chorus->out_gain < 0.0 )
        {
                lsx_fail("chorus: gain-out must be positive!");
                return (SOX_EOF);
        }
        for ( i = 0; i < chorus->num_chorus; i++ ) {
                chorus->samples[i] = (int) ( ( chorus->delay[i] +
                        chorus->depth[i] ) * effp->in_signal.rate / 1000.0);
                chorus->depth_samples[i] = (int) (chorus->depth[i] *
                        effp->in_signal.rate / 1000.0);

                if ( chorus->delay[i] < 20.0 )
                {
                        lsx_fail("chorus: delay must be more than 20.0 msec!");
                        return (SOX_EOF);
                }
                if ( chorus->delay[i] > 100.0 )
                {
                        lsx_fail("chorus: delay must be less than 100.0 msec!");
                        return (SOX_EOF);
                }
                if ( chorus->speed[i] < 0.1 )
                {
                        lsx_fail("chorus: speed must be more than 0.1 Hz!");
                        return (SOX_EOF);
                }
                if ( chorus->speed[i] > 5.0 )
                {
                        lsx_fail("chorus: speed must be less than 5.0 Hz!");
                        return (SOX_EOF);
                }
                if ( chorus->depth[i] < 0.0 )
                {
                        lsx_fail("chorus: delay must be more positive!");
                        return (SOX_EOF);
                }
                if ( chorus->depth[i] > 10.0 )
                {
                    lsx_fail("chorus: delay must be less than 10.0 msec!");
                    return (SOX_EOF);
                }
                if ( chorus->decay[i] < 0.0 )
                {
                        lsx_fail("chorus: decay must be positive!" );
                        return (SOX_EOF);
                }
                if ( chorus->decay[i] > 1.0 )
                {
                        lsx_fail("chorus: decay must be less that 1.0!" );
                        return (SOX_EOF);
                }
                chorus->length[i] = effp->in_signal.rate / chorus->speed[i];
                chorus->lookup_tab[i] = lsx_malloc(sizeof (int) * chorus->length[i]);

                if (chorus->modulation[i] == MOD_SINE)
                  lsx_generate_wave_table(SOX_WAVE_SINE, SOX_INT, chorus->lookup_tab[i],
                                         (size_t)chorus->length[i], 0., (double)chorus->depth_samples[i], 0.);
                else
                  lsx_generate_wave_table(SOX_WAVE_TRIANGLE, SOX_INT, chorus->lookup_tab[i],
                                         (size_t)chorus->length[i],
                                         (double)(chorus->samples[i] - 1 - 2 * chorus->depth_samples[i]),
                                         (double)(chorus->samples[i] - 1), 3 * M_PI_2);
                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 )
        lsx_warn("chorus: warning >>> gain-out can cause saturation or clipping of output <<<");


        chorus->chorusbuf = lsx_malloc(sizeof (float) * chorus->maxsamples);
        for ( i = 0; i < chorus->maxsamples; i++ )
                chorus->chorusbuf[i] = 0.0;

        chorus->counter = 0;
        chorus->fade_out = chorus->maxsamples;

  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_chorus_flow(sox_effect_t * effp, const sox_sample_t *ibuf, sox_sample_t *obuf,
                   size_t *isamp, size_t *osamp)
{
        priv_t * chorus = (priv_t *) effp->priv;
        int i;
        float 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 = (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 = SOX_24BIT_CLIP_COUNT((sox_sample_t) d_out, effp->clips);
                *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 */
        return (SOX_SUCCESS);
}

/*
 * Drain out reverb lines.
 */
static int sox_chorus_drain(sox_effect_t * effp, sox_sample_t *obuf, size_t *osamp)
{
        priv_t * chorus = (priv_t *) effp->priv;
        size_t done;
        int i;

        float d_in, d_out;
        sox_sample_t 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 = SOX_24BIT_CLIP_COUNT((sox_sample_t) d_out, effp->clips);
                *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;
        if (chorus->fade_out == 0)
            return SOX_EOF;
        else
            return SOX_SUCCESS;
}

/*
 * Clean up chorus effect.
 */
static int sox_chorus_stop(sox_effect_t * effp)
{
        priv_t * chorus = (priv_t *) effp->priv;
        int i;

        free(chorus->chorusbuf);
        chorus->chorusbuf = NULL;
        for ( i = 0; i < chorus->num_chorus; i++ ) {
                free(chorus->lookup_tab[i]);
                chorus->lookup_tab[i] = NULL;
        }
        return (SOX_SUCCESS);
}

static sox_effect_handler_t sox_chorus_effect = {
  "chorus",
  "gain-in gain-out delay decay speed depth [ -s | -t ]",
  SOX_EFF_LENGTH | SOX_EFF_GAIN,
  sox_chorus_getopts,
  sox_chorus_start,
  sox_chorus_flow,
  sox_chorus_drain,
  sox_chorus_stop,
  NULL, sizeof(priv_t)
};

const sox_effect_handler_t *lsx_chorus_effect_fn(void)
{
    return &sox_chorus_effect;
}