git/src/compand.c

/* libSoX compander effect
 *
 * Written by Nick Bailey (nick@bailey-family.org.uk or
 *                         n.bailey@elec.gla.ac.uk)
 *
 * Copyright 1999 Chris Bagwell And Nick Bailey
 * This source code is freely redistributable and may be used for
 * any purpose.  This copyright notice must be maintained.
 * Chris Bagwell And Nick Bailey are not responsible for
 * the consequences of using this software.
 */

#include "sox_i.h"

#include <string.h>
#include <stdlib.h>
#include "compandt.h"

/*
 * Compressor/expander effect for libSoX.
 *
 * Flow diagram for one channel:
 *
 *               ------------      ---------------
 *              |            |    |               |     ---
 * ibuff ---+---| integrator |--->| transfer func |--->|   |
 *          |   |            |    |               |    |   |
 *          |    ------------      ---------------     |   |  * gain
 *          |                                          | * |----------->obuff
 *          |       -------                            |   |
 *          |      |       |                           |   |
 *          +----->| delay |-------------------------->|   |
 *                 |       |                            ---
 *                  -------
 */
#define compand_usage \
  "attack1,decay1{,attack2,decay2} [soft-knee-dB:]in-dB1[,out-dB1]{,in-dB2,out-dB2} [gain [initial-volume-dB [delay]]]\n" \
  "\twhere {} means optional and repeatable and [] means optional.\n" \
  "\tdB values are floating point or -inf'; times are in seconds."
/*
 * Note: clipping can occur if the transfer function pushes things too
 * close to 0 dB.  In that case, use a negative gain, or reduce the
 * output level of the transfer function.
 */

typedef struct {
  sox_compandt_t transfer_fn;

  struct {
    double attack_times[2]; /* 0:attack_time, 1:decay_time */
    double volume;          /* Current "volume" of each channel */
  } * channels;
  unsigned expectedChannels;/* Also flags that channels aren't to be treated
                               individually when = 1 and input not mono */
  double delay;             /* Delay to apply before companding */
  sox_sample_t *delay_buf;   /* Old samples, used for delay processing */
  ptrdiff_t delay_buf_size;/* Size of delay_buf in samples */
  ptrdiff_t delay_buf_index; /* Index into delay_buf */
  ptrdiff_t delay_buf_cnt; /* No. of active entries in delay_buf */
  int delay_buf_full;       /* Shows buffer situation (important for drain) */

  char *arg0;  /* copies of arguments, so that they may be modified */
  char *arg1;
  char *arg2;
} priv_t;

static int getopts(sox_effect_t * effp, int argc, char * * argv)
{
  priv_t * l = (priv_t *) effp->priv;
  char * s;
  char dummy;     /* To check for extraneous chars. */
  unsigned pairs, i, j, commas;

  --argc, ++argv;
  if (argc < 2 || argc > 5)
    return lsx_usage(effp);

  l->arg0 = lsx_strdup(argv[0]);
  l->arg1 = lsx_strdup(argv[1]);
  l->arg2 = argc > 2 ? lsx_strdup(argv[2]) : NULL;

  /* Start by checking the attack and decay rates */
  for (s = l->arg0, commas = 0; *s; ++s) if (*s == ',') ++commas;
  if ((commas % 2) == 0) {
    lsx_fail("there must be an even number of attack/decay parameters");
    return SOX_EOF;
  }
  pairs = 1 + commas/2;
  l->channels = lsx_calloc(pairs, sizeof(*l->channels));
  l->expectedChannels = pairs;

  /* Now tokenise the rates string and set up these arrays.  Keep
     them in seconds at the moment: we don't know the sample rate yet. */
  for (i = 0, s = strtok(l->arg0, ","); s != NULL; ++i) {
    for (j = 0; j < 2; ++j) {
      if (sscanf(s, "%lf %c", &l->channels[i].attack_times[j], &dummy) != 1) {
        lsx_fail("syntax error trying to read attack/decay time");
        return SOX_EOF;
      } else if (l->channels[i].attack_times[j] < 0) {
        lsx_fail("attack & decay times can't be less than 0 seconds");
        return SOX_EOF;
      }
      s = strtok(NULL, ",");
    }
  }

  if (!lsx_compandt_parse(&l->transfer_fn, l->arg1, l->arg2))
    return SOX_EOF;

  /* Set the initial "volume" to be attibuted to the input channels.
     Unless specified, choose 0dB otherwise clipping will
     result if the user has seleced a long attack time */
  for (i = 0; i < l->expectedChannels; ++i) {
    double init_vol_dB = 0;
    if (argc > 3 && sscanf(argv[3], "%lf %c", &init_vol_dB, &dummy) != 1) {
      lsx_fail("syntax error trying to read initial volume");
      return SOX_EOF;
    } else if (init_vol_dB > 0) {
      lsx_fail("initial volume is relative to maximum volume so can't exceed 0dB");
      return SOX_EOF;
    }
    l->channels[i].volume = pow(10., init_vol_dB / 20);
  }

  /* If there is a delay, store it. */
  if (argc > 4 && sscanf(argv[4], "%lf %c", &l->delay, &dummy) != 1) {
    lsx_fail("syntax error trying to read delay value");
    return SOX_EOF;
  } else if (l->delay < 0) {
    lsx_fail("delay can't be less than 0 seconds");
    return SOX_EOF;
  }

  return SOX_SUCCESS;
}

static int start(sox_effect_t * effp)
{
  priv_t * l = (priv_t *) effp->priv;
  unsigned i, j;

  lsx_debug("%i input channel(s) expected: actually %i",
      l->expectedChannels, effp->out_signal.channels);
  for (i = 0; i < l->expectedChannels; ++i)
    lsx_debug("Channel %i: attack = %g decay = %g", i,
        l->channels[i].attack_times[0], l->channels[i].attack_times[1]);
  if (!lsx_compandt_show(&l->transfer_fn, effp->global_info->plot))
    return SOX_EOF;

  /* Convert attack and decay rates using number of samples */
  for (i = 0; i < l->expectedChannels; ++i)
    for (j = 0; j < 2; ++j)
      if (l->channels[i].attack_times[j] > 1.0/effp->out_signal.rate)
        l->channels[i].attack_times[j] = 1.0 -
          exp(-1.0/(effp->out_signal.rate * l->channels[i].attack_times[j]));
      else
        l->channels[i].attack_times[j] = 1.0;

  /* Allocate the delay buffer */
  l->delay_buf_size = l->delay * effp->out_signal.rate * effp->out_signal.channels;
  if (l->delay_buf_size > 0)
    l->delay_buf = lsx_calloc((size_t)l->delay_buf_size, sizeof(*l->delay_buf));
  l->delay_buf_index = 0;
  l->delay_buf_cnt = 0;
  l->delay_buf_full= 0;

  return SOX_SUCCESS;
}

/*
 * Update a volume value using the given sample
 * value, the attack rate and decay rate
 */
static void doVolume(double *v, double samp, priv_t * l, int chan)
{
  double s = -samp / SOX_SAMPLE_MIN;
  double delta = s - *v;

  if (delta > 0.0) /* increase volume according to attack rate */
    *v += delta * l->channels[chan].attack_times[0];
  else             /* reduce volume according to decay rate */
    *v += delta * l->channels[chan].attack_times[1];
}

static int flow(sox_effect_t * effp, const sox_sample_t *ibuf, sox_sample_t *obuf,
                    size_t *isamp, size_t *osamp)
{
  priv_t * l = (priv_t *) effp->priv;
  int len =  (*isamp > *osamp) ? *osamp : *isamp;
  int filechans = effp->out_signal.channels;
  int idone,odone;

  for (idone = 0,odone = 0; idone < len; ibuf += filechans) {
    int chan;

    /* Maintain the volume fields by simulating a leaky pump circuit */
    for (chan = 0; chan < filechans; ++chan) {
      if (l->expectedChannels == 1 && filechans > 1) {
        /* User is expecting same compander for all channels */
        int i;
        double maxsamp = 0.0;
        for (i = 0; i < filechans; ++i) {
          double rect = fabs((double)ibuf[i]);
          if (rect > maxsamp) maxsamp = rect;
        }
        doVolume(&l->channels[0].volume, maxsamp, l, 0);
        break;
      } else
        doVolume(&l->channels[chan].volume, fabs((double)ibuf[chan]), l, chan);
    }

    /* Volume memory is updated: perform compand */
    for (chan = 0; chan < filechans; ++chan) {
      int ch = l->expectedChannels > 1 ? chan : 0;
      double level_in_lin = l->channels[ch].volume;
      double level_out_lin = lsx_compandt(&l->transfer_fn, level_in_lin);
      double checkbuf;

      if (l->delay_buf_size <= 0) {
        checkbuf = ibuf[chan] * level_out_lin;
        SOX_SAMPLE_CLIP_COUNT(checkbuf, effp->clips);
        obuf[odone++] = checkbuf;
        idone++;
      } else {
        if (l->delay_buf_cnt >= l->delay_buf_size) {
          l->delay_buf_full=1; /* delay buffer is now definitely full */
          checkbuf = l->delay_buf[l->delay_buf_index] * level_out_lin;
          SOX_SAMPLE_CLIP_COUNT(checkbuf, effp->clips);
          obuf[odone] = checkbuf;
          odone++;
          idone++;
        } else {
          l->delay_buf_cnt++;
          idone++; /* no "odone++" because we did not fill obuf[...] */
        }
        l->delay_buf[l->delay_buf_index++] = ibuf[chan];
        l->delay_buf_index %= l->delay_buf_size;
      }
    }
  }

  *isamp = idone; *osamp = odone;
  return (SOX_SUCCESS);
}

static int drain(sox_effect_t * effp, sox_sample_t *obuf, size_t *osamp)
{
  priv_t * l = (priv_t *) effp->priv;
  size_t chan, done = 0;

  if (l->delay_buf_full == 0)
    l->delay_buf_index = 0;
  while (done+effp->out_signal.channels <= *osamp && l->delay_buf_cnt > 0)
    for (chan = 0; chan < effp->out_signal.channels; ++chan) {
      int c = l->expectedChannels > 1 ? chan : 0;
      double level_in_lin = l->channels[c].volume;
      double level_out_lin = lsx_compandt(&l->transfer_fn, level_in_lin);
      obuf[done++] = l->delay_buf[l->delay_buf_index++] * level_out_lin;
      l->delay_buf_index %= l->delay_buf_size;
      l->delay_buf_cnt--;
    }
  *osamp = done;
  return l->delay_buf_cnt > 0 ? SOX_SUCCESS : SOX_EOF;
}

static int stop(sox_effect_t * effp)
{
  priv_t * l = (priv_t *) effp->priv;

  free(l->delay_buf);
  return SOX_SUCCESS;
}

static int lsx_kill(sox_effect_t * effp)
{
  priv_t * l = (priv_t *) effp->priv;

  lsx_compandt_kill(&l->transfer_fn);
  free(l->channels);
  free(l->arg0);
  free(l->arg1);
  free(l->arg2);
  return SOX_SUCCESS;
}

sox_effect_handler_t const * lsx_compand_effect_fn(void)
{
  static sox_effect_handler_t handler = {
    "compand", compand_usage, SOX_EFF_MCHAN | SOX_EFF_GAIN,
    getopts, start, flow, drain, stop, lsx_kill, sizeof(priv_t)
  };
  return &handler;
}