ref: 95609fe504c606a09b660d2d1e27d4de2dd50f0c
dir: /src/stretch.c/
/* * (c) march/april 2000 Fabien COELHO <fabien@coelho.net> for sox. * * Basic time stretcher. * cross fade samples so as to go slower of faster. * * The automaton is based on 6 parameters: * - stretch factor f * - window size w * - input step i * output step o=f*i * - steady state of window s, ss = s*w * - type of cross fading * * I decided of the default values of these parameters based * on some small non extensive tests. maybe better defaults * can be suggested. * * It cannot handle different number of channels. * It cannot handle rate change. */ #include "st_i.h" #include <stdlib.h> /* malloc and free */ #include <string.h> /* memcpy() */ #ifndef MIN #define MIN(s1,s2) ((s1)<(s2)?(s1):(s2)) #endif #ifndef STRETCH_FLOAT #define STRETCH_FLOAT float #define STRETCH_FLOAT_SCAN "%f" #endif #define STRETCH_USAGE \ "Usage: stretch factor [window fade shift fading]\n" \ "\t(expansion, frame in ms, lin/..., unit<1.0, unit<0.5)\n" \ "\t(defaults: 1.0 20 lin ...)" /* ok, it looks stupid to have such constant. this is because of the cast, if floats are switched to doubles. */ #define ZERO ((STRETCH_FLOAT)(0.0e0)) #define HALF ((STRETCH_FLOAT)(0.5e0)) #define ONE ((STRETCH_FLOAT)(1.0e0)) #define MONE ((STRETCH_FLOAT)(-1.0e0)) #define ONETHOUSANDS ((STRETCH_FLOAT)(0.001e0)) #define DEFAULT_SLOW_SHIFT_RATIO ((STRETCH_FLOAT)(0.8e0)) #define DEFAULT_FAST_SHIFT_RATIO ONE #define DEFAULT_STRETCH_WINDOW ((STRETCH_FLOAT)(20.0e0)) /* ms */ /* I'm planing to put some common fading stuff outside. It's also used in pitch.c */ typedef enum { st_linear_fading } st_fading_t; #define DEFAULT_FADING st_linear_fading typedef enum { input_state, output_state } stretch_status_t; typedef struct { /* options * Q: maybe shift could be allowed > 1.0 with factor < 1.0 ??? */ STRETCH_FLOAT factor; /* strech factor. 1.0 means copy. */ STRETCH_FLOAT window; /* window in ms */ st_fading_t fade; /* type of fading */ STRETCH_FLOAT shift; /* shift ratio wrt window. <1.0 */ STRETCH_FLOAT fading; /* fading ratio wrt window. <0.5 */ /* internal stuff */ stretch_status_t state; /* automaton status */ int clipped; /* number of clipped values. */ int size; /* buffer size */ int index; /* next available element */ st_sample_t *ibuf; /* input buffer */ int ishift; /* input shift */ int oindex; /* next evailable element */ STRETCH_FLOAT * obuf; /* output buffer */ int oshift; /* output shift */ int fsize; /* fading size */ STRETCH_FLOAT * fbuf; /* fading, 1.0 -> 0.0 */ } * stretch_t; /* static void debug(stretch_t s, char * where) { fprintf(stderr, "%s: (f=%.2f w=%.2f r=%.2f f=%.2f)" " st=%d s=%d ii=%d is=%d oi=%d os=%d fs=%d\n", where, s->factor, s->window, s->shift, s->fading, s->state, s->size, s->index, s->ishift, s->oindex, s->oshift, s->fsize); } */ /* clip amplitudes and count number of clipped values. */ static st_sample_t clip(stretch_t stretch, STRETCH_FLOAT v) { if (v < ST_SAMPLE_MIN) { stretch->clipped++; return ST_SAMPLE_MIN; } else if (v > ST_SAMPLE_MAX) { stretch->clipped++; return ST_SAMPLE_MAX; } else { return (st_sample_t) v; } } /* * Process options */ int st_stretch_getopts(eff_t effp, int n, char **argv) { stretch_t stretch = (stretch_t) effp->priv; /* default options */ stretch->factor = ONE; /* default is no change */ stretch->window = DEFAULT_STRETCH_WINDOW; stretch->fade = st_linear_fading; if (n>0 && !sscanf(argv[0], STRETCH_FLOAT_SCAN, &stretch->factor)) { st_fail(STRETCH_USAGE "\n\terror while parsing factor"); return ST_EOF; } if (n>1 && !sscanf(argv[1], STRETCH_FLOAT_SCAN, &stretch->window)) { st_fail(STRETCH_USAGE "\n\terror while parsing window size"); return ST_EOF; } if (n>2) { switch (argv[2][0]) { case 'l': case 'L': stretch->fade = st_linear_fading; break; default: st_fail(STRETCH_USAGE "\n\terror while parsing fade type"); return ST_EOF; } } /* default shift depends whether we go slower or faster */ stretch->shift = (stretch->factor <= ONE) ? DEFAULT_FAST_SHIFT_RATIO: DEFAULT_SLOW_SHIFT_RATIO; if (n>3 && !sscanf(argv[3], STRETCH_FLOAT_SCAN, &stretch->shift)) { st_fail(STRETCH_USAGE "\n\terror while parsing shift ratio"); return ST_EOF; } if (stretch->shift > ONE || stretch->shift <= ZERO) { st_fail(STRETCH_USAGE "\n\terror with shift ratio value"); return ST_EOF; } /* default fading stuff... it makes sense for factor >= 0.5 */ if (stretch->factor<ONE) stretch->fading = ONE - (stretch->factor*stretch->shift); else stretch->fading = ONE - stretch->shift; if (stretch->fading > HALF) stretch->fading = HALF; if (n>4 && !sscanf(argv[4], STRETCH_FLOAT_SCAN, &stretch->fading)) { st_fail(STRETCH_USAGE "\n\terror while parsing fading ratio"); return ST_EOF; } if (stretch->fading > HALF || stretch->fading < ZERO) { st_fail(STRETCH_USAGE "\n\terror with fading ratio value"); return ST_EOF; } return ST_SUCCESS; } /* * Start processing */ int st_stretch_start(eff_t effp) { stretch_t stretch = (stretch_t) effp->priv; register int i; /* not necessary. taken care by effect processing? */ if (effp->outinfo.channels != effp->ininfo.channels) { st_fail("STRETCH cannot handle different channels (in=%d, out=%d)" " use avg or pan", effp->ininfo.channels, effp->outinfo.channels); return ST_EOF; } if (effp->outinfo.rate != effp->ininfo.rate) { st_fail("STRETCH cannot handle different rates (in=%ld, out=%ld)" " use resample or rate", effp->ininfo.rate, effp->outinfo.rate); return ST_EOF; } stretch->state = input_state; stretch->clipped = 0; stretch->size = (int)(effp->outinfo.rate * ONETHOUSANDS * stretch->window); /* start in the middle of an input to avoid initial fading... */ stretch->index = stretch->size/2; stretch->ibuf = (st_sample_t *) malloc(stretch->size * sizeof(st_sample_t)); /* the shift ratio deal with the longest of ishift/oshift hence ishift<=size and oshift<=size. should be asserted. */ if (stretch->factor < ONE) { stretch->ishift = (int) (stretch->shift * stretch->size); stretch->oshift = (int) (stretch->factor * stretch->ishift); } else { stretch->oshift = (int) (stretch->shift * stretch->size); stretch->ishift = (int) (stretch->oshift / stretch->factor); } stretch->oindex = stretch->index; /* start as synchronized */ stretch->obuf = (STRETCH_FLOAT *) malloc(stretch->size * sizeof(STRETCH_FLOAT)); stretch->fsize = (int) (stretch->fading * stretch->size); stretch->fbuf = (STRETCH_FLOAT *) malloc(stretch->fsize * sizeof(STRETCH_FLOAT)); if (!stretch->ibuf || !stretch->obuf || !stretch->fbuf) { st_fail("some malloc failed"); return ST_EOF; } /* initialize buffers */ for (i=0; i<stretch->size; i++) stretch->ibuf[i] = 0; for (i=0; i<stretch->size; i++) stretch->obuf[i] = ZERO; if (stretch->fsize>1) { register STRETCH_FLOAT slope = ONE / (stretch->fsize - 1); stretch->fbuf[0] = ONE; for (i=1; i<stretch->fsize-1; i++) stretch->fbuf[i] = slope * (stretch->fsize-i-1); stretch->fbuf[stretch->fsize-1] = ZERO; } else if (stretch->fsize==1) stretch->fbuf[0] = ONE; /* debug(stretch, "start"); */ return ST_SUCCESS; } /* accumulates input ibuf to output obuf with fading fbuf */ static void combine(stretch_t stretch) { register int i, size, fsize; size = stretch->size; fsize = stretch->fsize; /* fade in */ for (i=0; i<fsize; i++) stretch->obuf[i] += stretch->fbuf[fsize-i-1]*stretch->ibuf[i]; /* steady state */ for (; i<size-fsize; i++) stretch->obuf[i] += stretch->ibuf[i]; /* fade out */ for (; i<size; i++) stretch->obuf[i] += stretch->fbuf[i-size+fsize]*stretch->ibuf[i]; } /* * Processes flow. */ int st_stretch_flow(eff_t effp, st_sample_t *ibuf, st_sample_t *obuf, st_size_t *isamp, st_size_t *osamp) { stretch_t stretch = (stretch_t) effp->priv; st_size_t iindex, oindex; int i; iindex = 0; oindex = 0; while (iindex<*isamp && oindex<*osamp) { if (stretch->state == input_state) { st_size_t tocopy = MIN(*isamp-iindex, stretch->size-stretch->index); memcpy(stretch->ibuf+stretch->index, ibuf+iindex, tocopy*sizeof(st_sample_t)); iindex += tocopy; stretch->index += tocopy; if (stretch->index == stretch->size) { /* compute */ combine(stretch); /* shift input */ for (i=0; i+stretch->ishift<stretch->size; i++) stretch->ibuf[i] = stretch->ibuf[i+stretch->ishift]; stretch->index -= stretch->ishift; /* switch to output state */ stretch->state = output_state; } } if (stretch->state == output_state) { while (stretch->oindex<stretch->oshift && oindex<*osamp) obuf[oindex++] = clip(stretch, stretch->obuf[stretch->oindex++]); if (stretch->oindex >= stretch->oshift && oindex<*osamp) { stretch->oindex -= stretch->oshift; /* shift internal output buffer */ for (i=0; i+stretch->oshift<stretch->size; i++) stretch->obuf[i] = stretch->obuf[i+stretch->oshift]; /* pad with 0 */ for (; i<stretch->size; i++) stretch->obuf[i] = ZERO; stretch->state = input_state; } } } *isamp = iindex; *osamp = oindex; return ST_SUCCESS; } /* * Drain buffer at the end * maybe not correct ? end might be artificially faded? */ int st_stretch_drain(eff_t effp, st_sample_t *obuf, st_size_t *osamp) { stretch_t stretch = (stretch_t) effp->priv; register int i; st_size_t oindex; oindex = 0; if (stretch->state == input_state) { for (i=stretch->index; i<stretch->size; i++) stretch->ibuf[i] = 0; combine(stretch); stretch->state = output_state; } if (stretch->state == output_state) { for (; oindex<*osamp && stretch->oindex<stretch->index;) obuf[oindex++] = clip(stretch, stretch->obuf[stretch->oindex++]); } *osamp = oindex; return ST_SUCCESS; } /* * Do anything required when you stop reading samples. * Don't close input file! */ int st_stretch_stop(eff_t effp) { stretch_t stretch = (stretch_t) effp->priv; free(stretch->ibuf); free(stretch->obuf); free(stretch->fbuf); if (stretch->clipped) st_warn("STRETCH clipped %d values...", stretch->clipped); return ST_SUCCESS; }