src/stretch.c

   1 /* libSoX Basic time stretcher.
   2  * (c) march/april 2000 Fabien COELHO <fabien@coelho.net> for sox.
   3  *
   4  * cross fade samples so as to go slower or faster.
   5  *
   6  * The filter is based on 6 parameters:
   7  * - stretch factor f
   8  * - window size w
   9  * - input step i
  10  *   output step o=f*i
  11  * - steady state of window s, ss = s*w
  12  *
  13  * I decided of the default values of these parameters based
  14  * on some small non extensive tests. maybe better defaults
  15  * can be suggested.
  16  */
  17 #include "sox_i.h"
  18
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <assert.h>
  22
  23 #define DEFAULT_SLOW_SHIFT_RATIO        0.8
  24 #define DEFAULT_FAST_SHIFT_RATIO        1.0
  25
  26 #define DEFAULT_STRETCH_WINDOW          20.0  /* ms */
  27
  28 typedef enum { input_state, output_state } stretch_status_t;
  29
  30 typedef struct {
  31   /* options
  32    * FIXME: maybe shift could be allowed > 1.0 with factor < 1.0 ???
  33    */
  34   double factor;   /* strech factor. 1.0 means copy. */
  35   double window;   /* window in ms */
  36   double shift;    /* shift ratio wrt window. <1.0 */
  37   double fading;   /* fading ratio wrt window. <0.5 */
  38
  39   /* internal stuff */
  40   stretch_status_t state; /* automaton status */
  41
  42   size_t segment;         /* buffer size */
  43   size_t index;        /* next available element */
  44   sox_sample_t *ibuf;      /* input buffer */
  45   size_t ishift;       /* input shift */
  46
  47   size_t oindex;       /* next evailable element */
  48   double * obuf;   /* output buffer */
  49   size_t oshift;       /* output shift */
  50
  51   size_t overlap;        /* fading size */
  52   double * fade_coefs;   /* fading, 1.0 -> 0.0 */
  53
  54 } priv_t;
  55
  56 /*
  57  * Process options
  58  */
  59 static int getopts(sox_effect_t * effp, int argc, char **argv)
  60 {
  61   priv_t * p = (priv_t *) effp->priv;
  62   --argc, ++argv;
  63
  64   /* default options */
  65   p->factor = 1.0; /* default is no change */
  66   p->window = DEFAULT_STRETCH_WINDOW;
  67
  68   if (argc > 0 && !sscanf(argv[0], "%lf", &p->factor)) {
  69     lsx_fail("error while parsing factor");
  70     return lsx_usage(effp);
  71   }
  72
  73   if (argc > 1 && !sscanf(argv[1], "%lf", &p->window)) {
  74     lsx_fail("error while parsing window size");
  75     return lsx_usage(effp);
  76   }
  77
  78   if (argc > 2) {
  79     switch (argv[2][0]) {
  80     case 'l':
  81     case 'L':
  82       break;
  83     default:
  84       lsx_fail("error while parsing fade type");
  85       return lsx_usage(effp);
  86     }
  87   }
  88
  89   /* default shift depends whether we go slower or faster */
  90   p->shift = (p->factor <= 1.0) ?
  91     DEFAULT_FAST_SHIFT_RATIO: DEFAULT_SLOW_SHIFT_RATIO;
  92
  93   if (argc > 3 && !sscanf(argv[3], "%lf", &p->shift)) {
  94     lsx_fail("error while parsing shift ratio");
  95     return lsx_usage(effp);
  96   }
  97
  98   if (p->shift > 1.0 || p->shift <= 0.0) {
  99     lsx_fail("error with shift ratio value");
 100     return lsx_usage(effp);
 101   }
 102
 103   /* default fading stuff...
 104      it makes sense for factor >= 0.5 */
 105   if (p->factor < 1.0)
 106     p->fading = 1.0 - (p->factor * p->shift);
 107   else
 108     p->fading = 1.0 - p->shift;
 109   if (p->fading > 0.5)
 110     p->fading = 0.5;
 111
 112   if (argc > 4 && !sscanf(argv[4], "%lf", &p->fading)) {
 113     lsx_fail("error while parsing fading ratio");
 114     return lsx_usage(effp);
 115   }
 116
 117   if (p->fading > 0.5 || p->fading < 0.0) {
 118     lsx_fail("error with fading ratio value");
 119     return lsx_usage(effp);
 120   }
 121
 122   return SOX_SUCCESS;
 123 }
 124
 125 /*
 126  * Start processing
 127  */
 128 static int start(sox_effect_t * effp)
 129 {
 130   priv_t * p = (priv_t *)effp->priv;
 131   size_t i;
 132
 133   if (p->factor == 1)
 134     return SOX_EFF_NULL;
 135
 136   p->state = input_state;
 137
 138   p->segment = (int)(effp->out_signal.rate * 0.001 * p->window);
 139   /* start in the middle of an input to avoid initial fading... */
 140   p->index = p->segment / 2;
 141   p->ibuf = lsx_malloc(p->segment * sizeof(sox_sample_t));
 142
 143   /* the shift ratio deal with the longest of ishift/oshift
 144      hence ishift<=segment and oshift<=segment. */
 145   if (p->factor < 1.0) {
 146     p->ishift = p->shift * p->segment;
 147     p->oshift = p->factor * p->ishift;
 148   } else {
 149     p->oshift = p->shift * p->segment;
 150     p->ishift = p->oshift / p->factor;
 151   }
 152   assert(p->ishift <= p->segment);
 153   assert(p->oshift <= p->segment);
 154
 155   p->oindex = p->index; /* start as synchronized */
 156   p->obuf = lsx_malloc(p->segment * sizeof(double));
 157   p->overlap = (int)(p->fading * p->segment);
 158   p->fade_coefs = lsx_malloc(p->overlap * sizeof(double));
 159
 160   /* initialize buffers */
 161   for (i = 0; i<p->segment; i++)
 162     p->ibuf[i] = 0;
 163
 164   for (i = 0; i<p->segment; i++)
 165     p->obuf[i] = 0.0;
 166
 167   if (p->overlap>1) {
 168     double slope = 1.0 / (p->overlap - 1);
 169     p->fade_coefs[0] = 1.0;
 170     for (i = 1; i < p->overlap - 1; i++)
 171       p->fade_coefs[i] = slope * (p->overlap - i - 1);
 172     p->fade_coefs[p->overlap - 1] = 0.0;
 173   } else if (p->overlap == 1)
 174     p->fade_coefs[0] = 1.0;
 175
 176   lsx_debug("start: (factor=%g segment=%g shift=%g overlap=%g)\nstate=%d\n"
 177       "segment=%lu\nindex=%lu\nishift=%lu\noindex=%lu\noshift=%lu\noverlap=%lu",
 178       p->factor, p->window, p->shift, p->fading, p->state,
 179       (unsigned long)p->segment, (unsigned long)p->index,
 180       (unsigned long)p->ishift, (unsigned long)p->oindex,
 181       (unsigned long)p->oshift, (unsigned long)p->overlap);
 182
 183   return SOX_SUCCESS;
 184 }
 185
 186 /* accumulates input ibuf to output obuf with fading fade_coefs */
 187 static void combine(priv_t * p)
 188 {
 189   size_t i;
 190
 191   /* fade in */
 192   for (i = 0; i < p->overlap; i++)
 193     p->obuf[i] += p->fade_coefs[p->overlap - 1 - i] * p->ibuf[i];
 194
 195   /* steady state */
 196   for (; i < p->segment - p->overlap; i++)
 197     p->obuf[i] += p->ibuf[i];
 198
 199   /* fade out */
 200   for (; i<p->segment; i++)
 201     p->obuf[i] += p->fade_coefs[i - p->segment + p->overlap] * p->ibuf[i];
 202 }
 203
 204 /*
 205  * Processes flow.
 206  */
 207 static int flow(sox_effect_t * effp, const sox_sample_t *ibuf, sox_sample_t *obuf,
 208                     size_t *isamp, size_t *osamp)
 209 {
 210   priv_t * p = (priv_t *) effp->priv;
 211   size_t iindex = 0, oindex = 0;
 212   size_t i;
 213
 214   while (iindex<*isamp && oindex<*osamp) {
 215     if (p->state == input_state) {
 216       size_t tocopy = min(*isamp-iindex,
 217                              p->segment-p->index);
 218
 219       memcpy(p->ibuf + p->index, ibuf + iindex, tocopy * sizeof(sox_sample_t));
 220
 221       iindex += tocopy;
 222       p->index += tocopy;
 223
 224       if (p->index == p->segment) {
 225         /* compute */
 226         combine(p);
 227
 228         /* shift input */
 229         for (i = 0; i + p->ishift < p->segment; i++)
 230           p->ibuf[i] = p->ibuf[i+p->ishift];
 231
 232         p->index -= p->ishift;
 233
 234         /* switch to output state */
 235         p->state = output_state;
 236       }
 237     }
 238
 239     if (p->state == output_state) {
 240       while (p->oindex < p->oshift && oindex < *osamp) {
 241         float f;
 242         f = p->obuf[p->oindex++];
 243         SOX_SAMPLE_CLIP_COUNT(f, effp->clips);
 244         obuf[oindex++] = f;
 245       }
 246
 247       if (p->oindex >= p->oshift && oindex<*osamp) {
 248         p->oindex -= p->oshift;
 249
 250         /* shift internal output buffer */
 251         for (i = 0; i + p->oshift < p->segment; i++)
 252           p->obuf[i] = p->obuf[i + p->oshift];
 253
 254         /* pad with 0 */
 255         for (; i < p->segment; i++)
 256           p->obuf[i] = 0.0;
 257
 258         p->state = input_state;
 259       }
 260     }
 261   }
 262
 263   *isamp = iindex;
 264   *osamp = oindex;
 265
 266   return SOX_SUCCESS;
 267 }
 268
 269
 270 /*
 271  * Drain buffer at the end
 272  * maybe not correct ? end might be artificially faded?
 273  */
 274 static int drain(sox_effect_t * effp, sox_sample_t *obuf, size_t *osamp)
 275 {
 276   priv_t * p = (priv_t *) effp->priv;
 277   size_t i;
 278   size_t oindex = 0;
 279
 280   if (p->state == input_state) {
 281     for (i=p->index; i<p->segment; i++)
 282       p->ibuf[i] = 0;
 283
 284     combine(p);
 285
 286     p->state = output_state;
 287   }
 288
 289   while (oindex<*osamp && p->oindex<p->index) {
 290     float f = p->obuf[p->oindex++];
 291     SOX_SAMPLE_CLIP_COUNT(f, effp->clips);
 292     obuf[oindex++] = f;
 293   }
 294
 295   *osamp = oindex;
 296
 297   if (p->oindex == p->index)
 298     return SOX_EOF;
 299   else
 300     return SOX_SUCCESS;
 301 }
 302
 303
 304 static int stop(sox_effect_t * effp)
 305 {
 306   priv_t * p = (priv_t *) effp->priv;
 307
 308   free(p->ibuf);
 309   free(p->obuf);
 310   free(p->fade_coefs);
 311   return SOX_SUCCESS;
 312 }
 313
 314 const sox_effect_handler_t *lsx_stretch_effect_fn(void)
 315 {
 316   static const sox_effect_handler_t handler = {
 317     "stretch",
 318     "factor [window fade shift fading]\n"
 319     "       (expansion, frame in ms, lin/..., unit<1.0, unit<0.5)\n"
 320     "       (defaults: 1.0 20 lin ...)",
 321     SOX_EFF_LENGTH,
 322     getopts, start, flow, drain, stop, NULL, sizeof(priv_t)
 323   };
 324   return &handler;
 325 }