RubberBandStretcher.h

Go to the documentation of this file.

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
/* Copyright Chris Cannam - All Rights Reserved */

#ifndef _RUBBERBANDSTRETCHER_H_
#define _RUBBERBANDSTRETCHER_H_
    
#define RUBBERBAND_VERSION "1.2.0"    
#define RUBBERBAND_API_MAJOR_VERSION 2
#define RUBBERBAND_API_MINOR_VERSION 0

#include <vector>

namespace RubberBand
{

class RubberBandStretcher
{
public:
    enum Option {

        OptionProcessOffline       = 0x00000000,
        OptionProcessRealTime      = 0x00000001,

        OptionStretchElastic       = 0x00000000,
        OptionStretchPrecise       = 0x00000010,
    
        OptionTransientsCrisp      = 0x00000000,
        OptionTransientsMixed      = 0x00000100,
        OptionTransientsSmooth     = 0x00000200,

        OptionPhaseLaminar         = 0x00000000,
        OptionPhaseIndependent     = 0x00002000,
    
        OptionThreadingAuto        = 0x00000000,
        OptionThreadingNever       = 0x00010000,
        OptionThreadingAlways      = 0x00020000,

        OptionWindowStandard       = 0x00000000,
        OptionWindowShort          = 0x00100000,
        OptionWindowLong           = 0x00200000,

        OptionFormantShifted       = 0x00000000,
        OptionFormantPreserved     = 0x01000000,

        OptionPitchHighSpeed       = 0x00000000,
        OptionPitchHighQuality     = 0x02000000,
        OptionPitchHighConsistency = 0x04000000
    };

    typedef int Options;

    enum PresetOption {
        DefaultOptions             = 0x00000000,
        PercussiveOptions          = 0x00102000
    };

    RubberBandStretcher(size_t sampleRate,
                        size_t channels,
                        Options options = DefaultOptions,
                        double initialTimeRatio = 1.0,
                        double initialPitchScale = 1.0);
    ~RubberBandStretcher();

    void reset();

    void setTimeRatio(double ratio);

    void setPitchScale(double scale);

    double getTimeRatio() const;

    double getPitchScale() const;

    size_t getLatency() const;

    void setTransientsOption(Options options);

    void setPhaseOption(Options options);

    void setFormantOption(Options options);

    void setPitchOption(Options options);

    void setExpectedInputDuration(size_t samples);

     size_t getSamplesRequired() const;

    void setMaxProcessSize(size_t samples);

    void study(const float *const *input, size_t samples, bool final);

    void process(const float *const *input, size_t samples, bool final);

    int available() const;

    size_t retrieve(float *const *output, size_t samples) const;

    float getFrequencyCutoff(int n) const;

    void setFrequencyCutoff(int n, float f);
    
    size_t getInputIncrement() const;

    std::vector<int> getOutputIncrements() const;

    std::vector<float> getPhaseResetCurve() const;

    std::vector<int> getExactTimePoints() const;

    size_t getChannelCount() const;

    void calculateStretch();

    void setDebugLevel(int level);

    static void setDefaultDebugLevel(int level);

protected:
    class Impl;
    Impl *m_d;
};

}

#endif

---