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: */
 
/*
    Rubber Band Library
    An audio time-stretching and pitch-shifting library.
    Copyright 2007-2024 Particular Programs Ltd.
 
    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.
 
    Alternatively, if you have a valid commercial licence for the
    Rubber Band Library obtained by agreement with the copyright
    holders, you may redistribute and/or modify it under the terms
    described in that licence.
 
    If you wish to distribute code using the Rubber Band Library
    under terms other than those of the GNU General Public License,
    you must obtain a valid commercial licence before doing so.
*/
 
#ifndef RUBBERBAND_STRETCHER_H
#define RUBBERBAND_STRETCHER_H
    
#define RUBBERBAND_VERSION "4.0.0"
#define RUBBERBAND_API_MAJOR_VERSION 3
#define RUBBERBAND_API_MINOR_VERSION 0
 
#undef RUBBERBAND_DLLEXPORT
#ifdef _MSC_VER
#ifndef RUBBERBAND_STATIC
#define RUBBERBAND_DLLEXPORT __declspec(dllexport)
#else
#define RUBBERBAND_DLLEXPORT
#endif
#else
#define RUBBERBAND_DLLEXPORT
#endif
 
#include <vector>
#include <map>
#include <string>
#include <memory>
#include <cstddef>
 
namespace RubberBand
{
 
class RUBBERBAND_DLLEXPORT
RubberBandStretcher
{
public:
    enum Option {
 
        OptionProcessOffline       = 0x00000000,
        OptionProcessRealTime      = 0x00000001,
 
        OptionStretchElastic       = 0x00000000, // obsolete
        OptionStretchPrecise       = 0x00000010, // obsolete
    
        OptionTransientsCrisp      = 0x00000000,
        OptionTransientsMixed      = 0x00000100,
        OptionTransientsSmooth     = 0x00000200,
 
        OptionDetectorCompound     = 0x00000000,
        OptionDetectorPercussive   = 0x00000400,
        OptionDetectorSoft         = 0x00000800,
 
        OptionPhaseLaminar         = 0x00000000,
        OptionPhaseIndependent     = 0x00002000,
    
        OptionThreadingAuto        = 0x00000000,
        OptionThreadingNever       = 0x00010000,
        OptionThreadingAlways      = 0x00020000,
 
        OptionWindowStandard       = 0x00000000,
        OptionWindowShort          = 0x00100000,
        OptionWindowLong           = 0x00200000,
 
        OptionSmoothingOff         = 0x00000000,
        OptionSmoothingOn          = 0x00800000,
 
        OptionFormantShifted       = 0x00000000,
        OptionFormantPreserved     = 0x01000000,
 
        OptionPitchHighSpeed       = 0x00000000,
        OptionPitchHighQuality     = 0x02000000,
        OptionPitchHighConsistency = 0x04000000,
 
        OptionChannelsApart        = 0x00000000,
        OptionChannelsTogether     = 0x10000000,
 
        OptionEngineFaster         = 0x00000000,
        OptionEngineFiner          = 0x20000000
 
        // n.b. Options is int, so we must stop before 0x80000000
    };
 
    typedef int Options;
 
    enum PresetOption {
        DefaultOptions             = 0x00000000,
        PercussiveOptions          = 0x00102000
    };
 
    struct Logger {
        virtual void log(const char *) = 0;
 
        virtual void log(const char *, double) = 0;
 
        virtual void log(const char *, double, double) = 0;
        
        virtual ~Logger() { }
    };
    
    RubberBandStretcher(size_t sampleRate,
                        size_t channels,
                        Options options = DefaultOptions,
                        double initialTimeRatio = 1.0,
                        double initialPitchScale = 1.0);
 
    RubberBandStretcher(size_t sampleRate,
                        size_t channels,
                        std::shared_ptr<Logger> logger,
                        Options options = DefaultOptions,
                        double initialTimeRatio = 1.0,
                        double initialPitchScale = 1.0);
    
    ~RubberBandStretcher();
 
    void reset();
 
    int getEngineVersion() const;
    
    void setTimeRatio(double ratio);
 
    void setPitchScale(double scale);
 
    void setFormantScale(double scale);
    
    double getTimeRatio() const;
 
    double getPitchScale() const;
 
    double getFormantScale() const;
 
    size_t getPreferredStartPad() const;
    
    size_t getStartDelay() const;
 
    size_t getLatency() const;
    
    size_t getChannelCount() const;
 
    void setTransientsOption(Options options);
 
    void setDetectorOption(Options options);
 
    void setPhaseOption(Options options);
 
    void setFormantOption(Options options);
 
    void setPitchOption(Options options);
 
    void setExpectedInputDuration(size_t samples);
 
    void setMaxProcessSize(size_t samples);
 
    size_t getProcessSizeLimit() const;
    
     size_t getSamplesRequired() const;
 
    void setKeyFrameMap(const std::map<size_t, size_t> &);
    
    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;
 
    void calculateStretch();
 
    void setDebugLevel(int level);
 
    static void setDefaultDebugLevel(int level);
 
protected:
    class Impl;
    Impl *m_d;
 
    RubberBandStretcher(const RubberBandStretcher &) =delete;
    RubberBandStretcher &operator=(const RubberBandStretcher &) =delete;
};
 
}
 
#endif