src/splice.c

   1 /* libSoX effect: splice audio   Copyright (c) 2008-9 robs@users.sourceforge.net
   2  *
   3  * This library is free software; you can redistribute it and/or modify it
   4  * under the terms of the GNU Lesser General Public License as published by
   5  * the Free Software Foundation; either version 2.1 of the License, or (at
   6  * your option) any later version.
   7  *
   8  * This library is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU Lesser General Public License
  14  * along with this library; if not, write to the Free Software Foundation,
  15  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  16  */
  17
  18 #include "sox_i.h"
  19
  20 static double difference(
  21     const sox_sample_t * a, const sox_sample_t * b, size_t length)
  22 {
  23   double diff = 0;
  24   size_t i = 0;
  25
  26   #define _ diff += sqr((double)a[i] - b[i]), ++i; /* Loop optimisation */
  27   do {_ _ _ _ _ _ _ _} while (i < length); /* N.B. length ≡ 0 (mod 8) */
  28   #undef _
  29   return diff;
  30 }
  31
  32 /* Find where the two segments are most alike over the overlap period. */
  33 static size_t best_overlap_position(sox_sample_t const * f1,
  34     sox_sample_t const * f2, uint64_t overlap, uint64_t search, size_t channels)
  35 {
  36   size_t i, best_pos = 0;
  37   double diff, least_diff = difference(f2, f1, (size_t) (channels * overlap));
  38
  39   for (i = 1; i < search; ++i) { /* linear search */
  40     diff = difference(f2 + channels * i, f1, (size_t) (channels * overlap));
  41     if (diff < least_diff)
  42       least_diff = diff, best_pos = i;
  43   }
  44   return best_pos;
  45 }
  46
  47
  48 typedef struct {
  49   enum {Cosine_2, Cosine_4, Triangular} fade_type;
  50   unsigned nsplices;     /* Number of splices requested */
  51   struct {
  52     char * str;          /* Command-line argument to parse for this splice */
  53     uint64_t overlap;    /* Number of samples to overlap */
  54     uint64_t search;     /* Number of samples to search */
  55     uint64_t start;      /* Start splicing when in_pos equals this */
  56   } * splices;
  57
  58   uint64_t in_pos;       /* Number of samples read from the input stream */
  59   unsigned splices_pos;  /* Number of splices completed so far */
  60   size_t buffer_pos;     /* Number of samples through the current splice */
  61   size_t max_buffer_size;
  62   sox_sample_t * buffer;
  63   unsigned state;
  64 } priv_t;
  65
  66 static void splice(sox_effect_t * effp, const sox_sample_t * in1, const
  67     sox_sample_t * in2, sox_sample_t * output, uint64_t overlap, size_t channels)
  68 {
  69   priv_t * p = (priv_t *)effp->priv;
  70   size_t i, j, k = 0;
  71
  72   if (p->fade_type == Cosine_4) {
  73     double fade_step = M_PI_2 / overlap;
  74     for (i = 0; i < overlap; ++i) {
  75       double fade_in  = sin(i * fade_step);
  76       double fade_out = cos(i * fade_step); /* constant RMS level (`power') */
  77       for (j = 0; j < channels; ++j, ++k) {
  78         double d = in1[k] * fade_out + in2[k] * fade_in;
  79         output[k] = SOX_ROUND_CLIP_COUNT(d, effp->clips); /* Might clip */
  80       }
  81     }
  82   }
  83   else if (p->fade_type == Cosine_2) {
  84     double fade_step = M_PI / overlap;
  85     for (i = 0; i < overlap; ++i) {
  86       double fade_in  = .5 - .5 * cos(i * fade_step);
  87       double fade_out = 1 - fade_in;    /* constant peak level (`gain') */
  88       for (j = 0; j < channels; ++j, ++k) {
  89         double d = in1[k] * fade_out + in2[k] * fade_in;
  90         output[k] = SOX_ROUND_CLIP_COUNT(d, effp->clips); /* Should not clip */
  91       }
  92     }
  93   }
  94   else /* Triangular */ {
  95     double fade_step = 1. / overlap;
  96     for (i = 0; i < overlap; ++i) {
  97       double fade_in  = fade_step * i;
  98       double fade_out = 1 - fade_in;    /* constant peak level (`gain') */
  99       for (j = 0; j < channels; ++j, ++k) {
 100         double d = in1[k] * fade_out + in2[k] * fade_in;
 101         output[k] = SOX_ROUND_CLIP_COUNT(d, effp->clips); /* Should not clip */
 102       }
 103     }
 104   }
 105 }
 106
 107 static uint64_t do_splice(sox_effect_t * effp,
 108     sox_sample_t * f, uint64_t overlap, uint64_t search, size_t channels)
 109 {
 110   uint64_t offset = search? best_overlap_position(
 111       f, f + overlap * channels, overlap, search, channels) : 0;
 112   splice(effp, f, f + (overlap + offset) * channels,
 113       f + (overlap + offset) * channels, overlap, channels);
 114   return overlap + offset;
 115 }
 116
 117 static int parse(sox_effect_t * effp, char * * argv, sox_rate_t rate)
 118 {
 119   priv_t * p = (priv_t *)effp->priv;
 120   char const * next;
 121   size_t i, buffer_size;
 122
 123   p->max_buffer_size = 0;
 124   for (i = 0; i < p->nsplices; ++i) {
 125     if (argv) /* 1st parse only */
 126       p->splices[i].str = lsx_strdup(argv[i]);
 127
 128     p->splices[i].overlap = rate * 0.01 + .5;
 129     p->splices[i].search = p->fade_type == Cosine_4? 0 : p->splices[i].overlap;
 130
 131     next = lsx_parsesamples(rate, p->splices[i].str, &p->splices[i].start, 't');
 132     if (next == NULL) break;
 133
 134     if (*next == ',') {
 135       next = lsx_parsesamples(rate, next + 1, &p->splices[i].overlap, 't');
 136       if (next == NULL) break;
 137       p->splices[i].overlap *= 2;
 138       if (*next == ',') {
 139         next = lsx_parsesamples(rate, next + 1, &p->splices[i].search, 't');
 140         if (next == NULL) break;
 141         p->splices[i].search *= 2;
 142       }
 143     }
 144     if (*next != '\0') break;
 145     p->splices[i].overlap = max(p->splices[i].overlap + 4, 16);
 146     p->splices[i].overlap &= ~7; /* Make divisible by 8 for loop optimisation */
 147
 148     if (i > 0 && p->splices[i].start <= p->splices[i-1].start) break;
 149     if (p->splices[i].start < p->splices[i].overlap) break;
 150     p->splices[i].start -= p->splices[i].overlap;
 151     buffer_size = 2 * p->splices[i].overlap + p->splices[i].search;
 152     p->max_buffer_size = max(p->max_buffer_size, buffer_size);
 153   }
 154   if (i < p->nsplices)
 155     return lsx_usage(effp);
 156   return SOX_SUCCESS;
 157 }
 158
 159 static int create(sox_effect_t * effp, int argc, char * * argv)
 160 {
 161   priv_t * p = (priv_t *)effp->priv;
 162   --argc, ++argv;
 163   if (argc) {
 164     if      (!strcmp(*argv, "-t")) p->fade_type = Triangular, --argc, ++argv;
 165     else if (!strcmp(*argv, "-q")) p->fade_type = Cosine_4  , --argc, ++argv;
 166     else if (!strcmp(*argv, "-h")) p->fade_type = Cosine_2  , --argc, ++argv;
 167   }
 168   p->nsplices = argc;
 169   p->splices = lsx_calloc(p->nsplices, sizeof(*p->splices));
 170   return parse(effp, argv, 1e5); /* No rate yet; parse with dummy */
 171 }
 172
 173 static int start(sox_effect_t * effp)
 174 {
 175   priv_t * p = (priv_t *)effp->priv;
 176   unsigned i;
 177
 178   parse(effp, 0, effp->in_signal.rate); /* Re-parse now rate is known */
 179   p->buffer = lsx_calloc(p->max_buffer_size * effp->in_signal.channels, sizeof(*p->buffer));
 180   p->in_pos = p->buffer_pos = p->splices_pos = 0;
 181   p->state = p->splices_pos != p->nsplices && p->in_pos == p->splices[p->splices_pos].start;
 182   effp->out_signal.length = SOX_UNKNOWN_LEN; /* depends on input data */
 183   for (i = 0; i < p->nsplices; ++i)
 184     if (p->splices[i].overlap) {
 185       if (p->fade_type == Cosine_4 && effp->in_signal.mult)
 186         *effp->in_signal.mult *= pow(.5, .5);
 187       return SOX_SUCCESS;
 188     }
 189   return SOX_EFF_NULL;
 190 }
 191
 192 static int flow(sox_effect_t * effp, const sox_sample_t * ibuf,
 193     sox_sample_t * obuf, size_t * isamp, size_t * osamp)
 194 {
 195   priv_t * p = (priv_t *)effp->priv;
 196   size_t c, idone = 0, odone = 0;
 197   *isamp /= effp->in_signal.channels;
 198   *osamp /= effp->in_signal.channels;
 199
 200   while (sox_true) {
 201 copying:
 202     if (p->state == 0) {
 203       for (; idone < *isamp && odone < *osamp; ++idone, ++odone, ++p->in_pos) {
 204         if (p->splices_pos != p->nsplices && p->in_pos == p->splices[p->splices_pos].start) {
 205           p->state = 1;
 206           goto buffering;
 207         }
 208         for (c = 0; c < effp->in_signal.channels; ++c)
 209           *obuf++ = *ibuf++;
 210       }
 211       break;
 212     }
 213
 214 buffering:
 215     if (p->state == 1) {
 216       size_t buffer_size = (2 * p->splices[p->splices_pos].overlap + p->splices[p->splices_pos].search) * effp->in_signal.channels;
 217       for (; idone < *isamp; ++idone, ++p->in_pos) {
 218         if (p->buffer_pos == buffer_size) {
 219           p->buffer_pos = do_splice(effp, p->buffer,
 220               p->splices[p->splices_pos].overlap,
 221               p->splices[p->splices_pos].search,
 222               (size_t)effp->in_signal.channels) * effp->in_signal.channels;
 223           p->state = 2;
 224           goto flushing;
 225           break;
 226         }
 227         for (c = 0; c < effp->in_signal.channels; ++c)
 228           p->buffer[p->buffer_pos++] = *ibuf++;
 229       }
 230       break;
 231     }
 232
 233 flushing:
 234     if (p->state == 2) {
 235       size_t buffer_size = (2 * p->splices[p->splices_pos].overlap + p->splices[p->splices_pos].search) * effp->in_signal.channels;
 236       for (; odone < *osamp; ++odone) {
 237         if (p->buffer_pos == buffer_size) {
 238           p->buffer_pos = 0;
 239           ++p->splices_pos;
 240           p->state = p->splices_pos != p->nsplices && p->in_pos == p->splices[p->splices_pos].start;
 241           goto copying;
 242         }
 243         for (c = 0; c < effp->in_signal.channels; ++c)
 244           *obuf++ = p->buffer[p->buffer_pos++];
 245       }
 246       break;
 247     }
 248   }
 249
 250   *isamp = idone * effp->in_signal.channels;
 251   *osamp = odone * effp->in_signal.channels;
 252   return SOX_SUCCESS;
 253 }
 254
 255 static int drain(sox_effect_t * effp, sox_sample_t * obuf, size_t * osamp)
 256 {
 257   size_t isamp = 0;
 258   return flow(effp, 0, obuf, &isamp, osamp);
 259 }
 260
 261 static int stop(sox_effect_t * effp)
 262 {
 263   priv_t * p = (priv_t *)effp->priv;
 264   if (p->splices_pos != p->nsplices)
 265     lsx_warn("Input audio too short; splices not made: %u", p->nsplices - p->splices_pos);
 266   free(p->buffer);
 267   return SOX_SUCCESS;
 268 }
 269
 270 static int lsx_kill(sox_effect_t * effp)
 271 {
 272   priv_t * p = (priv_t *)effp->priv;
 273   unsigned i;
 274   for (i = 0; i < p->nsplices; ++i)
 275     free(p->splices[i].str);
 276   free(p->splices);
 277   return SOX_SUCCESS;
 278 }
 279
 280 sox_effect_handler_t const * lsx_splice_effect_fn(void)
 281 {
 282   static sox_effect_handler_t handler = {
 283     "splice", "[-h|-t|-q] {position[,excess[,leeway]]}"
 284     "\n  -h        Half sine fade (default); constant gain (for correlated audio)"
 285     "\n  -t        Triangular (linear) fade; constant gain (for correlated audio)"
 286     "\n  -q        Quarter sine fade; constant power (for correlated audio e.g. x-fade)"
 287     "\n  position  The length of part 1 (including the excess)"
 288     "\n  excess    At the end of part 1 & the start of part2 (default 0.005)"
 289     "\n  leeway    Before part2 (default 0.005; set to 0 for cross-fade)",
 290     SOX_EFF_MCHAN | SOX_EFF_LENGTH,
 291     create, start, flow, drain, stop, lsx_kill, sizeof(priv_t)
 292   };
 293   return &handler;
 294 }