Changeset 267

Timestamp:

08/18/08 14:43:44 (4 years ago)

Author:

ath

Message:

Update the built-in copy of RubberBand? to 1.2 and fix the server accordingly.

Location:

trunk

Files:

• fm_server/configure (modified) (4 diffs)
• fm_server/configure.ac (modified) (1 diff)
• fm_server/src/fm_effect_rubber/Makefile.am (modified) (1 diff)
• fm_server/src/fm_effect_rubber/Makefile.in (modified) (7 diffs)
• fm_server/src/fm_effect_rubber/fm_effect_rubber.c (modified) (10 diffs)
• fm_server/src/fm_effect_rubber/fm_effect_rubber.h (modified) (2 diffs)
• fm_server/src/fm_effect_rubber/fm_rubber_wrapper.cpp (deleted)
• fm_server/src/fm_effect_rubber/fm_rubber_wrapper.h (deleted)
• fm_server/src/fm_input_cdj.c (modified) (1 diff)
• rubberband/ChangeLog (modified) (1 diff)
• rubberband/README (modified) (3 diffs)
• rubberband/configure (modified) (1 diff)
• rubberband/configure.ac (modified) (1 diff)
• rubberband/include/Makefile.am (modified) (1 diff)
• rubberband/include/Makefile.in (modified) (1 diff)
• rubberband/include/RubberBandStretcher.h (modified) (29 diffs)
• rubberband/include/TimeStretcher.h (deleted)
• rubberband/include/rubberband-c.h (added)
• rubberband/misc/Makefile.osx (deleted)
• rubberband/rubberband.pc.in (modified) (1 diff)
• rubberband/src/AudioCurve.cpp (modified) (3 diffs)
• rubberband/src/AudioCurve.h (modified) (3 diffs)
• rubberband/src/ConstantAudioCurve.cpp (modified) (2 diffs)
• rubberband/src/ConstantAudioCurve.h (modified) (2 diffs)
• rubberband/src/FFT.cpp (modified) (43 diffs)
• rubberband/src/FFT.h (modified) (3 diffs)
• rubberband/src/HighFrequencyAudioCurve.cpp (modified) (2 diffs)
• rubberband/src/HighFrequencyAudioCurve.h (modified) (2 diffs)
• rubberband/src/Makefile.am (modified) (2 diffs)
• rubberband/src/Makefile.in (modified) (4 diffs)
• rubberband/src/PercussiveAudioCurve.cpp (modified) (5 diffs)
• rubberband/src/PercussiveAudioCurve.h (modified) (2 diffs)
• rubberband/src/Profiler.cpp (added)
• rubberband/src/Profiler.h (added)
• rubberband/src/Resampler.cpp (modified) (8 diffs)
• rubberband/src/Resampler.h (modified) (4 diffs)
• rubberband/src/RingBuffer.h (modified) (37 diffs)
• rubberband/src/RubberBandStretcher.cpp (modified) (3 diffs)
• rubberband/src/Scavenger.h (modified) (2 diffs)
• rubberband/src/SilentAudioCurve.cpp (added)
• rubberband/src/SilentAudioCurve.h (copied) (copied from trunk/rubberband/src/HighFrequencyAudioCurve.h) (2 diffs)
• rubberband/src/SpectralDifferenceAudioCurve.cpp (modified) (3 diffs)
• rubberband/src/SpectralDifferenceAudioCurve.h (modified) (2 diffs)
• rubberband/src/StretchCalculator.cpp (modified) (6 diffs)
• rubberband/src/StretchCalculator.h (modified) (2 diffs)
• rubberband/src/StretcherChannelData.cpp (modified) (14 diffs)
• rubberband/src/StretcherChannelData.h (modified) (8 diffs)
• rubberband/src/StretcherImpl.cpp (modified) (33 diffs)
• rubberband/src/StretcherImpl.h (modified) (8 diffs)
• rubberband/src/StretcherProcess.cpp (modified) (25 diffs)
• rubberband/src/Thread.cpp (modified) (12 diffs)
• rubberband/src/Thread.h (modified) (4 diffs)
• rubberband/src/Window.cpp (copied) (copied from trunk/rubberband/src/AudioCurve.cpp) (2 diffs)
• rubberband/src/Window.h (modified) (4 diffs)
• rubberband/src/main.cpp (added)
• rubberband/src/rubberband-c.cpp (added)
• rubberband/src/sysutils.cpp (modified) (5 diffs)
• rubberband/src/sysutils.h (modified) (3 diffs)

trunk/fm_server/configure

@@ -25268 +25268 @@
     else
         if test -n "$PKG_CONFIG" && \
-    { (echo "$as_me:$LINENO: \$PKG_CONFIG --exists --print-errors \"rubberband fftw3 samplerate\"") >&5
-  ($PKG_CONFIG --exists --print-errors "rubberband fftw3 samplerate") 2>&5
+    { (echo "$as_me:$LINENO: \$PKG_CONFIG --exists --print-errors \"rubberband = 1.2 fftw3 samplerate\"") >&5
+  ($PKG_CONFIG --exists --print-errors "rubberband = 1.2 fftw3 samplerate") 2>&5
   ac_status=$?
   echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; then
-  pkg_cv_RUBBERBAND_CFLAGS=`$PKG_CONFIG --cflags "rubberband fftw3 samplerate" 2>/dev/null`
+  pkg_cv_RUBBERBAND_CFLAGS=`$PKG_CONFIG --cflags "rubberband = 1.2 fftw3 samplerate" 2>/dev/null`
 else
   pkg_failed=yes
@@ -25286 +25286 @@
     else
         if test -n "$PKG_CONFIG" && \
-    { (echo "$as_me:$LINENO: \$PKG_CONFIG --exists --print-errors \"rubberband fftw3 samplerate\"") >&5
-  ($PKG_CONFIG --exists --print-errors "rubberband fftw3 samplerate") 2>&5
+    { (echo "$as_me:$LINENO: \$PKG_CONFIG --exists --print-errors \"rubberband = 1.2 fftw3 samplerate\"") >&5
+  ($PKG_CONFIG --exists --print-errors "rubberband = 1.2 fftw3 samplerate") 2>&5
   ac_status=$?
   echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; then
-  pkg_cv_RUBBERBAND_LIBS=`$PKG_CONFIG --libs "rubberband fftw3 samplerate" 2>/dev/null`
+  pkg_cv_RUBBERBAND_LIBS=`$PKG_CONFIG --libs "rubberband = 1.2 fftw3 samplerate" 2>/dev/null`
 else
   pkg_failed=yes
@@ -25310 +25310 @@
 fi
         if test $_pkg_short_errors_supported = yes; then
-                RUBBERBAND_PKG_ERRORS=`$PKG_CONFIG --short-errors --errors-to-stdout --print-errors "rubberband fftw3 samplerate"`
+                RUBBERBAND_PKG_ERRORS=`$PKG_CONFIG --short-errors --errors-to-stdout --print-errors "rubberband = 1.2 fftw3 samplerate"`
         else
-                RUBBERBAND_PKG_ERRORS=`$PKG_CONFIG --errors-to-stdout --print-errors "rubberband fftw3 samplerate"`
+                RUBBERBAND_PKG_ERRORS=`$PKG_CONFIG --errors-to-stdout --print-errors "rubberband = 1.2 fftw3 samplerate"`
         fi
         # Put the nasty error message in config.log where it belongs
         echo "$RUBBERBAND_PKG_ERRORS" >&5
 
-        { { echo "$as_me:$LINENO: error: Package requirements (rubberband fftw3 samplerate) were not met:
+        { { echo "$as_me:$LINENO: error: Package requirements (rubberband = 1.2 fftw3 samplerate) were not met:
 
 $RUBBERBAND_PKG_ERRORS
@@ -25328 +25328 @@
 See the pkg-config man page for more details.
 " >&5
-echo "$as_me: error: Package requirements (rubberband fftw3 samplerate) were not met:
+echo "$as_me: error: Package requirements (rubberband = 1.2 fftw3 samplerate) were not met:
 
 $RUBBERBAND_PKG_ERRORS

trunk/fm_server/configure.ac

@@ -65 +65 @@
 AC_SUBST(SAMPLERATE_CFLAGS)
 
-PKG_CHECK_MODULES(RUBBERBAND, rubberband fftw3 samplerate)
+PKG_CHECK_MODULES(RUBBERBAND, rubberband = 1.2 fftw3 samplerate)
 AC_SUBST(RUBBERBAND_LIBS)
 AC_SUBST(RUBBERBAND_CFLAGS)

trunk/fm_server/src/fm_effect_rubber/Makefile.am

@@ -3 +3 @@
 
 libfm_effect_rubber_la_SOURCES = \
-        fm_rubber_wrapper.cpp \
-        fm_rubber_wrapper.h \
         fm_effect_rubber.c \
         fm_effect_rubber.h
 
 
-libfm_effect_rubber_la_CPPFLAGS = \
+libfm_effect_rubber_la_CFLAGS = \
         $(GLIB_CFLAGS) \
         $(RGC_SERVER_CFLAGS) \

trunk/fm_server/src/fm_effect_rubber/Makefile.in

@@ -52 +52 @@
         $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1)
 am_libfm_effect_rubber_la_OBJECTS =  \
-        libfm_effect_rubber_la-fm_rubber_wrapper.lo \
         libfm_effect_rubber_la-fm_effect_rubber.lo
 libfm_effect_rubber_la_OBJECTS = $(am_libfm_effect_rubber_la_OBJECTS)
+libfm_effect_rubber_la_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \
+        $(LIBTOOLFLAGS) --mode=link $(CCLD) \
+        $(libfm_effect_rubber_la_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \
+        $(LDFLAGS) -o $@
 DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
 depcomp = $(SHELL) $(top_srcdir)/depcomp
@@ -66 +69 @@
 LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
         --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \
-        $(LDFLAGS) -o $@
-CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
-        $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
-LTCXXCOMPILE = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
-        --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
-        $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
-CXXLD = $(CXX)
-CXXLINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
-        --mode=link $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) \
         $(LDFLAGS) -o $@
 SOURCES = $(libfm_effect_rubber_la_SOURCES)
@@ -240 +234 @@
 noinst_LTLIBRARIES = libfm_effect_rubber.la
 libfm_effect_rubber_la_SOURCES = \
-        fm_rubber_wrapper.cpp \
-        fm_rubber_wrapper.h \
         fm_effect_rubber.c \
         fm_effect_rubber.h
 
-libfm_effect_rubber_la_CPPFLAGS = \
+libfm_effect_rubber_la_CFLAGS = \
         $(GLIB_CFLAGS) \
         $(RGC_SERVER_CFLAGS) \
@@ -258 +250 @@
 
 .SUFFIXES:
-.SUFFIXES: .c .cpp .lo .o .obj
+.SUFFIXES: .c .lo .o .obj
 $(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
         @for dep in $?; do \
@@ -298 +290 @@
         done
 libfm_effect_rubber.la: $(libfm_effect_rubber_la_OBJECTS) $(libfm_effect_rubber_la_DEPENDENCIES) 
-        $(CXXLINK)  $(libfm_effect_rubber_la_OBJECTS) $(libfm_effect_rubber_la_LIBADD) $(LIBS)
+        $(libfm_effect_rubber_la_LINK)  $(libfm_effect_rubber_la_OBJECTS) $(libfm_effect_rubber_la_LIBADD) $(LIBS)
 
 mostlyclean-compile:
@@ -307 +299 @@
 
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libfm_effect_rubber_la-fm_effect_rubber.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libfm_effect_rubber_la-fm_rubber_wrapper.Plo@am__quote@
 
 .c.o:
@@ -331 +322 @@
 
 libfm_effect_rubber_la-fm_effect_rubber.lo: fm_effect_rubber.c
-@am__fastdepCC_TRUE@    $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libfm_effect_rubber_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libfm_effect_rubber_la-fm_effect_rubber.lo -MD -MP -MF $(DEPDIR)/libfm_effect_rubber_la-fm_effect_rubber.Tpo -c -o libfm_effect_rubber_la-fm_effect_rubber.lo `test -f 'fm_effect_rubber.c' || echo '$(srcdir)/'`fm_effect_rubber.c
+@am__fastdepCC_TRUE@    $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libfm_effect_rubber_la_CFLAGS) $(CFLAGS) -MT libfm_effect_rubber_la-fm_effect_rubber.lo -MD -MP -MF $(DEPDIR)/libfm_effect_rubber_la-fm_effect_rubber.Tpo -c -o libfm_effect_rubber_la-fm_effect_rubber.lo `test -f 'fm_effect_rubber.c' || echo '$(srcdir)/'`fm_effect_rubber.c
 @am__fastdepCC_TRUE@    mv -f $(DEPDIR)/libfm_effect_rubber_la-fm_effect_rubber.Tpo $(DEPDIR)/libfm_effect_rubber_la-fm_effect_rubber.Plo
 @AMDEP_TRUE@@am__fastdepCC_FALSE@       source='fm_effect_rubber.c' object='libfm_effect_rubber_la-fm_effect_rubber.lo' libtool=yes @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@   $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libfm_effect_rubber_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libfm_effect_rubber_la-fm_effect_rubber.lo `test -f 'fm_effect_rubber.c' || echo '$(srcdir)/'`fm_effect_rubber.c
-
-.cpp.o:
-@am__fastdepCXX_TRUE@   $(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
-@am__fastdepCXX_TRUE@   mv -f $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(CXXCOMPILE) -c -o $@ $<
-
-.cpp.obj:
-@am__fastdepCXX_TRUE@   $(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
-@am__fastdepCXX_TRUE@   mv -f $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
-
-.cpp.lo:
-@am__fastdepCXX_TRUE@   $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
-@am__fastdepCXX_TRUE@   mv -f $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(LTCXXCOMPILE) -c -o $@ $<
-
-libfm_effect_rubber_la-fm_rubber_wrapper.lo: fm_rubber_wrapper.cpp
-@am__fastdepCXX_TRUE@   $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libfm_effect_rubber_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libfm_effect_rubber_la-fm_rubber_wrapper.lo -MD -MP -MF $(DEPDIR)/libfm_effect_rubber_la-fm_rubber_wrapper.Tpo -c -o libfm_effect_rubber_la-fm_rubber_wrapper.lo `test -f 'fm_rubber_wrapper.cpp' || echo '$(srcdir)/'`fm_rubber_wrapper.cpp
-@am__fastdepCXX_TRUE@   mv -f $(DEPDIR)/libfm_effect_rubber_la-fm_rubber_wrapper.Tpo $(DEPDIR)/libfm_effect_rubber_la-fm_rubber_wrapper.Plo
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      source='fm_rubber_wrapper.cpp' object='libfm_effect_rubber_la-fm_rubber_wrapper.lo' libtool=yes @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libfm_effect_rubber_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libfm_effect_rubber_la-fm_rubber_wrapper.lo `test -f 'fm_rubber_wrapper.cpp' || echo '$(srcdir)/'`fm_rubber_wrapper.cpp
+@am__fastdepCC_FALSE@   $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libfm_effect_rubber_la_CFLAGS) $(CFLAGS) -c -o libfm_effect_rubber_la-fm_effect_rubber.lo `test -f 'fm_effect_rubber.c' || echo '$(srcdir)/'`fm_effect_rubber.c
 
 mostlyclean-libtool:

trunk/fm_server/src/fm_effect_rubber/fm_effect_rubber.c

@@ -29 +29 @@
 #include <rgc_server.h>
 
+#include <rubberband-c.h>
+
 #include "../fm_buffer.h"
 #include "../fm_element.h"
 #include "../fm_input.h"
 #include "../fm_effect.h"
-#include "fm_rubber_wrapper.h"
 #include "fm_effect_rubber.h"
 
@@ -138 +139 @@
 fm_effect_rubber_init                   (FmEffectRubber         *rubber)
 {
-        rubber->wrap = NULL;
+        rubber->state = NULL;
         rubber->temp_buffer = NULL;
         rubber->time_ratio = 1.0;
@@ -166 +167 @@
                 return FALSE;
 
-        rubber->wrap = fm_rubber_wrapper_new ();
+        rubber->state = rubberband_new (44100, 2, RubberBandOptionProcessRealTime, 1.0, 1.0);   /* FIXME: 44100 */
         rubber->temp_buffer = fm_buffer_new (16384, FM_CHANNELS_STEREO);
         rubber->channel_ptr = g_new (gfloat *, FM_CHANNELS_STEREO);
@@ -181 +182 @@
         g_free (rubber->channel_ptr);
         fm_buffer_destroy (rubber->temp_buffer);
-        fm_rubber_wrapper_destroy (rubber->wrap);
+        rubberband_delete (rubber->state);
 
         return TRUE;
@@ -196 +197 @@
 
         if (rubber->change_time_ratio > -1) {
-                fm_rubber_wrapper_set_time_ratio (rubber->wrap, rubber->change_time_ratio);
+                rubberband_set_time_ratio (rubber->state, rubber->change_time_ratio);
                 rubber->time_ratio = rubber->change_time_ratio;
                 rubber->change_time_ratio = -1;
-                rubber->latency = fm_rubber_wrapper_get_latency (rubber->wrap);
+                rubber->latency = rubberband_get_latency (rubber->state);
         }
 
         if (rubber->change_pitch_scale > -1) {
-                fm_rubber_wrapper_set_pitch_scale (rubber->wrap, rubber->change_pitch_scale);
+                rubberband_set_pitch_scale (rubber->state, rubber->change_pitch_scale);
                 rubber->pitch_scale = rubber->change_pitch_scale;
                 rubber->change_pitch_scale = -1;
-                rubber->latency = fm_rubber_wrapper_get_latency (rubber->wrap);
+                rubber->latency = rubberband_get_latency (rubber->state);
         }
 
@@ -218 +219 @@
         
         while (samples_needed > 0) {
-                guint samples_avail = fm_rubber_wrapper_available (rubber->wrap);
+                guint samples_avail = rubberband_available (rubber->state);
 
                 if (samples_avail) {
@@ -226 +227 @@
                                 ask_for = samples_needed;
 
-                        guint retrieved = fm_rubber_wrapper_retrieve (rubber->wrap, rubber->channel_ptr, ask_for);
+                        guint retrieved = rubberband_retrieve (rubber->state, rubber->channel_ptr, ask_for);
                         samples_needed -= retrieved;
 
@@ -241 +242 @@
                 } else {
                         /* ask for another buffer from our source */
-                        guint samples_req = fm_rubber_wrapper_get_samples_required (rubber->wrap);
+                        guint samples_req = rubberband_get_samples_required (rubber->state);
 
                         //g_print ("Requested %u samples\n", samples_req);
@@ -250 +251 @@
                         if (rubber->temp_buffer->discont == TRUE) {
                                 g_print ("***************** DISCONT!!!!\n");
-                                fm_rubber_wrapper_reset (rubber->wrap);
+                                rubberband_reset (rubber->state);
                                 start_timestamp = rubber->temp_buffer->timestamp_ns;
 
@@ -261 +262 @@
                         rubber->temp_timestamp_ns = rubber->temp_buffer->timestamp_ns;
 
-                        fm_rubber_wrapper_process (rubber->wrap, rubber->temp_buffer->channel_data, samples_req, FALSE);
+                        rubberband_process (rubber->state, (const float *const *) rubber->temp_buffer->channel_data, samples_req, FALSE);
                 }
 

trunk/fm_server/src/fm_effect_rubber/fm_effect_rubber.h

@@ -32 +32 @@
 #define FM_EFFECT_RUBBER_GET_CLASS(obj)         (G_TYPE_INSTANCE_GET_CLASS ((obj), FM_TYPE_EFFECT_RUBBER, FmEffectRubberClass))
 
+/* Avoid the need of including "rubberband-c.h" from other plugins */
+#ifndef RubberBandState
+#define RubberBandState void*
+#endif
+
 
 typedef struct _FmEffectRubber FmEffectRubber;
@@ -40 +45 @@
         FmEffect effect;
 
-        FmRubberWrapper *wrap;
+        RubberBandState state;
 
         FmBuffer *temp_buffer;

trunk/fm_server/src/fm_input_cdj.c

@@ -31 +31 @@
 #include "fm_input_gst/fm_input_gst_common.h"
 #include "fm_input_gst/fm_input_gst.h"
-//#include "fm_effect_rate.h"
-#include "fm_effect_rubber/fm_rubber_wrapper.h"
 #include "fm_effect_rubber/fm_effect_rubber.h"
 #include "fm_output.h"

trunk/rubberband/ChangeLog

@@ +1 @@
+
+Changes since Rubber Band v1.0.1
+
+ * Added an initial "formant preservation" option when pitch shifting
+ * Real-time pitch shifting now uses a faster method by default, with
+   less variation in CPU usage
+ * The code is more amenable to compiler auto-vectorization (through
+   e.g. gcc --ftree-vectorize).
+

trunk/rubberband/README

@@ -5 +5 @@
 An audio time-stretching and pitch-shifting library and utility program.
 
-Copyright 2007 Chris Cannam, cannam@all-day-breakfast.com.
+Copyright 2008 Chris Cannam, cannam@all-day-breakfast.com.
 
 Distributed under the GNU General Public License.
@@ -20 +20 @@
 
     Rubber Band is a phase-vocoder-based frequency domain time
-    stretcher with partial phase locking to peak frequencies and phase
-    resynchronisation at noisy transients.  It is suitable for most
-    musical uses with its default settings, and has a range of options
-    for fine tuning.
+    stretcher with phase resynchronisation at noisy transients and a
+    phase lamination technique to reduce phasiness.  It is suitable for
+    most musical uses with its default settings, and has a range of
+    options for fine tuning.
 
   * Real-time capable
@@ -143 +143 @@
 There is extensive documentation in the class header.
 
+A header with C language bindings is also provided in
+<rubberband/rubberband-c.h>.  This is a wrapper around the C++
+implementation, and as the implementation is the same, it also
+requires linkage against the C++ standard libraries.  It is not yet
+documented separately from the C++ header.  You should include only
+one of the two headers, not both.
+
 The source code for the command-line utility (src/main.cpp) provides a
 good example of how to use Rubber Band in offline mode; the LADSPA

trunk/rubberband/configure

@@ -21300 +21300 @@
 
 if test "x$GCC" = "xyes"; then
+  case " $CFLAGS " in
+    *[\ \       ]-fPIC\ -Wall[\ \       ]*) ;;
+    *) CFLAGS="$CFLAGS -fPIC -Wall" ;;
+  esac
   case " $CXXFLAGS " in
     *[\ \       ]-fPIC\ -Wall[\ \       ]*) ;;

trunk/rubberband/configure.ac

@@ -29 +29 @@
 changequote(,)dnl
 if test "x$GCC" = "xyes"; then
+  case " $CFLAGS " in
+    *[\ \       ]-fPIC\ -Wall[\ \       ]*) ;;
+    *) CFLAGS="$CFLAGS -fPIC -Wall" ;;
+  esac
   case " $CXXFLAGS " in
     *[\ \       ]-fPIC\ -Wall[\ \       ]*) ;;

trunk/rubberband/include/Makefile.am

@@ -2 +2 @@
 
 librubberband_include_DATA = \
-        TimeStretcher.h \
+        rubberband-c.h \
         RubberBandStretcher.h
 

trunk/rubberband/include/Makefile.in

@@ -168 +168 @@
 librubberband_includedir = $(pkgincludedir)
 librubberband_include_DATA = \
-        TimeStretcher.h \
+        rubberband-c.h \
         RubberBandStretcher.h
 

trunk/rubberband/include/RubberBandStretcher.h

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -15 +15 @@
 #ifndef _RUBBERBANDSTRETCHER_H_
 #define _RUBBERBANDSTRETCHER_H_
-
-#include "TimeStretcher.h"
+    
+#define RUBBERBAND_VERSION "1.2.0-gpl"    
+#define RUBBERBAND_API_MAJOR_VERSION 2
+#define RUBBERBAND_API_MINOR_VERSION 0
 
 #include <vector>
+
+/**
+ * @mainpage RubberBand
+ * 
+ * The Rubber Band API is contained in the single class
+ * RubberBand::RubberBandStretcher.
+ *
+ * Threading notes for real-time applications:
+ * 
+ * Multiple instances of RubberBandStretcher may be created and used
+ * in separate threads concurrently.  However, for any single instance
+ * of RubberBandStretcher, you may not call process() more than once
+ * concurrently, and you may not change the time or pitch ratio while
+ * a process() call is being executed (if the stretcher was created in
+ * "real-time mode"; in "offline mode" you can't change the ratios
+ * during use anyway).
+ * 
+ * So you can run process() in its own thread if you like, but if you
+ * want to change ratios dynamically from a different thread, you will
+ * need some form of mutex in your code.  Changing the time or pitch
+ * ratio is real-time safe except in extreme circumstances, so for
+ * most applications that may change these dynamically it probably
+ * makes most sense to do so from the same thread as calls process(),
+ * even if that is a real-time thread.
+ */
 
 namespace RubberBand
 {
 
-class RubberBandStretcher : public TimeStretcher
+class RubberBandStretcher
 {
 public:
-
     /**
      * Processing options for the timestretcher.  The preferred
@@ -103 +129 @@
      * any time.
      *
-     *   \li \c OptionPhaseAdaptive - Lock the adjustments of phase
-     *   for frequencies close to peak frequencies to those of the
-     *   peak, but reduce the degree of locking as the stretch ratio
-     *   gets longer.  This, the default setting, should give a good
-     *   balance between clarity and smoothness in most situations.
-     *
-     *   \li \c OptionPhasePeakLocked - Lock the adjustments of phase
-     *   for frequencies close to peak frequencies to those of the
-     *   peak.  This should give a clear result in situations with
-     *   relatively low stretch ratios, but a relatively metallic
-     *   sound at longer stretches.
-     *
-     *   \li \c OptionPhaseIndependent - Do not lock phase adjustments
-     *   to peak frequencies.  This usually results in a softer,
-     *   phasier sound.
+     *   \li \c OptionPhaseLaminar - Adjust phases when stretching in
+     *   such a way as to try to retain the continuity of phase
+     *   relationships between adjacent frequency bins whose phases
+     *   are behaving in similar ways.  This, the default setting,
+     *   should give good results in most situations.
+     *
+     *   \li \c OptionPhaseIndependent - Adjust the phase in each
+     *   frequency bin independently from its neighbours.  This
+     *   usually results in a slightly softer, phasier sound.
      *
      * 5. Flags prefixed \c OptionThreading control the threading
@@ -152 +172 @@
      *   likely to result in a smoother sound at the expense of
      *   clarity and timing.
-     */
+     *
+     * 7. Flags prefixed \c OptionFormant control the handling of
+     * formant shape (spectral envelope) when pitch-shifting.  These
+     * options may be changed at any time.
+     *
+     *   \li \c OptionFormantShifted - Apply no special formant
+     *   processing.  The spectral envelope will be pitch shifted as
+     *   normal.
+     *
+     *   \li \c OptionFormantPreserved - Preserve the spectral
+     *   envelope of the unshifted signal.  This permits shifting the
+     *   note frequency without so substantially affecting the
+     *   perceived pitch profile of the voice or instrument.
+     *
+     * 8. Flags prefixed \c OptionPitch control the method used for
+     * pitch shifting.  These options may be changed at any time.
+     * They are only effective in realtime mode; in offline mode, the
+     * pitch-shift method is fixed.
+     *
+     *   \li \c OptionPitchHighSpeed - Use a method with a CPU cost
+     *   that is relatively moderate and predictable.  This may
+     *   sound less clear than OptionPitchHighQuality, especially
+     *   for large pitch shifts. 
+
+     *   \li \c OptionPitchHighQuality - Use the highest quality
+     *   method for pitch shifting.  This method has a CPU cost
+     *   approximately proportional to the required frequency shift.
+
+     *   \li \c OptionPitchHighConsistency - Use the method that gives
+     *   greatest consistency when used to create small variations in
+     *   pitch around the 1.0-ratio level.  Unlike the previous two
+     *   options, this avoids discontinuities when moving across the
+     *   1.0 pitch scale in real-time; it also consumes more CPU than
+     *   the others in the case where the pitch scale is exactly 1.0.
+     */
+    
+    enum Option {
+
+        OptionProcessOffline       = 0x00000000,
+        OptionProcessRealTime      = 0x00000001,
+
+        OptionStretchElastic       = 0x00000000,
+        OptionStretchPrecise       = 0x00000010,
+    
+        OptionTransientsCrisp      = 0x00000000,
+        OptionTransientsMixed      = 0x00000100,
+        OptionTransientsSmooth     = 0x00000200,
+
+        OptionPhaseLaminar         = 0x00000000,
+        OptionPhaseIndependent     = 0x00002000,
+    
+        OptionThreadingAuto        = 0x00000000,
+        OptionThreadingNever       = 0x00010000,
+        OptionThreadingAlways      = 0x00020000,
+
+        OptionWindowStandard       = 0x00000000,
+        OptionWindowShort          = 0x00100000,
+        OptionWindowLong           = 0x00200000,
+
+        OptionFormantShifted       = 0x00000000,
+        OptionFormantPreserved     = 0x01000000,
+
+        OptionPitchHighSpeed       = 0x00000000,
+        OptionPitchHighQuality     = 0x02000000,
+        OptionPitchHighConsistency = 0x04000000
+    };
+
     typedef int Options;
-    
-    static const int OptionProcessOffline   = 0x00000000;
-    static const int OptionProcessRealTime  = 0x00000001;
-
-    static const int OptionStretchElastic   = 0x00000000;
-    static const int OptionStretchPrecise   = 0x00000010;
-    
-    static const int OptionTransientsCrisp  = 0x00000000;
-    static const int OptionTransientsMixed  = 0x00000100;
-    static const int OptionTransientsSmooth = 0x00000200;
-
-    static const int OptionPhaseAdaptive    = 0x00000000;
-    static const int OptionPhasePeakLocked  = 0x00001000;
-    static const int OptionPhaseIndependent = 0x00002000;
-    
-    static const int OptionThreadingAuto    = 0x00000000;
-    static const int OptionThreadingNever   = 0x00010000;
-    static const int OptionThreadingAlways  = 0x00020000;
-
-    static const int OptionWindowStandard   = 0x00000000;
-    static const int OptionWindowShort      = 0x00100000;
-    static const int OptionWindowLong       = 0x00200000;
-
-    static const int DefaultOptions         = 0x00000000;
-    static const int PercussiveOptions      = OptionWindowShort | \
-                                              OptionPhaseIndependent;
+
+    enum PresetOption {
+        DefaultOptions             = 0x00000000,
+        PercussiveOptions          = 0x00102000
+    };
 
     /**
@@ -194 +259 @@
                         double initialTimeRatio = 1.0,
                         double initialPitchScale = 1.0);
-    virtual ~RubberBandStretcher();
+    ~RubberBandStretcher();
 
     /**
@@ -201 +266 @@
      * (although retaining the current time and pitch ratio).
      */
-    virtual void reset();
+    void reset();
 
     /**
@@ -224 +289 @@
      * run at once (there is no internal mutex for this purpose).
      */
-    virtual void setTimeRatio(double ratio);
+    void setTimeRatio(double ratio);
 
     /**
@@ -251 +316 @@
      * run at once (there is no internal mutex for this purpose).
      */
-    virtual void setPitchScale(double scale);
+    void setPitchScale(double scale);
 
     /**
@@ -257 +322 @@
      * construction or with setTimeRatio()).
      */
-    virtual double getTimeRatio() const;
+    double getTimeRatio() const;
 
     /**
@@ -263 +328 @@
      * on construction or with setPitchScale()).
      */
-    virtual double getPitchScale() const;
+    double getPitchScale() const;
 
     /**
@@ -274 +339 @@
      * ratio and other options.
      */
-    virtual size_t getLatency() const;
+    size_t getLatency() const;
 
     /**
@@ -282 +347 @@
      * construction).
      */
-    virtual void setTransientsOption(Options options);
+    void setTransientsOption(Options options);
 
     /**
@@ -292 +357 @@
      * way when this function is called.
      */
-    virtual void setPhaseOption(Options options);
+    void setPhaseOption(Options options);
+
+    /**
+     * Change an OptionFormant configuration setting.  This may be
+     * called at any time in any mode.
+     *
+     * Note that if running multi-threaded in Offline mode, the change
+     * may not take effect immediately if processing is already under
+     * way when this function is called.
+     */
+    void setFormantOption(Options options);
+
+    /**
+     * Change an OptionPitch configuration setting.  This may be
+     * called at any time in RealTime mode.  It may not be called in
+     * Offline mode (for which the transients option is fixed on
+     * construction).
+     */
+    void setPitchOption(Options options);
 
     /**
@@ -301 +384 @@
      * possible and this value is ignored.
      */
-    virtual void setExpectedInputDuration(size_t samples);
+    void setExpectedInputDuration(size_t samples);
 
     /**
@@ -315 +398 @@
      * and from which there is no output).
      */
-     virtual size_t getSamplesRequired() const;
+     size_t getSamplesRequired() const;
 
     /**
@@ -332 +415 @@
      * and from which there is no output).
      */
-    virtual void setMaxProcessSize(size_t samples);
+    void setMaxProcessSize(size_t samples);
 
     /**
@@ -351 +434 @@
      * be provided to study() before the first process() call.
      */
-    virtual void study(const float *const *input, size_t samples, bool final);
+    void study(const float *const *input, size_t samples, bool final);
 
     /**
@@ -359 +442 @@
      * Set "final" to true if this is the last block of input data.
      */
-    virtual void process(const float *const *input, size_t samples, bool final);
+    void process(const float *const *input, size_t samples, bool final);
 
     /**
@@ -374 +457 @@
      * and all output read, and the stretch process is now finished.
      */
-    virtual int available() const;
+    int available() const;
 
     /**
@@ -383 +466 @@
      * retrieved.
      */
-    virtual size_t retrieve(float *const *output, size_t samples) const;
+    size_t retrieve(float *const *output, size_t samples) const;
 
     /**
@@ -390 +473 @@
      * This function is not for general use.
      */
-    virtual float getFrequencyCutoff(int n) const;
+    float getFrequencyCutoff(int n) const;
 
     /** 
@@ -397 +480 @@
      * This function is not for general use.
      */
-    virtual void setFrequencyCutoff(int n, float f);
+    void setFrequencyCutoff(int n, float f);
     
     /**
@@ -404 +487 @@
      * This function is provided for diagnostic purposes only.
      */
-    virtual size_t getInputIncrement() const;
+    size_t getInputIncrement() const;
 
     /**
@@ -415 +498 @@
      * This function is provided for diagnostic purposes only.
      */
-    virtual std::vector<int> getOutputIncrements() const;
+    std::vector<int> getOutputIncrements() const;
 
     /**
@@ -426 +509 @@
      * This function is provided for diagnostic purposes only.
      */
-    virtual std::vector<float> getPhaseResetCurve() const;
+    std::vector<float> getPhaseResetCurve() const;
 
     /**
@@ -436 +519 @@
      * This function is provided for diagnostic purposes only.
      */
-    virtual std::vector<int> getExactTimePoints() const;
+    std::vector<int> getExactTimePoints() const;
 
     /**
@@ -442 +525 @@
      * with.
      */
-    virtual size_t getChannelCount() const;
+    size_t getChannelCount() const;
 
     /**
@@ -451 +534 @@
      * This function is provided for diagnostic purposes only.
      */
-    virtual void calculateStretch();
+    void calculateStretch();
 
     /**
@@ -460 +543 @@
      * called.
      */
-    virtual void setDebugLevel(int level);
+    void setDebugLevel(int level);
 
     /**

trunk/rubberband/rubberband.pc.in

@@ -2 +2 @@
 exec_prefix=@exec_prefix@
 libdir=@libdir@
-includedir=@includedir@/rubberband
+includedir=@includedir@
 
 Name: rubberband
-Version: 1.0
+Version: 1.2
 Description: 
-Requires: fftw3, samplerate
-Libs: -L@libdir@ -lrubberband
-Cflags: -I@includedir@/rubberband
+Libs: -L${libdir} -lrubberband
+Cflags: -I${includedir}/rubberband 

trunk/rubberband/src/AudioCurve.cpp

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -14 +14 @@
 
 #include "AudioCurve.h"
+
+#include <iostream>
+using namespace std;
 
 namespace RubberBand
@@ -28 +31 @@
 }
 
+float
+AudioCurve::process(const double *R__ mag, size_t increment)
+{
+    cerr << "WARNING: Using inefficient AudioCurve::process(double)" << endl;
+    float *tmp = new float[m_windowSize];
+    for (int i = 0; i < int(m_windowSize); ++i) tmp[i] = float(mag[i]);
+    float df = process(tmp, increment);
+    delete[] tmp;
+    return df;
+}
 
 }

trunk/rubberband/src/AudioCurve.h

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -18 +18 @@
 #include <sys/types.h>
 
+#include "sysutils.h"
+
 namespace RubberBand 
 {
@@ -29 +31 @@
     virtual void setWindowSize(size_t newSize) = 0;
     
-    virtual float process(float *mag, size_t increment) = 0;
+    virtual float process(const float *R__ mag, size_t increment) = 0;
+    virtual float process(const double *R__ mag, size_t increment);
     virtual void reset() = 0;
 

trunk/rubberband/src/ConstantAudioCurve.cpp

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -39 +39 @@
 
 float
-ConstantAudioCurve::process(float *, size_t)
+ConstantAudioCurve::process(const float *R__, size_t)
 {
     return 1.f;

trunk/rubberband/src/ConstantAudioCurve.h

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -29 +29 @@
     virtual void setWindowSize(size_t newSize);
 
-    virtual float process(float *mag, size_t increment);
+    virtual float process(const float *R__ mag, size_t increment);
     virtual void reset();
 };

trunk/rubberband/src/FFT.cpp

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -15 +15 @@
 #include "FFT.h"
 #include "Thread.h"
-
-
+#include "Profiler.h"
+
+//#define FFT_MEASUREMENT 1
+
+
+#ifdef HAVE_FFTW3
 #include <fftw3.h>
+#endif
+
+#ifdef USE_KISSFFT
+#include "bsd-3rdparty/kissfft/kiss_fftr.h"
+#endif
+
+#ifndef HAVE_FFTW3
+#ifndef USE_KISSFFT
+#ifndef USE_BUILTIN_FFT
+#error No FFT implementation selected!
+#endif
+#endif
+#endif
 
 #include <cmath>
@@ -23 +40 @@
 #include <map>
 #include <cstdio>
+#include <cstdlib>
 #include <vector>
 
@@ -35 +53 @@
     virtual void initDouble() = 0;
 
-    virtual void forward(double *realIn, double *realOut, double *imagOut) = 0;
-    virtual void forwardPolar(double *realIn, double *magOut, double *phaseOut) = 0;
-    virtual void forwardMagnitude(double *realIn, double *magOut) = 0;
-
-    virtual void forward(float *realIn, float *realOut, float *imagOut) = 0;
-    virtual void forwardPolar(float *realIn, float *magOut, float *phaseOut) = 0;
-    virtual void forwardMagnitude(float *realIn, float *magOut) = 0;
-
-    virtual void inverse(double *realIn, double *imagIn, double *realOut) = 0;
-    virtual void inversePolar(double *magIn, double *phaseIn, double *realOut) = 0;
-
-    virtual void inverse(float *realIn, float *imagIn, float *realOut) = 0;
-    virtual void inversePolar(float *magIn, float *phaseIn, float *realOut) = 0;
+    virtual void forward(const double *R__ realIn, double *R__ realOut, double *R__ imagOut) = 0;
+    virtual void forwardPolar(const double *R__ realIn, double *R__ magOut, double *R__ phaseOut) = 0;
+    virtual void forwardMagnitude(const double *R__ realIn, double *R__ magOut) = 0;
+
+    virtual void forward(const float *R__ realIn, float *R__ realOut, float *R__ imagOut) = 0;
+    virtual void forwardPolar(const float *R__ realIn, float *R__ magOut, float *R__ phaseOut) = 0;
+    virtual void forwardMagnitude(const float *R__ realIn, float *R__ magOut) = 0;
+
+    virtual void inverse(const double *R__ realIn, const double *R__ imagIn, double *R__ realOut) = 0;
+    virtual void inversePolar(const double *R__ magIn, const double *R__ phaseIn, double *R__ realOut) = 0;
+    virtual void inverseCepstral(const double *R__ magIn, double *R__ cepOut) = 0;
+
+    virtual void inverse(const float *R__ realIn, const float *R__ imagIn, float *R__ realOut) = 0;
+    virtual void inversePolar(const float *R__ magIn, const float *R__ phaseIn, float *R__ realOut) = 0;
+    virtual void inverseCepstral(const float *R__ magIn, float *R__ cepOut) = 0;
 
     virtual float *getFloatTimeBuffer() = 0;
@@ -53 +73 @@
 };    
 
-
-
+namespace FFTs {
+
+
+#ifdef HAVE_FFTW3
 
 // Define FFTW_DOUBLE_ONLY to make all uses of FFTW functions be
@@ -80 +102 @@
 
 #ifdef FFTW_DOUBLE_ONLY
+#define fft_float_type double
 #define fftwf_complex fftw_complex
 #define fftwf_plan fftw_plan
@@ -92 +115 @@
 #define cosf cos
 #define sinf sin
+#else
+#define fft_float_type float
 #endif /* FFTW_DOUBLE_ONLY */
 
 #ifdef FFTW_FLOAT_ONLY
+#define fft_double_type float
 #define fftw_complex fftwf_complex
 #define fftw_plan fftwf_plan
@@ -106 +132 @@
 #define sqrt sqrtf
 #define cos cosf
-#define sif sinf
+#define sin sinf
+#else
+#define fft_double_type double
 #endif /* FFTW_FLOAT_ONLY */
 
@@ -112 +140 @@
 {
 public:
-    D_FFTW(unsigned int size) : m_fplanf(0)
+    D_FFTW(int size) : m_fplanf(0)
 #ifdef FFTW_DOUBLE_ONLY
                               , m_frb(0)
@@ -130 +158 @@
             if (m_extantf > 0 && --m_extantf == 0) save = true;
             m_extantMutex.unlock();
+#ifndef FFTW_DOUBLE_ONLY
             if (save) saveWisdom('f');
+#endif
             fftwf_destroy_plan(m_fplanf);
             fftwf_destroy_plan(m_fplani);
@@ -144 +174 @@
             if (m_extantd > 0 && --m_extantd == 0) save = true;
             m_extantMutex.unlock();
+#ifndef FFTW_FLOAT_ONLY
             if (save) saveWisdom('d');
+#endif
             fftw_destroy_plan(m_dplanf);
             fftw_destroy_plan(m_dplani);
@@ -163 +195 @@
 #ifdef FFTW_DOUBLE_ONLY
         if (load) loadWisdom('d');
-        m_fbuf = (double *)fftw_malloc(m_size * sizeof(double));
 #else
         if (load) loadWisdom('f');
-        m_fbuf = (float *)fftwf_malloc(m_size * sizeof(float));
-#endif
+#endif
+        m_fbuf = (fft_float_type *)fftw_malloc(m_size * sizeof(fft_float_type));
         m_fpacked = (fftwf_complex *)fftw_malloc
             ((m_size/2 + 1) * sizeof(fftwf_complex));
@@ -184 +215 @@
 #ifdef FFTW_FLOAT_ONLY
         if (load) loadWisdom('f');
-        m_dbuf = (float *)fftwf_malloc(m_size * sizeof(float));
 #else
         if (load) loadWisdom('d');
-        m_dbuf = (double *)fftw_malloc(m_size * sizeof(double));
-#endif
+#endif
+        m_dbuf = (fft_double_type *)fftw_malloc(m_size * sizeof(fft_double_type));
         m_dpacked = (fftw_complex *)fftw_malloc
             ((m_size/2 + 1) * sizeof(fftw_complex));
@@ -251 +281 @@
     }
 
-    void packFloat(float *re, float *im) {
-        for (unsigned int i = 0; i <= m_size/2; ++i) {
-            m_fpacked[i][0] = re[i];
-            m_fpacked[i][1] = im[i];
-        }
-    }
-
-    void packDouble(double *re, double *im) {
-        for (unsigned int i = 0; i <= m_size/2; ++i) {
-            m_dpacked[i][0] = re[i];
-            m_dpacked[i][1] = im[i];
-        }
-    }
-
-    void unpackFloat(float *re, float *im) {
-        for (unsigned int i = 0; i <= m_size/2; ++i) {
+    void packFloat(const float *R__ re, const float *R__ im) {
+        const int hs = m_size/2;
+        fftwf_complex *const R__ fpacked = m_fpacked; 
+        for (int i = 0; i <= hs; ++i) {
+            fpacked[i][0] = re[i];
+        }
+        if (im) {
+            for (int i = 0; i <= hs; ++i) {
+                fpacked[i][1] = im[i];
+            }
+        } else {
+            for (int i = 0; i <= hs; ++i) {
+                fpacked[i][1] = 0.f;
+            }
+        }                
+    }
+
+    void packDouble(const double *R__ re, const double *R__ im) {
+        const int hs = m_size/2;
+        fftw_complex *const R__ dpacked = m_dpacked; 
+        for (int i = 0; i <= hs; ++i) {
+            dpacked[i][0] = re[i];
+        }
+        if (im) {
+            for (int i = 0; i <= hs; ++i) {
+                dpacked[i][1] = im[i];
+            }
+        } else {
+            for (int i = 0; i <= hs; ++i) {
+                dpacked[i][1] = 0.0;
+            }
+        }
+    }
+
+    void unpackFloat(float *R__ re, float *R__ im) {
+        const int hs = m_size/2;
+        for (int i = 0; i <= hs; ++i) {
             re[i] = m_fpacked[i][0];
-            im[i] = m_fpacked[i][1];
+        }
+        if (im) {
+            for (int i = 0; i <= hs; ++i) {
+                im[i] = m_fpacked[i][1];
+            }
         }
     }        
 
-    void unpackDouble(double *re, double *im) {
-        for (unsigned int i = 0; i <= m_size/2; ++i) {
+    void unpackDouble(double *R__ re, double *R__ im) {
+        const int hs = m_size/2;
+        for (int i = 0; i <= hs; ++i) {
             re[i] = m_dpacked[i][0];
-            im[i] = m_dpacked[i][1];
+        }
+        if (im) {
+            for (int i = 0; i <= hs; ++i) {
+                im[i] = m_dpacked[i][1];
+            }
         }
     }        
 
-    void forward(double *realIn, double *realOut, double *imagOut) {
+    void forward(const double *R__ realIn, double *R__ realOut, double *R__ imagOut) {
         if (!m_dplanf) initDouble();
+        const int sz = m_size;
+        fft_double_type *const R__ dbuf = m_dbuf;
 #ifndef FFTW_FLOAT_ONLY
-        if (realIn != m_dbuf) 
-#endif
-            for (unsigned int i = 0; i < m_size; ++i) {
-                m_dbuf[i] = realIn[i];
+        if (realIn != dbuf) 
+#endif
+            for (int i = 0; i < sz; ++i) {
+                dbuf[i] = realIn[i];
             }
         fftw_execute(m_dplanf);
@@ -291 +353 @@
     }
 
-    void forwardPolar(double *realIn, double *magOut, double *phaseOut) {
+    void forwardPolar(const double *R__ realIn, double *R__ magOut, double *R__ phaseOut) {
         if (!m_dplanf) initDouble();
+        fft_double_type *const R__ dbuf = m_dbuf;
+        const int sz = m_size;
+#ifndef FFTW_FLOAT_ONLY
+        if (realIn != dbuf)
+#endif
+            for (int i = 0; i < sz; ++i) {
+                dbuf[i] = realIn[i];
+            }
+        fftw_execute(m_dplanf);
+        const int hs = m_size/2;
+        for (int i = 0; i <= hs; ++i) {
+            magOut[i] = sqrt(m_dpacked[i][0] * m_dpacked[i][0] +
+                             m_dpacked[i][1] * m_dpacked[i][1]);
+        }
+        for (int i = 0; i <= hs; ++i) {
+            phaseOut[i] = atan2(m_dpacked[i][1], m_dpacked[i][0]);
+        }
+    }
+
+    void forwardMagnitude(const double *R__ realIn, double *R__ magOut) {
+        if (!m_dplanf) initDouble();
+        fft_double_type *const R__ dbuf = m_dbuf;
+        const int sz = m_size;
 #ifndef FFTW_FLOAT_ONLY
         if (realIn != m_dbuf)
 #endif
-            for (unsigned int i = 0; i < m_size; ++i) {
-                m_dbuf[i] = realIn[i];
+            for (int i = 0; i < sz; ++i) {
+                dbuf[i] = realIn[i];
             }
         fftw_execute(m_dplanf);
-        for (unsigned int i = 0; i <= m_size/2; ++i) {
+        const int hs = m_size/2;
+        for (int i = 0; i <= hs; ++i) {
             magOut[i] = sqrt(m_dpacked[i][0] * m_dpacked[i][0] +
                              m_dpacked[i][1] * m_dpacked[i][1]);
         }
-        for (unsigned int i = 0; i <= m_size/2; ++i) {
-            phaseOut[i] = atan2(m_dpacked[i][1], m_dpacked[i][0]);
-        }
-    }
-
-    void forwardMagnitude(double *realIn, double *magOut) {
-        if (!m_dplanf) initDouble();
-#ifndef FFTW_FLOAT_ONLY
-        if (realIn != m_dbuf)
-#endif
-            for (unsigned int i = 0; i < m_size; ++i) {
-                m_dbuf[i] = realIn[i];
-            }
-        fftw_execute(m_dplanf);
-        for (unsigned int i = 0; i <= m_size/2; ++i) {
-            magOut[i] = sqrt(m_dpacked[i][0] * m_dpacked[i][0] +
-                             m_dpacked[i][1] * m_dpacked[i][1]);
-        }
-    }
-
-    void forward(float *realIn, float *realOut, float *imagOut) {
+    }
+
+    void forward(const float *R__ realIn, float *R__ realOut, float *R__ imagOut) {
         if (!m_fplanf) initFloat();
+        fft_float_type *const R__ fbuf = m_fbuf;
+        const int sz = m_size;
 #ifndef FFTW_DOUBLE_ONLY
-        if (realIn != m_fbuf)
-#endif
-            for (unsigned int i = 0; i < m_size; ++i) {
-                m_fbuf[i] = realIn[i];
+        if (realIn != fbuf)
+#endif
+            for (int i = 0; i < sz; ++i) {
+                fbuf[i] = realIn[i];
             }
         fftwf_execute(m_fplanf);
@@ -336 +406 @@
     }
 
-    void forwardPolar(float *realIn, float *magOut, float *phaseOut) {
+    void forwardPolar(const float *R__ realIn, float *R__ magOut, float *R__ phaseOut) {
         if (!m_fplanf) initFloat();
+        fft_float_type *const R__ fbuf = m_fbuf;
+        const int sz = m_size;
 #ifndef FFTW_DOUBLE_ONLY
-        if (realIn != m_fbuf) 
-#endif
-            for (unsigned int i = 0; i < m_size; ++i) {
-                m_fbuf[i] = realIn[i];
+        if (realIn != fbuf) 
+#endif
+            for (int i = 0; i < sz; ++i) {
+                fbuf[i] = realIn[i];
             }
         fftwf_execute(m_fplanf);
-        for (unsigned int i = 0; i <= m_size/2; ++i) {
+        const int hs = m_size/2;
+        for (int i = 0; i <= hs; ++i) {
             magOut[i] = sqrtf(m_fpacked[i][0] * m_fpacked[i][0] +
                               m_fpacked[i][1] * m_fpacked[i][1]);
         }
-        for (unsigned int i = 0; i <= m_size/2; ++i) {
-          phaseOut[i] = atan2f(m_fpacked[i][1], m_fpacked[i][0]) ;
-        }
-    }
-
-    void forwardMagnitude(float *realIn, float *magOut) {
+        for (int i = 0; i <= hs; ++i) {
+            phaseOut[i] = atan2f(m_fpacked[i][1], m_fpacked[i][0]) ;
+        }
+    }
+
+    void forwardMagnitude(const float *R__ realIn, float *R__ magOut) {
         if (!m_fplanf) initFloat();
+        fft_float_type *const R__ fbuf = m_fbuf;
+        const int sz = m_size;
 #ifndef FFTW_DOUBLE_ONLY
-        if (realIn != m_fbuf)
-#endif
-            for (unsigned int i = 0; i < m_size; ++i) {
-                m_fbuf[i] = realIn[i];
+        if (realIn != fbuf)
+#endif
+            for (int i = 0; i < sz; ++i) {
+                fbuf[i] = realIn[i];
             }
         fftwf_execute(m_fplanf);
-        for (unsigned int i = 0; i <= m_size/2; ++i) {
+        const int hs = m_size/2;
+        for (int i = 0; i <= hs; ++i) {
             magOut[i] = sqrtf(m_fpacked[i][0] * m_fpacked[i][0] +
                               m_fpacked[i][1] * m_fpacked[i][1]);
@@ -369 +445 @@
     }
 
-    void inverse(double *realIn, double *imagIn, double *realOut) {
+    void inverse(const double *R__ realIn, const double *R__ imagIn, double *R__ realOut) {
         if (!m_dplanf) initDouble();
         packDouble(realIn, imagIn);
         fftw_execute(m_dplani);
+        const int sz = m_size;
+        fft_double_type *const R__ dbuf = m_dbuf;
 #ifndef FFTW_FLOAT_ONLY
-        if (realOut != m_dbuf) 
-#endif
-            for (unsigned int i = 0; i < m_size; ++i) {
-                realOut[i] = m_dbuf[i];
-            }
-    }
-
-    void inversePolar(double *magIn, double *phaseIn, double *realOut) {
+        if (realOut != dbuf) 
+#endif
+            for (int i = 0; i < sz; ++i) {
+                realOut[i] = dbuf[i];
+            }
+    }
+
+    void inversePolar(const double *R__ magIn, const double *R__ phaseIn, double *R__ realOut) {
         if (!m_dplanf) initDouble();
-        for (unsigned int i = 0; i <= m_size/2; ++i) {
-            m_dpacked[i][0] = magIn[i] * cos(phaseIn[i]);
-            m_dpacked[i][1] = magIn[i] * sin(phaseIn[i]);
+        const int hs = m_size/2;
+        fftw_complex *const R__ dpacked = m_dpacked;
+        for (int i = 0; i <= hs; ++i) {
+            dpacked[i][0] = magIn[i] * cos(phaseIn[i]);
+        }
+        for (int i = 0; i <= hs; ++i) {
+            dpacked[i][1] = magIn[i] * sin(phaseIn[i]);
         }
         fftw_execute(m_dplani);
+        const int sz = m_size;
+        fft_double_type *const R__ dbuf = m_dbuf;
 #ifndef FFTW_FLOAT_ONLY
-        if (realOut != m_dbuf)
-#endif
-            for (unsigned int i = 0; i < m_size; ++i) {
-                realOut[i] = m_dbuf[i];
-            }
-    }
-
-    void inverse(float *realIn, float *imagIn, float *realOut) {
+        if (realOut != dbuf)
+#endif
+            for (int i = 0; i < sz; ++i) {
+                realOut[i] = dbuf[i];
+            }
+    }
+
+    void inverseCepstral(const double *R__ magIn, double *R__ cepOut) {
+        if (!m_dplanf) initDouble();
+        fft_double_type *const R__ dbuf = m_dbuf;
+        fftw_complex *const R__ dpacked = m_dpacked;
+        const int hs = m_size/2;
+        for (int i = 0; i <= hs; ++i) {
+            dpacked[i][0] = log(magIn[i] + 0.000001);
+        }
+        for (int i = 0; i <= hs; ++i) {
+            dpacked[i][1] = 0.0;
+        }
+        fftw_execute(m_dplani);
+        const int sz = m_size;
+#ifndef FFTW_FLOAT_ONLY
+        if (cepOut != dbuf)
+#endif
+            for (int i = 0; i < sz; ++i) {
+                cepOut[i] = dbuf[i];
+            }
+    }
+
+    void inverse(const float *R__ realIn, const float *R__ imagIn, float *R__ realOut) {
         if (!m_fplanf) initFloat();
         packFloat(realIn, imagIn);
         fftwf_execute(m_fplani);
+        const int sz = m_size;
+        fft_float_type *const R__ fbuf = m_fbuf;
 #ifndef FFTW_DOUBLE_ONLY
-        if (realOut != m_fbuf)
-#endif
-            for (unsigned int i = 0; i < m_size; ++i) {
-                realOut[i] = m_fbuf[i];
-            }
-    }
-
-    void inversePolar(float *magIn, float *phaseIn, float *realOut) {
+        if (realOut != fbuf)
+#endif
+            for (int i = 0; i < sz; ++i) {
+                realOut[i] = fbuf[i];
+            }
+    }
+
+    void inversePolar(const float *R__ magIn, const float *R__ phaseIn, float *R__ realOut) {
         if (!m_fplanf) initFloat();
-        for (unsigned int i = 0; i <= m_size/2; ++i) {
-            m_fpacked[i][0] = magIn[i] * cosf(phaseIn[i]);
-            m_fpacked[i][1] = magIn[i] * sinf(phaseIn[i]);
+        const int hs = m_size/2;
+        fftwf_complex *const R__ fpacked = m_fpacked;
+        for (int i = 0; i <= hs; ++i) {
+            fpacked[i][0] = magIn[i] * cosf(phaseIn[i]);
+        }
+        for (int i = 0; i <= hs; ++i) {
+            fpacked[i][1] = magIn[i] * sinf(phaseIn[i]);
         }
         fftwf_execute(m_fplani);
+        const int sz = m_size;
+        fft_float_type *const R__ fbuf = m_fbuf;
 #ifndef FFTW_DOUBLE_ONLY
-        if (realOut != m_fbuf)
-#endif
-            for (unsigned int i = 0; i < m_size; ++i) {
-                realOut[i] = m_fbuf[i];
+        if (realOut != fbuf)
+#endif
+            for (int i = 0; i < sz; ++i) {
+                realOut[i] = fbuf[i];
+            }
+    }
+
+    void inverseCepstral(const float *R__ magIn, float *R__ cepOut) {
+        if (!m_fplanf) initFloat();
+        const int hs = m_size/2;
+        fftwf_complex *const R__ fpacked = m_fpacked;
+        for (int i = 0; i <= hs; ++i) {
+            fpacked[i][0] = logf(magIn[i] + 0.000001f);
+        }
+        for (int i = 0; i <= hs; ++i) {
+            fpacked[i][1] = 0.f;
+        }
+        fftwf_execute(m_fplani);
+        const int sz = m_size;
+        fft_float_type *const R__ fbuf = m_fbuf;
+#ifndef FFTW_DOUBLE_ONLY
+        if (cepOut != fbuf)
+#endif
+            for (int i = 0; i < sz; ++i) {
+                cepOut[i] = fbuf[i];
             }
     }
@@ -461 +595 @@
     double *m_dbuf;
 #endif
-    fftw_complex *m_dpacked;
-    unsigned int m_size;
-    static unsigned int m_extantf;
-    static unsigned int m_extantd;
+    fftw_complex * m_dpacked;
+    const int m_size;
+    static int m_extantf;
+    static int m_extantd;
     static Mutex m_extantMutex;
 };
 
-unsigned int
+int
 D_FFTW::m_extantf = 0;
 
-unsigned int
+int
 D_FFTW::m_extantd = 0;
 
@@ -477 +611 @@
 D_FFTW::m_extantMutex;
 
+#endif /* HAVE_FFTW3 */
+
+#ifdef USE_KISSFFT
+
+class D_KISSFFT : public FFTImpl
+{
+public:
+    D_KISSFFT(int size) :
+        m_size(size),
+        m_frb(0),
+        m_drb(0),
+        m_fplanf(0),  
+        m_fplani(0)
+    {
+#ifdef FIXED_POINT
+#error KISSFFT is not configured for float values
+#endif
+        if (sizeof(kiss_fft_scalar) != sizeof(float)) {
+            std::cerr << "ERROR: KISSFFT is not configured for float values"
+                      << std::endl;
+        }
+
+        m_fbuf = new kiss_fft_scalar[m_size + 2];
+        m_fpacked = new kiss_fft_cpx[m_size + 2];
+        m_fplanf = kiss_fftr_alloc(m_size, 0, NULL, NULL);
+        m_fplani = kiss_fftr_alloc(m_size, 1, NULL, NULL);
+    }
+
+    ~D_KISSFFT() {
+        kiss_fftr_free(m_fplanf);
+        kiss_fftr_free(m_fplani);
+        kiss_fft_cleanup();
+
+        delete[] m_fbuf;
+        delete[] m_fpacked;
+
+        if (m_frb) delete[] m_frb;
+        if (m_drb) delete[] m_drb;
+    }
+
+    void initFloat() { }
+    void initDouble() { }
+
+    void packFloat(const float *R__ re, const float *R__ im) {
+        const int hs = m_size/2;
+        for (int i = 0; i <= hs; ++i) {
+            m_fpacked[i].r = re[i];
+            m_fpacked[i].i = im[i];
+        }
+    }
+
+    void unpackFloat(float *R__ re, float *R__ im) {
+        const int hs = m_size/2;
+        for (int i = 0; i <= hs; ++i) {
+            re[i] = m_fpacked[i].r;
+            im[i] = m_fpacked[i].i;
+        }
+    }        
+
+    void packDouble(const double *R__ re, const double *R__ im) {
+        const int hs = m_size/2;
+        for (int i = 0; i <= hs; ++i) {
+            m_fpacked[i].r = float(re[i]);
+            m_fpacked[i].i = float(im[i]);
+        }
+    }
+
+    void unpackDouble(double *R__ re, double *R__ im) {
+        const int hs = m_size/2;
+        for (int i = 0; i <= hs; ++i) {
+            re[i] = double(m_fpacked[i].r);
+            im[i] = double(m_fpacked[i].i);
+        }
+    }        
+
+    void forward(const double *R__ realIn, double *R__ realOut, double *R__ imagOut) {
+
+        for (int i = 0; i < m_size; ++i) {
+            m_fbuf[i] = float(realIn[i]);
+        }
+
+        kiss_fftr(m_fplanf, m_fbuf, m_fpacked);
+        unpackDouble(realOut, imagOut);
+    }
+
+    void forwardPolar(const double *R__ realIn, double *R__ magOut, double *R__ phaseOut) {
+
+        for (int i = 0; i < m_size; ++i) {
+            m_fbuf[i] = float(realIn[i]);
+        }
+
+        kiss_fftr(m_fplanf, m_fbuf, m_fpacked);
+
+        const int hs = m_size/2;
+
+        for (int i = 0; i <= hs; ++i) {
+            magOut[i] = sqrt(double(m_fpacked[i].r) * double(m_fpacked[i].r) +
+                             double(m_fpacked[i].i) * double(m_fpacked[i].i));
+        }
+
+        for (int i = 0; i <= hs; ++i) {
+            phaseOut[i] = atan2(double(m_fpacked[i].i), double(m_fpacked[i].r));
+        }
+    }
+
+    void forwardMagnitude(const double *R__ realIn, double *R__ magOut) {
+
+        for (int i = 0; i < m_size; ++i) {
+            m_fbuf[i] = float(realIn[i]);
+        }
+
+        kiss_fftr(m_fplanf, m_fbuf, m_fpacked);
+
+        const int hs = m_size/2;
+
+        for (int i = 0; i <= hs; ++i) {
+            magOut[i] = sqrt(double(m_fpacked[i].r) * double(m_fpacked[i].r) +
+                             double(m_fpacked[i].i) * double(m_fpacked[i].i));
+        }
+    }
+
+    void forward(const float *R__ realIn, float *R__ realOut, float *R__ imagOut) {
+
+        kiss_fftr(m_fplanf, realIn, m_fpacked);
+        unpackFloat(realOut, imagOut);
+    }
+
+    void forwardPolar(const float *R__ realIn, float *R__ magOut, float *R__ phaseOut) {
+
+        kiss_fftr(m_fplanf, realIn, m_fpacked);
+
+        const int hs = m_size/2;
+
+        for (int i = 0; i <= hs; ++i) {
+            magOut[i] = sqrtf(m_fpacked[i].r * m_fpacked[i].r +
+                              m_fpacked[i].i * m_fpacked[i].i);
+        }
+
+        for (int i = 0; i <= hs; ++i) {
+            phaseOut[i] = atan2f(m_fpacked[i].i, m_fpacked[i].r);
+        }
+    }
+
+    void forwardMagnitude(const float *R__ realIn, float *R__ magOut) {
+
+        kiss_fftr(m_fplanf, realIn, m_fpacked);
+
+        const int hs = m_size/2;
+
+        for (int i = 0; i <= hs; ++i) {
+            magOut[i] = sqrtf(m_fpacked[i].r * m_fpacked[i].r +
+                              m_fpacked[i].i * m_fpacked[i].i);
+        }
+    }
+
+    void inverse(const double *R__ realIn, const double *R__ imagIn, double *R__ realOut) {
+
+        packDouble(realIn, imagIn);
+
+        kiss_fftri(m_fplani, m_fpacked, m_fbuf);
+
+        for (int i = 0; i < m_size; ++i) {
+            realOut[i] = m_fbuf[i];
+        }
+    }
+
+    void inversePolar(const double *R__ magIn, const double *R__ phaseIn, double *R__ realOut) {
+
+        const int hs = m_size/2;
+
+        for (int i = 0; i <= hs; ++i) {
+            m_fpacked[i].r = float(magIn[i] * cos(phaseIn[i]));
+            m_fpacked[i].i = float(magIn[i] * sin(phaseIn[i]));
+        }
+
+        kiss_fftri(m_fplani, m_fpacked, m_fbuf);
+
+        for (int i = 0; i < m_size; ++i) {
+            realOut[i] = m_fbuf[i];
+        }
+    }
+
+    void inverseCepstral(const double *R__ magIn, double *R__ cepOut) {
+
+        const int hs = m_size/2;
+
+        for (int i = 0; i <= hs; ++i) {
+            m_fpacked[i].r = float(log(magIn[i] + 0.000001));
+            m_fpacked[i].i = 0.0f;
+        }
+
+        kiss_fftri(m_fplani, m_fpacked, m_fbuf);
+
+        for (int i = 0; i < m_size; ++i) {
+            cepOut[i] = m_fbuf[i];
+        }
+    }
+    
+    void inverse(const float *R__ realIn, const float *R__ imagIn, float *R__ realOut) {
+
+        packFloat(realIn, imagIn);
+        kiss_fftri(m_fplani, m_fpacked, realOut);
+    }
+
+    void inversePolar(const float *R__ magIn, const float *R__ phaseIn, float *R__ realOut) {
+
+        const int hs = m_size/2;
+
+        for (int i = 0; i <= hs; ++i) {
+            m_fpacked[i].r = magIn[i] * cosf(phaseIn[i]);
+            m_fpacked[i].i = magIn[i] * sinf(phaseIn[i]);
+        }
+
+        kiss_fftri(m_fplani, m_fpacked, realOut);
+    }
+
+    void inverseCepstral(const float *R__ magIn, float *R__ cepOut) {
+
+        const int hs = m_size/2;
+
+        for (int i = 0; i <= hs; ++i) {
+            m_fpacked[i].r = logf(magIn[i] + 0.000001f);
+            m_fpacked[i].i = 0.0f;
+        }
+
+        kiss_fftri(m_fplani, m_fpacked, cepOut);
+    }
+    
+    float *getFloatTimeBuffer() {
+        if (!m_frb) m_frb = new float[m_size];
+        return m_frb;
+    }
+
+    double *getDoubleTimeBuffer() {
+        if (!m_drb) m_drb = new double[m_size];
+        return m_drb;
+    }
+
+private:
+    const int m_size;
+    float* m_frb;
+    double* m_drb;
+    kiss_fftr_cfg m_fplanf;
+    kiss_fftr_cfg m_fplani;
+    kiss_fft_scalar *m_fbuf;
+    kiss_fft_cpx *m_fpacked;
+};
+
+#endif /* USE_KISSFFT */
+
+#ifdef USE_BUILTIN_FFT
 
 class D_Cross : public FFTImpl
 {
 public:
-    D_Cross(unsigned int size) : m_size(size), m_table(0), m_frb(0), m_drb(0) {
+    D_Cross(int size) : m_size(size), m_table(0), m_frb(0), m_drb(0) {
         
         m_a = new double[size];
@@ -490 +875 @@
         m_table = new int[m_size];
     
-        unsigned int bits;
-        unsigned int i, j, k, m;
+        int bits;
+        int i, j, k, m;
 
         for (i = 0; ; ++i) {
@@ -526 +911 @@
     void initDouble() { }
 
-    void forward(double *realIn, double *realOut, double *imagOut) {
+    void forward(const double *R__ realIn, double *R__ realOut, double *R__ imagOut) {
         basefft(false, realIn, 0, m_c, m_d);
-        for (size_t i = 0; i <= m_size/2; ++i) realOut[i] = m_c[i];
-        for (size_t i = 0; i <= m_size/2; ++i) imagOut[i] = m_d[i];
-    }
-
-    void forwardPolar(double *realIn, double *magOut, double *phaseOut) {
+        const int hs = m_size/2;
+        for (int i = 0; i <= hs; ++i) realOut[i] = m_c[i];
+        if (imagOut) {
+            for (int i = 0; i <= hs; ++i) imagOut[i] = m_d[i];
+        }
+    }
+
+    void forwardPolar(const double *R__ realIn, double *R__ magOut, double *R__ phaseOut) {
         basefft(false, realIn, 0, m_c, m_d);
-        for (unsigned int i = 0; i <= m_size/2; ++i) {
+        const int hs = m_size/2;
+        for (int i = 0; i <= hs; ++i) {
             magOut[i] = sqrt(m_c[i] * m_c[i] + m_d[i] * m_d[i]);
             phaseOut[i] = atan2(m_d[i], m_c[i]) ;
@@ -540 +929 @@
     }
 
-    void forwardMagnitude(double *realIn, double *magOut) {
+    void forwardMagnitude(const double *R__ realIn, double *R__ magOut) {
         basefft(false, realIn, 0, m_c, m_d);
-        for (unsigned int i = 0; i <= m_size/2; ++i) {
+        const int hs = m_size/2;
+        for (int i = 0; i <= hs; ++i) {
             magOut[i] = sqrt(m_c[i] * m_c[i] + m_d[i] * m_d[i]);
         }
     }
 
-    void forward(float *realIn, float *realOut, float *imagOut) {
-        for (size_t i = 0; i < m_size; ++i) m_a[i] = realIn[i];
+    void forward(const float *R__ realIn, float *R__ realOut, float *R__ imagOut) {
+        for (int i = 0; i < m_size; ++i) m_a[i] = realIn[i];
         basefft(false, m_a, 0, m_c, m_d);
-        for (size_t i = 0; i <= m_size/2; ++i) realOut[i] = m_c[i];
-        for (size_t i = 0; i <= m_size/2; ++i) imagOut[i] = m_d[i];
-    }
-
-    void forwardPolar(float *realIn, float *magOut, float *phaseOut) {
-        for (size_t i = 0; i < m_size; ++i) m_a[i] = realIn[i];
+        const int hs = m_size/2;
+        for (int i = 0; i <= hs; ++i) realOut[i] = m_c[i];
+        if (imagOut) {
+            for (int i = 0; i <= hs; ++i) imagOut[i] = m_d[i];
+        }
+    }
+
+    void forwardPolar(const float *R__ realIn, float *R__ magOut, float *R__ phaseOut) {
+        for (int i = 0; i < m_size; ++i) m_a[i] = realIn[i];
         basefft(false, m_a, 0, m_c, m_d);
-        for (unsigned int i = 0; i <= m_size/2; ++i) {
+        const int hs = m_size/2;
+        for (int i = 0; i <= hs; ++i) {
             magOut[i] = sqrt(m_c[i] * m_c[i] + m_d[i] * m_d[i]);
             phaseOut[i] = atan2(m_d[i], m_c[i]) ;
@@ -563 +957 @@
     }
 
-    void forwardMagnitude(float *realIn, float *magOut) {
-        for (size_t i = 0; i < m_size; ++i) m_a[i] = realIn[i];
+    void forwardMagnitude(const float *R__ realIn, float *R__ magOut) {
+        for (int i = 0; i < m_size; ++i) m_a[i] = realIn[i];
         basefft(false, m_a, 0, m_c, m_d);
-        for (unsigned int i = 0; i <= m_size/2; ++i) {
+        const int hs = m_size/2;
+        for (int i = 0; i <= hs; ++i) {
             magOut[i] = sqrt(m_c[i] * m_c[i] + m_d[i] * m_d[i]);
         }
     }
 
-    void inverse(double *realIn, double *imagIn, double *realOut) {
-        for (unsigned int i = 0; i <= m_size/2; ++i) {
+    void inverse(const double *R__ realIn, const double *R__ imagIn, double *R__ realOut) {
+        const int hs = m_size/2;
+        for (int i = 0; i <= hs; ++i) {
             double real = realIn[i];
             double imag = imagIn[i];
@@ -585 +981 @@
     }
 
-    void inversePolar(double *magIn, double *phaseIn, double *realOut) {
-        for (unsigned int i = 0; i <= m_size/2; ++i) {
+    void inversePolar(const double *R__ magIn, const double *R__ phaseIn, double *R__ realOut) {
+        const int hs = m_size/2;
+        for (int i = 0; i <= hs; ++i) {
             double real = magIn[i] * cos(phaseIn[i]);
             double imag = magIn[i] * sin(phaseIn[i]);
@@ -599 +996 @@
     }
 
-    void inverse(float *realIn, float *imagIn, float *realOut) {
-        for (unsigned int i = 0; i <= m_size/2; ++i) {
+    void inverseCepstral(const double *R__ magIn, double *R__ cepOut) {
+        const int hs = m_size/2;
+        for (int i = 0; i <= hs; ++i) {
+            double real = log(magIn[i] + 0.000001);
+            m_a[i] = real;
+            m_b[i] = 0.0;
+            if (i > 0) {
+                m_a[m_size-i] = real;
+                m_b[m_size-i] = 0.0;
+            }
+        }
+        basefft(true, m_a, m_b, cepOut, m_d);
+    }
+
+    void inverse(const float *R__ realIn, const float *R__ imagIn, float *R__ realOut) {
+        const int hs = m_size/2;
+        for (int i = 0; i <= hs; ++i) {
             float real = realIn[i];
             float imag = imagIn[i];
@@ -611 +1023 @@
         }
         basefft(true, m_a, m_b, m_c, m_d);
-        for (unsigned int i = 0; i < m_size; ++i) realOut[i] = m_c[i];
-    }
-
-    void inversePolar(float *magIn, float *phaseIn, float *realOut) {
-        for (unsigned int i = 0; i <= m_size/2; ++i) {
+        for (int i = 0; i < m_size; ++i) realOut[i] = m_c[i];
+    }
+
+    void inversePolar(const float *R__ magIn, const float *R__ phaseIn, float *R__ realOut) {
+        const int hs = m_size/2;
+        for (int i = 0; i <= hs; ++i) {
             float real = magIn[i] * cosf(phaseIn[i]);
             float imag = magIn[i] * sinf(phaseIn[i]);
@@ -626 +1039 @@
         }
         basefft(true, m_a, m_b, m_c, m_d);
-        for (unsigned int i = 0; i < m_size; ++i) realOut[i] = m_c[i];
+        for (int i = 0; i < m_size; ++i) realOut[i] = m_c[i];
+    }
+
+    void inverseCepstral(const float *R__ magIn, float *R__ cepOut) {
+        const int hs = m_size/2;
+        for (int i = 0; i <= hs; ++i) {
+            float real = logf(magIn[i] + 0.000001);
+            m_a[i] = real;
+            m_b[i] = 0.0;
+            if (i > 0) {
+                m_a[m_size-i] = real;
+                m_b[m_size-i] = 0.0;
+            }
+        }
+        basefft(true, m_a, m_b, m_c, m_d);
+        for (int i = 0; i < m_size; ++i) cepOut[i] = m_c[i];
     }
 
@@ -640 +1068 @@
 
 private:
-    unsigned int m_size;
+    const int m_size;
     int *m_table;
     float *m_frb;
@@ -648 +1076 @@
     double *m_c;
     double *m_d;
-    void basefft(bool inverse, double *ri, double *ii, double *ro, double *io);
+    void basefft(bool inverse, const double *R__ ri, const double *R__ ii, double *R__ ro, double *R__ io);
 };
 
 void
-D_Cross::basefft(bool inverse, double *ri, double *ii, double *ro, double *io)
+D_Cross::basefft(bool inverse, const double *R__ ri, const double *R__ ii, double *R__ ro, double *R__ io)
 {
     if (!ri || !ro || !io) return;
 
-    unsigned int i, j, k, m;
-    unsigned int blockSize, blockEnd;
+    int i, j, k, m;
+    int blockSize, blockEnd;
 
     double tr, ti;
@@ -664 +1092 @@
     if (inverse) angle = -angle;
 
-    const unsigned int n = m_size;
+    const int n = m_size;
 
     if (ii) {
         for (i = 0; i < n; ++i) {
             ro[m_table[i]] = ri[i];
+        }
+        for (i = 0; i < n; ++i) {
             io[m_table[i]] = ii[i];
         }
@@ -674 +1104 @@
         for (i = 0; i < n; ++i) {
             ro[m_table[i]] = ri[i];
+        }
+        for (i = 0; i < n; ++i) {
             io[m_table[i]] = 0.0;
         }
@@ -737 +1169 @@
 }
 
+#endif /* USE_BUILTIN_FFT */
+
+} /* end namespace FFTs */
+
 int
 FFT::m_method = -1;
 
-FFT::FFT(unsigned int size)
-{
-    if (size < 2) throw InvalidSize;
-    if (size & (size-1)) throw InvalidSize;
+FFT::FFT(int size, int debugLevel)
+{
+    if ((size < 2) ||
+        (size & (size-1))) {
+        std::cerr << "FFT::FFT(" << size << "): power-of-two sizes only supported, minimum size 2" << std::endl;
+        throw InvalidSize;
+    }
 
     if (m_method == -1) {
+        m_method = 3;
+#ifdef USE_KISSFFT
+        m_method = 2;
+#endif
+#ifdef HAVE_FFTW3
         m_method = 1;
+#endif
     }
 
@@ -752 +1197 @@
 
     case 0:
-        d = new D_Cross(size);
+        std::cerr << "FFT::FFT(" << size << "): WARNING: Selected implemention not available" << std::endl;
+#ifdef USE_BUILTIN_FFT
+        d = new FFTs::D_Cross(size);
+#else
+        std::cerr << "FFT::FFT(" << size << "): ERROR: Fallback implementation not available!" << std::endl;
+        abort();
+#endif
         break;
 
     case 1:
-//        std::cerr << "FFT::FFT(" << size << "): using FFTW3 implementation"
-//                  << std::endl;
-        d = new D_FFTW(size);
+#ifdef HAVE_FFTW3
+        if (debugLevel > 0) {
+            std::cerr << "FFT::FFT(" << size << "): using FFTW3 implementation"
+                      << std::endl;
+        }
+        d = new FFTs::D_FFTW(size);
+#else
+        std::cerr << "FFT::FFT(" << size << "): WARNING: Selected implemention not available" << std::endl;
+#ifdef USE_BUILTIN_FFT
+        d = new FFTs::D_Cross(size);
+#else
+        std::cerr << "FFT::FFT(" << size << "): ERROR: Fallback implementation not available!" << std::endl;
+        abort();
+#endif
+#endif
         break;
 
+    case 2:
+#ifdef USE_KISSFFT
+        if (debugLevel > 0) {
+            std::cerr << "FFT::FFT(" << size << "): using KISSFFT implementation"
+                      << std::endl;
+        }
+        d = new FFTs::D_KISSFFT(size);
+#else
+        std::cerr << "FFT::FFT(" << size << "): WARNING: Selected implemention not available" << std::endl;
+#ifdef USE_BUILTIN_FFT
+        d = new FFTs::D_Cross(size);
+#else
+        std::cerr << "FFT::FFT(" << size << "): ERROR: Fallback implementation not available!" << std::endl;
+        abort();
+#endif
+#endif
+        break;
+
     default:
-        std::cerr << "FFT::FFT(" << size << "): WARNING: using slow built-in implementation"
-                  << std::endl;
-        d = new D_Cross(size);
+#ifdef USE_BUILTIN_FFT
+        std::cerr << "FFT::FFT(" << size << "): WARNING: using slow built-in implementation" << std::endl;
+        d = new FFTs::D_Cross(size);
+#else
+        std::cerr << "FFT::FFT(" << size << "): ERROR: Fallback implementation not available!" << std::endl;
+        abort();
+#endif
         break;
     }
@@ -775 +1260 @@
 
 void
-FFT::forward(double *realIn, double *realOut, double *imagOut)
+FFT::forward(const double *R__ realIn, double *R__ realOut, double *R__ imagOut)
 {
     d->forward(realIn, realOut, imagOut);
@@ -781 +1266 @@
 
 void
-FFT::forwardPolar(double *realIn, double *magOut, double *phaseOut)
+FFT::forwardPolar(const double *R__ realIn, double *R__ magOut, double *R__ phaseOut)
 {
     d->forwardPolar(realIn, magOut, phaseOut);
@@ -787 +1272 @@
 
 void
-FFT::forwardMagnitude(double *realIn, double *magOut)
+FFT::forwardMagnitude(const double *R__ realIn, double *R__ magOut)
 {
     d->forwardMagnitude(realIn, magOut);
@@ -793 +1278 @@
 
 void
-FFT::forward(float *realIn, float *realOut, float *imagOut)
+FFT::forward(const float *R__ realIn, float *R__ realOut, float *R__ imagOut)
 {
     d->forward(realIn, realOut, imagOut);
@@ -799 +1284 @@
 
 void
-FFT::forwardPolar(float *realIn, float *magOut, float *phaseOut)
+FFT::forwardPolar(const float *R__ realIn, float *R__ magOut, float *R__ phaseOut)
 {
     d->forwardPolar(realIn, magOut, phaseOut);
@@ -805 +1290 @@
 
 void
-FFT::forwardMagnitude(float *realIn, float *magOut)
+FFT::forwardMagnitude(const float *R__ realIn, float *R__ magOut)
 {
     d->forwardMagnitude(realIn, magOut);
@@ -811 +1296 @@
 
 void
-FFT::inverse(double *realIn, double *imagIn, double *realOut)
+FFT::inverse(const double *R__ realIn, const double *R__ imagIn, double *R__ realOut)
 {
     d->inverse(realIn, imagIn, realOut);
@@ -817 +1302 @@
 
 void
-FFT::inversePolar(double *magIn, double *phaseIn, double *realOut)
+FFT::inversePolar(const double *R__ magIn, const double *R__ phaseIn, double *R__ realOut)
 {
     d->inversePolar(magIn, phaseIn, realOut);
@@ -823 +1308 @@
 
 void
-FFT::inverse(float *realIn, float *imagIn, float *realOut)
+FFT::inverseCepstral(const double *R__ magIn, double *R__ cepOut)
+{
+    d->inverseCepstral(magIn, cepOut);
+}
+
+void
+FFT::inverse(const float *R__ realIn, const float *R__ imagIn, float *R__ realOut)
 {
     d->inverse(realIn, imagIn, realOut);
@@ -829 +1320 @@
 
 void
-FFT::inversePolar(float *magIn, float *phaseIn, float *realOut)
+FFT::inversePolar(const float *R__ magIn, const float *R__ phaseIn, float *R__ realOut)
 {
     d->inversePolar(magIn, phaseIn, realOut);
+}
+
+void
+FFT::inverseCepstral(const float *R__ magIn, float *R__ cepOut)
+{
+    d->inverseCepstral(magIn, cepOut);
 }
 

trunk/rubberband/src/FFT.h

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -15 +15 @@
 #ifndef _RUBBERBAND_FFT_H_
 #define _RUBBERBAND_FFT_H_
+
+#include "sysutils.h"
 
 namespace RubberBand {
@@ -37 +39 @@
     enum Exception { InvalidSize };
 
-    FFT(unsigned int size); // may throw InvalidSize
+    FFT(int size, int debugLevel = 0); // may throw InvalidSize
     ~FFT();
 
-    void forward(double *realIn, double *realOut, double *imagOut);
-    void forwardPolar(double *realIn, double *magOut, double *phaseOut);
-    void forwardMagnitude(double *realIn, double *magOut);
+    void forward(const double *R__ realIn, double *R__ realOut, double *R__ imagOut);
+    void forwardPolar(const double *R__ realIn, double *R__ magOut, double *R__ phaseOut);
+    void forwardMagnitude(const double *R__ realIn, double *R__ magOut);
 
-    void forward(float *realIn, float *realOut, float *imagOut);
-    void forwardPolar(float *realIn, float *magOut, float *phaseOut);
-    void forwardMagnitude(float *realIn, float *magOut);
+    void forward(const float *R__ realIn, float *R__ realOut, float *R__ imagOut);
+    void forwardPolar(const float *R__ realIn, float *R__ magOut, float *R__ phaseOut);
+    void forwardMagnitude(const float *R__ realIn, float *R__ magOut);
 
-    void inverse(double *realIn, double *imagIn, double *realOut);
-    void inversePolar(double *magIn, double *phaseIn, double *realOut);
+    void inverse(const double *R__ realIn, const double *R__ imagIn, double *R__ realOut);
+    void inversePolar(const double *R__ magIn, const double *R__ phaseIn, double *R__ realOut);
+    void inverseCepstral(const double *R__ magIn, double *R__ cepOut);
 
-    void inverse(float *realIn, float *imagIn, float *realOut);
-    void inversePolar(float *magIn, float *phaseIn, float *realOut);
+    void inverse(const float *R__ realIn, const float *R__ imagIn, float *R__ realOut);
+    void inversePolar(const float *R__ magIn, const float *R__ phaseIn, float *R__ realOut);
+    void inverseCepstral(const float *R__ magIn, float *R__ cepOut);
 
     // Calling one or both of these is optional -- if neither is

trunk/rubberband/src/HighFrequencyAudioCurve.cpp

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -39 +39 @@
 
 float
-HighFrequencyAudioCurve::process(float *mag, size_t increment)
+HighFrequencyAudioCurve::process(const float *R__ mag, size_t increment)
 {
     float result = 0.0;
 
-    for (size_t n = 0; n <= m_windowSize / 2; ++n) {
-        result += mag[n] * n;
+    const int sz = m_windowSize / 2;
+
+    for (int n = 0; n <= sz; ++n) {
+        result = result + mag[n] * n;
     }
 

trunk/rubberband/src/HighFrequencyAudioCurve.h

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -31 +31 @@
     virtual void setWindowSize(size_t newSize);
 
-    virtual float process(float *mag, size_t increment);
+    virtual float process(const float *R__ mag, size_t increment);
     virtual void reset();
 };

trunk/rubberband/src/Makefile.am

@@ -1 @@
-AM_CPPFLAGS= -DFFTW_DOUBLE_ONLY $(SRC_CFLAGS) $(FFTW_CFLAGS) $(OPTFLAGS) -I$(srcdir)/../include
+AM_CPPFLAGS= -DHAVE_FFTW3 -DFFTW_DOUBLE_ONLY $(SRC_CFLAGS) $(FFTW_CFLAGS) $(OPTFLAGS) -I$(srcdir)/../include
 
 
@@ -9 +9 @@
 
 librubberband_la_SOURCES = \
+        AudioCurve.cpp \
         AudioCurve.h \
+        ConstantAudioCurve.cpp \
         ConstantAudioCurve.h \
+        FFT.cpp \
         FFT.h \
+        HighFrequencyAudioCurve.cpp \
         HighFrequencyAudioCurve.h \
+        PercussiveAudioCurve.cpp \
         PercussiveAudioCurve.h \
+        HighFrequencyAudioCurve.h \
+        Profiler.cpp \
+        Profiler.h \
+        Resampler.cpp \
         Resampler.h \
         RingBuffer.h \
+        rubberband-c.cpp \
+        RubberBandStretcher.cpp \
         Scavenger.h \
+        SilentAudioCurve.cpp \
+        SilentAudioCurve.h \
+        SpectralDifferenceAudioCurve.cpp \
         SpectralDifferenceAudioCurve.h \
+        StretchCalculator.cpp \
         StretchCalculator.h \
+        StretcherChannelData.h \
+        StretcherImpl.cpp \
         StretcherImpl.h \
-        StretcherChannelData.h \
-        Thread.h \
-        Window.h \
-        sysutils.h \
-        RubberBandStretcher.cpp \
-        ConstantAudioCurve.cpp \
-        HighFrequencyAudioCurve.cpp \
-        PercussiveAudioCurve.cpp \
-        AudioCurve.cpp \
-        Resampler.cpp \
-        SpectralDifferenceAudioCurve.cpp \
-        StretchCalculator.cpp \
-        StretcherImpl.cpp \
         StretcherProcess.cpp \
         StretcherChannelData.cpp \
-        FFT.cpp \
         Thread.cpp \
-        sysutils.cpp
+        Thread.h \
+        Window.cpp \
+        Window.h \
+        sysutils.cpp \
+        sysutils.h
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

trunk/rubberband/src/Makefile.in

@@ -51 +51 @@
 LTLIBRARIES = $(lib_LTLIBRARIES)
 librubberband_la_LIBADD =
-am_librubberband_la_OBJECTS = RubberBandStretcher.lo \
-        ConstantAudioCurve.lo HighFrequencyAudioCurve.lo \
-        PercussiveAudioCurve.lo AudioCurve.lo Resampler.lo \
+am_librubberband_la_OBJECTS = AudioCurve.lo ConstantAudioCurve.lo \
+        FFT.lo HighFrequencyAudioCurve.lo PercussiveAudioCurve.lo \
+        Profiler.lo Resampler.lo rubberband-c.lo \
+        RubberBandStretcher.lo SilentAudioCurve.lo \
         SpectralDifferenceAudioCurve.lo StretchCalculator.lo \
         StretcherImpl.lo StretcherProcess.lo StretcherChannelData.lo \
-        FFT.lo Thread.lo sysutils.lo
+        Thread.lo Window.lo sysutils.lo
 librubberband_la_OBJECTS = $(am_librubberband_la_OBJECTS)
 librubberband_la_LINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) \
@@ -200 +201 @@
 top_builddir = @top_builddir@
 top_srcdir = @top_srcdir@
-AM_CPPFLAGS = -DFFTW_DOUBLE_ONLY $(SRC_CFLAGS) $(FFTW_CFLAGS) $(OPTFLAGS) -I$(srcdir)/../include
+AM_CPPFLAGS = -DHAVE_FFTW3 -DFFTW_DOUBLE_ONLY $(SRC_CFLAGS) $(FFTW_CFLAGS) $(OPTFLAGS) -I$(srcdir)/../include
 lib_LTLIBRARIES = librubberband.la
 librubberband_la_LDFLAGS = -lpthread
 librubberband_la_SOURCES = \
+        AudioCurve.cpp \
         AudioCurve.h \
+        ConstantAudioCurve.cpp \
         ConstantAudioCurve.h \
+        FFT.cpp \
         FFT.h \
+        HighFrequencyAudioCurve.cpp \
         HighFrequencyAudioCurve.h \
+        PercussiveAudioCurve.cpp \
         PercussiveAudioCurve.h \
+        HighFrequencyAudioCurve.h \
+        Profiler.cpp \
+        Profiler.h \
+        Resampler.cpp \
         Resampler.h \
         RingBuffer.h \
+        rubberband-c.cpp \
+        RubberBandStretcher.cpp \
         Scavenger.h \
+        SilentAudioCurve.cpp \
+        SilentAudioCurve.h \
+        SpectralDifferenceAudioCurve.cpp \
         SpectralDifferenceAudioCurve.h \
+        StretchCalculator.cpp \
         StretchCalculator.h \
+        StretcherChannelData.h \
+        StretcherImpl.cpp \
         StretcherImpl.h \
-        StretcherChannelData.h \
-        Thread.h \
-        Window.h \
-        sysutils.h \
-        RubberBandStretcher.cpp \
-        ConstantAudioCurve.cpp \
-        HighFrequencyAudioCurve.cpp \
-        PercussiveAudioCurve.cpp \
-        AudioCurve.cpp \
-        Resampler.cpp \
-        SpectralDifferenceAudioCurve.cpp \
-        StretchCalculator.cpp \
-        StretcherImpl.cpp \
         StretcherProcess.cpp \
         StretcherChannelData.cpp \
-        FFT.cpp \
         Thread.cpp \
-        sysutils.cpp
+        Thread.h \
+        Window.cpp \
+        Window.h \
+        sysutils.cpp \
+        sysutils.h
 
 all: all-am
@@ -308 +316 @@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/HighFrequencyAudioCurve.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/PercussiveAudioCurve.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Profiler.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Resampler.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/RubberBandStretcher.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SilentAudioCurve.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SpectralDifferenceAudioCurve.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/StretchCalculator.Plo@am__quote@
@@ -316 +326 @@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/StretcherProcess.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Thread.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Window.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rubberband-c.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sysutils.Plo@am__quote@
 

trunk/rubberband/src/PercussiveAudioCurve.cpp

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -15 +15 @@
 #include "PercussiveAudioCurve.h"
 
+#include "Profiler.h"
+
 #include <cmath>
+
 
 namespace RubberBand
@@ -23 +26 @@
     AudioCurve(sampleRate, windowSize)
 {
-    m_prevMag = new double[m_windowSize/2 + 1];
+    m_prevMag = new float[m_windowSize/2 + 1];
 
     for (size_t i = 0; i <= m_windowSize/2; ++i) {
@@ -46 +49 @@
 PercussiveAudioCurve::setWindowSize(size_t newSize)
 {
+    m_windowSize = newSize;
+
     delete[] m_prevMag;
-    m_windowSize = newSize;
-    
-    m_prevMag = new double[m_windowSize/2 + 1];
+    m_prevMag = new float[m_windowSize/2 + 1];
 
     reset();
@@ -55 +58 @@
 
 float
-PercussiveAudioCurve::process(float *mag, size_t increment)
+PercussiveAudioCurve::process(const float *R__ mag, size_t increment)
 {
-    static float threshold = pow(10, 0.3);
-    static float zeroThresh = pow(10, -16);
+    static float threshold = powf(10.f, 0.15f); // 3dB rise in square of magnitude
+    static float zeroThresh = powf(10.f, -8);
 
     size_t count = 0;
     size_t nonZeroCount = 0;
 
-    for (size_t n = 1; n <= m_windowSize / 2; ++n) {
-        float sqrmag = mag[n] * mag[n];
-        bool above = ((sqrmag / m_prevMag[n]) >= threshold);
+    const int sz = m_windowSize / 2;
+
+    for (int n = 1; n <= sz; ++n) {
+        bool above = ((mag[n] / m_prevMag[n]) >= threshold);
         if (above) ++count;
-        if (sqrmag > zeroThresh) ++nonZeroCount;
-        m_prevMag[n] = sqrmag;
+        if (mag[n] > zeroThresh) ++nonZeroCount;
+    }
+
+    for (int n = 1; n <= sz; ++n) {
+        m_prevMag[n] = mag[n];
+    }
+
+    if (nonZeroCount == 0) return 0;
+    else return float(count) / float(nonZeroCount);
+}
+
+float
+PercussiveAudioCurve::process(const double *R__ mag, size_t increment)
+{
+    Profiler profiler("PercussiveAudioCurve::process");
+
+    static double threshold = pow(10.0, 0.15); // 3dB rise in square of magnitude
+    static double zeroThresh = pow(10.0, -8);
+
+    size_t count = 0;
+    size_t nonZeroCount = 0;
+
+    const int sz = m_windowSize / 2;
+
+    for (int n = 1; n <= sz; ++n) {
+        bool above = ((mag[n] / m_prevMag[n]) >= threshold);
+        if (above) ++count;
+        if (mag[n] > zeroThresh) ++nonZeroCount;
+    }
+
+    for (int n = 1; n <= sz; ++n) {
+        m_prevMag[n] = mag[n];
     }
 

trunk/rubberband/src/PercussiveAudioCurve.h

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -30 +30 @@
     virtual void setWindowSize(size_t newSize);
 
-    virtual float process(float *mag, size_t increment);
+    virtual float process(const float *R__ mag, size_t increment);
+    virtual float process(const double *R__ mag, size_t increment);
     virtual void reset();
 
 protected:
-    double *m_prevMag;
+    float *R__ m_prevMag;
 };
 

trunk/rubberband/src/Resampler.cpp

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -15 +15 @@
 #include "Resampler.h"
 
+#include "Profiler.h"
+
 #include <cstdlib>
 #include <cmath>
@@ -23 +25 @@
 #include <samplerate.h>
 
+
+
 namespace RubberBand {
 
-class Resampler::D
+class ResamplerImpl
 {
 public:
-    D(Quality quality, size_t channels, size_t maxBufferSize);
-    ~D();
-
-    size_t resample(float **in, float **out,
-                    size_t incount, float ratio, bool final);
+    virtual ~ResamplerImpl() { }
+    
+    virtual int resample(const float *const R__ *const R__ in, 
+                         float *const R__ *const R__ out,
+                         int incount,
+                         float ratio,
+                         bool final) = 0;
+
+    virtual void reset() = 0;
+};
+
+namespace Resamplers {
+
+
+
+class D_SRC : public ResamplerImpl
+{
+public:
+    D_SRC(Resampler::Quality quality, int channels, int maxBufferSize,
+          int m_debugLevel);
+    ~D_SRC();
+
+    int resample(const float *const R__ *const R__ in,
+                 float *const R__ *const R__ out,
+                 int incount,
+                 float ratio,
+                 bool final);
 
     void reset();
@@ -40 +66 @@
     float *m_iin;
     float *m_iout;
-    size_t m_channels;
-    size_t m_iinsize;
-    size_t m_ioutsize;
+    float m_lastRatio;
+    int m_channels;
+    int m_iinsize;
+    int m_ioutsize;
+    int m_debugLevel;
 };
 
-Resampler::D::D(Quality quality, size_t channels, size_t maxBufferSize) :
+D_SRC::D_SRC(Resampler::Quality quality, int channels, int maxBufferSize,
+             int debugLevel) :
     m_src(0),
     m_iin(0),
     m_iout(0),
+    m_lastRatio(1.f),
     m_channels(channels),
     m_iinsize(0),
-    m_ioutsize(0)
-{
-//    std::cerr << "Resampler::Resampler: using libsamplerate implementation"
-//              << std::endl;
+    m_ioutsize(0),
+    m_debugLevel(debugLevel)
+{
+    if (m_debugLevel > 0) {
+        std::cerr << "Resampler::Resampler: using libsamplerate implementation"
+                  << std::endl;
+    }
 
     int err = 0;
-    m_src = src_new(quality == Best ? SRC_SINC_BEST_QUALITY :
-                    quality == Fastest ? SRC_LINEAR :
+    m_src = src_new(quality == Resampler::Best ? SRC_SINC_BEST_QUALITY :
+                    quality == Resampler::Fastest ? SRC_LINEAR :
                     SRC_SINC_FASTEST,
                     channels, &err);
 
-    //!!! check err, throw
+    if (err) {
+        std::cerr << "Resampler::Resampler: failed to create libsamplerate resampler: " 
+                  << src_strerror(err) << std::endl;
+        throw Resampler::ImplementationError; //!!! of course, need to catch this!
+    }
 
     if (maxBufferSize > 0 && m_channels > 1) {
-        //!!! alignment?
         m_iinsize = maxBufferSize * m_channels;
         m_ioutsize = maxBufferSize * m_channels * 2;
-        m_iin = (float *)malloc(m_iinsize * sizeof(float));
-        m_iout = (float *)malloc(m_ioutsize * sizeof(float));
-    }
-}
-
-Resampler::D::~D()
+        m_iin = allocFloat(m_iinsize);
+        m_iout = allocFloat(m_ioutsize);
+    }
+
+    reset();
+}
+
+D_SRC::~D_SRC()
 {
     src_delete(m_src);
@@ -84 +122 @@
 }
 
-size_t
-Resampler::D::resample(float **in, float **out, size_t incount, float ratio,
-                       bool final)
+int
+D_SRC::resample(const float *const R__ *const R__ in,
+                float *const R__ *const R__ out,
+                int incount,
+                float ratio,
+                bool final)
 {
     SRC_DATA data;
 
-    size_t outcount = lrintf(ceilf(incount * ratio));
+    int outcount = lrintf(ceilf(incount * ratio));
 
     if (m_channels == 1) {
-        data.data_in = *in;
+        data.data_in = const_cast<float *>(*in); //!!!???
         data.data_out = *out;
     } else {
         if (incount * m_channels > m_iinsize) {
-            m_iinsize = incount * m_channels;
-            m_iin = (float *)realloc(m_iin, m_iinsize * sizeof(float));
+            m_iin = allocFloat(m_iin, m_iinsize);
         }
         if (outcount * m_channels > m_ioutsize) {
-            m_ioutsize = outcount * m_channels;
-            m_iout = (float *)realloc(m_iout, m_ioutsize * sizeof(float));
-        }
-        for (size_t i = 0; i < incount; ++i) {
-            for (size_t c = 0; c < m_channels; ++c) {
+            m_iout = allocFloat(m_iout, m_ioutsize);
+        }
+        for (int i = 0; i < incount; ++i) {
+            for (int c = 0; c < m_channels; ++c) {
                 m_iin[i * m_channels + c] = in[c][i];
             }
@@ -118 +157 @@
     data.end_of_input = (final ? 1 : 0);
 
-    src_process(m_src, &data);
-
-    //!!! check err, respond appropriately
+    int err = src_process(m_src, &data);
+
+    if (err) {
+        std::cerr << "Resampler::process: libsamplerate error: "
+                  << src_strerror(err) << std::endl;
+        throw Resampler::ImplementationError; //!!! of course, need to catch this!
+    }
 
     if (m_channels > 1) {
         for (int i = 0; i < data.output_frames_gen; ++i) {
-            for (size_t c = 0; c < m_channels; ++c) {
+            for (int c = 0; c < m_channels; ++c) {
                 out[c][i] = m_iout[i * m_channels + c];
             }
@@ -130 +173 @@
     }
 
+    m_lastRatio = ratio;
+
     return data.output_frames_gen;
 }
 
 void
-Resampler::D::reset()
+D_SRC::reset()
 {
     src_reset(m_src);
 }
 
-} // end namespace
-
-
-namespace RubberBand {
-
-Resampler::Resampler(Quality quality, size_t channels, size_t maxBufferSize)
-{
-    m_d = new D(quality, channels, maxBufferSize);
+
+
+} /* end namespace Resamplers */
+
+Resampler::Resampler(Resampler::Quality quality, int channels,
+                     int maxBufferSize, int debugLevel)
+{
+    m_method = -1;
+    
+    switch (quality) {
+
+    case Resampler::Best:
+        m_method = 1;
+        break;
+
+    case Resampler::FastestTolerable:
+        m_method = 1;
+        break;
+
+    case Resampler::Fastest:
+        m_method = 1;
+        break;
+    }
+
+    if (m_method == -1) {
+        std::cerr << "Resampler::Resampler(" << quality << ", " << channels
+                  << ", " << maxBufferSize << "): No implementation available!"
+                  << std::endl;
+        abort();
+    }
+
+    switch (m_method) {
+    case 0:
+        std::cerr << "Resampler::Resampler(" << quality << ", " << channels
+                  << ", " << maxBufferSize << "): No implementation available!"
+                  << std::endl;
+        abort();
+        break;
+
+    case 1:
+        d = new Resamplers::D_SRC(quality, channels, maxBufferSize, debugLevel);
+        break;
+
+    case 2:
+        std::cerr << "Resampler::Resampler(" << quality << ", " << channels
+                  << ", " << maxBufferSize << "): No implementation available!"
+                  << std::endl;
+        abort();
+        break;
+    }
 }
 
 Resampler::~Resampler()
 {
-    delete m_d;
-}
-
-size_t 
-Resampler::resample(float **in, float **out,
-                    size_t incount, float ratio, bool final)
-{
-    return m_d->resample(in, out, incount, ratio, final);
+    delete d;
+}
+
+int 
+Resampler::resample(const float *const R__ *const R__ in,
+                    float *const R__ *const R__ out,
+                    int incount, float ratio, bool final)
+{
+    Profiler profiler("Resampler::resample");
+    return d->resample(in, out, incount, ratio, final);
 }
 
@@ -164 +253 @@
 Resampler::reset()
 {
-    m_d->reset();
-}
-
-}
+    d->reset();
+}
+
+}

trunk/rubberband/src/Resampler.h

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -18 +18 @@
 #include <sys/types.h>
 
+#include "sysutils.h"
+
 namespace RubberBand {
+
+class ResamplerImpl;
 
 class Resampler
@@ -24 +28 @@
 public:
     enum Quality { Best, FastestTolerable, Fastest };
+    enum Exception { ImplementationError };
 
     /**
@@ -31 +36 @@
      * resampler needs to reallocate its internal buffers.
      */
-    Resampler(Quality quality, size_t channels, size_t maxBufferSize = 0);
+    Resampler(Quality quality, int channels, int maxBufferSize = 0,
+              int debugLevel = 0);
     ~Resampler();
 
-    size_t resample(float **in, float **out,
-                    size_t incount, float ratio, bool final = false);
+    int resample(const float *const R__ *const R__ in,
+                 float *const R__ *const R__ out,
+                 int incount,
+                 float ratio,
+                 bool final = false);
 
     void reset();
 
 protected:
-    class D;
-    D *m_d;
+    ResamplerImpl *d;
+    int m_method;
 };
 

trunk/rubberband/src/RingBuffer.h

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -18 +18 @@
 #include <sys/types.h>
 
+#include <cstring>
+
 #ifndef _WIN32
 #include <sys/mman.h>
@@ -23 +25 @@
 
 #include "Scavenger.h"
+#include "Profiler.h"
+
 
 //#define DEBUG_RINGBUFFER 1
@@ -58 +62 @@
      * minus one.
      */
-    RingBuffer(size_t n);
+    RingBuffer(int n);
 
     virtual ~RingBuffer();
@@ -66 +70 @@
      * (This is the argument n passed to the constructor.)
      */
-    size_t getSize() const;
+    int getSize() const;
 
     /**
@@ -74 +78 @@
      * delay.  Should be called from the write thread.
      */
-    void resize(size_t newSize);
+    void resize(int newSize);
 
     /**
@@ -84 +88 @@
      * size, the contents are undefined.
      */
-    RingBuffer<T, N> *resized(size_t newSize, int R = 0) const;
+    RingBuffer<T, N> *resized(int newSize, int R = 0) const;
 
     /**
@@ -102 +106 @@
      * samples.
      */
-    size_t getReadSpace(int R = 0) const;
+    int getReadSpace(int R = 0) const;
 
     /**
      * Return the amount of space available for writing, in samples.
      */
-    size_t getWriteSpace() const;
+    int getWriteSpace() const;
 
     /**
@@ -114 +118 @@
      * number of samples actually read.
      */
-    size_t read(T *destination, size_t n, int R = 0);
+    int read(T *R__ destination, int n, int R = 0);
 
     /**
@@ -122 +126 @@
      * read.
      */
-    size_t readAdding(T *destination, size_t n, int R = 0);
+    int readAdding(T *R__ destination, int n, int R = 0);
 
     /**
@@ -140 +144 @@
      * number of samples actually read.
      */
-    size_t peek(T *destination, size_t n, int R = 0) const;
+    int peek(T *R__ destination, int n, int R = 0) const;
 
     /**
@@ -156 +160 @@
      * discarding.
      */
-    size_t skip(size_t n, int R = 0);
+    int skip(int n, int R = 0);
 
     /**
@@ -163 +167 @@
      * the number of samples actually written.
      */
-    size_t write(const T *source, size_t n);
+    int write(const T *source, int n);
 
     /**
@@ -170 +174 @@
      * Returns the number of zeroes actually written.
      */
-    size_t zero(size_t n);
+    int zero(int n);
 
 protected:
-    T               *m_buffer;
-    volatile size_t  m_writer;
-    volatile size_t  m_readers[N];
-    size_t           m_size;
+    T *R__      m_buffer;
+    volatile int     m_writer;
+    volatile int     m_readers[N];
+    int              m_size;
     bool             m_mlocked;
 
@@ -190 +194 @@
 
 template <typename T, int N>
-RingBuffer<T, N>::RingBuffer(size_t n) :
+RingBuffer<T, N>::RingBuffer(int n) :
     m_buffer(new T[n + 1]),
     m_writer(0),
@@ -221 +225 @@
 
 template <typename T, int N>
-size_t
+int
 RingBuffer<T, N>::getSize() const
 {
@@ -233 +237 @@
 template <typename T, int N>
 void
-RingBuffer<T, N>::resize(size_t newSize)
+RingBuffer<T, N>::resize(int newSize)
 {
 #ifdef DEBUG_RINGBUFFER
@@ -260 +264 @@
 template <typename T, int N>
 RingBuffer<T, N> *
-RingBuffer<T, N>::resized(size_t newSize, int R) const
+RingBuffer<T, N>::resized(int newSize, int R) const
 {
     RingBuffer<T, N> *newBuffer = new RingBuffer<T, N>(newSize);
 
-    size_t w = m_writer;
-    size_t r = m_readers[R];
+    int w = m_writer;
+    int r = m_readers[R];
 
     while (r != w) {
@@ -298 +302 @@
 
 template <typename T, int N>
-size_t
+int
 RingBuffer<T, N>::getReadSpace(int R) const
 {
-    size_t writer = m_writer;
-    size_t reader = m_readers[R];
-    size_t space;
+    int writer = m_writer;
+    int reader = m_readers[R];
+    int space;
 
 #ifdef DEBUG_RINGBUFFER
@@ -321 +325 @@
 
 template <typename T, int N>
-size_t
+int
 RingBuffer<T, N>::getWriteSpace() const
 {
-    size_t space = 0;
+    int space = 0;
     for (int i = 0; i < N; ++i) {
-        size_t writer = m_writer;
-        size_t reader = m_readers[i];
-        size_t here = (reader + m_size - writer - 1);
+        int writer = m_writer;
+        int reader = m_readers[i];
+        int here = (reader + m_size - writer - 1);
         if (here >= m_size) here -= m_size;
         if (i == 0 || here < space) space = here;
@@ -334 +338 @@
 
 #ifdef DEBUG_RINGBUFFER
-    size_t rs(getReadSpace()), rp(m_readers[0]);
+    int rs(getReadSpace()), rp(m_readers[0]);
 
     std::cerr << "RingBuffer: write space " << space << ", read space "
@@ -349 +353 @@
 
 template <typename T, int N>
-size_t
-RingBuffer<T, N>::read(T *destination, size_t n, int R)
-{
+int
+RingBuffer<T, N>::read(T *R__ destination, int n, int R)
+{
+    Profiler profiler("RingBuffer::read");
+
 #ifdef DEBUG_RINGBUFFER
     std::cerr << "RingBuffer<T," << N << ">[" << this << "]::read(dest, " << n << ", " << R << ")" << std::endl;
 #endif
 
-    size_t available = getReadSpace(R);
+    int available = getReadSpace(R);
     if (n > available) {
 #ifdef DEBUG_RINGBUFFER
@@ -362 +368 @@
                   << std::endl;
 #endif
-        for (size_t i = available; i < n; ++i) {
+        for (int i = available; i < n; ++i) {
             destination[i] = 0;
         }
@@ -369 +375 @@
     if (n == 0) return n;
 
-    size_t reader = m_readers[R];
-    size_t here = m_size - reader;
+    int reader = m_readers[R];
+    int here = m_size - reader;
+    T *const R__ bufbase = m_buffer + reader;
 
     if (here >= n) {
-        for (size_t i = 0; i < n; ++i) {
-            destination[i] = (m_buffer + reader)[i];
+        for (int i = 0; i < n; ++i) {
+            destination[i] = bufbase[i];
         }
     } else {
-        for (size_t i = 0; i < here; ++i) {
-            destination[i] = (m_buffer + reader)[i];
-        }
-        for (size_t i = 0; i < (n - here); ++i) {
-            destination[i + here] = m_buffer[i];
+        for (int i = 0; i < here; ++i) {
+            destination[i] = bufbase[i];
+        }
+        T *const R__ destbase = destination + here;
+        const int nh = n - here;
+        for (int i = 0; i < nh; ++i) {
+            destbase[i] = m_buffer[i];
         }
     }
@@ -397 +406 @@
 
 template <typename T, int N>
-size_t
-RingBuffer<T, N>::readAdding(T *destination, size_t n, int R)
-{
+int
+RingBuffer<T, N>::readAdding(T *R__ destination, int n, int R)
+{
+    Profiler profiler("RingBuffer::readAdding");
+
 #ifdef DEBUG_RINGBUFFER
     std::cerr << "RingBuffer<T," << N << ">[" << this << "]::readAdding(dest, " << n << ", " << R << ")" << std::endl;
 #endif
 
-    size_t available = getReadSpace(R);
+    int available = getReadSpace(R);
     if (n > available) {
 #ifdef DEBUG_RINGBUFFER
@@ -414 +425 @@
     if (n == 0) return n;
 
-    size_t reader = m_readers[R];
-    size_t here = m_size - reader;
+    int reader = m_readers[R];
+    int here = m_size - reader;
+    const T *const R__ bufbase = m_buffer + reader;
 
     if (here >= n) {
-        for (size_t i = 0; i < n; ++i) {
-            destination[i] += (m_buffer + reader)[i];
+        for (int i = 0; i < n; ++i) {
+            destination[i] += bufbase[i];
         }
     } else {
-        for (size_t i = 0; i < here; ++i) {
-            destination[i] += (m_buffer + reader)[i];
+        for (int i = 0; i < here; ++i) {
+            destination[i] += bufbase[i];
         }
-        for (size_t i = 0; i < (n - here); ++i) {
-            destination[i + here] += m_buffer[i];
+        T *const R__ destbase = destination + here;
+        const int nh = n - here;
+        for (int i = 0; i < nh; ++i) {
+            destbase[i] += m_buffer[i];
         }
     }
@@ -451 +465 @@
         return 0;
     }
-    size_t reader = m_readers[R];
+    int reader = m_readers[R];
     T value = m_buffer[reader];
     if (++reader == m_size) reader = 0;
@@ -459 +473 @@
 
 template <typename T, int N>
-size_t
-RingBuffer<T, N>::peek(T *destination, size_t n, int R) const
-{
+int
+RingBuffer<T, N>::peek(T *R__ destination, int n, int R) const
+{
+    Profiler profiler("RingBuffer::peek");
+
 #ifdef DEBUG_RINGBUFFER
     std::cerr << "RingBuffer<T," << N << ">[" << this << "]::peek(dest, " << n << ", " << R << ")" << std::endl;
 #endif
 
-    size_t available = getReadSpace(R);
+    int available = getReadSpace(R);
     if (n > available) {
 #ifdef DEBUG_RINGBUFFER
@@ -477 +493 @@
     if (n == 0) return n;
 
-    size_t reader = m_readers[R];
-    size_t here = m_size - reader;
+    int reader = m_readers[R];
+    int here = m_size - reader;
+    const T *const R__ bufbase = m_buffer + reader;
 
     if (here >= n) {
-        for (size_t i = 0; i < n; ++i) {
-            destination[i] = (m_buffer + reader)[i];
+        for (int i = 0; i < n; ++i) {
+            destination[i] = bufbase[i];
         }
     } else {
-        for (size_t i = 0; i < here; ++i) {
-            destination[i] = (m_buffer + reader)[i];
-        }
-        for (size_t i = 0; i < (n - here); ++i) {
-            destination[i + here] = m_buffer[i];
+        for (int i = 0; i < here; ++i) {
+            destination[i] = bufbase[i];
+        }
+        T *const R__ destbase = destination + here;
+        const int nh = n - here;
+        for (int i = 0; i < nh; ++i) {
+            destbase[i] = m_buffer[i];
         }
     }
@@ -520 +539 @@
 
 template <typename T, int N>
-size_t
-RingBuffer<T, N>::skip(size_t n, int R)
+int
+RingBuffer<T, N>::skip(int n, int R)
 {
 #ifdef DEBUG_RINGBUFFER
@@ -527 +546 @@
 #endif
 
-    size_t available = getReadSpace(R);
+    int available = getReadSpace(R);
     if (n > available) {
 #ifdef DEBUG_RINGBUFFER
@@ -537 +556 @@
     if (n == 0) return n;
 
-    size_t reader = m_readers[R];
+    int reader = m_readers[R];
     reader += n;
     while (reader >= m_size) reader -= m_size;
@@ -545 +564 @@
 
 template <typename T, int N>
-size_t
-RingBuffer<T, N>::write(const T *source, size_t n)
-{
+int
+RingBuffer<T, N>::write(const T *source, int n)
+{
+    Profiler profiler("RingBuffer::write");
+
 #ifdef DEBUG_RINGBUFFER
     std::cerr << "RingBuffer<T," << N << ">[" << this << "]::write(" << n << ")" << std::endl;
 #endif
 
-    size_t available = getWriteSpace();
+    int available = getWriteSpace();
     if (n > available) {
 #ifdef DEBUG_RINGBUFFER
@@ -562 +583 @@
     if (n == 0) return n;
 
-    size_t writer = m_writer;
-    size_t here = m_size - writer;
+    int writer = m_writer;
+    int here = m_size - writer;
+    T *const R__ bufbase = m_buffer + writer;
+
     if (here >= n) {
-        for (size_t i = 0; i < n; ++i) {
-            (m_buffer + writer)[i] = source[i];
+        for (int i = 0; i < n; ++i) {
+            bufbase[i] = source[i];
         }
     } else {
-        for (size_t i = 0; i < here; ++i) {
-            (m_buffer + writer)[i] = source[i];
-        }
-        for (size_t i = 0; i < (n - here); ++i) {
-            m_buffer[i] = (source + here)[i];
+        for (int i = 0; i < here; ++i) {
+            bufbase[i] = source[i];
+        }
+        const int nh = n - here;
+        const T *const R__ srcbase = source + here;
+        T *const R__ buf = m_buffer;
+        for (int i = 0; i < nh; ++i) {
+            buf[i] = srcbase[i];
         }
     }
@@ -589 +615 @@
 
 template <typename T, int N>
-size_t
-RingBuffer<T, N>::zero(size_t n)
-{
+int
+RingBuffer<T, N>::zero(int n)
+{
+    Profiler profiler("RingBuffer::zero");
+
 #ifdef DEBUG_RINGBUFFER
     std::cerr << "RingBuffer<T," << N << ">[" << this << "]::zero(" << n << ")" << std::endl;
 #endif
 
-    size_t available = getWriteSpace();
+    int available = getWriteSpace();
     if (n > available) {
 #ifdef DEBUG_RINGBUFFER
@@ -606 +634 @@
     if (n == 0) return n;
 
-    size_t writer = m_writer;
-    size_t here = m_size - writer;
+    int writer = m_writer;
+    int here = m_size - writer;
+    T *const R__ bufbase = m_buffer + writer;
+
     if (here >= n) {
-        for (size_t i = 0; i < n; ++i) {
-            (m_buffer + writer)[i] = 0;
+        for (int i = 0; i < n; ++i) {
+            bufbase[i] = 0;
         }
     } else {
-        for (size_t i = 0; i < here; ++i) {
-            (m_buffer + writer)[i] = 0;
-        }
-        for (size_t i = 0; i < (n - here); ++i) {
+        for (int i = 0; i < here; ++i) {
+            bufbase[i] = 0;
+        }
+        const int nh = n - here;
+        for (int i = 0; i < nh; ++i) {
             m_buffer[i] = 0;
         }
@@ -634 +665 @@
 }
 
+//#include "RingBuffer.cpp"
+
 #endif // _RINGBUFFER_H_

trunk/rubberband/src/RubberBandStretcher.cpp

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -23 +23 @@
                                          double initialTimeRatio,
                                          double initialPitchScale) :
-    TimeStretcher(sampleRate, channels),
-    m_d(new Impl(this, sampleRate, channels, options,
+    m_d(new Impl(sampleRate, channels, options,
                  initialTimeRatio, initialPitchScale))
 {
@@ -83 +82 @@
 
 void
+RubberBandStretcher::setFormantOption(Options options)
+{
+    m_d->setFormantOption(options);
+}
+
+void
+RubberBandStretcher::setPitchOption(Options options)
+{
+    m_d->setPitchOption(options);
+}
+
+void
 RubberBandStretcher::setExpectedInputDuration(size_t samples) 
 {

trunk/rubberband/src/Scavenger.h

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -18 +18 @@
 #include <vector>
 #include <list>
+#include <iostream>
+
+#ifndef WIN32
 #include <sys/time.h>
-#include <iostream>
+#endif
 
 #include "Thread.h"

trunk/rubberband/src/SilentAudioCurve.h

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -13 +13 @@
 */
 
-#ifndef _HIGHFREQUENCY_AUDIO_CURVE_H_
-#define _HIGHFREQUENCY_AUDIO_CURVE_H_
+#ifndef _SILENT_AUDIO_CURVE_H_
+#define _SILENT_AUDIO_CURVE_H_
 
 #include "AudioCurve.h"
-#include "Window.h"
 
 namespace RubberBand
 {
 
-class HighFrequencyAudioCurve : public AudioCurve
+class SilentAudioCurve : public AudioCurve
 {
 public:
-    HighFrequencyAudioCurve(size_t sampleRate, size_t windowSize);
-
-    virtual ~HighFrequencyAudioCurve();
+    SilentAudioCurve(size_t sampleRate, size_t windowSize);
+    virtual ~SilentAudioCurve();
 
     virtual void setWindowSize(size_t newSize);
 
-    virtual float process(float *mag, size_t increment);
+    virtual float process(const float *R__ mag, size_t increment);
+    virtual float process(const double *R__ mag, size_t increment);
     virtual void reset();
 };

trunk/rubberband/src/SpectralDifferenceAudioCurve.cpp

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -21 +21 @@
     AudioCurve(sampleRate, windowSize)
 {
-    m_prevMag = new double[m_windowSize/2 + 1];
+    m_prevMag = new float[m_windowSize/2 + 1];
 
     for (size_t i = 0; i <= m_windowSize/2; ++i) {
@@ -44 +44 @@
 SpectralDifferenceAudioCurve::setWindowSize(size_t newSize)
 {
+    delete[] m_prevMag;
     m_windowSize = newSize;
+    
+    m_prevMag = new float[m_windowSize/2 + 1];
+
+    reset();
 }
 
 float
-SpectralDifferenceAudioCurve::process(float *mag, size_t increment)
+SpectralDifferenceAudioCurve::process(const float *R__ mag, size_t increment)
 {
     float result = 0.0;

trunk/rubberband/src/SpectralDifferenceAudioCurve.h

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -31 +31 @@
     virtual void setWindowSize(size_t newSize);
 
-    virtual float process(float *mag, size_t increment);
+    virtual float process(const float *R__ mag, size_t increment);
     virtual void reset();
 
 protected:
-    double *m_prevMag;
+    float *R__ m_prevMag;
 };
 

trunk/rubberband/src/StretchCalculator.cpp

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -20 +20 @@
 #include <set>
 #include <cassert>
+#include <algorithm>
+
+#include "sysutils.h"
 
 namespace RubberBand
@@ -163 +166 @@
 int
 StretchCalculator::calculateSingle(double ratio,
-                                   size_t inputDurationSoFar,
-                                   float df)
-{
+                                   float df,
+                                   size_t increment)
+{
+    if (increment == 0) increment = m_increment;
+
     bool isTransient = false;
 
@@ -177 +182 @@
     // works well in common situations.
 
-    float transientThreshold = 0.35;
-    if (ratio > 1) transientThreshold = 0.25;
-
-    if (m_useHardPeaks && df > m_prevDf * 1.1 && df > transientThreshold) {
+    float transientThreshold = 0.35f;
+    if (ratio > 1) transientThreshold = 0.25f;
+
+    if (m_useHardPeaks && df > m_prevDf * 1.1f && df > transientThreshold) {
         isTransient = true;
     }
@@ -191 +196 @@
     m_prevDf = df;
 
+    bool ratioChanged = (ratio != m_prevRatio);
+    m_prevRatio = ratio;
+
     if (isTransient && m_transientAmnesty == 0) {
         if (m_debugLevel > 1) {
-            std::cerr << "StretchCalculator::calculateSingle: transient found at "
-                      << inputDurationSoFar << std::endl;
-        }
-        m_divergence += m_increment - (m_increment * ratio);
+            std::cerr << "StretchCalculator::calculateSingle: transient"
+                      << std::endl;
+        }
+        m_divergence += increment - (increment * ratio);
 
         // as in offline mode, 0.05 sec approx min between transients
         m_transientAmnesty =
-            lrint(ceil(double(m_sampleRate) / (20 * double(m_increment))));
-
-        m_recovery = m_divergence / ((m_sampleRate / 10.0) / m_increment);
-        return -m_increment;
-    }
-
-    if (m_prevRatio != ratio) {
-        m_recovery = m_divergence / ((m_sampleRate / 10.0) / m_increment);
-        m_prevRatio = ratio;
+            lrint(ceil(double(m_sampleRate) / (20 * double(increment))));
+
+        m_recovery = m_divergence / ((m_sampleRate / 10.0) / increment);
+        return -int(increment);
+    }
+
+    if (ratioChanged) {
+        m_recovery = m_divergence / ((m_sampleRate / 10.0) / increment);
     }
 
     if (m_transientAmnesty > 0) --m_transientAmnesty;
 
-    int incr = lrint(m_increment * ratio - m_recovery);
+    int incr = lrint(increment * ratio - m_recovery);
     if (m_debugLevel > 2 || (m_debugLevel > 1 && m_divergence != 0)) {
         std::cerr << "divergence = " << m_divergence << ", recovery = " << m_recovery << ", incr = " << incr << ", ";
     }
-    if (incr < lrint((m_increment * ratio) / 2)) {
-        incr = lrint((m_increment * ratio) / 2);
-    } else if (incr > lrint(m_increment * ratio * 2)) {
-        incr = lrint(m_increment * ratio * 2);
-    }
-
-    double divdiff = (m_increment * ratio) - incr;
+    if (incr < lrint((increment * ratio) / 2)) {
+        incr = lrint((increment * ratio) / 2);
+    } else if (incr > lrint(increment * ratio * 2)) {
+        incr = lrint(increment * ratio * 2);
+    }
+
+    double divdiff = (increment * ratio) - incr;
 
     if (m_debugLevel > 2 || (m_debugLevel > 1 && m_divergence != 0)) {
@@ -233 +240 @@
     if ((prevDivergence < 0 && m_divergence > 0) ||
         (prevDivergence > 0 && m_divergence < 0)) {
-        m_recovery = m_divergence / ((m_sampleRate / 10.0) / m_increment);
+        m_recovery = m_divergence / ((m_sampleRate / 10.0) / increment);
     }
 

trunk/rubberband/src/StretchCalculator.h

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -46 +46 @@
      * StretchCalculator object; call reset() to reset it.  This uses
      * a less sophisticated method than the offline calculate().
+     *
+     * If increment is non-zero, use it for the input increment for
+     * this block in preference to m_increment.
      */
-    virtual int calculateSingle(double ratio, size_t inputDurationSoFar,
-                                float curveValue);
+    virtual int calculateSingle(double ratio, float curveValue,
+                                size_t increment = 0);
 
     void setUseHardPeaks(bool use) { m_useHardPeaks = use; }

trunk/rubberband/src/StretcherChannelData.cpp

@@ -1 +1 @@
 /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
 
+/*
+    Rubber Band
+    An audio time-stretching and pitch-shifting library.
+    Copyright 2007-2008 Chris Cannam.
+    
+    This program 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.  See the file
+    COPYING included with this distribution for more information.
+*/
+
 #include "StretcherChannelData.h"
 
 #include "Resampler.h"
 
+
 namespace RubberBand 
 {
-
+      
 RubberBandStretcher::Impl::ChannelData::ChannelData(size_t windowSize,
-                                                    size_t outbufSize)
+                                                    int overSample,
+                                                    size_t outbufSize) :
+    oversample(overSample)
 {
     std::set<size_t> s;
@@ -16 +31 @@
 
 RubberBandStretcher::Impl::ChannelData::ChannelData(const std::set<size_t> &windowSizes,
+                                                    int overSample,
                                                     size_t initialWindowSize,
-                                                    size_t outbufSize)
+                                                    size_t outbufSize) :
+    oversample(overSample)
 {
     construct(windowSizes, initialWindowSize, outbufSize);
@@ -38 +55 @@
     }
 
-    size_t realSize = maxSize/2 + 1; // size of the real "half" of freq data
+    // max size of the real "half" of freq data
+    size_t realSize = (maxSize * oversample)/2 + 1;
 
 //    std::cerr << "ChannelData::construct([" << windowSizes.size() << "], " << maxSize << ", " << outbufSize << ")" << std::endl;
@@ -47 +65 @@
     outbuf = new RingBuffer<float>(outbufSize);
 
-    mag = new double[realSize];
-    phase = new double[realSize];
-    prevPhase = new double[realSize];
-    unwrappedPhase = new double[realSize];
+    mag = allocDouble(realSize);
+    phase = allocDouble(realSize);
+    prevPhase = allocDouble(realSize);
+    prevError = allocDouble(realSize);
+    unwrappedPhase = allocDouble(realSize);
+    envelope = allocDouble(realSize);
+
     freqPeak = new size_t[realSize];
 
-    accumulator = new float[maxSize];
-    windowAccumulator = new float[maxSize];
-
-    fltbuf = new float[maxSize];
+    fltbuf = allocFloat(maxSize);
+
+    accumulator = allocFloat(maxSize);
+    windowAccumulator = allocFloat(maxSize);
 
     for (std::set<size_t>::const_iterator i = windowSizes.begin();
          i != windowSizes.end(); ++i) {
-        ffts[*i] = new FFT(*i);
+        ffts[*i] = new FFT(*i * oversample);
         ffts[*i]->initDouble();
     }
     if (windowSizes.find(initialWindowSize) == windowSizes.end()) {
-        ffts[initialWindowSize] = new FFT(initialWindowSize);
+        ffts[initialWindowSize] = new FFT(initialWindowSize * oversample);
         ffts[initialWindowSize]->initDouble();
     }
@@ -78 +99 @@
 
     for (size_t i = 0; i < realSize; ++i) {
-        mag[i] = 0.0;
-        phase[i] = 0.0;
-        prevPhase[i] = 0.0;
-        unwrappedPhase[i] = 0.0;
         freqPeak[i] = 0;
     }
 
-    for (size_t i = 0; i < initialWindowSize; ++i) {
+    for (size_t i = 0; i < initialWindowSize * oversample; ++i) {
         dblbuf[i] = 0.0;
     }
-
-    for (size_t i = 0; i < maxSize; ++i) {
-        accumulator[i] = 0.f;
-        windowAccumulator[i] = 0.f;
-        fltbuf[i] = 0.0;
-    }
 }
 
@@ -100 +111 @@
 {
     size_t oldSize = inbuf->getSize();
-    size_t realSize = windowSize/2 + 1;
+    size_t realSize = (windowSize * oversample) / 2 + 1;
 
 //    std::cerr << "ChannelData::setWindowSize(" << windowSize << ") [from " << oldSize << "]" << std::endl;
@@ -115 +126 @@
             //!!! this also requires a lock, but it shouldn't occur in
             //RT mode with proper initialisation
-            ffts[windowSize] = new FFT(windowSize);
+            ffts[windowSize] = new FFT(windowSize * oversample);
             ffts[windowSize]->initDouble();
         }
@@ -123 +134 @@
         dblbuf = fft->getDoubleTimeBuffer();
 
-        for (size_t i = 0; i < windowSize; ++i) {
+        for (size_t i = 0; i < windowSize * oversample; ++i) {
             dblbuf[i] = 0.0;
         }
@@ -131 +142 @@
             phase[i] = 0.0;
             prevPhase[i] = 0.0;
+            prevError[i] = 0.0;
             unwrappedPhase[i] = 0.0;
             freqPeak[i] = 0;
@@ -151 +163 @@
     // We don't want to preserve data in these arrays
 
-    delete[] mag;
-    delete[] phase;
-    delete[] prevPhase;
-    delete[] unwrappedPhase;
+    mag = allocDouble(mag, realSize);
+    phase = allocDouble(phase, realSize);
+    prevPhase = allocDouble(prevPhase, realSize);
+    prevError = allocDouble(prevError, realSize);
+    unwrappedPhase = allocDouble(unwrappedPhase, realSize);
+    envelope = allocDouble(envelope, realSize);
+
     delete[] freqPeak;
-
-    mag = new double[realSize];
-    phase = new double[realSize];
-    prevPhase = new double[realSize];
-    unwrappedPhase = new double[realSize];
     freqPeak = new size_t[realSize];
 
-    delete[] fltbuf;
-    fltbuf = new float[windowSize];
+    fltbuf = allocFloat(fltbuf, windowSize);
 
     // But we do want to preserve data in these
 
-    float *newAcc = new float[windowSize];
+    float *newAcc = allocFloat(windowSize);
+
     for (size_t i = 0; i < oldSize; ++i) newAcc[i] = accumulator[i];
-    delete[] accumulator;
+
+    freeFloat(accumulator);
     accumulator = newAcc;
 
-    newAcc = new float[windowSize];
+    newAcc = allocFloat(windowSize);
+
     for (size_t i = 0; i < oldSize; ++i) newAcc[i] = windowAccumulator[i];
-    delete[] windowAccumulator;
+
+    freeFloat(windowAccumulator);
     windowAccumulator = newAcc;
     
@@ -181 +194 @@
 
     for (size_t i = 0; i < realSize; ++i) {
-        mag[i] = 0.0;
-        phase[i] = 0.0;
-        prevPhase[i] = 0.0;
-        unwrappedPhase[i] = 0.0;
         freqPeak[i] = 0;
     }
 
     for (size_t i = 0; i < windowSize; ++i) {
-        fltbuf[i] = 0.0;
-    }
-
-    for (size_t i = oldSize; i < windowSize; ++i) {
-        accumulator[i] = 0.f;
-        windowAccumulator[i] = 0.f;
+        fltbuf[i] = 0.f;
     }
 
     if (ffts.find(windowSize) == ffts.end()) {
-        ffts[windowSize] = new FFT(windowSize);
+        ffts[windowSize] = new FFT(windowSize * oversample);
         ffts[windowSize]->initDouble();
     }
@@ -206 +210 @@
     dblbuf = fft->getDoubleTimeBuffer();
 
-    for (size_t i = 0; i < windowSize; ++i) {
+    for (size_t i = 0; i < windowSize * oversample; ++i) {
         dblbuf[i] = 0.0;
     }
@@ -229 +233 @@
 }
 
+void
+RubberBandStretcher::Impl::ChannelData::setResampleBufSize(size_t sz)
+{
+    resamplebuf = allocFloat(resamplebuf, sz);
+    resamplebufSize = sz;
+}
+
 RubberBandStretcher::Impl::ChannelData::~ChannelData()
 {
     delete resampler;
-    delete[] resamplebuf;
+
+    freeFloat(resamplebuf);
 
     delete inbuf;
     delete outbuf;
-    delete[] mag;
-    delete[] phase;
-    delete[] prevPhase;
-    delete[] unwrappedPhase;
+
+    freeDouble(mag);
+    freeDouble(phase);
+    freeDouble(prevPhase);
+    freeDouble(prevError);
+    freeDouble(unwrappedPhase);
+    freeDouble(envelope);
     delete[] freqPeak;
-    delete[] accumulator;
-    delete[] windowAccumulator;
-    delete[] fltbuf;
+    freeFloat(accumulator);
+    freeFloat(windowAccumulator);
+    freeFloat(fltbuf);
 
     for (std::map<size_t, FFT *>::iterator i = ffts.begin();
@@ -265 +280 @@
     inputSize = -1;
     outCount = 0;
+    unchanged = true;
     draining = false;
     outputComplete = false;

trunk/rubberband/src/StretcherChannelData.h

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -19 +19 @@
 
 #include <set>
+
+//#define EXPERIMENT 1
 
 namespace RubberBand
@@ -40 +42 @@
      * size specified by the user of the code.
      */
-    ChannelData(size_t windowSize, size_t outbufSize);
+    ChannelData(size_t windowSize, int overSample, size_t outbufSize);
 
     /**
@@ -55 +57 @@
      */
     ChannelData(const std::set<size_t> &windowSizes,
-                size_t initialWindowSize, size_t outbufSize);
+                int overSample, size_t initialWindowSize, size_t outbufSize);
     ~ChannelData();
 
@@ -77 +79 @@
     void setOutbufSize(size_t outbufSize);
 
+    /**
+     * Set the resampler buffer size.  Default if not called is no
+     * buffer allocated at all.
+     */
+    void setResampleBufSize(size_t resamplebufSize);
+    
     RingBuffer<float> *inbuf;
     RingBuffer<float> *outbuf;
@@ -84 +92 @@
 
     double *prevPhase;
+    double *prevError;
     double *unwrappedPhase;
+
 
     size_t *freqPeak;
@@ -94 +104 @@
     float *fltbuf;
     double *dblbuf; // owned by FFT object, only used for time domain FFT i/o
+    double *envelope; // for cepstral formant shift
+    bool unchanged;
 
     size_t prevIncrement; // only used in RT mode
@@ -112 +124 @@
     size_t resamplebufSize;
 
+    int oversample;
+
 private:
     void construct(const std::set<size_t> &windowSizes,

trunk/rubberband/src/StretcherImpl.cpp

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -17 +17 @@
 #include "HighFrequencyAudioCurve.h"
 #include "SpectralDifferenceAudioCurve.h"
+#include "SilentAudioCurve.h"
 #include "ConstantAudioCurve.h"
 #include "StretchCalculator.h"
 #include "StretcherChannelData.h"
 #include "Resampler.h"
+#include "Profiler.h"
 
 #include <cassert>
@@ -35 +37 @@
 using std::min;
 
+
 namespace RubberBand {
 
@@ -47 +50 @@
 
 
-RubberBandStretcher::Impl::Impl(RubberBandStretcher *stretcher,
-                                size_t sampleRate,
+
+RubberBandStretcher::Impl::Impl(size_t sampleRate,
                                 size_t channels,
                                 Options options,
                                 double initialTimeRatio,
                                 double initialPitchScale) :
-    m_stretcher(stretcher),
+    m_sampleRate(sampleRate),
     m_channels(channels),
     m_timeRatio(initialTimeRatio),
@@ -71 +74 @@
     m_spaceAvailable("space"),
     m_inputDuration(0),
+    m_silentHistory(0),
     m_lastProcessOutputIncrements(16),
     m_lastProcessPhaseResetDf(16),
     m_phaseResetAudioCurve(0),
     m_stretchAudioCurve(0),
+    m_silentAudioCurve(0),
     m_stretchCalculator(0),
     m_freq0(600),
@@ -81 +86 @@
     m_baseWindowSize(m_defaultWindowSize)
 {
+
     if (m_debugLevel > 0) {
-        cerr << "RubberBandStretcher::Impl::Impl: rate = " << m_stretcher->m_sampleRate << ", options = " << options << endl;
+        cerr << "RubberBandStretcher::Impl::Impl: rate = " << m_sampleRate << ", options = " << options << endl;
     }
 
     // Window size will vary according to the audio sample rate, but
     // we don't let it drop below the 48k default
-    m_rateMultiple = float(m_stretcher->m_sampleRate) / 48000.f;
+    m_rateMultiple = float(m_sampleRate) / 48000.f;
     if (m_rateMultiple < 1.f) m_rateMultiple = 1.f;
     m_baseWindowSize = roundUp(int(m_defaultWindowSize * m_rateMultiple));
@@ -161 +167 @@
     delete m_phaseResetAudioCurve;
     delete m_stretchAudioCurve;
+    delete m_silentAudioCurve;
     delete m_stretchCalculator;
     delete m_studyFFT;
@@ -194 +201 @@
     if (m_phaseResetAudioCurve) m_phaseResetAudioCurve->reset();
     if (m_stretchAudioCurve) m_stretchAudioCurve->reset();
+    if (m_silentAudioCurve) m_silentAudioCurve->reset();
     m_inputDuration = 0;
+    m_silentHistory = 0;
 
     if (m_threaded) m_threadSetMutex.unlock();
@@ -228 +237 @@
 
     if (fs == m_pitchScale) return;
+    
+    bool was1 = (m_pitchScale == 1.f);
+    bool rbs = resampleBeforeStretching();
+
     m_pitchScale = fs;
 
     reconfigure();
+
+    if (!(m_options & OptionPitchHighConsistency) &&
+        (was1 || resampleBeforeStretching() != rbs) &&
+        m_pitchScale != 1.f) {
+        
+        // resampling mode has changed
+        for (int c = 0; c < int(m_channels); ++c) {
+            if (m_channelData[c]->resampler) {
+                m_channelData[c]->resampler->reset();
+            }
+        }
+    }
 }
 
@@ -322 +347 @@
     if (m_realtime) {
 
-        // use a fixed input increment
-
-        inputIncrement = roundUp(int(m_defaultIncrement * m_rateMultiple));
-
         if (r < 1) {
+            
+            bool rsb = (m_pitchScale < 1.0 && !resampleBeforeStretching());
+            float windowIncrRatio = 4.5;
+            if (r == 1.0) windowIncrRatio = 4;
+            else if (rsb) windowIncrRatio = 4.5;
+            else windowIncrRatio = 6;
+
+            inputIncrement = int(windowSize / windowIncrRatio);
             outputIncrement = int(floor(inputIncrement * r));
-            if (outputIncrement < 1) {
-                outputIncrement = 1;
-                inputIncrement = roundUp(lrint(ceil(outputIncrement / r)));
-                windowSize = inputIncrement * 4;
-            }
+
+            // Very long stretch or very low pitch shift
+            if (outputIncrement < m_defaultIncrement / 4) {
+                if (outputIncrement < 1) outputIncrement = 1;
+                while (outputIncrement < m_defaultIncrement / 4 &&
+                       windowSize < m_baseWindowSize * 4) {
+                    outputIncrement *= 2;
+                    inputIncrement = lrint(ceil(outputIncrement / r));
+                    windowSize = roundUp(lrint(ceil(inputIncrement * windowIncrRatio)));
+                }
+            }
+
         } else {
-            outputIncrement = int(ceil(inputIncrement * r));
-            while (outputIncrement > 1024 && inputIncrement > 1) {
-                inputIncrement /= 2;
-                outputIncrement = lrint(ceil(inputIncrement * r));
-            }
-            windowSize = std::max(windowSize, roundUp(outputIncrement * 6));
-            if (r > 5) while (windowSize < 8192) windowSize *= 2;
+
+            bool rsb = (m_pitchScale > 1.0 && resampleBeforeStretching());
+            float windowIncrRatio = 4.5;
+            if (r == 1.0) windowIncrRatio = 4;
+            else if (rsb) windowIncrRatio = 4.5;
+            else windowIncrRatio = 6;
+
+            outputIncrement = int(windowSize / windowIncrRatio);
+            inputIncrement = int(outputIncrement / r);
+            while (outputIncrement > 1024 * m_rateMultiple &&
+                   inputIncrement > 1) {
+                outputIncrement /= 2;
+                inputIncrement = int(outputIncrement / r);
+            }
+            size_t minwin = roundUp(lrint(outputIncrement * windowIncrRatio));
+            if (windowSize < minwin) windowSize = minwin;
+
+            if (rsb) {
+//                cerr << "adjusting window size from " << windowSize;
+                size_t newWindowSize = roundUp(lrint(windowSize / m_pitchScale));
+                if (newWindowSize < 512) newWindowSize = 512;
+                size_t div = windowSize / newWindowSize;
+                if (inputIncrement > div && outputIncrement > div) {
+                    inputIncrement /= div;
+                    outputIncrement /= div;
+                    windowSize /= div;
+                }
+//                cerr << " to " << windowSize << " (inputIncrement = " << inputIncrement << ", outputIncrement = " << outputIncrement << ")" << endl;
+            }
         }
 
     } else {
-
-        // use a variable increment
 
         if (r < 1) {
@@ -366 +422 @@
             if (r > 5) while (windowSize < 8192) windowSize *= 2;
         }
-    }        
+    }
 
     if (m_expectedInputDuration > 0) {
@@ -451 +507 @@
     if (m_realtime) {
         windowSizes.insert(m_baseWindowSize);
+        windowSizes.insert(m_baseWindowSize / 2);
         windowSizes.insert(m_baseWindowSize * 2);
-        windowSizes.insert(m_baseWindowSize * 4);
+//        windowSizes.insert(m_baseWindowSize * 4);
     }
     windowSizes.insert(m_windowSize);
@@ -480 +537 @@
         for (size_t c = 0; c < m_channels; ++c) {
             m_channelData.push_back
-                (new ChannelData(windowSizes, m_windowSize, m_outbufSize));
+                (new ChannelData(windowSizes, 1, m_windowSize, m_outbufSize));
         }
     }
@@ -486 +543 @@
     if (!m_realtime && windowSizeChanged) {
         delete m_studyFFT;
-        m_studyFFT = new FFT(m_windowSize);
+        m_studyFFT = new FFT(m_windowSize, m_debugLevel);
         m_studyFFT->initFloat();
     }
 
-    if (m_pitchScale != 1.0 || m_realtime) {
+    if (m_pitchScale != 1.0 ||
+        (m_options & OptionPitchHighConsistency) ||
+        m_realtime) {
 
         for (size_t c = 0; c < m_channels; ++c) {
@@ -497 +556 @@
 
             m_channelData[c]->resampler =
-                new Resampler(Resampler::FastestTolerable, 1, 4096 * 16);
+                new Resampler(Resampler::FastestTolerable, 1, 4096 * 16,
+                              m_debugLevel);
 
             // rbs is the amount of buffer space we think we'll need
@@ -505 +565 @@
                 lrintf(ceil((m_increment * m_timeRatio * 2) / m_pitchScale));
             if (rbs < m_increment * 16) rbs = m_increment * 16;
-            m_channelData[c]->resamplebufSize = rbs;
-            m_channelData[c]->resamplebuf = new float[rbs];
+            m_channelData[c]->setResampleBufSize(rbs);
         }
     }
     
+    // stretchAudioCurve is unused in RT mode; phaseResetAudioCurve,
+    // silentAudioCurve and stretchCalculator however are used in all
+    // modes
+
     delete m_phaseResetAudioCurve;
-    m_phaseResetAudioCurve = new PercussiveAudioCurve(m_stretcher->m_sampleRate,
-                                                      m_windowSize);
-
-    // stretchAudioCurve unused in RT mode; phaseResetAudioCurve and
-    // stretchCalculator however are used in all modes
+    m_phaseResetAudioCurve = new PercussiveAudioCurve
+        (m_sampleRate, m_windowSize);
+
+    delete m_silentAudioCurve;
+    m_silentAudioCurve = new SilentAudioCurve
+        (m_sampleRate, m_windowSize);
 
     if (!m_realtime) {
@@ -521 +585 @@
         if (!(m_options & OptionStretchPrecise)) {
             m_stretchAudioCurve = new SpectralDifferenceAudioCurve
-                (m_stretcher->m_sampleRate, m_windowSize);
+                (m_sampleRate, m_windowSize);
         } else {
             m_stretchAudioCurve = new ConstantAudioCurve
-                (m_stretcher->m_sampleRate, m_windowSize);
+                (m_sampleRate, m_windowSize);
         }
     }
@@ -530 +594 @@
     delete m_stretchCalculator;
     m_stretchCalculator = new StretchCalculator
-        (m_stretcher->m_sampleRate, m_increment,
+        (m_sampleRate, m_increment,
          !(m_options & OptionTransientsSmooth));
 
@@ -566 +630 @@
             m_phaseResetDf.clear();
             m_stretchDf.clear();
+            m_silence.clear();
             m_inputDuration = 0;
         }
@@ -610 +675 @@
 
             m_channelData[c]->resampler =
-                new Resampler(Resampler::FastestTolerable, 1, m_windowSize);
-
-            m_channelData[c]->resamplebufSize =
-                lrintf(ceil((m_increment * m_timeRatio * 2) / m_pitchScale));
-            m_channelData[c]->resamplebuf =
-                new float[m_channelData[c]->resamplebufSize];
+                new Resampler(Resampler::FastestTolerable, 1, m_windowSize,
+                              m_debugLevel);
+
+            m_channelData[c]->setResampleBufSize
+                (lrintf(ceil((m_increment * m_timeRatio * 2) / m_pitchScale)));
         }
     }
@@ -638 +702 @@
         return;
     }
-    m_options &= ~(OptionTransientsMixed |
-                   OptionTransientsSmooth |
-                   OptionTransientsCrisp);
+    int mask = (OptionTransientsMixed | OptionTransientsSmooth | OptionTransientsCrisp);
+    m_options &= ~mask;
+    options &= mask;
     m_options |= options;
 
@@ -650 +714 @@
 RubberBandStretcher::Impl::setPhaseOption(Options options)
 {
-    m_options &= ~(OptionPhaseAdaptive |
-                   OptionPhasePeakLocked |
-                   OptionPhaseIndependent);
+    int mask = (OptionPhaseLaminar | OptionPhaseIndependent);
+    m_options &= ~mask;
+    options &= mask;
     m_options |= options;
 }
 
 void
+RubberBandStretcher::Impl::setFormantOption(Options options)
+{
+    int mask = (OptionFormantShifted | OptionFormantPreserved);
+    m_options &= ~mask;
+    options &= mask;
+    m_options |= options;
+}
+
+void
+RubberBandStretcher::Impl::setPitchOption(Options options)
+{
+    if (!m_realtime) {
+        cerr << "RubberBandStretcher::Impl::setPitchOption: Pitch option is not used in non-RT mode" << endl;
+        return;
+    }
+
+    Options prior = m_options;
+
+    int mask = (OptionPitchHighQuality |
+                OptionPitchHighSpeed |
+                OptionPitchHighConsistency);
+    m_options &= ~mask;
+    options &= mask;
+    m_options |= options;
+
+    if (prior != m_options) reconfigure();
+}
+
+void
 RubberBandStretcher::Impl::study(const float *const *input, size_t samples, bool final)
 {
+    Profiler profiler("RubberBandStretcher::Impl::study");
+
     if (m_realtime) {
         if (m_debugLevel > 1) {
@@ -716 +811 @@
         }
 
-        while ((inbuf.getReadSpace() >= m_windowSize) ||
-               (final && (inbuf.getReadSpace() >= m_windowSize/2))) {
+        while ((inbuf.getReadSpace() >= int(m_windowSize)) ||
+               (final && (inbuf.getReadSpace() >= int(m_windowSize/2)))) {
 
             // We know we have at least m_windowSize samples available
@@ -744 +839 @@
             df = m_stretchAudioCurve->process(cd.fltbuf, m_increment);
             m_stretchDf.push_back(df);
+
+            df = m_silentAudioCurve->process(cd.fltbuf, m_increment);
+            bool silent = (df > 0.f);
+            if (silent && m_debugLevel > 1) {
+                cerr << "silence found at " << m_inputDuration << endl;
+            }
+            m_silence.push_back(silent);
 
 //            cout << df << endl;
@@ -818 +920 @@
 RubberBandStretcher::Impl::calculateStretch()
 {
+    Profiler profiler("RubberBandStretcher::Impl::calculateStretch");
+
     std::vector<int> increments = m_stretchCalculator->calculate
         (getEffectiveRatio(),
@@ -824 +928 @@
          m_stretchDf);
 
+    int history = 0;
+    for (size_t i = 0; i < increments.size(); ++i) {
+        if (i >= m_silence.size()) break;
+        if (m_silence[i]) ++history;
+        else history = 0;
+        if (history >= int(m_windowSize / m_increment) && increments[i] >= 0) {
+            increments[i] = -increments[i];
+            if (m_debugLevel > 1) {
+                std::cerr << "phase reset on silence (silent history == "
+                          << history << ")" << std::endl;
+            }
+        }
+    }
+
     if (m_outputIncrements.empty()) m_outputIncrements = increments;
     else {
@@ -844 +962 @@
 RubberBandStretcher::Impl::getSamplesRequired() const
 {
+    Profiler profiler("RubberBandStretcher::Impl::getSamplesRequired");
+
     size_t reqd = 0;
 
@@ -879 +999 @@
 RubberBandStretcher::Impl::process(const float *const *input, size_t samples, bool final)
 {
+    Profiler profiler("RubberBandStretcher::Impl::process");
+
     if (m_mode == Finished) {
         cerr << "RubberBandStretcher::Impl::process: Cannot process again after final chunk" << endl;
@@ -914 +1036 @@
     bool allConsumed = false;
 
-    map<size_t, size_t> consumed;
+    size_t *consumed = (size_t *)alloca(m_channels * sizeof(size_t));
     for (size_t c = 0; c < m_channels; ++c) {
         consumed[c] = 0;
@@ -920 +1042 @@
 
     while (!allConsumed) {
-
-//        cerr << "process looping" << endl;
 
 //#ifndef NO_THREADING
@@ -936 +1056 @@
 
         allConsumed = true;
+
         for (size_t c = 0; c < m_channels; ++c) {
             consumed[c] += consumeChannel(c,
                                           input[c] + consumed[c],
-                                          samples - consumed[c]);
+                                          samples - consumed[c],
+                                          final);
             if (consumed[c] < samples) {
                 allConsumed = false;
@@ -982 +1104 @@
 */
         }
+
+//        if (!allConsumed) cerr << "process looping" << endl;
+
     }
     
@@ -989 +1114 @@
 }
 
-size_t
-RubberBandStretcher::Impl::consumeChannel(size_t c, const float *input, size_t samples)
-{
-    size_t consumed = 0;
-    
-    ChannelData &cd = *m_channelData[c];
-    RingBuffer<float> &inbuf = *cd.inbuf;
-    
-    while (consumed < samples) {
-
-        size_t writable = inbuf.getWriteSpace();
-
-//        cerr << "channel " << c << ": samples remaining = " << samples - consumed << ", writable space = " << writable << endl;
-
-        writable = min(writable, samples - consumed);
-
-        if (writable == 0) {
-            // warn
-//            cerr << "WARNING: writable == 0 for ch " << c << " (consumed = " << consumed << ", samples = " << samples << ")" << endl;
-            return consumed;
-        } else {
-            inbuf.write(input + consumed, writable);
-            consumed += writable;
-            cd.inCount += writable;
-        }
-    }
-
-    return samples;
-}
-
-
-}
-
+
+}
+

trunk/rubberband/src/StretcherImpl.h

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -35 +35 @@
 {
 public:
-    Impl(RubberBandStretcher *stretcher,
-         size_t sampleRate, size_t channels, Options options,
+    Impl(size_t sampleRate, size_t channels, Options options,
          double initialTimeRatio, double initialPitchScale);
     ~Impl();
@@ -51 +50 @@
     void setTransientsOption(Options);
     void setPhaseOption(Options);
+    void setFormantOption(Options);
+    void setPitchOption(Options);
 
     void setExpectedInputDuration(size_t samples);
@@ -84 +85 @@
 
 protected:
-    RubberBandStretcher *m_stretcher;
+    size_t m_sampleRate;
     size_t m_channels;
 
-    size_t consumeChannel(size_t channel, const float *input, size_t samples);
+    size_t consumeChannel(size_t channel, const float *input,
+                          size_t samples, bool final);
     void processChunks(size_t channel, bool &any, bool &last);
     bool processOneChunk(); // across all channels, for real time use
@@ -99 +101 @@
     void analyseChunk(size_t channel);
     void modifyChunk(size_t channel, size_t outputIncrement, bool phaseReset);
+    void formantShiftChunk(size_t channel);
     void synthesiseChunk(size_t channel);
     void writeChunk(size_t channel, size_t shiftIncrement, bool last);
@@ -110 +113 @@
     size_t roundUp(size_t value); // to next power of two
 
+    bool resampleBeforeStretching() const;
+    
     double m_timeRatio;
     double m_pitchScale;
@@ -162 +167 @@
     std::vector<float> m_phaseResetDf;
     std::vector<float> m_stretchDf;
+    std::vector<bool> m_silence;
+    int m_silentHistory;
 
     class ChannelData; 
@@ -173 +180 @@
     AudioCurve *m_phaseResetAudioCurve;
     AudioCurve *m_stretchAudioCurve;
+    AudioCurve *m_silentAudioCurve;
     StretchCalculator *m_stretchCalculator;
 

trunk/rubberband/src/StretcherProcess.cpp

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -20 +20 @@
 #include "StretcherChannelData.h"
 #include "Resampler.h"
+#include "Profiler.h"
 
 #include <cassert>
@@ -25 +26 @@
 #include <set>
 #include <map>
+#include <deque>
+
 
 using std::cerr;
@@ -98 +101 @@
 }
 
+bool
+RubberBandStretcher::Impl::resampleBeforeStretching() const
+{
+    // We can't resample before stretching in offline mode, because
+    // the stretch calculation is based on doing it the other way
+    // around.  It would take more work (and testing) to enable this.
+    if (!m_realtime) return false;
+
+    if (m_options & OptionPitchHighQuality) {
+        return (m_pitchScale < 1.0); // better sound
+    } else if (m_options & OptionPitchHighConsistency) {
+        return false;
+    } else {
+        return (m_pitchScale > 1.0); // better performance
+    }
+}
+    
+size_t
+RubberBandStretcher::Impl::consumeChannel(size_t c, const float *input,
+                                          size_t samples, bool final)
+{
+    Profiler profiler("RubberBandStretcher::Impl::consumeChannel");
+
+    ChannelData &cd = *m_channelData[c];
+    RingBuffer<float> &inbuf = *cd.inbuf;
+
+    size_t toWrite = samples;
+    size_t writable = inbuf.getWriteSpace();
+
+    bool resampling = resampleBeforeStretching();
+
+    if (resampling) {
+
+        toWrite = int(ceil(samples / m_pitchScale));
+        if (writable < toWrite) {
+            samples = int(floor(writable * m_pitchScale));
+            if (samples == 0) return 0;
+        }
+
+        size_t reqSize = int(ceil(samples / m_pitchScale));
+        if (reqSize > cd.resamplebufSize) {
+            cerr << "WARNING: RubberBandStretcher::Impl::consumeChannel: resizing resampler buffer from "
+                 << cd.resamplebufSize << " to " << reqSize << endl;
+            cd.setResampleBufSize(reqSize);
+        }
+
+
+        toWrite = cd.resampler->resample(&input,
+                                         &cd.resamplebuf,
+                                         samples,
+                                         1.0 / m_pitchScale,
+                                         final);
+
+    }
+
+    if (writable < toWrite) {
+        if (resampling) {
+            return 0;
+        }
+        toWrite = writable;
+    }
+
+    if (resampling) {
+        inbuf.write(cd.resamplebuf, toWrite);
+        cd.inCount += samples;
+        return samples;
+    } else {
+        inbuf.write(input, toWrite);
+        cd.inCount += toWrite;
+        return toWrite;
+    }
+}
+
 void
 RubberBandStretcher::Impl::processChunks(size_t c, bool &any, bool &last)
 {
+    Profiler profiler("RubberBandStretcher::Impl::processChunks");
+
     // Process as many chunks as there are available on the input
     // buffer for channel c.  This requires that the increments have
@@ -141 +219 @@
 RubberBandStretcher::Impl::processOneChunk()
 {
+    Profiler profiler("RubberBandStretcher::Impl::processOneChunk");
+
     // Process a single chunk for all channels, provided there is
     // enough data on each channel for at least one chunk.  This is
@@ -174 +254 @@
 RubberBandStretcher::Impl::testInbufReadSpace(size_t c)
 {
+    Profiler profiler("RubberBandStretcher::Impl::testInbufReadSpace");
+
     ChannelData &cd = *m_channelData[c];
     RingBuffer<float> &inbuf = *cd.inbuf;
@@ -224 +306 @@
                                                   bool phaseReset)
 {
+    Profiler profiler("RubberBandStretcher::Impl::processChunkForChannel");
+
     // Process a single chunk on a single channel.  This assumes
     // enough input data is available; caller must have tested this
@@ -250 +334 @@
         // We need to peek m_windowSize samples for processing, and
         // then skip m_increment to advance the read pointer.
-        
+
         modifyChunk(c, phaseIncrement, phaseReset);
         synthesiseChunk(c); // reads from cd.mag, cd.phase
@@ -285 +369 @@
         
     if (m_threaded) {
-        size_t required = shiftIncrement;
+
+        int required = shiftIncrement;
+
         if (m_pitchScale != 1.0) {
             required = int(required / m_pitchScale) + 1;
@@ -314 +400 @@
                                                bool &phaseReset)
 {
+    Profiler profiler("RubberBandStretcher::Impl::calculateIncrements");
+
 //    cerr << "calculateIncrements" << endl;
     
@@ -342 +430 @@
         }
     }
+
+    const int hs = m_windowSize/2 + 1;
 
     // Normally we would mix down the time-domain signal and apply a
@@ -353 +443 @@
     // be apparent.
 
-    for (size_t i = 0; i <= m_windowSize/2; ++i) {
-        cd.fltbuf[i] = 0.0;
-    }
-
-    for (size_t c = 0; c < m_channels; ++c) {
-        for (size_t i = 0; i <= m_windowSize/2; ++i) {
-            cd.fltbuf[i] += m_channelData[c]->mag[i];
-        }
-    }
-    
-    float df = m_phaseResetAudioCurve->process(cd.fltbuf, m_increment);
+    float df = 0.f;
+    bool silent = false;
+
+    if (m_channels == 1) {
+
+        df = m_phaseResetAudioCurve->process(cd.mag, m_increment);
+        silent = (m_silentAudioCurve->process(cd.mag, m_increment) > 0.f);
+
+    } else {
+
+        double *tmp = (double *)alloca(hs * sizeof(double));
+
+        for (int i = 0; i < hs; ++i) {
+            tmp[i] = 0.0;
+        }
+        for (size_t c = 0; c < m_channels; ++c) {
+            for (int i = 0; i < hs; ++i) {
+                tmp[i] += m_channelData[c]->mag[i];
+            }
+        }
+    
+        df = m_phaseResetAudioCurve->process(tmp, m_increment);
+        silent = (m_silentAudioCurve->process(tmp, m_increment) > 0.f);
+    }
 
     int incr = m_stretchCalculator->calculateSingle
-        (getEffectiveRatio(),
-         m_inputDuration, //!!! no, totally wrong... fortunately it doesn't matter atm
-         df);
+            (getEffectiveRatio(), df, m_increment);
 
     m_lastProcessPhaseResetDf.write(&df, 1);
@@ -400 +501 @@
 
     cd.prevIncrement = shiftIncrementRtn;
+
+    if (silent) ++m_silentHistory;
+    else m_silentHistory = 0;
+
+    if (m_silentHistory >= int(m_windowSize / m_increment) && !phaseReset) {
+        phaseReset = true;
+        if (m_debugLevel > 1) {
+            cerr << "calculateIncrements: phase reset on silence (silent history == "
+                 << m_silentHistory << ")" << endl;
+        }
+    }
 }
 
@@ -408 +520 @@
                                          bool &phaseReset)
 {
+    Profiler profiler("RubberBandStretcher::Impl::getIncrements");
+
     if (channel >= m_channels) {
         phaseIncrementRtn = m_increment;
@@ -479 +593 @@
 RubberBandStretcher::Impl::analyseChunk(size_t channel)
 {
-    size_t i;
+    Profiler profiler("RubberBandStretcher::Impl::analyseChunk");
+
+    int i;
 
     ChannelData &cd = *m_channelData[channel];
 
+    double *const R__ dblbuf = cd.dblbuf;
+    float *const R__ fltbuf = cd.fltbuf;
+
+    int sz = m_windowSize;
+    int hs = m_windowSize/2;
+
     // cd.fltbuf is known to contain m_windowSize samples
 
-    m_window->cut(cd.fltbuf);
-
-    for (i = 0; i < m_windowSize/2; ++i) {
-        cd.dblbuf[i] = cd.fltbuf[i + m_windowSize/2];
-        cd.dblbuf[i + m_windowSize/2] = cd.fltbuf[i];
-    }
-
-    cd.fft->forwardPolar(cd.dblbuf, cd.mag, cd.phase);
-}
-
-double mod(double x, double y) { return x - (y * floor(x / y)); }
-double princarg(double a) { return mod(a + M_PI, -2 * M_PI) + M_PI; }
+    m_window->cut(fltbuf);
+
+    if (cd.oversample > 1) {
+
+        int bufsiz = sz * cd.oversample;
+        int offset = (bufsiz - sz) / 2;
+
+        // eek
+
+        for (i = 0; i < offset; ++i) {
+            dblbuf[i] = 0.0;
+        }
+        for (i = 0; i < offset; ++i) {
+            dblbuf[bufsiz - i - 1] = 0.0;
+        }
+        for (i = 0; i < sz; ++i) {
+            dblbuf[offset + i] = fltbuf[i];
+        }
+        for (i = 0; i < bufsiz / 2; ++i) {
+            double tmp = dblbuf[i];
+            dblbuf[i] = dblbuf[i + bufsiz/2];
+            dblbuf[i + bufsiz/2] = tmp;
+        }
+    } else {
+        for (i = 0; i < hs; ++i) {
+            dblbuf[i] = fltbuf[i + hs];
+            dblbuf[i + hs] = fltbuf[i];
+        }
+    }
+
+    cd.fft->forwardPolar(dblbuf, cd.mag, cd.phase);
+}
+
+static inline double mod(double x, double y) { return x - (y * floor(x / y)); }
+static inline double princarg(double a) { return mod(a + M_PI, -2.0 * M_PI) + M_PI; }
 
 void
-RubberBandStretcher::Impl::modifyChunk(size_t channel, size_t outputIncrement,
+RubberBandStretcher::Impl::modifyChunk(size_t channel,
+                                       size_t outputIncrement,
                                        bool phaseReset)
 {
+    Profiler profiler("RubberBandStretcher::Impl::modifyChunk");
+
     ChannelData &cd = *m_channelData[channel];
 
@@ -508 +656 @@
     }
 
-    size_t count = m_windowSize/2;
-    size_t pfp = 0;
-    double rate = m_stretcher->m_sampleRate;
-
-    if (!(m_options & OptionPhaseIndependent)) {
-
-        cd.freqPeak[0] = 0;
-
-        float freq0 = m_freq0;
-        float freq1 = m_freq1;
-        float freq2 = m_freq2;
-
-        // As the stretch ratio increases, so the frequency thresholds
-        // for phase lamination should increase.  Beyond a ratio of
-        // about 1.5, the threshold should be about 1200Hz; beyond a
-        // ratio of 2, we probably want no lamination to happen at all
-        // by default.  This calculation aims for more or less that.
-        // We only do this if the phase option is OptionPhaseAdaptive
-        // (the default), i.e. not Independent or PeakLocked.
-
-        if (!(m_options & OptionPhasePeakLocked)) {
-            float r = getEffectiveRatio();
-            if (r > 1) {
-                float rf0 = 600 + (600 * ((r-1)*(r-1)*(r-1)*2));
-                float f1ratio = freq1 / freq0;
-                float f2ratio = freq2 / freq0;
-                freq0 = std::max(freq0, rf0);
-                freq1 = freq0 * f1ratio;
-                freq2 = freq0 * f2ratio;
-            }
-        }
-
-        size_t limit0 = lrint((freq0 * m_windowSize) / rate);
-        size_t limit1 = lrint((freq1 * m_windowSize) / rate);
-        size_t limit2 = lrint((freq2 * m_windowSize) / rate);
-
-        size_t range = 0;
-
-        if (limit1 < limit0) limit1 = limit0;
-        if (limit2 < limit1) limit2 = limit1;
-    
-//        cerr << "limit0 = " << limit0 << " limit1 = " << limit1 << " limit2 = " << limit2 << endl;
-
-        int peakCount = 0;
-
-        for (size_t i = 0; i <= count; ++i) {
-
-            double mag = cd.mag[i];
-            bool isPeak = true;
-
-            for (size_t j = 1; j <= range; ++j) {
-
-                if (mag < cd.mag[i-j]) {
-                    isPeak = false;
-                    break;
-                }
-
-                if (mag < cd.mag[i+j]) {
-                    isPeak = false;
-                    break;
-                }
-            }        
-
-            if (isPeak) {
-
-                // i is a peak bin.
-
-                // The previous peak bin was at pfp; make freqPeak entries
-                // from pfp to half-way between pfp and i point at pfp, and
-                // those from the half-way mark to i point at i.
-            
-                size_t halfway = (pfp + i) / 2;
-                if (halfway == pfp) halfway = pfp + 1;
-
-                for (size_t j = pfp + 1; j < halfway; ++j) {
-                    cd.freqPeak[j] = pfp;
-                }
-                for (size_t j = halfway; j <= i; ++j) {
-                    cd.freqPeak[j] = i;
-                }
-
-                pfp = i;
-
-                ++peakCount;
-            }
-
-            if (i == limit0) range = 1;
-            if (i == limit1) range = 2;
-            if (i >= limit2) {
-                range = 3;
-                if (i + range + 1 > count) range = count - i;
-            }
-        }
-
-//        cerr << "peakCount = " << peakCount << endl;
-        
-        cd.freqPeak[count-1] = count-1;
-        cd.freqPeak[count] = count;
-    }
-
-    double peakInPhase = 0.0;
-    double peakOutPhase = 0.0;
-    size_t p, pp;
-
-    for (size_t i = 0; i <= count; ++i) {
-        
-        if (m_options & OptionPhaseIndependent) {
-            p = i;
-            pp = i-1;
-        } else {
-            p = cd.freqPeak[i];
-            pp = cd.freqPeak[i-1];
-        }
+    const double rate = m_sampleRate;
+    const int sz = m_windowSize;
+    const int count = (sz * cd.oversample) / 2;
+
+    bool unchanged = cd.unchanged && (outputIncrement == m_increment);
+    bool fullReset = phaseReset;
+    bool laminar = !(m_options & OptionPhaseIndependent);
+    bool bandlimited = (m_options & OptionTransientsMixed);
+    int bandlow = lrint((150 * sz * cd.oversample) / rate);
+    int bandhigh = lrint((1000 * sz * cd.oversample) / rate);
+
+    float freq0 = m_freq0;
+    float freq1 = m_freq1;
+    float freq2 = m_freq2;
+
+    if (laminar) {
+        float r = getEffectiveRatio();
+        if (r > 1) {
+            float rf0 = 600 + (600 * ((r-1)*(r-1)*(r-1)*2));
+            float f1ratio = freq1 / freq0;
+            float f2ratio = freq2 / freq0;
+            freq0 = std::max(freq0, rf0);
+            freq1 = freq0 * f1ratio;
+            freq2 = freq0 * f2ratio;
+        }
+    }
+
+    int limit0 = lrint((freq0 * sz * cd.oversample) / rate);
+    int limit1 = lrint((freq1 * sz * cd.oversample) / rate);
+    int limit2 = lrint((freq2 * sz * cd.oversample) / rate);
+
+    if (limit1 < limit0) limit1 = limit0;
+    if (limit2 < limit1) limit2 = limit1;
+    
+    double prevInstability = 0.0;
+    bool prevDirection = false;
+
+    double distance = 0.0;
+    const double maxdist = 8.0;
+
+    const int lookback = 1;
+
+    double distacc = 0.0;
+
+    for (int i = count; i >= 0; i -= lookback) {
 
         bool resetThis = phaseReset;
         
-        if (m_options & OptionTransientsMixed) {
-            size_t low = lrint((150 * m_windowSize) / rate);
-            size_t high = lrint((1000 * m_windowSize) / rate);
+        if (bandlimited) {
             if (resetThis) {
-                if (i > low && i < high) resetThis = false;
-            }
-        }
+                if (i > bandlow && i < bandhigh) {
+                    resetThis = false;
+                    fullReset = false;
+                }
+            }
+        }
+
+        double p = cd.phase[i];
+        double perr = 0.0;
+        double outphase = p;
+
+        double mi = maxdist;
+        if (i <= limit0) mi = 0.0;
+        else if (i <= limit1) mi = 1.0;
+        else if (i <= limit2) mi = 3.0;
 
         if (!resetThis) {
 
-            if (i == 0 || p != pp) {
-        
-                double omega = (2 * M_PI * m_increment * p) / m_windowSize;
-                double expectedPhase = cd.prevPhase[p] + omega;
-                double phaseError = princarg(cd.phase[p] - expectedPhase);
-                double phaseIncrement = (omega + phaseError) / m_increment;
-            
-                double unwrappedPhase = cd.unwrappedPhase[p] +
-                    outputIncrement * phaseIncrement;
-
-                cd.prevPhase[p] = cd.phase[p];
-                cd.phase[p] = unwrappedPhase;
-                cd.unwrappedPhase[p] = unwrappedPhase;
-
-                peakInPhase = cd.prevPhase[p];
-                peakOutPhase = unwrappedPhase;
-            }
-
-            if (i != p) {
-
-                double diffToPeak = peakInPhase - cd.phase[i];
-                double unwrappedPhase = peakOutPhase - diffToPeak;
-                
-                cd.prevPhase[i] = cd.phase[i];
-                cd.phase[i] = unwrappedPhase;
-                cd.unwrappedPhase[i] = unwrappedPhase;
-            }
+            double omega = (2 * M_PI * m_increment * i) / (sz * cd.oversample);
+
+            double pp = cd.prevPhase[i];
+            double ep = pp + omega;
+            perr = princarg(p - ep);
+
+            double instability = fabs(perr - cd.prevError[i]);
+            bool direction = (perr > cd.prevError[i]);
+
+            bool inherit = false;
+
+            if (laminar) {
+                if (distance >= mi) {
+                    inherit = false;
+                } else if (bandlimited && (i == bandhigh || i == bandlow)) {
+                    inherit = false;
+                } else if (instability > prevInstability &&
+                           direction == prevDirection) {
+                    inherit = true;
+                }
+            }
+
+            double advance = outputIncrement * ((omega + perr) / m_increment);
+
+            if (inherit) {
+                double inherited =
+                    cd.unwrappedPhase[i + lookback] - cd.prevPhase[i + lookback];
+                advance = ((advance * distance) +
+                           (inherited * (maxdist - distance)))
+                    / maxdist;
+                outphase = p + advance;
+                distacc += distance;
+                distance += 1.0;
+            } else {
+                outphase = cd.unwrappedPhase[i] + advance;
+                distance = 0.0;
+            }
+
+            prevInstability = instability;
+            prevDirection = direction;
 
         } else {
-            cd.prevPhase[i] = cd.phase[i];
-            cd.unwrappedPhase[i] = cd.phase[i];
-        }
-    }
+            distance = 0.0;
+        }
+
+        cd.prevError[i] = perr;
+        cd.prevPhase[i] = p;
+        cd.phase[i] = outphase;
+        cd.unwrappedPhase[i] = outphase;
+    }
+
+    if (m_debugLevel > 1) {
+        cerr << "mean inheritance distance = " << distacc / count << endl;
+    }
+
+    if (fullReset) unchanged = true;
+    cd.unchanged = unchanged;
+
+    if (unchanged && m_debugLevel > 1) {
+        cerr << "frame unchanged on channel " << channel << endl;
+    }
+}    
+
+
+void
+RubberBandStretcher::Impl::formantShiftChunk(size_t channel)
+{
+    Profiler profiler("RubberBandStretcher::Impl::formantShiftChunk");
+
+    ChannelData &cd = *m_channelData[channel];
+
+    double *const R__ mag = cd.mag;
+    double *const R__ envelope = cd.envelope;
+    double *const R__ dblbuf = cd.dblbuf;
+
+    const int sz = m_windowSize;
+    const int hs = m_windowSize/2;
+    const double denom = sz;
+
+    
+    cd.fft->inverseCepstral(mag, dblbuf);
+
+    for (int i = 0; i < sz; ++i) {
+        dblbuf[i] /= denom;
+    }
+
+    const int cutoff = m_sampleRate / 700;
+
+//    cerr <<"cutoff = "<< cutoff << ", m_sampleRate/cutoff = " << m_sampleRate/cutoff << endl;
+
+    dblbuf[0] /= 2;
+    dblbuf[cutoff-1] /= 2;
+
+    for (int i = cutoff; i < sz; ++i) {
+        dblbuf[i] = 0.0;
+    }
+
+    cd.fft->forward(dblbuf, envelope, 0);
+
+
+    for (int i = 0; i <= hs; ++i) {
+        envelope[i] = exp(envelope[i]);
+    }
+    for (int i = 0; i <= hs; ++i) {
+        mag[i] /= envelope[i];
+    }
+
+    if (m_pitchScale > 1.0) {
+        // scaling up, we want a new envelope that is lower by the pitch factor
+        for (int target = 0; target <= hs; ++target) {
+            int source = lrint(target * m_pitchScale);
+            if (source > int(m_windowSize)) {
+                envelope[target] = 0.0;
+            } else {
+                envelope[target] = envelope[source];
+            }
+        }
+    } else {
+        // scaling down, we want a new envelope that is higher by the pitch factor
+        for (int target = hs; target > 0; ) {
+            --target;
+            int source = lrint(target * m_pitchScale);
+            envelope[target] = envelope[source];
+        }
+    }
+
+    for (int i = 0; i <= hs; ++i) {
+        mag[i] *= envelope[i];
+    }
+
+    cd.unchanged = false;
 }
 
@@ -672 +860 @@
 RubberBandStretcher::Impl::synthesiseChunk(size_t channel)
 {
+    Profiler profiler("RubberBandStretcher::Impl::synthesiseChunk");
+
+
+    if ((m_options & OptionFormantPreserved) &&
+        (m_pitchScale != 1.0)) {
+        formantShiftChunk(channel);
+    }
+
     ChannelData &cd = *m_channelData[channel];
 
-    cd.fft->inversePolar(cd.mag, cd.phase, cd.dblbuf);
-
-    for (size_t i = 0; i < m_windowSize/2; ++i) {
-        cd.fltbuf[i] = cd.dblbuf[i + m_windowSize/2];
-        cd.fltbuf[i + m_windowSize/2] = cd.dblbuf[i];
-    }
-
-    // our ffts produced unscaled results
-    for (size_t i = 0; i < m_windowSize; ++i) {
-        cd.fltbuf[i] = cd.fltbuf[i] / m_windowSize;
-    }
-
-    m_window->cut(cd.fltbuf);
-
-    for (size_t i = 0; i < m_windowSize; ++i) {
-        cd.accumulator[i] += cd.fltbuf[i];
+    double *const R__ dblbuf = cd.dblbuf;
+    float *const R__ fltbuf = cd.fltbuf;
+    float *const R__ accumulator = cd.accumulator;
+    float *const R__ windowAccumulator = cd.windowAccumulator;
+    
+    int sz = m_windowSize;
+    int hs = m_windowSize/2;
+    int i;
+
+
+    if (!cd.unchanged) {
+
+        cd.fft->inversePolar(cd.mag, cd.phase, cd.dblbuf);
+
+        if (cd.oversample > 1) {
+
+            int bufsiz = sz * cd.oversample;
+            int hbs = hs * cd.oversample;
+            int offset = (bufsiz - sz) / 2;
+
+            for (i = 0; i < hbs; ++i) {
+                double tmp = dblbuf[i];
+                dblbuf[i] = dblbuf[i + hbs];
+                dblbuf[i + hbs] = tmp;
+            }
+            for (i = 0; i < sz; ++i) {
+                fltbuf[i] = float(dblbuf[i + offset]);
+            }
+        } else {
+            for (i = 0; i < hs; ++i) {
+                fltbuf[i] = float(dblbuf[i + hs]);
+            }
+            for (i = 0; i < hs; ++i) {
+                fltbuf[i + hs] = float(dblbuf[i]);
+            }
+        }
+
+        float denom = float(sz * cd.oversample);
+
+        // our ffts produced unscaled results
+        for (i = 0; i < sz; ++i) {
+            fltbuf[i] = fltbuf[i] / denom;
+        }
+    }
+
+    m_window->cut(fltbuf);
+
+    for (i = 0; i < sz; ++i) {
+        accumulator[i] += fltbuf[i];
     }
 
     cd.accumulatorFill = m_windowSize;
 
-    float fixed = m_window->getArea() * 1.5;
-
-    for (size_t i = 0; i < m_windowSize; ++i) {
+    float fixed = m_window->getArea() * 1.5f;
+
+    for (i = 0; i < sz; ++i) {
         float val = m_window->getValue(i);
-        cd.windowAccumulator[i] += val * fixed;
+        windowAccumulator[i] += val * fixed;
     }
 }
@@ -705 +934 @@
 RubberBandStretcher::Impl::writeChunk(size_t channel, size_t shiftIncrement, bool last)
 {
+    Profiler profiler("RubberBandStretcher::Impl::writeChunk");
+
     ChannelData &cd = *m_channelData[channel];
-
+    
+    float *const R__ accumulator = cd.accumulator;
+    float *const R__ windowAccumulator = cd.windowAccumulator;
+
+    const int sz = m_windowSize;
+    const int si = shiftIncrement;
+
+    int i;
+    
     if (m_debugLevel > 2) {
         cerr << "writeChunk(" << channel << ", " << shiftIncrement << ", " << last << ")" << endl;
     }
 
-    for (size_t i = 0; i < shiftIncrement; ++i) {
-        if (cd.windowAccumulator[i] > 0.f) {
-            cd.accumulator[i] /= cd.windowAccumulator[i];
+    for (i = 0; i < si; ++i) {
+        if (windowAccumulator[i] > 0.f) {
+            accumulator[i] /= windowAccumulator[i];
         }
     }
@@ -724 +963 @@
     }
 
-    if (m_pitchScale != 1.0 && cd.resampler) {
-
-        size_t reqSize = int(ceil(shiftIncrement / m_pitchScale));
+    bool resampledAlready = resampleBeforeStretching();
+
+    if (!resampledAlready &&
+        (m_pitchScale != 1.0 || m_options & OptionPitchHighConsistency) &&
+        cd.resampler) {
+
+        size_t reqSize = int(ceil(si / m_pitchScale));
         if (reqSize > cd.resamplebufSize) {
             // This shouldn't normally happen -- the buffer is
@@ -735 +978 @@
             cerr << "WARNING: RubberBandStretcher::Impl::writeChunk: resizing resampler buffer from "
                       << cd.resamplebufSize << " to " << reqSize << endl;
-            cd.resamplebufSize = reqSize;
-            if (cd.resamplebuf) delete[] cd.resamplebuf;
-            cd.resamplebuf = new float[cd.resamplebufSize];
+            cd.setResampleBufSize(reqSize);
         }
 
@@ -743 +984 @@
         size_t outframes = cd.resampler->resample(&cd.accumulator,
                                                   &cd.resamplebuf,
-                                                  shiftIncrement,
+                                                  si,
                                                   1.0 / m_pitchScale,
                                                   last);
@@ -752 +993 @@
 
     } else {
-        writeOutput(*cd.outbuf, cd.accumulator,
-                    shiftIncrement, cd.outCount, theoreticalOut);
-    }
-    
-    for (size_t i = 0; i < m_windowSize - shiftIncrement; ++i) {
-        cd.accumulator[i] = cd.accumulator[i + shiftIncrement];
-    }
-    
-    for (size_t i = m_windowSize - shiftIncrement; i < m_windowSize; ++i) {
-        cd.accumulator[i] = 0.0f;
-    }
-    
-    for (size_t i = 0; i < m_windowSize - shiftIncrement; ++i) {
-        cd.windowAccumulator[i] = cd.windowAccumulator[i + shiftIncrement];
-    }
-    
-    for (size_t i = m_windowSize - shiftIncrement; i < m_windowSize; ++i) {
-        cd.windowAccumulator[i] = 0.0f;
-    }
-    
-    if (cd.accumulatorFill > shiftIncrement) {
-        cd.accumulatorFill -= shiftIncrement;
+        writeOutput(*cd.outbuf, accumulator,
+                    si, cd.outCount, theoreticalOut);
+    }
+    
+    for (i = 0; i < sz - si; ++i) {
+        accumulator[i] = accumulator[i + si];
+    }
+    
+    for (i = sz - si; i < sz; ++i) {
+        accumulator[i] = 0.0f;
+    }
+    
+    for (i = 0; i < sz - si; ++i) {
+        windowAccumulator[i] = windowAccumulator[i + si];
+    }
+    
+    for (i = sz - si; i < sz; ++i) {
+        windowAccumulator[i] = 0.0f;
+    }
+    
+    if (int(cd.accumulatorFill) > si) {
+        cd.accumulatorFill -= si;
     } else {
         cd.accumulatorFill = 0;
@@ -788 +1029 @@
 RubberBandStretcher::Impl::writeOutput(RingBuffer<float> &to, float *from, size_t qty, size_t &outCount, size_t theoreticalOut)
 {
+    Profiler profiler("RubberBandStretcher::Impl::writeOutput");
+
     // In non-RT mode, we don't want to write the first startSkip
     // samples, because the first chunk is centred on the start of the
@@ -860 +1103 @@
 RubberBandStretcher::Impl::available() const
 {
+    Profiler profiler("RubberBandStretcher::Impl::available");
+
     if (m_threaded) {
         MutexLocker locker(&m_threadSetMutex);
@@ -907 +1152 @@
 RubberBandStretcher::Impl::retrieve(float *const *output, size_t samples) const
 {
+    Profiler profiler("RubberBandStretcher::Impl::retrieve");
+
     size_t got = samples;
 

trunk/rubberband/src/Thread.cpp

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -16 +16 @@
 
 #include <iostream>
+#include <cstdlib>
 
 #include <sys/time.h>
 #include <time.h>
-
-//#define DEBUG_THREAD 1
-//#define DEBUG_MUTEX 1
-//#define DEBUG_CONDITION 1
 
 using std::cerr;
@@ -108 +105 @@
 }
 
-Mutex::Mutex() :
-    m_locked(false)
+Mutex::Mutex()
+#ifndef NO_THREAD_CHECKS
+    :
+    m_lockedBy(-1)
+#endif
 {
     m_mutex = CreateMutex(NULL, FALSE, NULL);
@@ -128 +128 @@
 Mutex::lock()
 {
-    if (m_locked) {
+#ifndef NO_THREAD_CHECKS
+    DWORD tid = GetCurrentThreadId();
+    if (m_lockedBy == tid) {
         cerr << "ERROR: Deadlock on mutex " << &m_mutex << endl;
     }
-#ifdef DEBUG_MUTEX
-    cerr << "MUTEX DEBUG: " << (void *)GetCurrentThreadId() << ": Want to lock mutex " << &m_mutex << endl;
+#endif
+#ifdef DEBUG_MUTEX
+    cerr << "MUTEX DEBUG: " << (void *)tid << ": Want to lock mutex " << &m_mutex << endl;
 #endif
     WaitForSingleObject(m_mutex, INFINITE);
-    m_locked = true;
-#ifdef DEBUG_MUTEX
-    cerr << "MUTEX DEBUG: " << (void *)GetCurrentThreadId() << ": Locked mutex " << &m_mutex << endl;
+#ifndef NO_THREAD_CHECKS
+    m_lockedBy = tid;
+#endif
+#ifdef DEBUG_MUTEX
+    cerr << "MUTEX DEBUG: " << (void *)tid << ": Locked mutex " << &m_mutex << endl;
 #endif
 }
@@ -144 +149 @@
 Mutex::unlock()
 {
-#ifdef DEBUG_MUTEX
-    cerr << "MUTEX DEBUG: " << (void *)GetCurrentThreadId() << ": Unlocking mutex " << &m_mutex << endl;
-#endif
-    m_locked = false;
+#ifndef NO_THREAD_CHECKS
+    DWORD tid = GetCurrentThreadId();
+    if (m_lockedBy != tid) {
+        cerr << "ERROR: Mutex " << &m_mutex << " not owned by unlocking thread" << endl;
+        return;
+    }
+#endif
+#ifdef DEBUG_MUTEX
+    cerr << "MUTEX DEBUG: " << (void *)tid << ": Unlocking mutex " << &m_mutex << endl;
+#endif
+#ifndef NO_THREAD_CHECKS
+    m_lockedBy = -1;
+#endif
     ReleaseMutex(m_mutex);
 }
@@ -154 +168 @@
 Mutex::trylock()
 {
+#ifndef NO_THREAD_CHECKS
+    DWORD tid = GetCurrentThreadId();
+#endif
     DWORD result = WaitForSingleObject(m_mutex, 0);
     if (result == WAIT_TIMEOUT || result == WAIT_FAILED) {
 #ifdef DEBUG_MUTEX
-        cerr << "MUTEX DEBUG: " << (void *)GetCurrentThreadId() << ": Mutex " << &m_mutex << " unavailable" << endl;
+        cerr << "MUTEX DEBUG: " << (void *)tid << ": Mutex " << &m_mutex << " unavailable" << endl;
 #endif
         return false;
     } else {
-        m_locked = true;
-#ifdef DEBUG_MUTEX
-        cerr << "MUTEX DEBUG: " << (void *)GetCurrentThreadId() << ": Locked mutex " << &m_mutex << " (from trylock)" << endl;
+#ifndef NO_THREAD_CHECKS
+        m_lockedBy = tid;
+#endif
+#ifdef DEBUG_MUTEX
+        cerr << "MUTEX DEBUG: " << (void *)tid << ": Locked mutex " << &m_mutex << " (from trylock)" << endl;
 #endif
         return true;
@@ -170 +189 @@
 
 Condition::Condition(string name) :
-    m_name(name),
     m_locked(false)
+#ifdef DEBUG_CONDITION
+    , m_name(name)
+#endif
 {
     m_mutex = CreateMutex(NULL, FALSE, NULL);
@@ -344 +365 @@
 }
 
-Mutex::Mutex() :
+Mutex::Mutex()
+#ifndef NO_THREAD_CHECKS
+    :
+    m_lockedBy(0),
     m_locked(false)
+#endif
 {
     pthread_mutex_init(&m_mutex, 0);
@@ -364 +389 @@
 Mutex::lock()
 {
-    if (m_locked) {
+#ifndef NO_THREAD_CHECKS
+    pthread_t tid = pthread_self();
+    if (m_locked && m_lockedBy == tid) {
         cerr << "ERROR: Deadlock on mutex " << &m_mutex << endl;
     }
-#ifdef DEBUG_MUTEX
-    cerr << "MUTEX DEBUG: " << (void *)pthread_self() << ": Want to lock mutex " << &m_mutex << endl;
+#endif
+#ifdef DEBUG_MUTEX
+    cerr << "MUTEX DEBUG: " << (void *)tid << ": Want to lock mutex " << &m_mutex << endl;
 #endif
     pthread_mutex_lock(&m_mutex);
+#ifndef NO_THREAD_CHECKS
+    m_lockedBy = tid;
     m_locked = true;
-#ifdef DEBUG_MUTEX
-    cerr << "MUTEX DEBUG: " << (void *)pthread_self() << ": Locked mutex " << &m_mutex << endl;
+#endif
+#ifdef DEBUG_MUTEX
+    cerr << "MUTEX DEBUG: " << (void *)tid << ": Locked mutex " << &m_mutex << endl;
 #endif
 }
@@ -380 +411 @@
 Mutex::unlock()
 {
-#ifdef DEBUG_MUTEX
-    cerr << "MUTEX DEBUG: " << (void *)pthread_self() << ": Unlocking mutex " << &m_mutex << endl;
-#endif
+#ifndef NO_THREAD_CHECKS
+    pthread_t tid = pthread_self();
+    if (!m_locked) {
+        cerr << "ERROR: Mutex " << &m_mutex << " not locked in unlock" << endl;
+        return;
+    } else if (m_lockedBy != tid) {
+        cerr << "ERROR: Mutex " << &m_mutex << " not owned by unlocking thread" << endl;
+        return;
+    }
+#endif
+#ifdef DEBUG_MUTEX
+    cerr << "MUTEX DEBUG: " << (void *)tid << ": Unlocking mutex " << &m_mutex << endl;
+#endif
+#ifndef NO_THREAD_CHECKS
     m_locked = false;
+#endif
     pthread_mutex_unlock(&m_mutex);
 }
@@ -390 +433 @@
 Mutex::trylock()
 {
+#ifndef NO_THREAD_CHECKS
+    pthread_t tid = pthread_self();
+#endif
     if (pthread_mutex_trylock(&m_mutex)) {
 #ifdef DEBUG_MUTEX
-        cerr << "MUTEX DEBUG: " << (void *)pthread_self() << ": Mutex " << &m_mutex << " unavailable" << endl;
+        cerr << "MUTEX DEBUG: " << (void *)tid << ": Mutex " << &m_mutex << " unavailable" << endl;
 #endif
         return false;
     } else {
+#ifndef NO_THREAD_CHECKS
+        m_lockedBy = tid;
         m_locked = true;
-#ifdef DEBUG_MUTEX
-        cerr << "MUTEX DEBUG: " << (void *)pthread_self() << ": Locked mutex " << &m_mutex << " (from trylock)" << endl;
+#endif
+#ifdef DEBUG_MUTEX
+        cerr << "MUTEX DEBUG: " << (void *)tid << ": Locked mutex " << &m_mutex << " (from trylock)" << endl;
 #endif
         return true;
@@ -405 +454 @@
 
 Condition::Condition(string name) :
-    m_locked(false),
-    m_name(name)
+    m_locked(false)
+#ifdef DEBUG_CONDITION
+    , m_name(name)
+#endif
 {
     pthread_mutex_init(&m_mutex, 0);

trunk/rubberband/src/Thread.h

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -23 +23 @@
 
 #include <string>
+
+//#define DEBUG_THREAD 1
+//#define DEBUG_MUTEX 1
+//#define DEBUG_CONDITION 1
 
 namespace RubberBand
@@ -74 +78 @@
 #ifdef _WIN32
     HANDLE m_mutex;
-    bool m_locked;
+#ifndef NO_THREAD_CHECKS
+    DWORD m_lockedBy;
+#endif
 #else
     pthread_mutex_t m_mutex;
+#ifndef NO_THREAD_CHECKS
+    pthread_t m_lockedBy;
     bool m_locked;
+#endif
 #endif
 };
@@ -114 +123 @@
     
 private:
+
 #ifdef _WIN32
     HANDLE m_mutex;
+    HANDLE m_condition;
     bool m_locked;
-    HANDLE m_condition;
-    std::string m_name;
 #else
     pthread_mutex_t m_mutex;
+    pthread_cond_t m_condition;
     bool m_locked;
-    pthread_cond_t m_condition;
+#endif
+#ifdef DEBUG_CONDITION
     std::string m_name;
 #endif

trunk/rubberband/src/Window.cpp

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -13 +13 @@
 */
 
-#include "AudioCurve.h"
-
-namespace RubberBand
-{
-
-AudioCurve::AudioCurve(size_t sampleRate, size_t windowSize) :
-    m_sampleRate(sampleRate),
-    m_windowSize(windowSize)
-{
-}
-
-AudioCurve::~AudioCurve()
-{
-}
+#include "Window.h"
 
 
-}

trunk/rubberband/src/Window.h

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -18 +18 @@
 #include <cmath>
 #include <iostream>
+#include <cstdlib>
 #include <map>
+
+#include "sysutils.h"
 
 namespace RubberBand {
@@ -41 +44 @@
      * Construct a windower of the given type.
      */
-    Window(WindowType type, size_t size) : m_type(type), m_size(size) { encache(); }
+    Window(WindowType type, int size) : m_type(type), m_size(size) { encache(); }
     Window(const Window &w) : m_type(w.m_type), m_size(w.m_size) { encache(); }
     Window &operator=(const Window &w) {
@@ -52 +55 @@
     virtual ~Window() { delete[] m_cache; }
     
-    void cut(T *src) const { cut(src, src); }
-    void cut(T *src, T *dst) const {
-        for (size_t i = 0; i < m_size; ++i) dst[i] = src[i] * m_cache[i];
+    void cut(T *R__ src) const
+    {
+        const int sz = m_size;
+        for (int i = 0; i < sz; ++i) {
+            src[i] *= m_cache[i];
+        }
+    }
+
+    void cut(T *R__ src, T *dst) const {
+        const int sz = m_size;
+        for (int i = 0; i < sz; ++i) {
+            dst[i] = src[i];
+        }
+        for (int i = 0; i < sz; ++i) {
+            dst[i] *= m_cache[i];
+        }
     }
 
     T getArea() { return m_area; }
-    T getValue(size_t i) { return m_cache[i]; }
+    T getValue(int i) { return m_cache[i]; }
 
     WindowType getType() const { return m_type; }
-    size_t getSize() const { return m_size; }
+    int getSize() const { return m_size; }
 
 protected:
     WindowType m_type;
-    size_t m_size;
-    T *m_cache;
+    int m_size;
+    T *R__ m_cache;
     T m_area;
     

trunk/rubberband/src/sysutils.cpp

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -27 +27 @@
 
 #include <iostream>
+
 
 namespace RubberBand {
@@ -82 +83 @@
 #ifdef _WIN32
 
-void gettimeofday(struct timeval *tv, void *tz)
+int gettimeofday(struct timeval *tv, void *tz)
 {
     union { 
@@ -92 +93 @@
     tv->tv_usec = (long)((now.ns100 / 10LL) % 1000000LL); 
     tv->tv_sec = (long)((now.ns100 - 116444736000000000LL) / 10000000LL); 
+    return 0;
 }
 
@@ -101 +103 @@
 #endif
 
+
+float *allocFloat(float *ptr, int count)
+{
+    if (ptr) free((void *)ptr);
+    void *allocated;
+#ifndef _WIN32
+    if (!posix_memalign(&allocated, 16, count * sizeof(float)))
+#endif
+        allocated = malloc(count * sizeof(float));
+    for (int i = 0; i < count; ++i) ((float *)allocated)[i] = 0.f;
+    return (float *)allocated;
+}
+
+float *allocFloat(int count)
+{
+    return allocFloat(0, count);
+}
+
+void freeFloat(float *ptr)
+{
+    if (ptr) free(ptr);
+}
+      
+double *allocDouble(double *ptr, int count)
+{
+    if (ptr) free((void *)ptr);
+    void *allocated;
+#ifndef _WIN32
+    if (!posix_memalign(&allocated, 16, count * sizeof(double)))
+#endif
+        allocated = malloc(count * sizeof(double));
+    for (int i = 0; i < count; ++i) ((double *)allocated)[i] = 0.f;
+    return (double *)allocated;
+}
+
+double *allocDouble(int count)
+{
+    return allocDouble(0, count);
+}
+
+void freeDouble(double *ptr)
+{
+    if (ptr) free(ptr);
+}
+ 
+
 }
 

trunk/rubberband/src/sysutils.h

@@ -4 +4 @@
     Rubber Band
     An audio time-stretching and pitch-shifting library.
-    Copyright 2007 Chris Cannam.
+    Copyright 2007-2008 Chris Cannam.
     
     This program is free software; you can redistribute it and/or
@@ -16 +16 @@
 #define _RUBBERBAND_SYSINFO_H_
 
+#ifdef __MSVC__
+#include "bsd-3rdparty/float_cast/float_cast.h"
+#define R__ __restrict
+#endif
+
+#ifdef __GNUC__
+#define R__ __restrict__
+#endif
+
+#ifndef R__
+#define R__
+#endif
+
+#ifdef __MINGW32__
+#include <malloc.h>
+#endif
+
+#ifdef __MSVC__
+#define alloca _alloca
+#endif
+
 namespace RubberBand {
 
@@ -21 +42 @@
 
 #ifdef _WIN32
+
 struct timeval { long tv_sec; long tv_usec; };
-void gettimeofday(struct timeval *p, void *tz);
+int gettimeofday(struct timeval *p, void *tz);
+
 void usleep(unsigned long);
+
 #endif
+
+extern float *allocFloat(int);    
+extern float *allocFloat(float *, int);
+extern void freeFloat(float *);
+
+extern double *allocDouble(int);    
+extern double *allocDouble(double *, int);
+extern void freeDouble(double *);
 
 }