shithub: sox

ref: 2515cb2de68b10eff93b876159dcbf180474f146
dir: /src/rabbit.c/

View raw version
/*
 * libsamplerate (aka Secret Rabbit Code) support for sox
 * (c) Reuben Thomas <rrt@sc3d.org> 2006
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library. If not, write to the Free Software
 * Foundation, Fifth Floor, 51 Franklin Street, Boston, MA 02111-1301,
 * USA.  */

#include "st_i.h"

#ifdef HAVE_SAMPLERATE

#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <samplerate.h>

static st_effect_t st_rabbit_effect;

/* Private data for resampling */
typedef struct {
  int converter_type;           /* SRC converter type */
  SRC_STATE *state;             /* SRC state struct */
  SRC_DATA *data;               /* SRC_DATA control struct */
  st_size_t samples;            /* Number of samples read so far */
  st_size_t outsamp;            /* Next output sample */
} *rabbit_t;

/*
 * Process options
 */
static int st_rabbit_getopts(eff_t effp, int n, char **argv)
{
  rabbit_t r = (rabbit_t) effp->priv;

  r->converter_type = SRC_SINC_BEST_QUALITY;

  if (n >= 1) {
    if (!strcmp(argv[0], "-c0")) {
      r->converter_type = SRC_SINC_BEST_QUALITY;
      n--; argv++;
    } else if (!strcmp(argv[0], "-c1")) {
      r->converter_type = SRC_SINC_MEDIUM_QUALITY;
      n--; argv++;
    } else if (!strcmp(argv[0], "-c2")) {
      r->converter_type = SRC_SINC_FASTEST;
      n--; argv++;
    } else if (!strcmp(argv[0], "-c3")) {
      r->converter_type = SRC_ZERO_ORDER_HOLD;
      n--; argv++;
    } else if (!strcmp(argv[0], "-c4")) {
      r->converter_type = SRC_LINEAR;
      n--; argv++;
    }
  }

  if (n >= 1) {
    st_fail(st_rabbit_effect.usage);
    return (ST_EOF);
  }

  return (ST_SUCCESS);
}

/*
 * Prepare processing.
 */
static int st_rabbit_start(eff_t effp)
{
  rabbit_t r = (rabbit_t) effp->priv;

  if (effp->ininfo.rate == effp->outinfo.rate) {
    st_fail("Input and Output rates must be different to use rabbit effect");
    return (ST_EOF);
  }
  if (effp->ininfo.channels != effp->outinfo.channels) {
    st_fail("number of Input and Output channels must be equal to use rabbit effect");
    return (ST_EOF);
  }

  if ((r->data = (SRC_DATA *)calloc(1, sizeof(SRC_DATA))) == NULL) {
    st_fail("could not allocate SRC_DATA buffer");
    return (ST_EOF);
  }
  r->data->src_ratio = (double)effp->outinfo.rate / effp->ininfo.rate;
  r->data->input_frames_used = 0;
  r->data->output_frames_gen = 0;

  return (ST_SUCCESS);
}

/*
 * Read all the data.
 */
static int st_rabbit_flow(eff_t effp, const st_sample_t *ibuf, st_sample_t *obuf UNUSED,
                   st_size_t *isamp, st_size_t *osamp)
{
  rabbit_t r = (rabbit_t) effp->priv;
  int channels = effp->ininfo.channels;
  st_size_t i, newsamples;

  newsamples = r->samples + *isamp;
  if (newsamples / channels > INT_MAX) {
      st_fail("input data size %d too large for libsamplerate", newsamples);
      return (ST_EOF);
  }

  if ((r->data->data_in = (float *)realloc(r->data->data_in, newsamples * sizeof(float))) == NULL) {
    st_fail("unable to allocate input buffer of size %d", newsamples);
    return (ST_EOF);
  }

  for (i = 0 ; i < *isamp; i++)
    r->data->data_in[r->samples + i] = ST_SAMPLE_TO_FLOAT_DWORD(ibuf[i], effp->clippedCount);

  r->samples = newsamples;
  r->data->input_frames = r->samples / channels;
  r->outsamp = 0;

  *osamp = 0;           /* Signal that we didn't produce any output */

  return (ST_SUCCESS);
}

/*
 * Process samples and write output.
 */
static int st_rabbit_drain(eff_t effp, st_sample_t *obuf, st_size_t *osamp)
{
  rabbit_t r = (rabbit_t) effp->priv;
  int channels = effp->ininfo.channels;
  st_size_t i, outsamps;

  /* On first call, process the data */
  if (r->data->data_out == NULL) {
    /* Guess maximum number of possible output frames */
    st_size_t outframes = r->data->input_frames * (r->data->src_ratio + 0.01) + 8;
    int error;

    if (outframes > INT_MAX) {
      st_fail("too many output frames (%d) for libsamplerate", outframes);
      return (ST_EOF);
    }
    r->data->output_frames = outframes;
    r->data->data_out = (float *)malloc(r->data->output_frames * channels * sizeof(float));
    if (r->data->data_out == NULL) {
      st_fail("unable to allocate output frames buffer of size %d", r->data->output_frames);
      return (ST_EOF);
    }

    /* Process the data */
    if ((error = src_simple(r->data, r->converter_type, channels))) {
      st_fail("libsamplerate processing failed: %s", src_strerror(error));
      return (ST_EOF);
    }
  }

  /* Return the data one bufferful at a time */
  if (*osamp > INT_MAX) {
    st_fail("output buffer size %d too large for libsamplerate", *osamp);
    return (ST_EOF);
  }

  outsamps = min(r->data->output_frames_gen * channels - r->outsamp, *osamp);
  for (i = 0; i < outsamps; i++)
    obuf[i] = ST_FLOAT_DWORD_TO_SAMPLE(r->data->data_out[r->outsamp + i], effp->clippedCount);
  *osamp = (st_size_t)outsamps;
  r->outsamp += outsamps;

  return (ST_SUCCESS);
}

/*
 * Do anything required when you stop reading samples.
 * Don't close input file!
 */
static int st_rabbit_stop(eff_t effp)
{
  rabbit_t r = (rabbit_t) effp->priv;

  free(r->data);
  src_delete(r->state);
  return (ST_SUCCESS);
}

static st_effect_t st_rabbit_effect = {
  "rabbit",
  "Usage: rabbit [ -c0 | -c1 | -c2 | -c3 | -c4 ]",
  ST_EFF_RATE | ST_EFF_MCHAN,
  st_rabbit_getopts,
  st_rabbit_start,
  st_rabbit_flow,
  st_rabbit_drain,
  st_rabbit_stop
};

const st_effect_t *st_rabbit_effect_fn(void)
{
  return &st_rabbit_effect;
}

#endif /* HAVE_SAMPLERATE */