Add audio filter scaletempo

Patch by Robert Juliano, juliano.1 osu edu


git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@24924 b3059339-0415-0410-9bf9-f77b7e298cf2

4 files changed, 553 insertions, 0 deletions

diff --git a/libaf/Makefile b/libaf/Makefile
index a4a7b14ca5..e11643e270 100644
--- a/libaf/Makefile
+++ b/libaf/Makefile
@@ -16,6 +16,7 @@ SRCS_COMMON = af.c \
               af_karaoke.c \
               af_pan.c \
               af_resample.c \
+              af_scaletempo.c \
               af_sinesuppress.c \
               af_sub.c \
               af_surround.c \
diff --git a/libaf/af.c b/libaf/af.c
index b86bfe3d14..32c59dbbcd 100644
--- a/libaf/af.c
+++ b/libaf/af.c
@@ -31,6 +31,7 @@ extern af_info_t af_info_ladspa;
 extern af_info_t af_info_center;
 extern af_info_t af_info_sinesuppress;
 extern af_info_t af_info_karaoke;
+extern af_info_t af_info_scaletempo;
 
 static af_info_t* filter_list[]={ 
    &af_info_dummy,
@@ -61,6 +62,7 @@ static af_info_t* filter_list[]={
    &af_info_center,
    &af_info_sinesuppress,
    &af_info_karaoke,
+   &af_info_scaletempo,
    NULL 
 };
 
diff --git a/libaf/af_scaletempo.c b/libaf/af_scaletempo.c
new file mode 100644
index 0000000000..bc2cdba157
--- /dev/null
+++ b/libaf/af_scaletempo.c
@@ -0,0 +1,547 @@
+/*
+ * scaletempo audio filter
+ * Copyright (c) 2007 Robert Juliano
+ *
+ * This file is part of MPlayer.
+ *
+ * MPlayer is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * MPlayer 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with MPlayer; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * scale tempo while maintaining pitch
+ * (WSOLA technique with cross correlation)
+ * inspired by SoundTouch library by Olli Parviainen
+ *
+ * basic algorithm
+ *   - produce 'stride' output samples per loop
+ *   - consume stride*scale input samples per loop
+ *
+ * to produce smoother transitions between strides, blend next overlap
+ * samples from last stride with correlated samples of current input
+ *
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+
+#include "af.h"
+#include "libavutil/common.h"
+#include "subopt-helper.h"
+#include "help_mp.h"
+
+// Data for specific instances of this filter
+typedef struct af_scaletempo_s
+{
+  // stride
+  float   scale;
+  float   speed;
+  float   frames_stride_scaled;
+  float   frames_stride_error;
+  int     bytes_per_frame;
+  int     bytes_stride;
+  float   bytes_stride_scaled;
+  int     bytes_queue;
+  int     bytes_queued;
+  int     bytes_to_slide;
+  int8_t* buf_queue;
+  // overlap
+  int     samples_overlap;
+  int     samples_standing;
+  int     bytes_overlap;
+  int     bytes_standing;
+  int8_t* buf_overlap;
+  int8_t* table_blend;
+  void    (*output_overlap)(struct af_scaletempo_s* s, int8_t* out_buf, int bytes_off);
+  // best overlap
+  int     frames_search;
+  int     num_channels;
+  int8_t* buf_pre_corr;
+  int8_t* table_window;
+  int     (*best_overlap_offset)(struct af_scaletempo_s* s);
+  short   shift_corr;
+  // command line
+  float   scale_nominal;
+  float   ms_stride;
+  float   percent_overlap;
+  float   ms_search;
+  short   speed_tempo;
+  short   speed_pitch;
+} af_scaletempo_t;
+
+int fill_queue(struct af_instance_s* af, af_data_t* data, int offset) {
+  af_scaletempo_t* s = af->setup;
+  int bytes_in = data->len - offset;
+  int offset_unchanged = offset;
+
+  if (s->bytes_to_slide > 0) {
+    if (s->bytes_to_slide < s->bytes_queued) {
+      int bytes_move = s->bytes_queued - s->bytes_to_slide;
+      memmove(s->buf_queue,
+              s->buf_queue + s->bytes_to_slide,
+              bytes_move);
+      s->bytes_to_slide = 0;
+      s->bytes_queued = bytes_move;
+    } else {
+      int bytes_skip;
+      s->bytes_to_slide -= s->bytes_queued;
+      bytes_skip = FFMIN(s->bytes_to_slide, bytes_in);
+      s->bytes_queued = 0;
+      s->bytes_to_slide -= bytes_skip;
+      offset += bytes_skip;
+      bytes_in -= bytes_skip;
+    }
+  }
+
+  if (bytes_in > 0) {
+    int bytes_copy = FFMIN(s->bytes_queue - s->bytes_queued, bytes_in);
+    memcpy(s->buf_queue + s->bytes_queued,
+           (int8_t*)data->audio + offset,
+           bytes_copy);
+    s->bytes_queued += bytes_copy;
+    offset += bytes_copy;
+  }
+
+  return offset - offset_unchanged;
+}
+
+int _best_overlap_offset_float(af_scaletempo_t* s) {
+  float *pw, *po, *ppc, *search_start;
+  float best_corr = INT_MIN;
+  int best_off = 0;
+  int i, off;
+
+  pw  = (float*)s->table_window;
+  po  = (float*)s->buf_overlap + s->num_channels;
+  ppc = (float*)s->buf_pre_corr;
+  for (i=s->num_channels; i<s->samples_overlap; i++) {
+    *ppc++ = *pw++ * *po++;
+  }
+
+  search_start = (float*)s->buf_queue + s->num_channels;
+  for (off=0; off<s->frames_search; off++) {
+    float corr = 0;
+    float* ps = search_start;
+    ppc = (float*)s->buf_pre_corr;
+    for (i=s->num_channels; i<s->samples_overlap; i++) {
+      corr += *ppc++ * *ps++;
+    }
+    if (corr > best_corr) {
+      best_corr = corr;
+      best_off  = off;
+    }
+    search_start += s->num_channels;
+  }
+
+  return best_off * 4;
+}
+
+int _best_overlap_offset_s16(af_scaletempo_t* s) {
+  int32_t *pw, *ppc;
+  int16_t *po, *search_start;
+  int32_t best_corr = INT_MIN;
+  int best_off = 0;
+  int i, off;
+
+  pw  = (int32_t*)s->table_window;
+  po  = (int16_t*)s->buf_overlap + s->num_channels;
+  ppc = (int32_t*)s->buf_pre_corr;
+  for (i=s->num_channels; i<s->samples_overlap; i++) {
+    *ppc++ = ( *pw++ * *po++ ) >> 15;
+  }
+
+  search_start = (int16_t*)s->buf_queue + s->num_channels;
+  for (off=0; off<s->frames_search; off++) {
+    int32_t corr = 0;
+    int16_t* ps = search_start;
+    ppc = (int32_t*)s->buf_pre_corr;
+    for (i=s->num_channels; i<s->samples_overlap; i++) {
+      corr += ( *ppc++ * *ps++ ) >> s->shift_corr;
+    }
+    if (corr > best_corr) {
+      best_corr = corr;
+      best_off  = off;
+    }
+    search_start += s->num_channels;
+  }
+
+  return best_off * 2;
+}
+
+void _output_overlap_float(af_scaletempo_t* s, int8_t* buf_out, int bytes_off) {
+  float* pout = (float*)buf_out;
+  float* pb   = (float*)s->table_blend;
+  float* po   = (float*)s->buf_overlap;
+  float* pin  = (float*)(s->buf_queue + bytes_off);
+  int i;
+  for (i=0; i<s->samples_overlap; i++) {
+    *pout++ = *po - *pb++ * ( *po - *pin++ ); po++;
+  }
+}
+void _output_overlap_s16(af_scaletempo_t* s, int8_t* buf_out, int bytes_off) {
+  int16_t* pout = (int16_t*)buf_out;
+  int32_t* pb   = (int32_t*)s->table_blend;
+  int16_t* po   = (int16_t*)s->buf_overlap;
+  int16_t* pin  = (int16_t*)(s->buf_queue + bytes_off);
+  int i;
+  for (i=0; i<s->samples_overlap; i++) {
+    *pout++ = *po - ( ( *pb++ * ( *po - *pin++ ) ) >> 16 ); po++;
+  }
+}
+
+// Filter data through filter
+static af_data_t* play(struct af_instance_s* af, af_data_t* data)
+{
+  af_scaletempo_t* s = af->setup;
+  int offset_in;
+  int max_bytes_out;
+  int8_t* pout;
+
+  if (s->scale == 1.0) {
+    return data;
+  }
+
+  // RESIZE_LOCAL_BUFFER - can't use macro
+  max_bytes_out = ((int)(data->len / s->bytes_stride_scaled) + 1) * s->bytes_stride;
+  if (max_bytes_out > af->data->len) {
+    af_msg(AF_MSG_VERBOSE, "[libaf] Reallocating memory in module %s, "
+          "old len = %i, new len = %i\n",af->info->name,af->data->len,max_bytes_out);
+    af->data->audio = realloc(af->data->audio, max_bytes_out);
+    if (!af->data->audio) {
+      af_msg(AF_MSG_FATAL, "[libaf] Could not allocate memory\n");
+      return NULL;
+    }
+    af->data->len = max_bytes_out;
+  }
+
+  offset_in = fill_queue(af, data, 0);
+  pout = af->data->audio;
+  while (s->bytes_queued >= s->bytes_queue) {
+    int ti;
+    float tf;
+    int bytes_off = 0;
+
+    // output stride
+    if (s->output_overlap) {
+      if (s->best_overlap_offset)
+        bytes_off = s->best_overlap_offset(s);
+      s->output_overlap(s, pout, bytes_off);
+    }
+    memcpy(pout + s->bytes_overlap,
+           s->buf_queue + bytes_off + s->bytes_overlap,
+           s->bytes_standing);
+    pout += s->bytes_stride;
+
+    // input stride
+    memcpy(s->buf_overlap,
+           s->buf_queue + bytes_off + s->bytes_stride,
+           s->bytes_overlap);
+    tf = s->frames_stride_scaled + s->frames_stride_error;
+    ti = (int)tf;
+    s->frames_stride_error = tf - ti;
+    s->bytes_to_slide = ti * s->bytes_per_frame;
+
+    offset_in += fill_queue(af, data, offset_in);
+  }
+
+  data->audio = af->data->audio;
+  data->len   = (int)pout - (int)af->data->audio;
+  return data;
+}
+
+// Initialization and runtime control
+static int control(struct af_instance_s* af, int cmd, void* arg)
+{
+  af_scaletempo_t* s = af->setup;
+  switch(cmd){
+  case AF_CONTROL_REINIT:{
+    af_data_t* data = (af_data_t*)arg;
+    float srate = data->rate / 1000;
+    int nch = data->nch;
+    int bps;
+    int use_int = 0;
+    int frames_stride, frames_overlap;
+    int i, j;
+
+    af_msg(AF_MSG_VERBOSE,
+           "[scaletempo] %.3f speed * %.3f scale_nominal = %.3f\n",
+           s->speed, s->scale_nominal, s->scale);
+
+    if (s->scale == 1.0) {
+      if (s->speed_tempo && s->speed_pitch)
+        return AF_DETACH;
+      memcpy(af->data, data, sizeof(af_data_t));
+      return af_test_output(af, data);
+    }
+
+    af->data->rate = data->rate;
+    af->data->nch  = data->nch;
+    if ( data->format == AF_FORMAT_S16_LE
+         || data->format == AF_FORMAT_S16_BE ) {
+      use_int = 1;
+      af->data->format  = AF_FORMAT_S16_NE;
+      af->data->bps     = bps = 2;
+    } else {
+      af->data->format = AF_FORMAT_FLOAT_NE;
+      af->data->bps    = bps = 4;
+    }
+
+    frames_stride           = srate * s->ms_stride;
+    s->bytes_stride         = frames_stride * bps * nch;
+    s->bytes_stride_scaled  = s->scale * s->bytes_stride;
+    s->frames_stride_scaled = s->scale * frames_stride;
+    s->frames_stride_error  = 0;
+    af->mul = (double)s->bytes_stride / s->bytes_stride_scaled;
+
+    frames_overlap = frames_stride * s->percent_overlap;
+    if (frames_overlap <= 0) {
+      s->bytes_standing   = s->bytes_stride;
+      s->samples_standing = s->bytes_standing / bps;
+      s->output_overlap   = NULL;
+    } else {
+      s->samples_overlap  = frames_overlap * nch;
+      s->bytes_overlap    = frames_overlap * nch * bps;
+      s->bytes_standing   = s->bytes_stride - s->bytes_overlap;
+      s->samples_standing = s->bytes_standing / bps;
+      s->buf_overlap      = realloc(s->buf_overlap, s->bytes_overlap);
+      s->table_blend      = realloc(s->table_blend, s->bytes_overlap * 4);
+      if(!s->buf_overlap || !s->table_blend) {
+        af_msg(AF_MSG_FATAL, "[scaletempo] Out of memory\n");
+        return AF_ERROR;
+      }
+      bzero(s->buf_overlap, s->bytes_overlap);
+      if (use_int) {
+        int32_t* pb = (int32_t*)s->table_blend;
+        int64_t blend = 0;
+        for (i=0; i<frames_overlap; i++) {
+          int32_t v = blend / frames_overlap;
+          for (j=0; j<nch; j++) {
+            *pb++ = v;
+          }
+          blend += 65536;  // 2^16
+        }
+        s->output_overlap = _output_overlap_s16;
+      } else {
+        float* pb = (float*)s->table_blend;
+        for (i=0; i<frames_overlap; i++) {
+          float v = i / (float)frames_overlap;
+          for (j=0; j<nch; j++) {
+            *pb++ = v;
+          }
+        }
+        s->output_overlap = _output_overlap_float;
+      }
+    }
+
+    s->frames_search = (frames_overlap > 1) ? srate * s->ms_search : 0;
+    if (s->frames_search <= 0) {
+      s->best_overlap_offset = NULL;
+    } else {
+      if (use_int) {
+        int64_t t = frames_overlap;
+        int32_t n = 8589934588LL / (t * t);  // 4 * (2^31 - 1) / t^2
+        int32_t* pw;
+        s->buf_pre_corr = realloc(s->buf_pre_corr, s->bytes_overlap * 2);
+        s->table_window = realloc(s->table_window, s->bytes_overlap * 2 - nch * bps * 2);
+        if(!s->buf_pre_corr && !s->table_window) {
+          af_msg(AF_MSG_FATAL, "[scaletempo] Out of memory\n");
+          return AF_ERROR;
+        }
+        pw = (int32_t*)s->table_window;
+        for (i=1; i<frames_overlap; i++) {
+          int32_t v = ( i * (t - i) * n ) >> 15;
+          for (j=0; j<nch; j++) {
+            *pw++ = v;
+          }
+        }
+        s->shift_corr = av_log2( 2*(s->samples_overlap - nch) - 1 );
+        s->best_overlap_offset = _best_overlap_offset_s16;
+      } else {
+        float* pw;
+        s->buf_pre_corr = realloc(s->buf_pre_corr, s->bytes_overlap);
+        s->table_window = realloc(s->table_window, s->bytes_overlap - nch * bps);
+        if(!s->buf_pre_corr || !s->table_window) {
+          af_msg(AF_MSG_FATAL, "[scaletempo] Out of memory\n");
+          return AF_ERROR;
+        }
+        pw = (float*)s->table_window;
+        for (i=1; i<frames_overlap; i++) {
+          float v = i * (frames_overlap - i);
+          for (j=0; j<nch; j++) {
+            *pw++ = v;
+          }
+        }
+        s->best_overlap_offset = _best_overlap_offset_float;
+      }
+    }
+
+    s->bytes_per_frame = bps * nch;
+    s->num_channels    = nch;
+
+    s->bytes_queue
+      = (s->frames_search + frames_stride + frames_overlap) * bps * nch;
+    s->buf_queue = realloc(s->buf_queue, s->bytes_queue);
+    if(!s->buf_queue) {
+      af_msg(AF_MSG_FATAL, "[scaletempo] Out of memory\n");
+      return AF_ERROR;
+    }
+
+    af_msg (AF_MSG_DEBUG0, "[scaletempo] "
+            "%.2f stride_in, %i stride_out, %i standing, "
+            "%i overlap, %i search, %i queue, %s mode\n",
+            s->frames_stride_scaled,
+            (int)(s->bytes_stride / nch / bps),
+            (int)(s->bytes_standing / nch / bps),
+            (int)(s->bytes_overlap / nch / bps),
+            s->frames_search,
+            (int)(s->bytes_queue / nch / bps),
+            (use_int?"s16":"float"));
+
+    return af_test_output(af, (af_data_t*)arg);
+  }
+  case AF_CONTROL_PLAYBACK_SPEED | AF_CONTROL_SET:{
+    if (s->speed_tempo) {
+      if (s->speed_pitch) {
+        break;
+      }
+      s->speed = *(float*)arg;
+      s->scale = s->speed * s->scale_nominal;
+    } else {
+      if (s->speed_pitch) {
+        s->speed = 1 / *(float*)arg;
+        s->scale = s->speed * s->scale_nominal;
+        break;
+      }
+    }
+    return AF_OK;
+  }
+  case AF_CONTROL_SCALETEMPO_AMOUNT | AF_CONTROL_SET:{
+    s->scale = *(float*)arg;
+    s->scale = s->speed * s->scale_nominal;
+    return AF_OK;
+  }
+  case AF_CONTROL_SCALETEMPO_AMOUNT | AF_CONTROL_GET:
+    *(float*)arg = s->scale;
+    return AF_OK;
+  case AF_CONTROL_COMMAND_LINE:{
+    strarg_t speed;
+    opt_t subopts[] = {
+      {"scale",   OPT_ARG_FLOAT, &s->scale_nominal, NULL},
+      {"stride",  OPT_ARG_FLOAT, &s->ms_stride, NULL},
+      {"overlap", OPT_ARG_FLOAT, &s->percent_overlap, NULL},
+      {"search",  OPT_ARG_FLOAT, &s->ms_search, NULL},
+      {"speed",   OPT_ARG_STR,   &speed, NULL},
+      {NULL},
+    };
+    if (subopt_parse(arg, subopts) != 0) {
+      return AF_ERROR;
+    }
+    if (s->scale_nominal <= 0) {
+      af_msg(AF_MSG_ERROR, "[scaletempo] "
+             MSGTR_ErrorParsingCommandLine ": " MSGTR_AF_ValueOutOfRange
+             ": scale > 0\n");
+      return AF_ERROR;
+    }
+    if (s->ms_stride <= 0) {
+      af_msg(AF_MSG_ERROR, "[scaletempo] "
+             MSGTR_ErrorParsingCommandLine ": " MSGTR_AF_ValueOutOfRange
+             ": stride > 0\n");
+      return AF_ERROR;
+    }
+    if (s->percent_overlap < 0 || s->percent_overlap > 1) {
+      af_msg(AF_MSG_ERROR, "[scaletempo] "
+             MSGTR_ErrorParsingCommandLine ": " MSGTR_AF_ValueOutOfRange
+             ": 0 <= overlap <= 1\n");
+      return AF_ERROR;
+    }
+    if (s->ms_search < 0) {
+      af_msg(AF_MSG_ERROR, "[scaletempo] "
+             MSGTR_ErrorParsingCommandLine ": " MSGTR_AF_ValueOutOfRange
+             ": search >= 0\n");
+      return AF_ERROR;
+    }
+    if (speed.len > 0) {
+      if (strcmp(speed.str, "pitch") == 0) {
+        s->speed_tempo = 0;
+        s->speed_pitch = 1;
+      } else if (strcmp(speed.str, "tempo") == 0) {
+        s->speed_tempo = 1;
+        s->speed_pitch = 0;
+      } else if (strcmp(speed.str, "none") == 0) {
+        s->speed_tempo = 0;
+        s->speed_pitch = 0;
+      } else if (strcmp(speed.str, "both") == 0) {
+        s->speed_tempo = 1;
+        s->speed_pitch = 1;
+      } else {
+        af_msg(AF_MSG_ERROR, "[scaletempo] "
+               MSGTR_ErrorParsingCommandLine ": " MSGTR_AF_ValueOutOfRange
+               ": speed=[pitch|tempo|none|both]\n");
+        return AF_ERROR;
+      }
+    }
+    s->scale = s->speed * s->scale_nominal;
+    af_msg(AF_MSG_DEBUG0, "[scaletempo] %6.3f scale, %6.2f stride, %6.2f overlap, %6.2f search, speed = %s\n", s->scale_nominal, s->ms_stride, s->percent_overlap, s->ms_search, (s->speed_tempo?(s->speed_pitch?"tempo and speed":"tempo"):(s->speed_pitch?"pitch":"none")));
+    return AF_OK;
+  }
+  }
+  return AF_UNKNOWN;
+}
+
+// Deallocate memory
+static void uninit(struct af_instance_s* af)
+{
+  af_scaletempo_t* s = af->setup;
+  free(af->data->audio);
+  free(af->data);
+  free(s->buf_queue);
+  free(s->buf_overlap);
+  free(s->buf_pre_corr);
+  free(s->table_blend);
+  free(s->table_window);
+  free(af->setup);
+}
+
+// Allocate memory and set function pointers
+static int af_open(af_instance_t* af){
+  af_scaletempo_t* s;
+
+  af->control   = control;
+  af->uninit    = uninit;
+  af->play      = play;
+  af->mul       = 1;
+  af->data      = calloc(1,sizeof(af_data_t));
+  af->setup     = calloc(1,sizeof(af_scaletempo_t));
+  if(af->data == NULL || af->setup == NULL)
+    return AF_ERROR;
+
+  s = af->setup;
+  s->scale = s->speed = s->scale_nominal = 1.0;
+  s->speed_tempo = 1;
+  s->speed_pitch = 0;
+  s->ms_stride = 60;
+  s->percent_overlap = .20;
+  s->ms_search = 14;
+
+  return AF_OK;
+}
+
+// Description of this filter
+af_info_t af_info_scaletempo = {
+  "Scale audio tempo while maintaining pitch",
+  "scaletempo",
+  "Robert Juliano",
+  "",
+  AF_FLAGS_REENTRANT,
+  af_open
+};
diff --git a/libaf/control.h b/libaf/control.h
index 80eff7c584..7c6a8dd371 100644
--- a/libaf/control.h
+++ b/libaf/control.h
@@ -231,4 +231,7 @@ typedef struct af_control_ext_s{
 #define AF_CONTROL_SS_FREQ		0x00002300 | AF_CONTROL_FILTER_SPECIFIC
 #define AF_CONTROL_SS_DECAY		0x00002400 | AF_CONTROL_FILTER_SPECIFIC
 
+#define AF_CONTROL_PLAYBACK_SPEED	0x00002500 | AF_CONTROL_FILTER_SPECIFIC
+#define AF_CONTROL_SCALETEMPO_AMOUNT	0x00002600 | AF_CONTROL_FILTER_SPECIFIC
+
 #endif /*__af_control_h */