bool realtime = false;
bool precise = false;
bool peaklock = true;
- bool softening = true;
bool longwin = false;
bool shortwin = false;
string txt;
if (realtime) options |= RubberBandStretcher::OptionProcessRealTime;
if (precise) options |= RubberBandStretcher::OptionStretchPrecise;
if (!peaklock) options |= RubberBandStretcher::OptionPhaseIndependent;
- if (!softening) options |= RubberBandStretcher::OptionPhasePeakLocked;
if (longwin) options |= RubberBandStretcher::OptionWindowLong;
if (shortwin) options |= RubberBandStretcher::OptionWindowShort;
/*
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
modify it under the terms of the GNU General Public License as
#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
* options should normally be set in the constructor, as a bitwise
* during non-transient segments. These options may be changed at
* 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 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 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 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
* model of the stretcher. These options may not be changed after
* \li \c OptionWindowLong - Use a longer window. This is
* 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.
*/
- typedef int Options;
- static const int OptionProcessOffline = 0x00000000;
- static const int OptionProcessRealTime = 0x00000001;
+ enum Option {
+
+ OptionProcessOffline = 0x00000000,
+ OptionProcessRealTime = 0x00000001,
- static const int OptionStretchElastic = 0x00000000;
- static const int OptionStretchPrecise = 0x00000010;
+ OptionStretchElastic = 0x00000000,
+ OptionStretchPrecise = 0x00000010,
- static const int OptionTransientsCrisp = 0x00000000;
- static const int OptionTransientsMixed = 0x00000100;
- static const int OptionTransientsSmooth = 0x00000200;
+ OptionTransientsCrisp = 0x00000000,
+ OptionTransientsMixed = 0x00000100,
+ OptionTransientsSmooth = 0x00000200,
- static const int OptionPhaseAdaptive = 0x00000000;
- static const int OptionPhasePeakLocked = 0x00001000;
- static const int OptionPhaseIndependent = 0x00002000;
+ OptionPhaseLaminar = 0x00000000,
+ OptionPhaseIndependent = 0x00002000,
- static const int OptionThreadingAuto = 0x00000000;
- static const int OptionThreadingNever = 0x00010000;
- static const int OptionThreadingAlways = 0x00020000;
+ OptionThreadingAuto = 0x00000000,
+ OptionThreadingNever = 0x00010000,
+ OptionThreadingAlways = 0x00020000,
- static const int OptionWindowStandard = 0x00000000;
- static const int OptionWindowShort = 0x00100000;
- static const int OptionWindowLong = 0x00200000;
+ OptionWindowStandard = 0x00000000,
+ OptionWindowShort = 0x00100000,
+ OptionWindowLong = 0x00200000,
+
+ OptionFormantShifted = 0x00000000,
+ OptionFormantPreserved = 0x01000000,
+
+ OptionPitchHighSpeed = 0x00000000,
+ OptionPitchHighQuality = 0x02000000,
+ OptionPitchHighConsistency = 0x04000000
+ };
+
+ typedef int Options;
- static const int DefaultOptions = 0x00000000;
- static const int PercussiveOptions = OptionWindowShort | \
- OptionPhaseIndependent;
+ enum PresetOption {
+ DefaultOptions = 0x00000000,
+ PercussiveOptions = 0x00102000
+ };
/**
* Construct a time and pitch stretcher object to run at the given
Options options = DefaultOptions,
double initialTimeRatio = 1.0,
double initialPitchScale = 1.0);
- virtual ~RubberBandStretcher();
+ ~RubberBandStretcher();
/**
* Reset the stretcher's internal buffers. The stretcher should
* subsequently behave as if it had just been constructed
* (although retaining the current time and pitch ratio).
*/
- virtual void reset();
+ void reset();
/**
* Set the time ratio for the stretcher. This is the ratio of
* mechanism to ensure that setTimeRatio and process() cannot be
* run at once (there is no internal mutex for this purpose).
*/
- virtual void setTimeRatio(double ratio);
+ void setTimeRatio(double ratio);
/**
* Set the pitch scaling ratio for the stretcher. This is the
* mechanism to ensure that setPitchScale and process() cannot be
* run at once (there is no internal mutex for this purpose).
*/
- virtual void setPitchScale(double scale);
+ void setPitchScale(double scale);
/**
* Return the last time ratio value that was set (either on
* construction or with setTimeRatio()).
*/
- virtual double getTimeRatio() const;
+ double getTimeRatio() const;
/**
* Return the last pitch scaling ratio value that was set (either
* on construction or with setPitchScale()).
*/
- virtual double getPitchScale() const;
+ double getPitchScale() const;
/**
* Return the processing latency of the stretcher. This is the
* In RealTime mode, the latency may depend on the time and pitch
* ratio and other options.
*/
- virtual size_t getLatency() const;
+ size_t getLatency() const;
/**
* Change an OptionTransients configuration setting. This may be
* Offline mode (for which the transients option is fixed on
* construction).
*/
- virtual void setTransientsOption(Options options);
+ void setTransientsOption(Options options);
/**
* Change an OptionPhase configuration setting. This may be
* may not take effect immediately if processing is already under
* 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);
/**
* Tell the stretcher exactly how many input samples it will
* exactly correct. In RealTime mode no such guarantee is
* possible and this value is ignored.
*/
- virtual void setExpectedInputDuration(size_t samples);
+ void setExpectedInputDuration(size_t samples);
/**
* Ask the stretcher how many audio sample frames should be
* study() (to which you may pass any number of samples at a time,
* and from which there is no output).
*/
- virtual size_t getSamplesRequired() const;
+ size_t getSamplesRequired() const;
/**
* Tell the stretcher the maximum number of sample frames that you
* study() (to which you may pass any number of samples at a time,
* and from which there is no output).
*/
- virtual void setMaxProcessSize(size_t samples);
+ void setMaxProcessSize(size_t samples);
/**
* Provide a block of "samples" sample frames for the stretcher to
* Set "final" to true if this is the last block of data that will
* 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);
/**
* Provide a block of "samples" sample frames for processing.
*
* 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);
/**
* Ask the stretcher how many audio sample frames of output data
* This function returns -1 if all data has been fully processed
* and all output read, and the stretch process is now finished.
*/
- virtual int available() const;
+ int available() const;
/**
* Obtain some processed output data from the stretcher. Up to
* The return value is the actual number of sample frames
* retrieved.
*/
- virtual size_t retrieve(float *const *output, size_t samples) const;
+ size_t retrieve(float *const *output, size_t samples) const;
- virtual float getFrequencyCutoff(int n) const;
- virtual void setFrequencyCutoff(int n, float f);
-
- virtual size_t getInputIncrement() const;
- virtual std::vector<int> getOutputIncrements() const; //!!! document particular meaning in RT mode
- virtual std::vector<float> getPhaseResetCurve() const; //!!! document particular meaning in RT mode
- virtual std::vector<int> getExactTimePoints() const; //!!! meaningless in RT mode
+ /**
+ * Return the value of internal frequency cutoff value n.
+ *
+ * This function is not for general use.
+ */
+ float getFrequencyCutoff(int n) const;
- virtual size_t getChannelCount() const;
+ /**
+ * Set the value of internal frequency cutoff n to f Hz.
+ *
+ * This function is not for general use.
+ */
+ void setFrequencyCutoff(int n, float f);
- virtual void calculateStretch();
+ /**
+ * Retrieve the value of the internal input block increment value.
+ *
+ * This function is provided for diagnostic purposes only.
+ */
+ size_t getInputIncrement() const;
+
+ /**
+ * In offline mode, retrieve the sequence of internal block
+ * increments for output, for the entire audio data, provided the
+ * stretch profile has been calculated. In realtime mode,
+ * retrieve any output increments that have accumulated since the
+ * last call to getOutputIncrements, to a limit of 16.
+ *
+ * This function is provided for diagnostic purposes only.
+ */
+ std::vector<int> getOutputIncrements() const;
- virtual void setDebugLevel(int level);
+ /**
+ * In offline mode, retrieve the sequence of internal phase reset
+ * detection function values, for the entire audio data, provided
+ * the stretch profile has been calculated. In realtime mode,
+ * retrieve any phase reset points that have accumulated since the
+ * last call to getPhaseResetCurve, to a limit of 16.
+ *
+ * This function is provided for diagnostic purposes only.
+ */
+ std::vector<float> getPhaseResetCurve() const;
+ /**
+ * In offline mode, retrieve the sequence of internal frames for
+ * which exact timing has been sought, for the entire audio data,
+ * provided the stretch profile has been calculated. In realtime
+ * mode, return an empty sequence.
+ *
+ * This function is provided for diagnostic purposes only.
+ */
+ std::vector<int> getExactTimePoints() const;
+
+ /**
+ * Return the number of channels this stretcher was constructed
+ * with.
+ */
+ size_t getChannelCount() const;
+
+ /**
+ * Force the stretcher to calculate a stretch profile. Normally
+ * this happens automatically for the first process() call in
+ * offline mode.
+ *
+ * This function is provided for diagnostic purposes only.
+ */
+ void calculateStretch();
+
+ /**
+ * Set the level of debug output. The value may be from 0 (errors
+ * only) to 3 (very verbose, with audible ticks in the output at
+ * phase reset points). The default is whatever has been set
+ * using setDefaultDebugLevel, or 0 if that function has not been
+ * called.
+ */
+ void setDebugLevel(int level);
+
+ /**
+ * Set the default level of debug output for subsequently
+ * constructed stretchers.
+ *
+ * @see setDebugLevel
+ */
static void setDefaultDebugLevel(int level);
protected:
--- /dev/null
+/* -*- 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.
+*/
+
+#ifndef _RUBBERBAND_C_API_H_
+#define _RUBBERBAND_C_API_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define RUBBERBAND_VERSION "1.2.0-gpl"
+#define RUBBERBAND_API_MAJOR_VERSION 2
+#define RUBBERBAND_API_MINOR_VERSION 0
+
+/**
+ * This is a C-linkage interface to the Rubber Band time stretcher.
+ *
+ * This is a wrapper interface: the primary interface is in C++ and is
+ * defined and documented in RubberBandStretcher.h. The library
+ * itself is implemented in C++, and requires C++ standard library
+ * support even when using the C-linkage API.
+ *
+ * Please see RubberBandStretcher.h for documentation.
+ *
+ * If you are writing to the C++ API, do not include this header.
+ */
+
+enum RubberBandOption {
+
+ RubberBandOptionProcessOffline = 0x00000000,
+ RubberBandOptionProcessRealTime = 0x00000001,
+
+ RubberBandOptionStretchElastic = 0x00000000,
+ RubberBandOptionStretchPrecise = 0x00000010,
+
+ RubberBandOptionTransientsCrisp = 0x00000000,
+ RubberBandOptionTransientsMixed = 0x00000100,
+ RubberBandOptionTransientsSmooth = 0x00000200,
+
+ RubberBandOptionPhaseLaminar = 0x00000000,
+ RubberBandOptionPhaseIndependent = 0x00002000,
+
+ RubberBandOptionThreadingAuto = 0x00000000,
+ RubberBandOptionThreadingNever = 0x00010000,
+ RubberBandOptionThreadingAlways = 0x00020000,
+
+ RubberBandOptionWindowStandard = 0x00000000,
+ RubberBandOptionWindowShort = 0x00100000,
+ RubberBandOptionWindowLong = 0x00200000,
+
+ RubberBandOptionFormantShifted = 0x00000000,
+ RubberBandOptionFormantPreserved = 0x01000000,
+
+ RubberBandOptionPitchHighQuality = 0x00000000,
+ RubberBandOptionPitchHighSpeed = 0x02000000,
+ RubberBandOptionPitchHighConsistency = 0x04000000
+};
+
+typedef int RubberBandOptions;
+
+struct RubberBandState_;
+typedef struct RubberBandState_ *RubberBandState;
+
+extern RubberBandState rubberband_new(unsigned int sampleRate,
+ unsigned int channels,
+ RubberBandOptions options,
+ double initialTimeRatio,
+ double initialPitchScale);
+
+extern void rubberband_delete(RubberBandState);
+
+extern void rubberband_reset(RubberBandState);
+
+extern void rubberband_set_time_ratio(RubberBandState, double ratio);
+extern void rubberband_set_pitch_scale(RubberBandState, double scale);
+
+extern double rubberband_get_time_ratio(const RubberBandState);
+extern double rubberband_get_pitch_scale(const RubberBandState);
+
+extern unsigned int rubberband_get_latency(const RubberBandState);
+
+extern void rubberband_set_transients_option(RubberBandState, RubberBandOptions options);
+extern void rubberband_set_phase_option(RubberBandState, RubberBandOptions options);
+extern void rubberband_set_formant_option(RubberBandState, RubberBandOptions options);
+extern void rubberband_set_pitch_option(RubberBandState, RubberBandOptions options);
+
+extern void rubberband_set_expected_input_duration(RubberBandState, unsigned int samples);
+
+extern unsigned int rubberband_get_samples_required(const RubberBandState);
+
+extern void rubberband_set_max_process_size(RubberBandState, unsigned int samples);
+
+extern void rubberband_study(RubberBandState, const float *const *input, unsigned int samples, int final);
+extern void rubberband_process(RubberBandState, const float *const *input, unsigned int samples, int final);
+
+extern int rubberband_available(const RubberBandState);
+extern unsigned int rubberband_retrieve(const RubberBandState, float *const *output, unsigned int samples);
+
+extern unsigned int rubberband_get_channel_count(const RubberBandState);
+
+extern void rubberband_calculate_stretch(RubberBandState);
+
+extern void rubberband_set_debug_level(RubberBandState, int level);
+extern void rubberband_set_default_debug_level(int level);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
/*
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
modify it under the terms of the GNU General Public License as
#include "AudioCurve.h"
+#include <iostream>
+using namespace std;
+
namespace RubberBand
{
{
}
+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;
+}
}
/*
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
modify it under the terms of the GNU General Public License as
#include <sys/types.h>
+#include "sysutils.h"
+
namespace RubberBand
{
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;
protected:
/*
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
modify it under the terms of the GNU General Public License as
}
float
-ConstantAudioCurve::process(float *, size_t)
+ConstantAudioCurve::process(const float *R__, size_t)
{
return 1.f;
}
/*
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
modify it under the terms of the GNU General Public License as
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();
};
/*
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
modify it under the terms of the GNU General Public License as
#include "FFT.h"
#include "Thread.h"
+#include "Profiler.h"
+//#define FFT_MEASUREMENT 1
+#define HAVE_FFTW3 // for Ardour
+
+#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>
#include <iostream>
virtual void initFloat() = 0;
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(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(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 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(double *realIn, double *imagIn, double *realOut) = 0;
- virtual void inversePolar(double *magIn, double *phaseIn, double *realOut) = 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(float *realIn, float *imagIn, float *realOut) = 0;
- virtual void inversePolar(float *magIn, float *phaseIn, float *realOut) = 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;
virtual double *getDoubleTimeBuffer() = 0;
};
+namespace FFTs {
+#ifdef HAVE_FFTW3
// Define FFTW_DOUBLE_ONLY to make all uses of FFTW functions be
// double-precision (so "float" FFTs are calculated by casting to
//#define FFTW_DOUBLE_ONLY 1
//#define FFTW_FLOAT_ONLY 1
-#ifdef FFTW_DOUBLE_ONLY
-#ifdef FFTW_FLOAT_ONLY
-#error Building for FFTW-DOUBLE BOTH
+#if defined(FFTW_DOUBLE_ONLY) && defined(FFTW_FLOAT_ONLY)
// Can't meaningfully define both
#undef FFTW_DOUBLE_ONLY
#undef FFTW_FLOAT_ONLY
-#else /* !FFTW_FLOAT_ONLY */
+#endif
+
+#ifdef FFTW_DOUBLE_ONLY
+#define fft_float_type double
#define fftwf_complex fftw_complex
#define fftwf_plan fftw_plan
#define fftwf_plan_dft_r2c_1d fftw_plan_dft_r2c_1d
#define sqrtf sqrt
#define cosf cos
#define sinf sin
-#endif /* !FFTW_FLOAT_ONLY */
-#endif
+#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
#define fftw_plan_dft_r2c_1d fftwf_plan_dft_r2c_1d
#define atan2 atan2f
#define sqrt sqrtf
#define cos cosf
-#define sif sinf
+#define sin sinf
+#else
+#define fft_double_type double
#endif /* FFTW_FLOAT_ONLY */
class D_FFTW : public FFTImpl
{
public:
- D_FFTW(unsigned int size) : m_fplanf(0)
+ D_FFTW(int size) : m_fplanf(0)
#ifdef FFTW_DOUBLE_ONLY
, m_frb(0)
#endif
m_extantMutex.lock();
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);
fftwf_free(m_fbuf);
m_extantMutex.lock();
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);
fftw_free(m_dbuf);
m_extantMutex.unlock();
#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
+ 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));
m_fplanf = fftwf_plan_dft_r2c_1d
m_extantMutex.unlock();
#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
+ 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));
m_dplanf = fftw_plan_dft_r2c_1d
fclose(f);
}
- 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 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(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 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 *re, float *im) {
- for (unsigned int i = 0; i <= m_size/2; ++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][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)
+ if (realIn != 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);
unpackDouble(realOut, imagOut);
}
- 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 != m_dbuf)
+ if (realIn != 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) {
+ for (int i = 0; i <= hs; ++i) {
phaseOut[i] = atan2(m_dpacked[i][1], m_dpacked[i][0]);
}
}
- void forwardMagnitude(double *realIn, double *magOut) {
+ 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]);
}
}
- 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)
+ if (realIn != fbuf)
#endif
- for (unsigned int i = 0; i < m_size; ++i) {
- m_fbuf[i] = realIn[i];
+ for (int i = 0; i < sz; ++i) {
+ fbuf[i] = realIn[i];
}
fftwf_execute(m_fplanf);
unpackFloat(realOut, imagOut);
}
- 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)
+ if (realIn != fbuf)
#endif
- for (unsigned int i = 0; i < m_size; ++i) {
- m_fbuf[i] = realIn[i];
+ 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]) ;
+ for (int i = 0; i <= hs; ++i) {
+ phaseOut[i] = atan2f(m_fpacked[i][1], m_fpacked[i][0]) ;
}
}
- void forwardMagnitude(float *realIn, float *magOut) {
+ 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)
+ if (realIn != fbuf)
#endif
- for (unsigned int i = 0; i < m_size; ++i) {
- m_fbuf[i] = realIn[i];
+ 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]);
}
}
- 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 != 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();
+ 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)
+ if (realOut != dbuf)
#endif
- for (unsigned int i = 0; i < m_size; ++i) {
- realOut[i] = m_dbuf[i];
+ for (int i = 0; i < sz; ++i) {
+ realOut[i] = dbuf[i];
}
}
- void inversePolar(double *magIn, double *phaseIn, double *realOut) {
+ void inverseCepstral(const double *R__ magIn, double *R__ cepOut) {
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]);
+ 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 (realOut != m_dbuf)
+ if (cepOut != dbuf)
#endif
- for (unsigned int i = 0; i < m_size; ++i) {
- realOut[i] = m_dbuf[i];
+ for (int i = 0; i < sz; ++i) {
+ cepOut[i] = dbuf[i];
}
}
- void inverse(float *realIn, float *imagIn, float *realOut) {
+ 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 != 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();
+ 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)
+ if (realOut != fbuf)
#endif
- for (unsigned int i = 0; i < m_size; ++i) {
- realOut[i] = m_fbuf[i];
+ for (int i = 0; i < sz; ++i) {
+ realOut[i] = fbuf[i];
}
}
- void inversePolar(float *magIn, float *phaseIn, float *realOut) {
+ void inverseCepstral(const float *R__ magIn, float *R__ cepOut) {
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] = 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 (realOut != m_fbuf)
+ if (cepOut != fbuf)
#endif
- for (unsigned int i = 0; i < m_size; ++i) {
- realOut[i] = m_fbuf[i];
+ for (int i = 0; i < sz; ++i) {
+ cepOut[i] = fbuf[i];
}
}
#else
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;
Mutex
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];
m_b = new double[size];
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) {
if (m_size & (1 << i)) {
void initFloat() { }
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];
+ 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(double *realIn, double *magOut, double *phaseOut) {
+ 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]) ;
}
}
- 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];
+ 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(float *realIn, float *magOut, float *phaseOut) {
- for (size_t i = 0; i < m_size; ++i) m_a[i] = realIn[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]) ;
}
}
- 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];
m_a[i] = real;
basefft(true, m_a, m_b, realOut, m_d);
}
- 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]);
m_a[i] = real;
basefft(true, m_a, m_b, realOut, m_d);
}
- 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];
m_a[i] = real;
}
}
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 inversePolar(float *magIn, float *phaseIn, float *realOut) {
- for (unsigned int i = 0; i <= m_size/2; ++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]);
m_a[i] = real;
}
}
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];
}
float *getFloatTimeBuffer() {
}
private:
- unsigned int m_size;
+ const int m_size;
int *m_table;
float *m_frb;
double *m_drb;
double *m_b;
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;
double angle = 2.0 * M_PI;
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];
}
} else {
for (i = 0; i < n; ++i) {
ro[m_table[i]] = ri[i];
+ }
+ for (i = 0; i < n; ++i) {
io[m_table[i]] = 0.0;
}
}
*/
}
+#endif /* USE_BUILTIN_FFT */
+
+} /* end namespace FFTs */
+
int
FFT::m_method = -1;
-FFT::FFT(unsigned int size)
+FFT::FFT(int size, int debugLevel)
{
- if (size < 2) throw InvalidSize;
- if (size & (size-1)) throw InvalidSize;
+ 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
}
switch (m_method) {
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;
}
}
}
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);
}
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);
}
void
-FFT::forwardMagnitude(double *realIn, double *magOut)
+FFT::forwardMagnitude(const double *R__ realIn, double *R__ magOut)
{
d->forwardMagnitude(realIn, magOut);
}
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);
}
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);
}
void
-FFT::forwardMagnitude(float *realIn, float *magOut)
+FFT::forwardMagnitude(const float *R__ realIn, float *R__ magOut)
{
d->forwardMagnitude(realIn, magOut);
}
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);
}
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);
}
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);
}
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);
+}
+
void
FFT::initFloat()
{
/*
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
modify it under the terms of the GNU General Public License as
#ifndef _RUBBERBAND_FFT_H_
#define _RUBBERBAND_FFT_H_
+#include "sysutils.h"
+
namespace RubberBand {
class FFTImpl;
public:
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
// called, the first call to a forward or inverse method will call
/*
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
modify it under the terms of the GNU General Public License as
}
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;
}
return result;
/*
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
modify it under the terms of the GNU General Public License as
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();
};
/*
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
modify it under the terms of the GNU General Public License as
#include "PercussiveAudioCurve.h"
+#include "Profiler.h"
+
#include <cmath>
+
namespace RubberBand
{
PercussiveAudioCurve::PercussiveAudioCurve(size_t sampleRate, size_t windowSize) :
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) {
m_prevMag[i] = 0.f;
void
PercussiveAudioCurve::setWindowSize(size_t newSize)
{
- delete[] m_prevMag;
m_windowSize = newSize;
-
- m_prevMag = new double[m_windowSize/2 + 1];
+
+ delete[] m_prevMag;
+ m_prevMag = new float[m_windowSize/2 + 1];
reset();
}
float
-PercussiveAudioCurve::process(float *mag, size_t increment)
+PercussiveAudioCurve::process(const float *R__ mag, size_t increment)
+{
+ 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;
+
+ 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];
+ }
+
+ if (nonZeroCount == 0) return 0;
+ else return float(count) / float(nonZeroCount);
+}
+
+float
+PercussiveAudioCurve::process(const double *R__ mag, size_t increment)
{
- static float threshold = pow(10, 0.3);
- static float zeroThresh = pow(10, -16);
+ 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;
- 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;
/*
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
modify it under the terms of the GNU General Public License as
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;
};
}
--- /dev/null
+/* -*- 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 "Profiler.h"
+
+#include <algorithm>
+#include <set>
+#include <string>
+#include <map>
+
+#include <cstdio>
+
+namespace RubberBand {
+
+#ifndef NO_TIMING
+
+Profiler::ProfileMap
+Profiler::m_profiles;
+
+Profiler::WorstCallMap
+Profiler::m_worstCalls;
+
+void
+Profiler::add(const char *id, float ms)
+{
+ ProfileMap::iterator pmi = m_profiles.find(id);
+ if (pmi != m_profiles.end()) {
+ ++pmi->second.first;
+ pmi->second.second += ms;
+ } else {
+ m_profiles[id] = TimePair(1, ms);
+ }
+
+ WorstCallMap::iterator wci = m_worstCalls.find(id);
+ if (wci != m_worstCalls.end()) {
+ if (ms > wci->second) wci->second = ms;
+ } else {
+ m_worstCalls[id] = ms;
+ }
+}
+
+void
+Profiler::dump()
+{
+#ifdef PROFILE_CLOCKS
+ fprintf(stderr, "Profiling points [CPU time]:\n");
+#else
+ fprintf(stderr, "Profiling points [Wall time]:\n");
+#endif
+
+ fprintf(stderr, "\nBy name:\n");
+
+ typedef std::set<const char *, std::less<std::string> > StringSet;
+
+ StringSet profileNames;
+ for (ProfileMap::const_iterator i = m_profiles.begin();
+ i != m_profiles.end(); ++i) {
+ profileNames.insert(i->first);
+ }
+
+ for (StringSet::const_iterator i = profileNames.begin();
+ i != profileNames.end(); ++i) {
+
+ ProfileMap::const_iterator j = m_profiles.find(*i);
+ if (j == m_profiles.end()) continue;
+
+ const TimePair &pp(j->second);
+ fprintf(stderr, "%s(%d):\n", *i, pp.first);
+ fprintf(stderr, "\tReal: \t%f ms \t[%f ms total]\n",
+ (pp.second / pp.first),
+ (pp.second));
+
+ WorstCallMap::const_iterator k = m_worstCalls.find(*i);
+ if (k == m_worstCalls.end()) continue;
+
+ fprintf(stderr, "\tWorst:\t%f ms/call\n", k->second);
+ }
+
+ typedef std::multimap<float, const char *> TimeRMap;
+ typedef std::multimap<int, const char *> IntRMap;
+ TimeRMap totmap, avgmap, worstmap;
+ IntRMap ncallmap;
+
+ for (ProfileMap::const_iterator i = m_profiles.begin();
+ i != m_profiles.end(); ++i) {
+ totmap.insert(TimeRMap::value_type(i->second.second, i->first));
+ avgmap.insert(TimeRMap::value_type(i->second.second /
+ i->second.first, i->first));
+ ncallmap.insert(IntRMap::value_type(i->second.first, i->first));
+ }
+
+ for (WorstCallMap::const_iterator i = m_worstCalls.begin();
+ i != m_worstCalls.end(); ++i) {
+ worstmap.insert(TimeRMap::value_type(i->second, i->first));
+ }
+
+ fprintf(stderr, "\nBy total:\n");
+ for (TimeRMap::const_iterator i = totmap.end(); i != totmap.begin(); ) {
+ --i;
+ fprintf(stderr, "%-40s %f ms\n", i->second, i->first);
+ }
+
+ fprintf(stderr, "\nBy average:\n");
+ for (TimeRMap::const_iterator i = avgmap.end(); i != avgmap.begin(); ) {
+ --i;
+ fprintf(stderr, "%-40s %f ms\n", i->second, i->first);
+ }
+
+ fprintf(stderr, "\nBy worst case:\n");
+ for (TimeRMap::const_iterator i = worstmap.end(); i != worstmap.begin(); ) {
+ --i;
+ fprintf(stderr, "%-40s %f ms\n", i->second, i->first);
+ }
+
+ fprintf(stderr, "\nBy number of calls:\n");
+ for (IntRMap::const_iterator i = ncallmap.end(); i != ncallmap.begin(); ) {
+ --i;
+ fprintf(stderr, "%-40s %d\n", i->second, i->first);
+ }
+}
+
+Profiler::Profiler(const char* c) :
+ m_c(c),
+ m_ended(false)
+{
+#ifdef PROFILE_CLOCKS
+ m_start = clock();
+#else
+ (void)gettimeofday(&m_start, 0);
+#endif
+}
+
+Profiler::~Profiler()
+{
+ if (!m_ended) end();
+}
+
+void
+Profiler::end()
+{
+#ifdef PROFILE_CLOCKS
+ clock_t end = clock();
+ clock_t elapsed = end - m_start;
+ float ms = float((double(elapsed) / double(CLOCKS_PER_SEC)) * 1000.0);
+#else
+ struct timeval tv;
+ (void)gettimeofday(&tv, 0);
+
+ tv.tv_sec -= m_start.tv_sec;
+ if (tv.tv_usec < m_start.tv_usec) {
+ tv.tv_usec += 1000000;
+ tv.tv_sec -= 1;
+ }
+ tv.tv_usec -= m_start.tv_usec;
+ float ms = float((double(tv.tv_sec) + (double(tv.tv_usec) / 1000000.0)) * 1000.0);
+#endif
+
+ add(m_c, ms);
+
+ m_ended = true;
+}
+
+#endif
+
+}
--- /dev/null
+/* -*- 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.
+*/
+
+#ifndef _PROFILER_H_
+#define _PROFILER_H_
+
+#define NO_TIMING 1
+
+//#define WANT_TIMING 1
+//#define PROFILE_CLOCKS 1
+
+#ifdef NDEBUG
+#ifndef WANT_TIMING
+#define NO_TIMING 1
+#endif
+#endif
+
+#ifndef NO_TIMING
+#ifdef PROFILE_CLOCKS
+#include <time.h>
+#else
+#include "sysutils.h"
+#ifndef _WIN32
+#include <sys/time.h>
+#endif
+#endif
+#endif
+
+#include <map>
+
+namespace RubberBand {
+
+#ifndef NO_TIMING
+
+class Profiler
+{
+public:
+ Profiler(const char *name);
+ ~Profiler();
+
+ void end(); // same action as dtor
+
+ static void dump();
+
+protected:
+ const char* m_c;
+#ifdef PROFILE_CLOCKS
+ clock_t m_start;
+#else
+ struct timeval m_start;
+#endif
+ bool m_showOnDestruct;
+ bool m_ended;
+
+ typedef std::pair<int, float> TimePair;
+ typedef std::map<const char *, TimePair> ProfileMap;
+ typedef std::map<const char *, float> WorstCallMap;
+ static ProfileMap m_profiles;
+ static WorstCallMap m_worstCalls;
+ static void add(const char *, float);
+};
+
+#else
+
+class Profiler
+{
+public:
+ Profiler(const char *) { }
+ ~Profiler() { }
+
+ void update() const { }
+ void end() { }
+ static void dump() { }
+};
+
+#endif
+
+}
+
+#endif
/*
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
modify it under the terms of the GNU General Public License as
#include "Resampler.h"
+#include "Profiler.h"
+
#include <cstdlib>
#include <cmath>
#include <samplerate.h>
+
+
namespace RubberBand {
-class Resampler::D
+class ResamplerImpl
+{
+public:
+ 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(Quality quality, size_t channels, size_t maxBufferSize);
- ~D();
+ D_SRC(Resampler::Quality quality, int channels, int maxBufferSize,
+ int m_debugLevel);
+ ~D_SRC();
- size_t resample(float **in, float **out,
- size_t incount, float ratio, bool final);
+ int resample(const float *const R__ *const R__ in,
+ float *const R__ *const R__ out,
+ int incount,
+ float ratio,
+ bool final);
void reset();
SRC_STATE *m_src;
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)
+ m_ioutsize(0),
+ m_debugLevel(debugLevel)
{
-// std::cerr << "Resampler::Resampler: using libsamplerate implementation"
-// << std::endl;
+ 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));
+ m_iin = allocFloat(m_iinsize);
+ m_iout = allocFloat(m_ioutsize);
}
+
+ reset();
}
-Resampler::D::~D()
+D_SRC::~D_SRC()
{
src_delete(m_src);
if (m_iinsize > 0) {
}
}
-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));
+ m_iout = allocFloat(m_iout, m_ioutsize);
}
- for (size_t i = 0; i < incount; ++i) {
- for (size_t c = 0; c < m_channels; ++c) {
+ for (int i = 0; i < incount; ++i) {
+ for (int c = 0; c < m_channels; ++c) {
m_iin[i * m_channels + c] = in[c][i];
}
}
int err = 0;
err = src_process(m_src, &data);
- //!!! check err, respond appropriately
+ 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];
}
}
}
+ m_lastRatio = ratio;
+
return data.output_frames_gen;
}
void
-Resampler::D::reset()
+D_SRC::reset()
{
src_reset(m_src);
}
-} // end namespace
-namespace RubberBand {
+} /* end namespace Resamplers */
-Resampler::Resampler(Quality quality, size_t channels, size_t maxBufferSize)
+Resampler::Resampler(Resampler::Quality quality, int channels,
+ int maxBufferSize, int debugLevel)
{
- m_d = new D(quality, channels, maxBufferSize);
+ 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;
+ delete d;
}
-size_t
-Resampler::resample(float **in, float **out,
- size_t incount, float ratio, bool final)
+int
+Resampler::resample(const float *const R__ *const R__ in,
+ float *const R__ *const R__ out,
+ int incount, float ratio, bool final)
{
- return m_d->resample(in, out, incount, ratio, final);
+ Profiler profiler("Resampler::resample");
+ return d->resample(in, out, incount, ratio, final);
}
void
Resampler::reset()
{
- m_d->reset();
+ d->reset();
}
}
/*
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
modify it under the terms of the GNU General Public License as
#include <sys/types.h>
+#include "sysutils.h"
+
namespace RubberBand {
+class ResamplerImpl;
+
class Resampler
{
public:
enum Quality { Best, FastestTolerable, Fastest };
+ enum Exception { ImplementationError };
/**
* Construct a resampler with the given quality level and channel
* that may be passed to the resample function before the
* 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;
};
}
/*
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
modify it under the terms of the GNU General Public License as
#include <cstring>
#include <sys/types.h>
+#include <cstring>
+
#ifndef _WIN32
#include <sys/mman.h>
#endif
#include "Scavenger.h"
+#include "Profiler.h"
+
//#define DEBUG_RINGBUFFER 1
* power of two, this means n should ideally be some power of two
* minus one.
*/
- RingBuffer(size_t n);
+ RingBuffer(int n);
virtual ~RingBuffer();
* Return the total capacity of the ring buffer in samples.
* (This is the argument n passed to the constructor.)
*/
- size_t getSize() const;
+ int getSize() const;
/**
* Resize the ring buffer. This also empties it; use resized()
* new, larger buffer; the old buffer is scavenged after a seemly
* delay. Should be called from the write thread.
*/
- void resize(size_t newSize);
+ void resize(int newSize);
/**
* Return a new ring buffer (allocated with "new" -- called must
* or inconsistent. If this buffer's data will not fit in the new
* 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;
/**
* Lock the ring buffer into physical memory. Returns true
* Return the amount of data available for reading by reader R, in
* 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;
/**
* Read n samples from the buffer, for reader R. If fewer than n
* are available, the remainder will be zeroed out. Returns the
* 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);
/**
* Read n samples from the buffer, for reader R, adding them to
* will be left alone. Returns the number of samples actually
* read.
*/
- size_t readAdding(T *destination, size_t n, int R = 0);
+ int readAdding(T *R__ destination, int n, int R = 0);
/**
* Read one sample from the buffer, for reader R. If no sample is
* n are available, the remainder will be zeroed out. Returns the
* 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;
/**
* Read one sample from the buffer, if available, without
* samples). Returns the number of samples actually available for
* discarding.
*/
- size_t skip(size_t n, int R = 0);
+ int skip(int n, int R = 0);
/**
* Write n samples to the buffer. If insufficient space is
* available, not all samples may actually be written. Returns
* the number of samples actually written.
*/
- size_t write(const T *source, size_t n);
+ int write(const T *source, int n);
/**
* Write n zero-value samples to the buffer. If insufficient
* space is available, not all zeros may actually be written.
* 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;
static Scavenger<ScavengerArrayWrapper<T> > m_scavenger;
Scavenger<ScavengerArrayWrapper<T> > RingBuffer<T, N>::m_scavenger;
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),
m_size(n + 1),
}
template <typename T, int N>
-size_t
+int
RingBuffer<T, N>::getSize() const
{
#ifdef DEBUG_RINGBUFFER
template <typename T, int N>
void
-RingBuffer<T, N>::resize(size_t newSize)
+RingBuffer<T, N>::resize(int newSize)
{
#ifdef DEBUG_RINGBUFFER
std::cerr << "RingBuffer<T," << N << ">[" << this << "]::resize(" << newSize << ")" << std::endl;
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) {
T value = m_buffer[r];
}
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
std::cerr << "RingBuffer<T," << N << ">[" << this << "]::getReadSpace(" << R << "): reader " << reader << ", writer " << writer << std::endl;
}
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;
}
#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 "
<< rs << ", total " << (space + rs) << ", m_size " << m_size << std::endl;
}
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
std::cerr << "WARNING: Only " << available << " samples available"
<< std::endl;
#endif
- for (size_t i = available; i < n; ++i) {
+ for (int i = available; i < n; ++i) {
destination[i] = 0;
}
n = available;
}
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 (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];
}
}
}
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
std::cerr << "WARNING: Only " << available << " samples available"
}
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];
}
}
#endif
return 0;
}
- size_t reader = m_readers[R];
+ int reader = m_readers[R];
T value = m_buffer[reader];
if (++reader == m_size) reader = 0;
m_readers[R] = reader;
}
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
std::cerr << "WARNING: Only " << available << " samples available"
}
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];
}
}
}
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
std::cerr << "RingBuffer<T," << N << ">[" << this << "]::skip(" << n << ", " << R << ")" << std::endl;
#endif
- size_t available = getReadSpace(R);
+ int available = getReadSpace(R);
if (n > available) {
#ifdef DEBUG_RINGBUFFER
std::cerr << "WARNING: Only " << available << " samples available"
}
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;
m_readers[R] = reader;
}
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
std::cerr << "WARNING: Only room for " << available << " samples"
}
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 (int i = 0; i < here; ++i) {
+ bufbase[i] = source[i];
}
- for (size_t i = 0; i < (n - here); ++i) {
- m_buffer[i] = (source + here)[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];
}
}
}
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
std::cerr << "WARNING: Only room for " << available << " samples"
}
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 (int i = 0; i < here; ++i) {
+ bufbase[i] = 0;
}
- for (size_t i = 0; i < (n - here); ++i) {
+ const int nh = n - here;
+ for (int i = 0; i < nh; ++i) {
m_buffer[i] = 0;
}
}
}
+//#include "RingBuffer.cpp"
+
#endif // _RINGBUFFER_H_
/*
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
modify it under the terms of the GNU General Public License as
Options options,
double initialTimeRatio,
double initialPitchScale) :
- TimeStretcher(sampleRate, channels),
- m_d(new Impl(this, sampleRate, channels, options,
+ m_d(new Impl(sampleRate, channels, options,
initialTimeRatio, initialPitchScale))
{
}
m_d->setPhaseOption(options);
}
+void
+RubberBandStretcher::setFormantOption(Options options)
+{
+ m_d->setFormantOption(options);
+}
+
+void
+RubberBandStretcher::setPitchOption(Options options)
+{
+ m_d->setPitchOption(options);
+}
+
void
RubberBandStretcher::setExpectedInputDuration(size_t samples)
{
/*
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
modify it under the terms of the GNU General Public License as
#include <vector>
#include <list>
-#include <sys/time.h>
#include <iostream>
+#ifndef WIN32
+#include <sys/time.h>
+#endif
+
#include "Thread.h"
#include "sysutils.h"
--- /dev/null
+/* -*- 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 "SilentAudioCurve.h"
+
+#include <cmath>
+
+namespace RubberBand
+{
+
+SilentAudioCurve::SilentAudioCurve(size_t sampleRate, size_t windowSize) :
+ AudioCurve(sampleRate, windowSize)
+{
+}
+
+SilentAudioCurve::~SilentAudioCurve()
+{
+}
+
+void
+SilentAudioCurve::reset()
+{
+}
+
+void
+SilentAudioCurve::setWindowSize(size_t newSize)
+{
+ m_windowSize = newSize;
+}
+
+float
+SilentAudioCurve::process(const float *R__ mag, size_t)
+{
+ const int hs = m_windowSize / 2;
+ static float threshold = powf(10.f, -6);
+
+ for (int i = 0; i <= hs; ++i) {
+ if (mag[i] > threshold) return 0.f;
+ }
+
+ return 1.f;
+}
+
+float
+SilentAudioCurve::process(const double *R__ mag, size_t)
+{
+ const int hs = m_windowSize / 2;
+ static double threshold = pow(10.0, -6);
+
+ for (int i = 0; i <= hs; ++i) {
+ if (mag[i] > threshold) return 0.f;
+ }
+
+ return 1.f;
+}
+
+}
+
--- /dev/null
+/* -*- 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.
+*/
+
+#ifndef _SILENT_AUDIO_CURVE_H_
+#define _SILENT_AUDIO_CURVE_H_
+
+#include "AudioCurve.h"
+
+namespace RubberBand
+{
+
+class SilentAudioCurve : public AudioCurve
+{
+public:
+ SilentAudioCurve(size_t sampleRate, size_t windowSize);
+ virtual ~SilentAudioCurve();
+
+ virtual void setWindowSize(size_t newSize);
+
+ virtual float process(const float *R__ mag, size_t increment);
+ virtual float process(const double *R__ mag, size_t increment);
+ virtual void reset();
+};
+
+}
+
+#endif
/*
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
modify it under the terms of the GNU General Public License as
SpectralDifferenceAudioCurve::SpectralDifferenceAudioCurve(size_t sampleRate, size_t windowSize) :
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) {
m_prevMag[i] = 0.f;
void
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;
/*
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
modify it under the terms of the GNU General Public License as
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;
};
}
/*
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
modify it under the terms of the GNU General Public License as
#include <deque>
#include <set>
#include <cassert>
+#include <algorithm>
+
+#include "sysutils.h"
namespace RubberBand
{
int
StretchCalculator::calculateSingle(double ratio,
- size_t inputDurationSoFar,
- float df)
+ float df,
+ size_t increment)
{
+ if (increment == 0) increment = m_increment;
+
bool isTransient = false;
// We want to ensure, as close as possible, that the phase reset
// from the ratio directly. For the moment we're happy if it
// works well in common situations.
- float transientThreshold = 0.35;
- if (ratio > 1) transientThreshold = 0.25;
+ float transientThreshold = 0.35f;
+ if (ratio > 1) transientThreshold = 0.25f;
- if (m_useHardPeaks && df > m_prevDf * 1.1 && df > transientThreshold) {
+ if (m_useHardPeaks && df > m_prevDf * 1.1f && df > transientThreshold) {
isTransient = true;
}
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;
+ std::cerr << "StretchCalculator::calculateSingle: transient"
+ << std::endl;
}
- m_divergence += m_increment - (m_increment * ratio);
+ 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))));
+ lrint(ceil(double(m_sampleRate) / (20 * double(increment))));
- m_recovery = m_divergence / ((m_sampleRate / 10.0) / m_increment);
- return -m_increment;
+ m_recovery = m_divergence / ((m_sampleRate / 10.0) / increment);
+ return -int(increment);
}
- if (m_prevRatio != ratio) {
- m_recovery = m_divergence / ((m_sampleRate / 10.0) / m_increment);
- m_prevRatio = ratio;
+ 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);
+ 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 = (m_increment * ratio) - incr;
+ double divdiff = (increment * ratio) - incr;
if (m_debugLevel > 2 || (m_debugLevel > 1 && m_divergence != 0)) {
std::cerr << "divdiff = " << divdiff << std::endl;
m_divergence -= divdiff;
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);
}
return incr;
/*
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
modify it under the terms of the GNU General Public License as
* phase-lock audio curve. State is retained between calls in the
* 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; }
/* -*- 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;
construct(s, windowSize, outbufSize);
}
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);
}
if (initialWindowSize > maxSize) maxSize = initialWindowSize;
}
- 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;
inbuf = new RingBuffer<float>(maxSize);
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 = allocFloat(maxSize);
- fltbuf = new float[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();
}
fft = ffts[initialWindowSize];
reset();
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;
- }
}
void
RubberBandStretcher::Impl::ChannelData::setWindowSize(size_t windowSize)
{
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;
if (ffts.find(windowSize) == ffts.end()) {
//!!! 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();
}
dblbuf = fft->getDoubleTimeBuffer();
- for (size_t i = 0; i < windowSize; ++i) {
+ for (size_t i = 0; i < windowSize * oversample; ++i) {
dblbuf[i] = 0.0;
}
mag[i] = 0.0;
phase[i] = 0.0;
prevPhase[i] = 0.0;
+ prevError[i] = 0.0;
unwrappedPhase[i] = 0.0;
freqPeak[i] = 0;
}
// We don't want to preserve data in these arrays
- delete[] mag;
- delete[] phase;
- delete[] prevPhase;
- delete[] unwrappedPhase;
- delete[] freqPeak;
+ mag = allocDouble(mag, realSize);
+ phase = allocDouble(phase, realSize);
+ prevPhase = allocDouble(prevPhase, realSize);
+ prevError = allocDouble(prevError, realSize);
+ unwrappedPhase = allocDouble(unwrappedPhase, realSize);
+ envelope = allocDouble(envelope, realSize);
- mag = new double[realSize];
- phase = new double[realSize];
- prevPhase = new double[realSize];
- unwrappedPhase = new double[realSize];
+ delete[] freqPeak;
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;
//!!! and resampler?
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();
}
dblbuf = fft->getDoubleTimeBuffer();
- for (size_t i = 0; i < windowSize; ++i) {
+ for (size_t i = 0; i < windowSize * oversample; ++i) {
dblbuf[i] = 0.0;
}
}
}
}
+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();
i != ffts.end(); ++i) {
inCount = 0;
inputSize = -1;
outCount = 0;
+ unchanged = true;
draining = false;
outputComplete = false;
}
/*
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
modify it under the terms of the GNU General Public License as
#include <set>
+//#define EXPERIMENT 1
+
namespace RubberBand
{
* the pitch scale factor and any maximum processing block
* size specified by the user of the code.
*/
- ChannelData(size_t windowSize, size_t outbufSize);
+ ChannelData(size_t windowSize, int overSample, size_t outbufSize);
/**
* Construct a ChannelData structure that can process at
* called subsequently.
*/
ChannelData(const std::set<size_t> &windowSizes,
- size_t initialWindowSize, size_t outbufSize);
+ int overSample, size_t initialWindowSize, size_t outbufSize);
~ChannelData();
/**
*/
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;
double *phase;
double *prevPhase;
+ double *prevError;
double *unwrappedPhase;
+
size_t *freqPeak;
float *accumulator;
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
float *resamplebuf;
size_t resamplebufSize;
+ int oversample;
+
private:
void construct(const std::set<size_t> &windowSizes,
size_t initialWindowSize, size_t outbufSize);
/*
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
modify it under the terms of the GNU General Public License as
#include "PercussiveAudioCurve.h"
#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>
#include <cmath>
using std::max;
using std::min;
+
namespace RubberBand {
const size_t
RubberBandStretcher::Impl::m_defaultDebugLevel = 0;
-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),
m_pitchScale(initialPitchScale),
m_studyFFT(0),
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),
m_freq1(1200),
m_freq2(12000),
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));
delete m_phaseResetAudioCurve;
delete m_stretchAudioCurve;
+ delete m_silentAudioCurve;
delete m_stretchCalculator;
delete m_studyFFT;
m_mode = JustCreated;
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();
}
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();
+ }
+ }
+ }
}
double
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));
+
+ 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;
}
- windowSize = std::max(windowSize, roundUp(outputIncrement * 6));
- if (r > 5) while (windowSize < 8192) windowSize *= 2;
}
} else {
- // use a variable increment
-
if (r < 1) {
inputIncrement = windowSize / 4;
while (inputIncrement >= 512) inputIncrement /= 2;
windowSize = std::max(windowSize, roundUp(outputIncrement * 6));
if (r > 5) while (windowSize < 8192) windowSize *= 2;
}
- }
+ }
if (m_expectedInputDuration > 0) {
while (inputIncrement * 4 > m_expectedInputDuration &&
set<size_t> windowSizes;
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);
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));
}
}
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) {
if (m_channelData[c]->resampler) continue;
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
// for resampling; but allocate a sensible amount in case
size_t rbs =
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);
+ m_phaseResetAudioCurve = new PercussiveAudioCurve
+ (m_sampleRate, m_windowSize);
- // stretchAudioCurve unused in RT mode; phaseResetAudioCurve and
- // stretchCalculator however are used in all modes
+ delete m_silentAudioCurve;
+ m_silentAudioCurve = new SilentAudioCurve
+ (m_sampleRate, m_windowSize);
if (!m_realtime) {
delete m_stretchAudioCurve;
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);
}
}
delete m_stretchCalculator;
m_stretchCalculator = new StretchCalculator
- (m_stretcher->m_sampleRate, m_increment,
+ (m_sampleRate, m_increment,
!(m_options & OptionTransientsSmooth));
m_stretchCalculator->setDebugLevel(m_debugLevel);
calculateStretch();
m_phaseResetDf.clear();
m_stretchDf.clear();
+ m_silence.clear();
m_inputDuration = 0;
}
configure();
std::cerr << "WARNING: reconfigure(): resampler construction required in RT mode" << std::endl;
m_channelData[c]->resampler =
- new Resampler(Resampler::FastestTolerable, 1, m_windowSize);
+ new Resampler(Resampler::FastestTolerable, 1, m_windowSize,
+ m_debugLevel);
- m_channelData[c]->resamplebufSize =
- lrintf(ceil((m_increment * m_timeRatio * 2) / m_pitchScale));
- m_channelData[c]->resamplebuf =
- new float[m_channelData[c]->resamplebufSize];
+ m_channelData[c]->setResampleBufSize
+ (lrintf(ceil((m_increment * m_timeRatio * 2) / m_pitchScale)));
}
}
cerr << "RubberBandStretcher::Impl::setTransientsOption: Not permissible in non-realtime mode" << endl;
return;
}
- m_options &= ~(OptionTransientsMixed |
- OptionTransientsSmooth |
- OptionTransientsCrisp);
+ int mask = (OptionTransientsMixed | OptionTransientsSmooth | OptionTransientsCrisp);
+ m_options &= ~mask;
+ options &= mask;
m_options |= options;
m_stretchCalculator->setUseHardPeaks
void
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) {
cerr << "RubberBandStretcher::Impl::study: Not meaningful in realtime mode" << endl;
consumed += writable;
}
- 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
// in m_inbuf. We need to peek m_windowSize of them for
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;
// We have augmented the input by m_windowSize/2 so
void
RubberBandStretcher::Impl::calculateStretch()
{
+ Profiler profiler("RubberBandStretcher::Impl::calculateStretch");
+
std::vector<int> increments = m_stretchCalculator->calculate
(getEffectiveRatio(),
m_inputDuration,
m_phaseResetDf,
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 {
for (size_t i = 0; i < increments.size(); ++i) {
size_t
RubberBandStretcher::Impl::getSamplesRequired() const
{
+ Profiler profiler("RubberBandStretcher::Impl::getSamplesRequired");
+
size_t reqd = 0;
for (size_t c = 0; c < m_channels; ++c) {
void
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;
return;
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;
}
while (!allConsumed) {
-// cerr << "process looping" << endl;
-
//#ifndef NO_THREADING
// if (m_threaded) {
// pthread_mutex_lock(&m_inputProcessedMutex);
// have actually been processed.
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;
// cerr << "process: waiting on input consumption for channel " << c << endl;
}
*/
}
+
+// if (!allConsumed) cerr << "process looping" << endl;
+
}
// cerr << "process returning" << endl;
if (final) m_mode = Finished;
}
-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;
-}
-
}
/*
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
modify it under the terms of the GNU General Public License as
class RubberBandStretcher::Impl
{
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();
void setTransientsOption(Options);
void setPhaseOption(Options);
+ void setFormantOption(Options);
+ void setPitchOption(Options);
void setExpectedInputDuration(size_t samples);
void setMaxProcessSize(size_t samples);
static void setDefaultDebugLevel(int level) { m_defaultDebugLevel = level; }
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
bool processChunkForChannel(size_t channel, size_t phaseIncrement,
size_t &shiftIncrement, bool &phaseReset);
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);
size_t roundUp(size_t value); // to next power of two
+ bool resampleBeforeStretching() const;
+
double m_timeRatio;
double m_pitchScale;
size_t m_inputDuration;
std::vector<float> m_phaseResetDf;
std::vector<float> m_stretchDf;
+ std::vector<bool> m_silence;
+ int m_silentHistory;
class ChannelData;
std::vector<ChannelData *> m_channelData;
AudioCurve *m_phaseResetAudioCurve;
AudioCurve *m_stretchAudioCurve;
+ AudioCurve *m_silentAudioCurve;
StretchCalculator *m_stretchCalculator;
float m_freq0;
/*
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
modify it under the terms of the GNU General Public License as
#include "StretchCalculator.h"
#include "StretcherChannelData.h"
#include "Resampler.h"
+#include "Profiler.h"
#include <cassert>
#include <cmath>
#include <set>
#include <map>
+#include <deque>
+
using std::cerr;
using std::endl;
m_abandoning = true;
}
+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
// already been calculated.
bool
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
// able to calculate increments as it goes along.
bool
RubberBandStretcher::Impl::testInbufReadSpace(size_t c)
{
+ Profiler profiler("RubberBandStretcher::Impl::testInbufReadSpace");
+
ChannelData &cd = *m_channelData[c];
RingBuffer<float> &inbuf = *cd.inbuf;
size_t shiftIncrement,
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
// using e.g. testInbufReadSpace first. Return true if this is
// 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
}
if (m_threaded) {
- size_t required = shiftIncrement;
+
+ int required = shiftIncrement;
+
if (m_pitchScale != 1.0) {
required = int(required / m_pitchScale) + 1;
}
size_t &shiftIncrementRtn,
bool &phaseReset)
{
+ Profiler profiler("RubberBandStretcher::Impl::calculateIncrements");
+
// cerr << "calculateIncrements" << endl;
// Calculate the next upcoming phase and shift increment, on the
}
}
+ const int hs = m_windowSize/2 + 1;
+
// Normally we would mix down the time-domain signal and apply a
// single FFT, or else mix down the Cartesian form of the
// frequency-domain signal. Both of those would be inefficient
// phases to cancel each other, and broadband effects will still
// be apparent.
- for (size_t i = 0; i <= m_windowSize/2; ++i) {
- cd.fltbuf[i] = 0.0;
- }
+ float df = 0.f;
+ bool silent = false;
- 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];
+ 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];
+ }
}
- }
- float df = m_phaseResetAudioCurve->process(cd.fltbuf, m_increment);
+ 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);
m_lastProcessOutputIncrements.write(&incr, 1);
}
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;
+ }
+ }
}
bool
size_t &shiftIncrementRtn,
bool &phaseReset)
{
+ Profiler profiler("RubberBandStretcher::Impl::getIncrements");
+
if (channel >= m_channels) {
phaseIncrementRtn = m_increment;
shiftIncrementRtn = m_increment;
void
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);
+ m_window->cut(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];
+ 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(cd.dblbuf, cd.mag, cd.phase);
+ cd.fft->forwardPolar(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; }
+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];
if (phaseReset && m_debugLevel > 1) {
cerr << "phase reset: leaving phases unmodified" << endl;
}
- size_t count = m_windowSize/2;
- size_t pfp = 0;
- double rate = m_stretcher->m_sampleRate;
+ 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;
- if (!(m_options & OptionPhaseIndependent)) {
+ double distance = 0.0;
+ const double maxdist = 8.0;
- cd.freqPeak[0] = 0;
+ const int lookback = 1;
- float freq0 = m_freq0;
- float freq1 = m_freq1;
- float freq2 = m_freq2;
+ double distacc = 0.0;
- // 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.
+ for (int i = count; i >= 0; i -= lookback) {
- 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;
+ bool resetThis = phaseReset;
+
+ if (bandlimited) {
+ if (resetThis) {
+ if (i > bandlow && i < bandhigh) {
+ resetThis = false;
+ fullReset = false;
+ }
}
}
- size_t limit0 = lrint((freq0 * m_windowSize) / rate);
- size_t limit1 = lrint((freq1 * m_windowSize) / rate);
- size_t limit2 = lrint((freq2 * m_windowSize) / rate);
+ double p = cd.phase[i];
+ double perr = 0.0;
+ double outphase = p;
- size_t range = 0;
+ double mi = maxdist;
+ if (i <= limit0) mi = 0.0;
+ else if (i <= limit1) mi = 1.0;
+ else if (i <= limit2) mi = 3.0;
- if (limit1 < limit0) limit1 = limit0;
- if (limit2 < limit1) limit2 = limit1;
-
-// cerr << "limit0 = " << limit0 << " limit1 = " << limit1 << " limit2 = " << limit2 << endl;
+ if (!resetThis) {
- int peakCount = 0;
+ double omega = (2 * M_PI * m_increment * i) / (sz * cd.oversample);
- for (size_t i = 0; i <= count; ++i) {
+ double pp = cd.prevPhase[i];
+ double ep = pp + omega;
+ perr = princarg(p - ep);
- double mag = cd.mag[i];
- bool isPeak = true;
+ double instability = fabs(perr - cd.prevError[i]);
+ bool direction = (perr > cd.prevError[i]);
- for (size_t j = 1; j <= range; ++j) {
+ bool inherit = false;
- if (mag < cd.mag[i-j]) {
- isPeak = false;
- break;
+ if (laminar) {
+ if (distance >= mi) {
+ inherit = false;
+ } else if (bandlimited && (i == bandhigh || i == bandlow)) {
+ inherit = false;
+ } else if (instability > prevInstability &&
+ direction == prevDirection) {
+ inherit = true;
}
+ }
- if (mag < cd.mag[i+j]) {
- isPeak = false;
- break;
- }
- }
+ 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;
+ }
- if (isPeak) {
+ prevInstability = instability;
+ prevDirection = direction;
- // i is a peak bin.
+ } else {
+ distance = 0.0;
+ }
- // 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;
+ cd.prevError[i] = perr;
+ cd.prevPhase[i] = p;
+ cd.phase[i] = outphase;
+ cd.unwrappedPhase[i] = outphase;
+ }
- 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;
- }
+ if (m_debugLevel > 1) {
+ cerr << "mean inheritance distance = " << distacc / count << endl;
+ }
- pfp = i;
+ if (fullReset) unchanged = true;
+ cd.unchanged = unchanged;
- ++peakCount;
- }
+ if (unchanged && m_debugLevel > 1) {
+ cerr << "frame unchanged on channel " << channel << endl;
+ }
+}
- 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;
- }
+void
+RubberBandStretcher::Impl::formantShiftChunk(size_t channel)
+{
+ Profiler profiler("RubberBandStretcher::Impl::formantShiftChunk");
- double peakInPhase = 0.0;
- double peakOutPhase = 0.0;
- size_t p, pp;
+ ChannelData &cd = *m_channelData[channel];
- 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];
- }
+ double *const R__ mag = cd.mag;
+ double *const R__ envelope = cd.envelope;
+ double *const R__ dblbuf = cd.dblbuf;
- bool resetThis = phaseReset;
-
- if (m_options & OptionTransientsMixed) {
- size_t low = lrint((150 * m_windowSize) / rate);
- size_t high = lrint((1000 * m_windowSize) / rate);
- if (resetThis) {
- if (i > low && i < high) resetThis = false;
- }
- }
+ const int sz = m_windowSize;
+ const int hs = m_windowSize/2;
+ const double denom = sz;
- if (!resetThis) {
+
+ cd.fft->inverseCepstral(mag, dblbuf);
- 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;
+ for (int i = 0; i < sz; ++i) {
+ dblbuf[i] /= denom;
+ }
- cd.prevPhase[p] = cd.phase[p];
- cd.phase[p] = unwrappedPhase;
- cd.unwrappedPhase[p] = unwrappedPhase;
+ const int cutoff = m_sampleRate / 700;
- peakInPhase = cd.prevPhase[p];
- peakOutPhase = unwrappedPhase;
- }
+// cerr <<"cutoff = "<< cutoff << ", m_sampleRate/cutoff = " << m_sampleRate/cutoff << endl;
- if (i != p) {
+ dblbuf[0] /= 2;
+ dblbuf[cutoff-1] /= 2;
- double diffToPeak = peakInPhase - cd.phase[i];
- double unwrappedPhase = peakOutPhase - diffToPeak;
-
- cd.prevPhase[i] = cd.phase[i];
- cd.phase[i] = unwrappedPhase;
- cd.unwrappedPhase[i] = unwrappedPhase;
- }
+ for (int i = cutoff; i < sz; ++i) {
+ dblbuf[i] = 0.0;
+ }
- } else {
- cd.prevPhase[i] = cd.phase[i];
- cd.unwrappedPhase[i] = cd.phase[i];
+ 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;
}
void
RubberBandStretcher::Impl::synthesiseChunk(size_t channel)
{
- ChannelData &cd = *m_channelData[channel];
+ Profiler profiler("RubberBandStretcher::Impl::synthesiseChunk");
- 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];
+ if ((m_options & OptionFormantPreserved) &&
+ (m_pitchScale != 1.0)) {
+ formantShiftChunk(channel);
}
- // our ffts produced unscaled results
- for (size_t i = 0; i < m_windowSize; ++i) {
- cd.fltbuf[i] = cd.fltbuf[i] / m_windowSize;
+ ChannelData &cd = *m_channelData[channel];
+
+ 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(cd.fltbuf);
+ m_window->cut(fltbuf);
- for (size_t i = 0; i < m_windowSize; ++i) {
- cd.accumulator[i] += cd.fltbuf[i];
+ for (i = 0; i < sz; ++i) {
+ accumulator[i] += fltbuf[i];
}
cd.accumulatorFill = m_windowSize;
- float fixed = m_window->getArea() * 1.5;
+ float fixed = m_window->getArea() * 1.5f;
- for (size_t i = 0; i < m_windowSize; ++i) {
+ for (i = 0; i < sz; ++i) {
float val = m_window->getValue(i);
- cd.windowAccumulator[i] += val * fixed;
+ windowAccumulator[i] += val * fixed;
}
}
void
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 (unsigned int 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];
}
}
theoreticalOut = lrint(cd.inputSize * m_timeRatio);
}
- if (m_pitchScale != 1.0 && cd.resampler) {
+ bool resampledAlready = resampleBeforeStretching();
+
+ if (!resampledAlready &&
+ (m_pitchScale != 1.0 || m_options & OptionPitchHighConsistency) &&
+ cd.resampler) {
- size_t reqSize = int(ceil(shiftIncrement / m_pitchScale));
+ size_t reqSize = int(ceil(si / m_pitchScale));
if (reqSize > cd.resamplebufSize) {
// This shouldn't normally happen -- the buffer is
// supposed to be initialised with enough space in the
// calculator has gone mad, or something.
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);
}
size_t outframes = cd.resampler->resample(&cd.accumulator,
&cd.resamplebuf,
- shiftIncrement,
+ si,
1.0 / m_pitchScale,
last);
outframes, cd.outCount, theoreticalOut);
} else {
- writeOutput(*cd.outbuf, cd.accumulator,
- shiftIncrement, cd.outCount, theoreticalOut);
+ writeOutput(*cd.outbuf, accumulator,
+ si, cd.outCount, theoreticalOut);
}
- for (size_t i = 0; i < m_windowSize - shiftIncrement; ++i) {
- cd.accumulator[i] = cd.accumulator[i + shiftIncrement];
+ for (i = 0; i < sz - si; ++i) {
+ accumulator[i] = accumulator[i + si];
}
- for (size_t i = m_windowSize - shiftIncrement; i < m_windowSize; ++i) {
- cd.accumulator[i] = 0.0f;
+ for (i = sz - si; i < sz; ++i) {
+ accumulator[i] = 0.0f;
}
- for (size_t i = 0; i < m_windowSize - shiftIncrement; ++i) {
- cd.windowAccumulator[i] = cd.windowAccumulator[i + shiftIncrement];
+ for (i = 0; i < sz - si; ++i) {
+ windowAccumulator[i] = windowAccumulator[i + si];
}
- for (size_t i = m_windowSize - shiftIncrement; i < m_windowSize; ++i) {
- cd.windowAccumulator[i] = 0.0f;
+ for (i = sz - si; i < sz; ++i) {
+ windowAccumulator[i] = 0.0f;
}
- if (cd.accumulatorFill > shiftIncrement) {
- cd.accumulatorFill -= shiftIncrement;
+ if (int(cd.accumulatorFill) > si) {
+ cd.accumulatorFill -= si;
} else {
cd.accumulatorFill = 0;
if (cd.draining) {
void
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
// output. In RT mode we didn't apply any pre-padding in
int
RubberBandStretcher::Impl::available() const
{
+ Profiler profiler("RubberBandStretcher::Impl::available");
+
if (m_threaded) {
MutexLocker locker(&m_threadSetMutex);
if (m_channelData.empty()) return 0;
size_t
RubberBandStretcher::Impl::retrieve(float *const *output, size_t samples) const
{
+ Profiler profiler("RubberBandStretcher::Impl::retrieve");
+
size_t got = samples;
for (size_t c = 0; c < m_channels; ++c) {
/*
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
modify it under the terms of the GNU General Public License as
#include <cstdlib>
#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;
using std::endl;
using std::string;
return 0;
}
-Mutex::Mutex() :
- m_locked(false)
+Mutex::Mutex()
+#ifndef NO_THREAD_CHECKS
+ :
+ m_lockedBy(-1)
+#endif
{
m_mutex = CreateMutex(NULL, FALSE, NULL);
#ifdef DEBUG_MUTEX
void
Mutex::lock()
{
- if (m_locked) {
+#ifndef NO_THREAD_CHECKS
+ DWORD tid = GetCurrentThreadId();
+ if (m_lockedBy == tid) {
cerr << "ERROR: Deadlock on mutex " << &m_mutex << endl;
}
+#endif
#ifdef DEBUG_MUTEX
- cerr << "MUTEX DEBUG: " << (void *)GetCurrentThreadId() << ": Want to lock mutex " << &m_mutex << endl;
+ cerr << "MUTEX DEBUG: " << (void *)tid << ": Want to lock mutex " << &m_mutex << endl;
#endif
WaitForSingleObject(m_mutex, INFINITE);
- m_locked = true;
+#ifndef NO_THREAD_CHECKS
+ m_lockedBy = tid;
+#endif
#ifdef DEBUG_MUTEX
- cerr << "MUTEX DEBUG: " << (void *)GetCurrentThreadId() << ": Locked mutex " << &m_mutex << endl;
+ cerr << "MUTEX DEBUG: " << (void *)tid << ": Locked mutex " << &m_mutex << endl;
#endif
}
void
Mutex::unlock()
{
+#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 *)GetCurrentThreadId() << ": Unlocking mutex " << &m_mutex << endl;
+ cerr << "MUTEX DEBUG: " << (void *)tid << ": Unlocking mutex " << &m_mutex << endl;
+#endif
+#ifndef NO_THREAD_CHECKS
+ m_lockedBy = -1;
#endif
- m_locked = false;
ReleaseMutex(m_mutex);
}
bool
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;
+#ifndef NO_THREAD_CHECKS
+ m_lockedBy = tid;
+#endif
#ifdef DEBUG_MUTEX
- cerr << "MUTEX DEBUG: " << (void *)GetCurrentThreadId() << ": Locked mutex " << &m_mutex << " (from trylock)" << endl;
+ cerr << "MUTEX DEBUG: " << (void *)tid << ": Locked mutex " << &m_mutex << " (from trylock)" << endl;
#endif
return true;
}
}
Condition::Condition(string name) :
- m_name(name),
m_locked(false)
+#ifdef DEBUG_CONDITION
+ , m_name(name)
+#endif
{
m_mutex = CreateMutex(NULL, FALSE, NULL);
m_condition = CreateEvent(NULL, FALSE, FALSE, NULL);
return 0;
}
-Mutex::Mutex() :
+Mutex::Mutex()
+#ifndef NO_THREAD_CHECKS
+ :
+ m_lockedBy(0),
m_locked(false)
+#endif
{
pthread_mutex_init(&m_mutex, 0);
#ifdef DEBUG_MUTEX
void
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;
}
+#endif
#ifdef DEBUG_MUTEX
- cerr << "MUTEX DEBUG: " << (void *)pthread_self() << ": Want to lock mutex " << &m_mutex << endl;
+ 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;
+#endif
#ifdef DEBUG_MUTEX
- cerr << "MUTEX DEBUG: " << (void *)pthread_self() << ": Locked mutex " << &m_mutex << endl;
+ cerr << "MUTEX DEBUG: " << (void *)tid << ": Locked mutex " << &m_mutex << endl;
#endif
}
void
Mutex::unlock()
{
+#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 *)pthread_self() << ": Unlocking mutex " << &m_mutex << endl;
+ cerr << "MUTEX DEBUG: " << (void *)tid << ": Unlocking mutex " << &m_mutex << endl;
#endif
+#ifndef NO_THREAD_CHECKS
m_locked = false;
+#endif
pthread_mutex_unlock(&m_mutex);
}
bool
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;
+#endif
#ifdef DEBUG_MUTEX
- cerr << "MUTEX DEBUG: " << (void *)pthread_self() << ": Locked mutex " << &m_mutex << " (from trylock)" << endl;
+ cerr << "MUTEX DEBUG: " << (void *)tid << ": Locked mutex " << &m_mutex << " (from trylock)" << endl;
#endif
return true;
}
}
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);
pthread_cond_init(&m_condition, 0);
/*
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
modify it under the terms of the GNU General Public License as
#include <string>
+//#define DEBUG_THREAD 1
+//#define DEBUG_MUTEX 1
+//#define DEBUG_CONDITION 1
+
namespace RubberBand
{
private:
#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
};
class MutexLocker
void signal();
private:
+
#ifdef _WIN32
HANDLE m_mutex;
- bool m_locked;
HANDLE m_condition;
- std::string m_name;
+ bool m_locked;
#else
pthread_mutex_t m_mutex;
- bool m_locked;
pthread_cond_t m_condition;
+ bool m_locked;
+#endif
+#ifdef DEBUG_CONDITION
std::string m_name;
#endif
};
--- /dev/null
+/* -*- 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 "Window.h"
+
+
/*
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
modify it under the terms of the GNU General Public License as
#include <cmath>
#include <cstdlib>
#include <iostream>
+#include <cstdlib>
#include <map>
+#include "sysutils.h"
+
namespace RubberBand {
enum WindowType {
/**
* 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) {
if (&w == this) return *this;
}
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;
void encache();
--- /dev/null
+/*
+** Copyright (C) 2001 Erik de Castro Lopo <erikd AT mega-nerd DOT com>
+**
+** Permission to use, copy, modify, distribute, and sell this file for any
+** purpose is hereby granted without fee, provided that the above copyright
+** and this permission notice appear in all copies. No representations are
+** made about the suitability of this software for any purpose. It is
+** provided "as is" without express or implied warranty.
+*/
+
+/* Version 1.1 */
+
+
+/*============================================================================
+** On Intel Pentium processors (especially PIII and probably P4), converting
+** from float to int is very slow. To meet the C specs, the code produced by
+** most C compilers targeting Pentium needs to change the FPU rounding mode
+** before the float to int conversion is performed.
+**
+** Changing the FPU rounding mode causes the FPU pipeline to be flushed. It
+** is this flushing of the pipeline which is so slow.
+**
+** Fortunately the ISO C99 specifications define the functions lrint, lrintf,
+** llrint and llrintf which fix this problem as a side effect.
+**
+** On Unix-like systems, the configure process should have detected the
+** presence of these functions. If they weren't found we have to replace them
+** here with a standard C cast.
+*/
+
+/*
+** The C99 prototypes for lrint and lrintf are as follows:
+**
+** long int lrintf (float x) ;
+** long int lrint (double x) ;
+*/
+
+#if (defined (WIN32) || defined (_WIN32))
+
+ #include <math.h>
+
+ /* Win32 doesn't seem to have these functions.
+ ** Therefore implement inline versions of these functions here.
+ */
+
+ __inline long int
+ lrint (double flt)
+ { int intgr;
+
+ _asm
+ { fld flt
+ fistp intgr
+ } ;
+
+ return intgr ;
+ }
+
+ __inline long int
+ lrintf (float flt)
+ { int intgr;
+
+ _asm
+ { fld flt
+ fistp intgr
+ } ;
+
+ return intgr ;
+ }
+
+#endif
+
+
+
--- /dev/null
+/*
+ * Copyright (c) 1987, 1993, 1994
+ * The Regents of the University of California. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int opterr = 1, /* if error message should be printed */
+ optind = 1, /* index into parent argv vector */
+ optopt, /* character checked for validity */
+ optreset; /* reset getopt */
+char *optarg; /* argument associated with option */
+
+#define BADCH (int)'?'
+#define BADARG (int)':'
+#define EMSG ""
+
+/*
+ * getopt --
+ * Parse argc/argv argument vector.
+ */
+int
+getopt(nargc, nargv, ostr)
+ int nargc;
+ char * const *nargv;
+ const char *ostr;
+{
+ static char *place = EMSG; /* option letter processing */
+ char *oli; /* option letter list index */
+
+ if (optreset || !*place) { /* update scanning pointer */
+ optreset = 0;
+ if (optind >= nargc || *(place = nargv[optind]) != '-') {
+ place = EMSG;
+ return (-1);
+ }
+ if (place[1] && *++place == '-') { /* found "--" */
+ ++optind;
+ place = EMSG;
+ return (-1);
+ }
+ } /* option letter okay? */
+ if ((optopt = (int)*place++) == (int)':' ||
+ !(oli = strchr(ostr, optopt))) {
+ /*
+ * if the user didn't specify '-' as an option,
+ * assume it means -1.
+ */
+ if (optopt == (int)'-')
+ return (-1);
+ if (!*place)
+ ++optind;
+ if (opterr && *ostr != ':' && optopt != BADCH)
+ (void)fprintf(stderr, "%s: illegal option -- %c\n",
+ "progname", optopt);
+ return (BADCH);
+ }
+ if (*++oli != ':') { /* don't need argument */
+ optarg = NULL;
+ if (!*place)
+ ++optind;
+ }
+ else { /* need an argument */
+ if (*place) /* no white space */
+ optarg = place;
+ else if (nargc <= ++optind) { /* no arg */
+ place = EMSG;
+ if (*ostr == ':')
+ return (BADARG);
+ if (opterr)
+ (void)fprintf(stderr,
+ "%s: option requires an argument -- %c\n",
+ "progname", optopt);
+ return (BADCH);
+ }
+ else /* white space */
+ optarg = nargv[optind];
+ place = EMSG;
+ ++optind;
+ }
+ return (optopt); /* dump back option letter */
+}
--- /dev/null
+/* $NetBSD: getopt.h,v 1.4 2000/07/07 10:43:54 ad Exp $ */
+/* $FreeBSD: src/include/getopt.h,v 1.1 2002/09/29 04:14:30 eric Exp $ */
+
+/*-
+ * Copyright (c) 2000 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Dieter Baron and Thomas Klausner.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the NetBSD
+ * Foundation, Inc. and its contributors.
+ * 4. Neither the name of The NetBSD Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _GETOPT_H_
+#define _GETOPT_H_
+
+#ifdef _WIN32
+/* from <sys/cdefs.h> */
+# ifdef __cplusplus
+# define __BEGIN_DECLS extern "C" {
+# define __END_DECLS }
+# else
+# define __BEGIN_DECLS
+# define __END_DECLS
+# endif
+# define __P(args) args
+#endif
+
+/*#ifndef _WIN32
+#include <sys/cdefs.h>
+#include <unistd.h>
+#endif*/
+
+#ifdef _WIN32
+# if !defined(GETOPT_API)
+# define GETOPT_API __declspec(dllimport)
+# endif
+#endif
+
+/*
+ * Gnu like getopt_long() and BSD4.4 getsubopt()/optreset extensions
+ */
+#if !defined(_POSIX_SOURCE) && !defined(_XOPEN_SOURCE)
+#define no_argument 0
+#define required_argument 1
+#define optional_argument 2
+
+struct option {
+ /* name of long option */
+ const char *name;
+ /*
+ * one of no_argument, required_argument, and optional_argument:
+ * whether option takes an argument
+ */
+ int has_arg;
+ /* if not NULL, set *flag to val when option found */
+ int *flag;
+ /* if flag not NULL, value to set *flag to; else return value */
+ int val;
+};
+
+__BEGIN_DECLS
+GETOPT_API int getopt_long __P((int, char * const *, const char *,
+ const struct option *, int *));
+__END_DECLS
+#endif
+
+#ifdef _WIN32
+/* These are global getopt variables */
+__BEGIN_DECLS
+
+GETOPT_API extern int opterr, /* if error message should be printed */
+ optind, /* index into parent argv vector */
+ optopt, /* character checked for validity */
+ optreset; /* reset getopt */
+GETOPT_API extern char* optarg; /* argument associated with option */
+
+/* Original getopt */
+GETOPT_API int getopt __P((int, char * const *, const char *));
+
+__END_DECLS
+#endif
+
+#endif /* !_GETOPT_H_ */
--- /dev/null
+/* $NetBSD: getopt_long.c,v 1.15 2002/01/31 22:43:40 tv Exp $ */
+/* $FreeBSD: src/lib/libc/stdlib/getopt_long.c,v 1.2 2002/10/16 22:18:42 alfred Exp $ */
+
+/*-
+ * Copyright (c) 2000 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Dieter Baron and Thomas Klausner.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the NetBSD
+ * Foundation, Inc. and its contributors.
+ * 4. Neither the name of The NetBSD Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef _WIN32
+
+/* Windows needs warnx(). We change the definition though:
+ * 1. (another) global is defined, opterrmsg, which holds the error message
+ * 2. errors are always printed out on stderr w/o the program name
+ * Note that opterrmsg always gets set no matter what opterr is set to. The
+ * error message will not be printed if opterr is 0 as usual.
+ */
+
+#include "getopt.h"
+#include <stdio.h>
+#include <stdarg.h>
+
+GETOPT_API extern char opterrmsg[128];
+char opterrmsg[128]; /* last error message is stored here */
+
+static void warnx(int print_error, const char *fmt, ...)
+{
+ va_list ap;
+ va_start(ap, fmt);
+ if (fmt != NULL)
+ _vsnprintf(opterrmsg, 128, fmt, ap);
+ else
+ opterrmsg[0]='\0';
+ va_end(ap);
+ if (print_error) {
+ fprintf(stderr, opterrmsg);
+ fprintf(stderr, "\n");
+ }
+}
+
+#endif /*_WIN32*/
+
+/* not part of the original file */
+#ifndef _DIAGASSERT
+#define _DIAGASSERT(X)
+#endif
+
+#if HAVE_CONFIG_H && !HAVE_GETOPT_LONG && !HAVE_DECL_OPTIND
+#define REPLACE_GETOPT
+#endif
+
+#ifdef REPLACE_GETOPT
+#ifdef __weak_alias
+__weak_alias(getopt,_getopt)
+#endif
+int opterr = 1; /* if error message should be printed */
+int optind = 1; /* index into parent argv vector */
+int optopt = '?'; /* character checked for validity */
+int optreset; /* reset getopt */
+char *optarg; /* argument associated with option */
+#elif HAVE_CONFIG_H && !HAVE_DECL_OPTRESET
+static int optreset;
+#endif
+
+#ifdef __weak_alias
+__weak_alias(getopt_long,_getopt_long)
+#endif
+
+#if !HAVE_GETOPT_LONG
+#define IGNORE_FIRST (*options == '-' || *options == '+')
+#define PRINT_ERROR ((opterr) && ((*options != ':') \
+ || (IGNORE_FIRST && options[1] != ':')))
+#define IS_POSIXLY_CORRECT (getenv("POSIXLY_CORRECT") != NULL)
+#define PERMUTE (!IS_POSIXLY_CORRECT && !IGNORE_FIRST)
+/* XXX: GNU ignores PC if *options == '-' */
+#define IN_ORDER (!IS_POSIXLY_CORRECT && *options == '-')
+
+/* return values */
+#define BADCH (int)'?'
+#define BADARG ((IGNORE_FIRST && options[1] == ':') \
+ || (*options == ':') ? (int)':' : (int)'?')
+#define INORDER (int)1
+
+#define EMSG ""
+
+static int getopt_internal(int, char * const *, const char *);
+static int gcd(int, int);
+static void permute_args(int, int, int, char * const *);
+
+static char *place = EMSG; /* option letter processing */
+
+/* XXX: set optreset to 1 rather than these two */
+static int nonopt_start = -1; /* first non option argument (for permute) */
+static int nonopt_end = -1; /* first option after non options (for permute) */
+
+/* Error messages */
+static const char recargchar[] = "option requires an argument -- %c";
+static const char recargstring[] = "option requires an argument -- %s";
+static const char ambig[] = "ambiguous option -- %.*s";
+static const char noarg[] = "option doesn't take an argument -- %.*s";
+static const char illoptchar[] = "unknown option -- %c";
+static const char illoptstring[] = "unknown option -- %s";
+
+
+/*
+ * Compute the greatest common divisor of a and b.
+ */
+static int
+gcd(a, b)
+ int a;
+ int b;
+{
+ int c;
+
+ c = a % b;
+ while (c != 0) {
+ a = b;
+ b = c;
+ c = a % b;
+ }
+
+ return b;
+}
+
+/*
+ * Exchange the block from nonopt_start to nonopt_end with the block
+ * from nonopt_end to opt_end (keeping the same order of arguments
+ * in each block).
+ */
+static void
+permute_args(panonopt_start, panonopt_end, opt_end, nargv)
+ int panonopt_start;
+ int panonopt_end;
+ int opt_end;
+ char * const *nargv;
+{
+ int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos;
+ char *swap;
+
+ _DIAGASSERT(nargv != NULL);
+
+ /*
+ * compute lengths of blocks and number and size of cycles
+ */
+ nnonopts = panonopt_end - panonopt_start;
+ nopts = opt_end - panonopt_end;
+ ncycle = gcd(nnonopts, nopts);
+ cyclelen = (opt_end - panonopt_start) / ncycle;
+
+ for (i = 0; i < ncycle; i++) {
+ cstart = panonopt_end+i;
+ pos = cstart;
+ for (j = 0; j < cyclelen; j++) {
+ if (pos >= panonopt_end)
+ pos -= nnonopts;
+ else
+ pos += nopts;
+ swap = nargv[pos];
+ /* LINTED const cast */
+ ((char **) nargv)[pos] = nargv[cstart];
+ /* LINTED const cast */
+ ((char **)nargv)[cstart] = swap;
+ }
+ }
+}
+
+/*
+ * getopt_internal --
+ * Parse argc/argv argument vector. Called by user level routines.
+ * Returns -2 if -- is found (can be long option or end of options marker).
+ */
+static int
+getopt_internal(nargc, nargv, options)
+ int nargc;
+ char * const *nargv;
+ const char *options;
+{
+ char *oli; /* option letter list index */
+ int optchar;
+
+ _DIAGASSERT(nargv != NULL);
+ _DIAGASSERT(options != NULL);
+
+ optarg = NULL;
+
+ /*
+ * XXX Some programs (like rsyncd) expect to be able to
+ * XXX re-initialize optind to 0 and have getopt_long(3)
+ * XXX properly function again. Work around this braindamage.
+ */
+ if (optind == 0)
+ optind = 1;
+
+ if (optreset)
+ nonopt_start = nonopt_end = -1;
+start:
+ if (optreset || !*place) { /* update scanning pointer */
+ optreset = 0;
+ if (optind >= nargc) { /* end of argument vector */
+ place = EMSG;
+ if (nonopt_end != -1) {
+ /* do permutation, if we have to */
+ permute_args(nonopt_start, nonopt_end,
+ optind, nargv);
+ optind -= nonopt_end - nonopt_start;
+ }
+ else if (nonopt_start != -1) {
+ /*
+ * If we skipped non-options, set optind
+ * to the first of them.
+ */
+ optind = nonopt_start;
+ }
+ nonopt_start = nonopt_end = -1;
+ return -1;
+ }
+ if ((*(place = nargv[optind]) != '-')
+ || (place[1] == '\0')) { /* found non-option */
+ place = EMSG;
+ if (IN_ORDER) {
+ /*
+ * GNU extension:
+ * return non-option as argument to option 1
+ */
+ optarg = nargv[optind++];
+ return INORDER;
+ }
+ if (!PERMUTE) {
+ /*
+ * if no permutation wanted, stop parsing
+ * at first non-option
+ */
+ return -1;
+ }
+ /* do permutation */
+ if (nonopt_start == -1)
+ nonopt_start = optind;
+ else if (nonopt_end != -1) {
+ permute_args(nonopt_start, nonopt_end,
+ optind, nargv);
+ nonopt_start = optind -
+ (nonopt_end - nonopt_start);
+ nonopt_end = -1;
+ }
+ optind++;
+ /* process next argument */
+ goto start;
+ }
+ if (nonopt_start != -1 && nonopt_end == -1)
+ nonopt_end = optind;
+ if (place[1] && *++place == '-') { /* found "--" */
+ place++;
+ return -2;
+ }
+ }
+ if ((optchar = (int)*place++) == (int)':' ||
+ (oli = strchr(options + (IGNORE_FIRST ? 1 : 0), optchar)) == NULL) {
+ /* option letter unknown or ':' */
+ if (!*place)
+ ++optind;
+#ifndef _WIN32
+ if (PRINT_ERROR)
+ warnx(illoptchar, optchar);
+#else
+ warnx(PRINT_ERROR, illoptchar, optchar);
+#endif
+ optopt = optchar;
+ return BADCH;
+ }
+ if (optchar == 'W' && oli[1] == ';') { /* -W long-option */
+ /* XXX: what if no long options provided (called by getopt)? */
+ if (*place)
+ return -2;
+
+ if (++optind >= nargc) { /* no arg */
+ place = EMSG;
+#ifndef _WIN32
+ if (PRINT_ERROR)
+ warnx(recargchar, optchar);
+#else
+ warnx(PRINT_ERROR, recargchar, optchar);
+#endif
+ optopt = optchar;
+ return BADARG;
+ } else /* white space */
+ place = nargv[optind];
+ /*
+ * Handle -W arg the same as --arg (which causes getopt to
+ * stop parsing).
+ */
+ return -2;
+ }
+ if (*++oli != ':') { /* doesn't take argument */
+ if (!*place)
+ ++optind;
+ } else { /* takes (optional) argument */
+ optarg = NULL;
+ if (*place) /* no white space */
+ optarg = place;
+ /* XXX: disable test for :: if PC? (GNU doesn't) */
+ else if (oli[1] != ':') { /* arg not optional */
+ if (++optind >= nargc) { /* no arg */
+ place = EMSG;
+#ifndef _WIN32
+ if (PRINT_ERROR)
+ warnx(recargchar, optchar);
+#else
+ warnx(PRINT_ERROR, recargchar, optchar);
+#endif
+ optopt = optchar;
+ return BADARG;
+ } else
+ optarg = nargv[optind];
+ }
+ place = EMSG;
+ ++optind;
+ }
+ /* dump back option letter */
+ return optchar;
+}
+
+#ifdef REPLACE_GETOPT
+/*
+ * getopt --
+ * Parse argc/argv argument vector.
+ *
+ * [eventually this will replace the real getopt]
+ */
+int
+getopt(nargc, nargv, options)
+ int nargc;
+ char * const *nargv;
+ const char *options;
+{
+ int retval;
+
+ _DIAGASSERT(nargv != NULL);
+ _DIAGASSERT(options != NULL);
+
+ if ((retval = getopt_internal(nargc, nargv, options)) == -2) {
+ ++optind;
+ /*
+ * We found an option (--), so if we skipped non-options,
+ * we have to permute.
+ */
+ if (nonopt_end != -1) {
+ permute_args(nonopt_start, nonopt_end, optind,
+ nargv);
+ optind -= nonopt_end - nonopt_start;
+ }
+ nonopt_start = nonopt_end = -1;
+ retval = -1;
+ }
+ return retval;
+}
+#endif
+
+/*
+ * getopt_long --
+ * Parse argc/argv argument vector.
+ */
+int
+getopt_long(nargc, nargv, options, long_options, idx)
+ int nargc;
+ char * const *nargv;
+ const char *options;
+ const struct option *long_options;
+ int *idx;
+{
+ int retval;
+
+ _DIAGASSERT(nargv != NULL);
+ _DIAGASSERT(options != NULL);
+ _DIAGASSERT(long_options != NULL);
+ /* idx may be NULL */
+
+ if ((retval = getopt_internal(nargc, nargv, options)) == -2) {
+ char *current_argv, *has_equal;
+ size_t current_argv_len;
+ int i, match;
+
+ current_argv = place;
+ match = -1;
+
+ optind++;
+ place = EMSG;
+
+ if (*current_argv == '\0') { /* found "--" */
+ /*
+ * We found an option (--), so if we skipped
+ * non-options, we have to permute.
+ */
+ if (nonopt_end != -1) {
+ permute_args(nonopt_start, nonopt_end,
+ optind, nargv);
+ optind -= nonopt_end - nonopt_start;
+ }
+ nonopt_start = nonopt_end = -1;
+ return -1;
+ }
+ if ((has_equal = strchr(current_argv, '=')) != NULL) {
+ /* argument found (--option=arg) */
+ current_argv_len = has_equal - current_argv;
+ has_equal++;
+ } else
+ current_argv_len = strlen(current_argv);
+
+ for (i = 0; long_options[i].name; i++) {
+ /* find matching long option */
+ if (strncmp(current_argv, long_options[i].name,
+ current_argv_len))
+ continue;
+
+ if (strlen(long_options[i].name) ==
+ (unsigned)current_argv_len) {
+ /* exact match */
+ match = i;
+ break;
+ }
+ if (match == -1) /* partial match */
+ match = i;
+ else {
+ /* ambiguous abbreviation */
+#ifndef _WIN32
+ if (PRINT_ERROR)
+ warnx(ambig, (int)current_argv_len,
+ current_argv);
+#else
+ warnx(PRINT_ERROR, ambig, (int)current_argv_len,
+ current_argv);
+#endif
+ optopt = 0;
+ return BADCH;
+ }
+ }
+ if (match != -1) { /* option found */
+ if (long_options[match].has_arg == no_argument
+ && has_equal) {
+#ifndef _WIN32
+ if (PRINT_ERROR)
+ warnx(noarg, (int)current_argv_len,
+ current_argv);
+#else
+ warnx(PRINT_ERROR, noarg, (int)current_argv_len,
+ current_argv);
+#endif
+ /*
+ * XXX: GNU sets optopt to val regardless of
+ * flag
+ */
+ if (long_options[match].flag == NULL)
+ optopt = long_options[match].val;
+ else
+ optopt = 0;
+ return BADARG;
+ }
+ if (long_options[match].has_arg == required_argument ||
+ long_options[match].has_arg == optional_argument) {
+ if (has_equal)
+ optarg = has_equal;
+ else if (long_options[match].has_arg ==
+ required_argument) {
+ /*
+ * optional argument doesn't use
+ * next nargv
+ */
+ optarg = nargv[optind++];
+ }
+ }
+ if ((long_options[match].has_arg == required_argument)
+ && (optarg == NULL)) {
+ /*
+ * Missing argument; leading ':'
+ * indicates no error should be generated
+ */
+#ifndef _WIN32
+ if (PRINT_ERROR)
+ warnx(recargstring, current_argv);
+#else
+ warnx(PRINT_ERROR, recargstring, current_argv);
+#endif
+ /*
+ * XXX: GNU sets optopt to val regardless
+ * of flag
+ */
+ if (long_options[match].flag == NULL)
+ optopt = long_options[match].val;
+ else
+ optopt = 0;
+ --optind;
+ return BADARG;
+ }
+ } else { /* unknown option */
+#ifndef _WIN32
+ if (PRINT_ERROR)
+ warnx(illoptstring, current_argv);
+#else
+ warnx(PRINT_ERROR, illoptstring, current_argv);
+#endif
+ optopt = 0;
+ return BADCH;
+ }
+ if (long_options[match].flag) {
+ *long_options[match].flag = long_options[match].val;
+ retval = 0;
+ } else
+ retval = long_options[match].val;
+ if (idx)
+ *idx = match;
+ }
+ return retval;
+}
+#endif /* !GETOPT_LONG */
/*
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
modify it under the terms of the GNU General Public License as
using namespace RubberBand;
+using std::cout;
+using std::cerr;
+using std::endl;
+using std::min;
+
const char *const
RubberBandPitchShifter::portNamesMono[PortCountMono] =
{
- "_latency",
+ "latency",
"Cents",
"Semitones",
"Octaves",
"Crispness",
+ "Formant Preserving",
+ "Faster",
"Input",
"Output"
};
const char *const
RubberBandPitchShifter::portNamesStereo[PortCountStereo] =
{
- "_latency",
+ "latency",
"Cents",
"Semitones",
"Octaves",
"Crispness",
+ "Formant Preserving",
+ "Faster",
"Input L",
"Output L",
"Input R",
LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL,
LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL,
LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL,
+ LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL,
+ LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL,
LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO,
LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO
};
LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL,
LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL,
LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL,
+ LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL,
+ LADSPA_PORT_INPUT | LADSPA_PORT_CONTROL,
LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO,
LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO,
LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO,
const LADSPA_PortRangeHint
RubberBandPitchShifter::hintsMono[PortCountMono] =
{
- { 0, 0, 0 },
- { LADSPA_HINT_DEFAULT_0 |
+ { 0, 0, 0 }, // latency
+ { LADSPA_HINT_DEFAULT_0 | // cents
LADSPA_HINT_BOUNDED_BELOW |
LADSPA_HINT_BOUNDED_ABOVE,
-100.0, 100.0 },
- { LADSPA_HINT_DEFAULT_0 |
+ { LADSPA_HINT_DEFAULT_0 | // semitones
LADSPA_HINT_BOUNDED_BELOW |
LADSPA_HINT_BOUNDED_ABOVE |
LADSPA_HINT_INTEGER,
-12.0, 12.0 },
- { LADSPA_HINT_DEFAULT_0 |
+ { LADSPA_HINT_DEFAULT_0 | // octaves
LADSPA_HINT_BOUNDED_BELOW |
LADSPA_HINT_BOUNDED_ABOVE |
LADSPA_HINT_INTEGER,
- -4.0, 4.0 },
- { LADSPA_HINT_DEFAULT_MAXIMUM |
+ -3.0, 3.0 },
+ { LADSPA_HINT_DEFAULT_MAXIMUM | // crispness
LADSPA_HINT_BOUNDED_BELOW |
LADSPA_HINT_BOUNDED_ABOVE |
LADSPA_HINT_INTEGER,
0.0, 3.0 },
+ { LADSPA_HINT_DEFAULT_0 | // formant preserving
+ LADSPA_HINT_BOUNDED_BELOW |
+ LADSPA_HINT_BOUNDED_ABOVE |
+ LADSPA_HINT_TOGGLED,
+ 0.0, 1.0 },
+ { LADSPA_HINT_DEFAULT_0 | // fast
+ LADSPA_HINT_BOUNDED_BELOW |
+ LADSPA_HINT_BOUNDED_ABOVE |
+ LADSPA_HINT_TOGGLED,
+ 0.0, 1.0 },
{ 0, 0, 0 },
{ 0, 0, 0 }
};
const LADSPA_PortRangeHint
RubberBandPitchShifter::hintsStereo[PortCountStereo] =
{
- { 0, 0, 0 },
- { LADSPA_HINT_DEFAULT_0 |
+ { 0, 0, 0 }, // latency
+ { LADSPA_HINT_DEFAULT_0 | // cents
LADSPA_HINT_BOUNDED_BELOW |
LADSPA_HINT_BOUNDED_ABOVE,
-100.0, 100.0 },
- { LADSPA_HINT_DEFAULT_0 |
+ { LADSPA_HINT_DEFAULT_0 | // semitones
LADSPA_HINT_BOUNDED_BELOW |
LADSPA_HINT_BOUNDED_ABOVE |
LADSPA_HINT_INTEGER,
-12.0, 12.0 },
- { LADSPA_HINT_DEFAULT_0 |
+ { LADSPA_HINT_DEFAULT_0 | // octaves
LADSPA_HINT_BOUNDED_BELOW |
LADSPA_HINT_BOUNDED_ABOVE |
LADSPA_HINT_INTEGER,
- -4.0, 4.0 },
- { LADSPA_HINT_DEFAULT_MAXIMUM |
+ -3.0, 3.0 },
+ { LADSPA_HINT_DEFAULT_MAXIMUM | // crispness
LADSPA_HINT_BOUNDED_BELOW |
LADSPA_HINT_BOUNDED_ABOVE |
LADSPA_HINT_INTEGER,
0.0, 3.0 },
+ { LADSPA_HINT_DEFAULT_0 | // formant preserving
+ LADSPA_HINT_BOUNDED_BELOW |
+ LADSPA_HINT_BOUNDED_ABOVE |
+ LADSPA_HINT_TOGGLED,
+ 0.0, 1.0 },
+ { LADSPA_HINT_DEFAULT_0 | // fast
+ LADSPA_HINT_BOUNDED_BELOW |
+ LADSPA_HINT_BOUNDED_ABOVE |
+ LADSPA_HINT_TOGGLED,
+ 0.0, 1.0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
"rubberband-pitchshifter-mono", // Label
properties,
"Rubber Band Mono Pitch Shifter", // Name
- "Chris Cannam",
+ "Breakfast Quay",
"GPL",
PortCountMono,
portsMono,
"rubberband-pitchshifter-stereo", // Label
properties,
"Rubber Band Stereo Pitch Shifter", // Name
- "Chris Cannam",
+ "Breakfast Quay",
"GPL",
PortCountStereo,
portsStereo,
m_semitones(0),
m_octaves(0),
m_crispness(0),
+ m_formant(0),
+ m_fast(0),
m_ratio(1.0),
m_prevRatio(1.0),
m_currentCrispness(-1),
- m_extraLatency(8192), //!!! this should be at least the maximum possible displacement from linear at input rates, divided by the pitch scale factor. It could be very large
+ m_currentFormant(false),
+ m_currentFast(false),
+ m_blockSize(1024),
+ m_reserve(1024),
+ m_minfill(0),
m_stretcher(new RubberBandStretcher
(sampleRate, channels,
- RubberBandStretcher::OptionProcessRealTime)),
+ RubberBandStretcher::OptionProcessRealTime |
+ RubberBandStretcher::OptionPitchHighConsistency)),
m_sampleRate(sampleRate),
m_channels(channels)
{
for (size_t c = 0; c < m_channels; ++c) {
+
m_input[c] = 0;
m_output[c] = 0;
- //!!! size must be at least max process size plus m_extraLatency:
- m_outputBuffer[c] = new RingBuffer<float>(8092); //!!!
- m_outputBuffer[c]->zero(m_extraLatency);
- //!!! size must be at least max process size:
- m_scratch[c] = new float[16384];//!!!
+
+ int bufsize = m_blockSize + m_reserve + 8192;
+
+ m_outputBuffer[c] = new RingBuffer<float>(bufsize);
+
+ m_scratch[c] = new float[bufsize];
+ for (int i = 0; i < bufsize; ++i) m_scratch[c][i] = 0.f;
}
+
+ activateImpl();
}
RubberBandPitchShifter::~RubberBandPitchShifter()
&shifter->m_semitones,
&shifter->m_octaves,
&shifter->m_crispness,
- &shifter->m_input[0],
+ &shifter->m_formant,
+ &shifter->m_fast,
+ &shifter->m_input[0],
&shifter->m_output[0],
&shifter->m_input[1],
&shifter->m_output[1]
};
+ if (shifter->m_channels == 1) {
+ if (port >= PortCountMono) return;
+ } else {
+ if (port >= PortCountStereo) return;
+ }
+
*ports[port] = (float *)location;
+
+ if (shifter->m_latency) {
+ *(shifter->m_latency) =
+ float(shifter->m_stretcher->getLatency() + shifter->m_reserve);
+ }
}
void
RubberBandPitchShifter::activate(LADSPA_Handle handle)
{
RubberBandPitchShifter *shifter = (RubberBandPitchShifter *)handle;
- shifter->updateRatio();
- shifter->m_prevRatio = shifter->m_ratio;
- shifter->m_stretcher->reset();
- shifter->m_stretcher->setPitchScale(shifter->m_ratio);
+ shifter->activateImpl();
+}
+
+void
+RubberBandPitchShifter::activateImpl()
+{
+ updateRatio();
+ m_prevRatio = m_ratio;
+ m_stretcher->reset();
+ m_stretcher->setPitchScale(m_ratio);
+
+ for (size_t c = 0; c < m_channels; ++c) {
+ m_outputBuffer[c]->reset();
+ m_outputBuffer[c]->zero(m_reserve);
+ }
+
+ m_minfill = 0;
+
+ // prime stretcher
+// for (int i = 0; i < 8; ++i) {
+// int reqd = m_stretcher->getSamplesRequired();
+// m_stretcher->process(m_scratch, reqd, false);
+// int avail = m_stretcher->available();
+// if (avail > 0) {
+// m_stretcher->retrieve(m_scratch, avail);
+// }
+// }
}
void
void
RubberBandPitchShifter::updateRatio()
{
- double oct = *m_octaves;
- oct += *m_semitones / 12;
- oct += *m_cents / 1200;
+ double oct = (m_octaves ? *m_octaves : 0.0);
+ oct += (m_semitones ? *m_semitones : 0.0) / 12;
+ oct += (m_cents ? *m_cents : 0.0) / 1200;
m_ratio = pow(2.0, oct);
}
s->setTransientsOption(RubberBandStretcher::OptionTransientsSmooth);
break;
case 1:
- s->setPhaseOption(RubberBandStretcher::OptionPhaseAdaptive);
+ s->setPhaseOption(RubberBandStretcher::OptionPhaseLaminar);
s->setTransientsOption(RubberBandStretcher::OptionTransientsSmooth);
break;
case 2:
- s->setPhaseOption(RubberBandStretcher::OptionPhaseAdaptive);
+ s->setPhaseOption(RubberBandStretcher::OptionPhaseLaminar);
s->setTransientsOption(RubberBandStretcher::OptionTransientsMixed);
break;
case 3:
- s->setPhaseOption(RubberBandStretcher::OptionPhaseAdaptive);
+ s->setPhaseOption(RubberBandStretcher::OptionPhaseLaminar);
s->setTransientsOption(RubberBandStretcher::OptionTransientsCrisp);
break;
}
m_currentCrispness = c;
}
+void
+RubberBandPitchShifter::updateFormant()
+{
+ if (!m_formant) return;
+
+ bool f = (*m_formant > 0.5f);
+ if (f == m_currentFormant) return;
+
+ RubberBandStretcher *s = m_stretcher;
+
+ s->setFormantOption(f ?
+ RubberBandStretcher::OptionFormantPreserved :
+ RubberBandStretcher::OptionFormantShifted);
+
+ m_currentFormant = f;
+}
+
+void
+RubberBandPitchShifter::updateFast()
+{
+ if (!m_fast) return;
+
+ bool f = (*m_fast > 0.5f);
+ if (f == m_currentFast) return;
+
+ RubberBandStretcher *s = m_stretcher;
+
+ s->setPitchOption(f ?
+ RubberBandStretcher::OptionPitchHighSpeed :
+ RubberBandStretcher::OptionPitchHighConsistency);
+
+ m_currentFast = f;
+}
+
void
RubberBandPitchShifter::runImpl(unsigned long insamples)
{
-// std::cerr << "RubberBandPitchShifter::runImpl(" << insamples << ")" << std::endl;
+ unsigned long offset = 0;
+
+ // We have to break up the input into chunks like this because
+ // insamples could be arbitrarily large and our output buffer is
+ // of limited size
+
+ while (offset < insamples) {
+
+ unsigned long block = (unsigned long)m_blockSize;
+ if (block + offset > insamples) block = insamples - offset;
+
+ runImpl(block, offset);
+
+ offset += block;
+ }
+}
+
+void
+RubberBandPitchShifter::runImpl(unsigned long insamples, unsigned long offset)
+{
+// cerr << "RubberBandPitchShifter::runImpl(" << insamples << ")" << endl;
+
+// static int incount = 0, outcount = 0;
updateRatio();
if (m_ratio != m_prevRatio) {
}
if (m_latency) {
- *m_latency = m_stretcher->getLatency() + m_extraLatency;
-// std::cerr << "latency = " << *m_latency << std::endl;
+ *m_latency = float(m_stretcher->getLatency() + m_reserve);
+// cerr << "latency = " << *m_latency << endl;
}
updateCrispness();
+ updateFormant();
+ updateFast();
- int samples = insamples;
+ const int samples = insamples;
int processed = 0;
size_t outTotal = 0;
float *ptrs[2];
- // We have to break up the input into chunks like this because
- // insamples could be arbitrarily large
+ int rs = m_outputBuffer[0]->getReadSpace();
+ if (rs < int(m_minfill)) {
+// cerr << "temporary expansion (have " << rs << ", want " << m_reserve << ")" << endl;
+ m_stretcher->setTimeRatio(1.1); // fill up temporarily
+ } else if (rs > 8192) {
+// cerr << "temporary reduction (have " << rs << ", want " << m_reserve << ")" << endl;
+ m_stretcher->setTimeRatio(0.9); // reduce temporarily
+ } else {
+ m_stretcher->setTimeRatio(1.0);
+ }
while (processed < samples) {
- //!!! size_t:
+ // never feed more than the minimum necessary number of
+ // samples at a time; ensures nothing will overflow internally
+ // and we don't need to call setMaxProcessSize
+
int toCauseProcessing = m_stretcher->getSamplesRequired();
-// std::cout << "to-cause: " << toCauseProcessing << ", remain = " << samples - processed;
- int inchunk = std::min(samples - processed, toCauseProcessing);
+ int inchunk = min(samples - processed, toCauseProcessing);
for (size_t c = 0; c < m_channels; ++c) {
- ptrs[c] = &(m_input[c][processed]);
+ ptrs[c] = &(m_input[c][offset + processed]);
}
m_stretcher->process(ptrs, inchunk, false);
processed += inchunk;
int avail = m_stretcher->available();
int writable = m_outputBuffer[0]->getWriteSpace();
- int outchunk = std::min(avail, writable);
+ int outchunk = min(avail, writable);
size_t actual = m_stretcher->retrieve(m_scratch, outchunk);
outTotal += actual;
-// std::cout << ", avail: " << avail << ", outchunk = " << outchunk;
-// if (actual != outchunk) std::cout << " (" << actual << ")";
-// std::cout << std::endl;
+// incount += inchunk;
+// outcount += actual;
+
+// cout << "avail: " << avail << ", outchunk = " << outchunk;
+// if (actual != outchunk) cout << " (" << actual << ")";
+// cout << endl;
outchunk = actual;
for (size_t c = 0; c < m_channels; ++c) {
if (int(m_outputBuffer[c]->getWriteSpace()) < outchunk) {
- std::cerr << "RubberBandPitchShifter::runImpl: buffer overrun: chunk = " << outchunk << ", space = " << m_outputBuffer[c]->getWriteSpace() << std::endl;
+ cerr << "RubberBandPitchShifter::runImpl: buffer overrun: chunk = " << outchunk << ", space = " << m_outputBuffer[c]->getWriteSpace() << endl;
}
m_outputBuffer[c]->write(m_scratch[c], outchunk);
}
}
-
-// std::cout << "processed = " << processed << " in, " << outTotal << " out" << ", fill = " << m_outputBuffer[0]->getReadSpace() << " of " << m_outputBuffer[0]->getSize() << std::endl;
for (size_t c = 0; c < m_channels; ++c) {
- int avail = m_outputBuffer[c]->getReadSpace();
-// std::cout << "avail: " << avail << std::endl;
- if (avail < samples && c == 0) {
- std::cerr << "RubberBandPitchShifter::runImpl: buffer underrun: required = " << samples << ", available = " << avail << std::endl;
+ int toRead = m_outputBuffer[c]->getReadSpace();
+ if (toRead < samples && c == 0) {
+ cerr << "RubberBandPitchShifter::runImpl: buffer underrun: required = " << samples << ", available = " << toRead << endl;
}
- int chunk = std::min(avail, samples);
-// std::cout << "out chunk: " << chunk << std::endl;
- m_outputBuffer[c]->read(m_output[c], chunk);
+ int chunk = min(toRead, samples);
+ m_outputBuffer[c]->read(&(m_output[c][offset]), chunk);
}
- static int minr = -1;
- int avail = m_outputBuffer[0]->getReadSpace();
- if (minr == -1 || (avail >= 0 && avail < minr)) {
- std::cerr << "RubberBandPitchShifter::runImpl: new min remaining " << avail << " from " << minr << std::endl;
- minr = avail;
+ if (m_minfill == 0) {
+ m_minfill = m_outputBuffer[0]->getReadSpace();
+// cerr << "minfill = " << m_minfill << endl;
}
}
/*
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
modify it under the terms of the GNU General Public License as
#ifndef _RUBBERBAND_PITCH_SHIFTER_H_
#define _RUBBERBAND_PITCH_SHIFTER_H_
-#include "ladspa.h"
+#include <ladspa.h>
#include "RingBuffer.h"
SemitonesPort = 2,
CentsPort = 3,
CrispnessPort = 4,
- InputPort1 = 5,
- OutputPort1 = 6,
+ FormantPort = 5,
+ FastPort = 6,
+ InputPort1 = 7,
+ OutputPort1 = 8,
PortCountMono = OutputPort1 + 1,
- InputPort2 = 7,
- OutputPort2 = 8,
+ InputPort2 = 9,
+ OutputPort2 = 10,
PortCountStereo = OutputPort2 + 1
};
static void deactivate(LADSPA_Handle);
static void cleanup(LADSPA_Handle);
+ void activateImpl();
void runImpl(unsigned long);
+ void runImpl(unsigned long, unsigned long offset);
void updateRatio();
void updateCrispness();
+ void updateFormant();
+ void updateFast();
float *m_input[2];
float *m_output[2];
float *m_semitones;
float *m_octaves;
float *m_crispness;
+ float *m_formant;
+ float *m_fast;
double m_ratio;
double m_prevRatio;
int m_currentCrispness;
+ bool m_currentFormant;
+ bool m_currentFast;
- size_t m_extraLatency;
+ size_t m_blockSize;
+ size_t m_reserve;
+ size_t m_minfill;
RubberBand::RubberBandStretcher *m_stretcher;
RubberBand::RingBuffer<float> *m_outputBuffer[2];
/*
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
modify it under the terms of the GNU General Public License as
/*
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
modify it under the terms of the GNU General Public License as
#include <iostream>
#include <sndfile.h>
#include <cmath>
-#include <cstdlib>
-#include <sys/time.h>
#include <time.h>
+#include <cstdlib>
+#include <cstring>
#include "sysutils.h"
+#ifdef __MSVC__
+#include "bsd-3rdparty/getopt/getopt.h"
+#else
#include <getopt.h>
+#include <sys/time.h>
+#endif
-// for import and export of FFTW wisdom
-#include <fftw3.h>
+#include "Profiler.h"
using namespace std;
using namespace RubberBand;
using RubberBand::usleep;
#endif
+double tempo_convert(const char *str)
+{
+ char *d = strchr((char *)str, ':');
+
+ if (!d || !*d) {
+ double m = atof(str);
+ if (m != 0.0) return 1.0 / m;
+ else return 1.0;
+ }
+
+ char *a = strdup(str);
+ char *b = strdup(d+1);
+ a[d-str] = '\0';
+ double m = atof(a);
+ double n = atof(b);
+ free(a);
+ free(b);
+ if (n != 0.0 && m != 0.0) return m / n;
+ else return 1.0;
+}
+
int main(int argc, char **argv)
{
int c;
double ratio = 1.0;
- double pitchshift = 1.0;
+ double duration = 0.0;
+ double pitchshift = 0.0;
double frequencyshift = 1.0;
int debug = 0;
bool realtime = false;
bool precise = false;
int threading = 0;
- bool peaklock = true;
+ bool lamination = true;
bool longwin = false;
bool shortwin = false;
- bool softening = true;
+ bool hqpitch = false;
+ bool formant = false;
+ bool crispchanged = false;
int crispness = -1;
bool help = false;
+ bool version = false;
bool quiet = false;
bool haveRatio = false;
Transients
} transients = Transients;
- float fthresh0 = -1.f;
- float fthresh1 = -1.f;
- float fthresh2 = -1.f;
-
while (1) {
int optionIndex = 0;
static struct option longOpts[] = {
{ "help", 0, 0, 'h' },
+ { "version", 0, 0, 'V' },
{ "time", 1, 0, 't' },
{ "tempo", 1, 0, 'T' },
+ { "duration", 1, 0, 'D' },
{ "pitch", 1, 0, 'p' },
{ "frequency", 1, 0, 'f' },
{ "crisp", 1, 0, 'c' },
{ "debug", 1, 0, 'd' },
{ "realtime", 0, 0, 'R' },
{ "precise", 0, 0, 'P' },
+ { "formant", 0, 0, 'F' },
{ "no-threads", 0, 0, '0' },
{ "no-transients", 0, 0, '1' },
- { "no-peaklock", 0, 0, '2' },
+ { "no-lamination", 0, 0, '2' },
{ "window-long", 0, 0, '3' },
{ "window-short", 0, 0, '4' },
- { "thresh0", 1, 0, '5' },
- { "thresh1", 1, 0, '6' },
- { "thresh2", 1, 0, '7' },
{ "bl-transients", 0, 0, '8' },
- { "no-softening", 0, 0, '9' },
+ { "pitch-hq", 0, 0, '%' },
{ "threads", 0, 0, '@' },
{ "quiet", 0, 0, 'q' },
{ 0, 0, 0 }
};
- c = getopt_long(argc, argv, "t:p:d:RPc:f:qh", longOpts, &optionIndex);
+ c = getopt_long(argc, argv, "t:p:d:RPFc:f:T:D:qhV", longOpts, &optionIndex);
if (c == -1) break;
switch (c) {
case 'h': help = true; break;
+ case 'V': version = true; break;
case 't': ratio *= atof(optarg); haveRatio = true; break;
- case 'T': { double m = atof(optarg); if (m != 0.0) ratio /= m; }; haveRatio = true; break;
+ case 'T': ratio *= tempo_convert(optarg); haveRatio = true; break;
+ case 'D': duration = atof(optarg); haveRatio = true; break;
case 'p': pitchshift = atof(optarg); haveRatio = true; break;
case 'f': frequencyshift = atof(optarg); haveRatio = true; break;
case 'd': debug = atoi(optarg); break;
case 'R': realtime = true; break;
case 'P': precise = true; break;
+ case 'F': formant = true; break;
case '0': threading = 1; break;
case '@': threading = 2; break;
- case '1': transients = NoTransients; break;
- case '2': peaklock = false; break;
- case '3': longwin = true; break;
- case '4': shortwin = true; break;
- case '5': fthresh0 = atof(optarg); break;
- case '6': fthresh1 = atof(optarg); break;
- case '7': fthresh2 = atof(optarg); break;
- case '8': transients = BandLimitedTransients; break;
- case '9': softening = false; break;
+ case '1': transients = NoTransients; crispchanged = true; break;
+ case '2': lamination = false; crispchanged = true; break;
+ case '3': longwin = true; crispchanged = true; break;
+ case '4': shortwin = true; crispchanged = true; break;
+ case '8': transients = BandLimitedTransients; crispchanged = true; break;
+ case '%': hqpitch = true; break;
case 'c': crispness = atoi(optarg); break;
case 'q': quiet = true; break;
default: help = true; break;
}
}
+ if (version) {
+ cerr << RUBBERBAND_VERSION << endl;
+ return 0;
+ }
+
if (help || !haveRatio || optind + 2 != argc) {
cerr << endl;
cerr << "Rubber Band" << endl;
cerr << "An audio time-stretching and pitch-shifting library and utility program." << endl;
- cerr << "Copyright 2007 Chris Cannam. Distributed under the GNU General Public License." << endl;
+ cerr << "Copyright 2008 Chris Cannam. Distributed under the GNU General Public License." << endl;
cerr << endl;
cerr << " Usage: " << argv[0] << " [options] <infile.wav> <outfile.wav>" << endl;
cerr << endl;
cerr << "You must specify at least one of the following time and pitch ratio options." << endl;
cerr << endl;
cerr << " -t<X>, --time <X> Stretch to X times original duration, or" << endl;
- cerr << " -T<X>, --tempo <X> Change tempo by multiple X (equivalent to --time 1/X)" << endl;
+ cerr << " -T<X>, --tempo <X> Change tempo by multiple X (same as --time 1/X), or" << endl;
+ cerr << " -T<X>, --tempo <X>:<Y> Change tempo from X to Y (same as --time X/Y), or" << endl;
+ cerr << " -D<X>, --duration <X> Stretch or squash to make output file X seconds long" << endl;
cerr << endl;
cerr << " -p<X>, --pitch <X> Raise pitch by X semitones, or" << endl;
cerr << " -f<X>, --frequency <X> Change frequency by multiple X" << endl;
cerr << endl;
- cerr << "The following option provides a simple way to adjust the sound. See below" << endl;
+ cerr << "The following options provide a simple way to adjust the sound. See below" << endl;
cerr << "for more details." << endl;
cerr << endl;
cerr << " -c<N>, --crisp <N> Crispness (N = 0,1,2,3,4,5); default 4 (see below)" << endl;
+ cerr << " -F, --formant Enable formant preservation when pitch shifting" << endl;
cerr << endl;
cerr << "The remaining options fine-tune the processing mode and stretch algorithm." << endl;
cerr << "These are mostly included for test purposes; the default settings and standard" << endl;
cerr << "crispness parameter are intended to provide the best sounding set of options" << endl;
- cerr << "for most situations." << endl;
+ cerr << "for most situations. The default is to use none of these options." << endl;
cerr << endl;
cerr << " -P, --precise Aim for minimal time distortion (implied by -R)" << endl;
cerr << " -R, --realtime Select realtime mode (implies -P --no-threads)" << endl;
cerr << " --threads Assume multi-CPU even if only one CPU is identified" << endl;
cerr << " --no-transients Disable phase resynchronisation at transients" << endl;
cerr << " --bl-transients Band-limit phase resync to extreme frequencies" << endl;
- cerr << " --no-peaklock Disable phase locking to peak frequencies" << endl;
- cerr << " --no-softening Disable large-ratio softening of phase locking" << endl;
+ cerr << " --no-lamination Disable phase lamination" << endl;
cerr << " --window-long Use longer processing window (actual size may vary)" << endl;
cerr << " --window-short Use shorter processing window" << endl;
- cerr << " --thresh<N> <F> Set internal freq threshold N (N = 0,1,2) to F Hz" << endl;
+ cerr << " --pitch-hq In RT mode, use a slower, higher quality pitch shift" << endl;
cerr << endl;
cerr << " -d<N>, --debug <N> Select debug level (N = 0,1,2,3); default 0, full 3" << endl;
cerr << " (N.B. debug level 3 includes audible ticks in output)" << endl;
cerr << " -q, --quiet Suppress progress output" << endl;
cerr << endl;
+ cerr << " -V, --version Show version number and exit" << endl;
cerr << " -h, --help Show this help" << endl;
cerr << endl;
cerr << "\"Crispness\" levels:" << endl;
- cerr << " -c 0 equivalent to --no-transients --no-peaklock --window-long" << endl;
- cerr << " -c 1 equivalent to --no-transients --no-peaklock" << endl;
+ cerr << " -c 0 equivalent to --no-transients --no-lamination --window-long" << endl;
+ cerr << " -c 1 equivalent to --no-transients --no-lamination" << endl;
cerr << " -c 2 equivalent to --no-transients" << endl;
cerr << " -c 3 equivalent to --bl-transients" << endl;
cerr << " -c 4 default processing options" << endl;
- cerr << " -c 5 equivalent to --no-peaklock --window-short (may be suitable for drums)" << endl;
+ cerr << " -c 5 equivalent to --no-lamination --window-short (may be good for drums)" << endl;
cerr << endl;
return 2;
}
+ if (crispness >= 0 && crispchanged) {
+ cerr << "WARNING: Both crispness option and transients, lamination or window options" << endl;
+ cerr << " provided -- crispness will override these other options" << endl;
+ }
+
switch (crispness) {
case -1: crispness = 4; break;
- case 0: transients = NoTransients; peaklock = false; longwin = true; shortwin = false; break;
- case 1: transients = NoTransients; peaklock = false; longwin = false; shortwin = false; break;
- case 2: transients = NoTransients; peaklock = true; longwin = false; shortwin = false; break;
- case 3: transients = BandLimitedTransients; peaklock = true; longwin = false; shortwin = false; break;
- case 4: transients = Transients; peaklock = true; longwin = false; shortwin = false; break;
- case 5: transients = Transients; peaklock = false; longwin = false; shortwin = true; break;
+ case 0: transients = NoTransients; lamination = false; longwin = true; shortwin = false; break;
+ case 1: transients = NoTransients; lamination = false; longwin = false; shortwin = false; break;
+ case 2: transients = NoTransients; lamination = true; longwin = false; shortwin = false; break;
+ case 3: transients = BandLimitedTransients; lamination = true; longwin = false; shortwin = false; break;
+ case 4: transients = Transients; lamination = true; longwin = false; shortwin = false; break;
+ case 5: transients = Transients; lamination = false; longwin = false; shortwin = true; break;
};
if (!quiet) {
char *fileName = strdup(argv[optind++]);
char *fileNameOut = strdup(argv[optind++]);
-
+
SNDFILE *sndfile;
SNDFILE *sndfileOut;
SF_INFO sfinfo;
return 1;
}
+ if (duration != 0.0) {
+ if (sfinfo.frames == 0 || sfinfo.samplerate == 0) {
+ cerr << "ERROR: File lacks frame count or sample rate in header, cannot use --duration" << endl;
+ return 1;
+ }
+ double induration = double(sfinfo.frames) / double(sfinfo.samplerate);
+ if (induration != 0.0) ratio = duration / induration;
+ }
+
sfinfoOut.channels = sfinfo.channels;
sfinfoOut.format = sfinfo.format;
sfinfoOut.frames = int(sfinfo.frames * ratio + 0.1);
sndfileOut = sf_open(fileNameOut, SFM_WRITE, &sfinfoOut) ;
if (!sndfileOut) {
- cerr << "ERROR: Failed to open output file \"" << fileName << "\" for writing: "
- << sf_strerror(sndfile) << endl;
+ cerr << "ERROR: Failed to open output file \"" << fileNameOut << "\" for writing: "
+ << sf_strerror(sndfileOut) << endl;
return 1;
}
RubberBandStretcher::Options options = 0;
if (realtime) options |= RubberBandStretcher::OptionProcessRealTime;
if (precise) options |= RubberBandStretcher::OptionStretchPrecise;
- if (!peaklock) options |= RubberBandStretcher::OptionPhaseIndependent;
- if (!softening) options |= RubberBandStretcher::OptionPhasePeakLocked;
+ if (!lamination) options |= RubberBandStretcher::OptionPhaseIndependent;
if (longwin) options |= RubberBandStretcher::OptionWindowLong;
if (shortwin) options |= RubberBandStretcher::OptionWindowShort;
+ if (formant) options |= RubberBandStretcher::OptionFormantPreserved;
+ if (hqpitch) options |= RubberBandStretcher::OptionPitchHighQuality;
switch (threading) {
case 0:
break;
}
- if (pitchshift != 1.0) {
+ if (pitchshift != 0.0) {
frequencyshift *= pow(2.0, pitchshift / 12);
}
+ cerr << "Using time ratio " << ratio;
+ cerr << " and frequency ratio " << frequencyshift << endl;
+
#ifdef _WIN32
RubberBand::
#endif
cerr << "elapsed time: " << sec << " sec, in frames/sec: " << countIn/sec << ", out frames/sec: " << countOut/sec << endl;
}
+ Profiler::dump();
+
return 0;
}
--- /dev/null
+/* -*- 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 "rubberband-c.h"
+#include "RubberBandStretcher.h"
+
+struct RubberBandState_
+{
+ RubberBand::RubberBandStretcher *m_s;
+};
+
+RubberBandState rubberband_new(unsigned int sampleRate,
+ unsigned int channels,
+ RubberBandOptions options,
+ double initialTimeRatio,
+ double initialPitchScale)
+{
+ RubberBandState_ *state = new RubberBandState_();
+ state->m_s = new RubberBand::RubberBandStretcher
+ (sampleRate, channels, options,
+ initialTimeRatio, initialPitchScale);
+ return state;
+}
+
+void rubberband_delete(RubberBandState state)
+{
+ delete state->m_s;
+ delete state;
+}
+
+void rubberband_reset(RubberBandState state)
+{
+ state->m_s->reset();
+}
+
+void rubberband_set_time_ratio(RubberBandState state, double ratio)
+{
+ state->m_s->setTimeRatio(ratio);
+}
+
+void rubberband_set_pitch_scale(RubberBandState state, double scale)
+{
+ state->m_s->setPitchScale(scale);
+}
+
+double rubberband_get_time_ratio(const RubberBandState state)
+{
+ return state->m_s->getTimeRatio();
+}
+
+double rubberband_get_pitch_scale(const RubberBandState state)
+{
+ return state->m_s->getPitchScale();
+}
+
+unsigned int rubberband_get_latency(const RubberBandState state)
+{
+ return state->m_s->getLatency();
+}
+
+void rubberband_set_transients_option(RubberBandState state, RubberBandOptions options)
+{
+ state->m_s->setTransientsOption(options);
+}
+
+void rubberband_set_phase_option(RubberBandState state, RubberBandOptions options)
+{
+ state->m_s->setPhaseOption(options);
+}
+
+void rubberband_set_formant_option(RubberBandState state, RubberBandOptions options)
+{
+ state->m_s->setFormantOption(options);
+}
+
+void rubberband_set_pitch_option(RubberBandState state, RubberBandOptions options)
+{
+ state->m_s->setPitchOption(options);
+}
+
+void rubberband_set_expected_input_duration(RubberBandState state, unsigned int samples)
+{
+ state->m_s->setExpectedInputDuration(samples);
+}
+
+unsigned int rubberband_get_samples_required(const RubberBandState state)
+{
+ return state->m_s->getSamplesRequired();
+}
+
+void rubberband_set_max_process_size(RubberBandState state, unsigned int samples)
+{
+ state->m_s->setMaxProcessSize(samples);
+}
+
+void rubberband_study(RubberBandState state, const float *const *input, unsigned int samples, int final)
+{
+ state->m_s->study(input, samples, final != 0);
+}
+
+void rubberband_process(RubberBandState state, const float *const *input, unsigned int samples, int final)
+{
+ state->m_s->process(input, samples, final != 0);
+}
+
+int rubberband_available(const RubberBandState state)
+{
+ return state->m_s->available();
+}
+
+unsigned int rubberband_retrieve(const RubberBandState state, float *const *output, unsigned int samples)
+{
+ return state->m_s->retrieve(output, samples);
+}
+
+unsigned int rubberband_get_channel_count(const RubberBandState state)
+{
+ return state->m_s->getChannelCount();
+}
+
+void rubberband_calculate_stretch(RubberBandState state)
+{
+ state->m_s->calculateStretch();
+}
+
+void rubberband_set_debug_level(RubberBandState state, int level)
+{
+ state->m_s->setDebugLevel(level);
+}
+
+void rubberband_set_default_debug_level(int level)
+{
+ RubberBand::RubberBandStretcher::setDefaultDebugLevel(level);
+}
+
/*
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
modify it under the terms of the GNU General Public License as
#include <iostream>
+
namespace RubberBand {
bool
#ifdef _WIN32
-void gettimeofday(struct timeval *tv, void *tz)
+int gettimeofday(struct timeval *tv, void *tz)
{
union {
long long ns100;
::GetSystemTimeAsFileTime(&now.ft);
tv->tv_usec = (long)((now.ns100 / 10LL) % 1000000LL);
tv->tv_sec = (long)((now.ns100 - 116444736000000000LL) / 10000000LL);
+ return 0;
}
void usleep(unsigned long usec)
#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);
+}
+
+
}
/*
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
modify it under the terms of the GNU General Public License as
#ifndef _RUBBERBAND_SYSINFO_H_
#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 {
extern bool system_is_multiprocessor();
#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 *);
+
}
#endif
/*
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
modify it under the terms of the GNU General Public License as
#include "RubberBandVampPlugin.h"
#include "StretchCalculator.h"
+#include "sysutils.h"
#include <cmath>
string
RubberBandVampPlugin::getMaker() const
{
- return "Rubber Band"; ///!!!
+ return "Breakfast Quay";
}
int
d.isQuantized = true;
d.quantizeStep = 1.0;
d.sampleType = OutputDescriptor::VariableSampleRate;
- d.sampleRate = rate;
+ d.sampleRate = float(rate);
m_d->m_incrementsOutput = list.size();
list.push_back(d);
d.name = "Phase Reset Detection Function";
d.description = "Curve whose peaks are used to identify transients for phase reset points";
d.unit = "";
- d.sampleRate = rate;
+ d.sampleRate = float(rate);
m_d->m_phaseResetDfOutput = list.size();
list.push_back(d);
{
if (id == "timeratio") return m_d->m_timeRatio * 100.f;
if (id == "pitchratio") return m_d->m_pitchRatio * 100.f;
- if (id == "mode") return m_d->m_realtime ? 1 : 0;
- if (id == "stretchtype") return m_d->m_elasticTiming ? 0 : 1;
- if (id == "transientmode") return m_d->m_transientMode;
- if (id == "phasemode") return m_d->m_phaseIndependent ? 1 : 0;
- if (id == "windowmode") return m_d->m_windowLength;
+ if (id == "mode") return m_d->m_realtime ? 1.f : 0.f;
+ if (id == "stretchtype") return m_d->m_elasticTiming ? 0.f : 1.f;
+ if (id == "transientmode") return float(m_d->m_transientMode);
+ if (id == "phasemode") return m_d->m_phaseIndependent ? 1.f : 0.f;
+ if (id == "windowmode") return float(m_d->m_windowLength);
return 0.f;
}
if (m_d->m_phaseIndependent)
options |= RubberBand::RubberBandStretcher::OptionPhaseIndependent;
- else options |= RubberBand::RubberBandStretcher::OptionPhasePeakLocked;
+ else options |= RubberBand::RubberBandStretcher::OptionPhaseLaminar;
if (m_d->m_windowLength == 0)
options |= RubberBand::RubberBandStretcher::OptionWindowStandard;
Feature feature;
feature.hasTimestamp = true;
feature.timestamp = t;
- feature.values.push_back(oi);
+ feature.values.push_back(float(oi));
feature.label = Vamp::RealTime::frame2RealTime(oi, rate).toText();
features[m_incrementsOutput].push_back(feature);
feature.values.clear();
- feature.values.push_back(actual);
+ feature.values.push_back(float(actual));
feature.label = Vamp::RealTime::frame2RealTime(actual, rate).toText();
features[m_aggregateIncrementsOutput].push_back(feature);
if (i < phaseResetDf.size()) {
feature.values.clear();
feature.values.push_back(phaseResetDf[i]);
- sprintf(buf, "%d", baseCount + i);
+ sprintf(buf, "%d", int(baseCount + i));
feature.label = buf;
features[m_phaseResetDfOutput].push_back(feature);
}
feature.timestamp = t;
feature.label = Vamp::RealTime::frame2RealTime(actual, rate).toText();
feature.values.clear();
- feature.values.push_back(actual);
+ feature.values.push_back(float(actual));
features[m_aggregateIncrementsOutput].push_back(feature);
float linear = ((baseCount + outputIncrements.size())
/*
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
modify it under the terms of the GNU General Public License as
/*
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
modify it under the terms of the GNU General Public License as
#ifndef __ardour_svn_revision_h__
#define __ardour_svn_revision_h__
-static const char* ardour_svn_revision = "3527";
+static const char* ardour_svn_revision = "3530";
#endif
projects / ardour.git / commitdiff