Updated SoundTouch library to 1.8.1 [r198]

Externals/soundtouch/RateTransposer.h

@@ -14,10 +14,10 @@
 ///
 ////////////////////////////////////////////////////////////////////////////////
 //
-// Last changed  : $Date: 2013-06-12 15:24:44 +0000 (Wed, 12 Jun 2013) $
+// Last changed  : $Date: 2014-04-07 01:57:21 +1000 (Mon, 07 Apr 2014) $
 // File revision : $Revision: 4 $
 //
-// $Id: RateTransposer.h 171 2013-06-12 15:24:44Z oparviai $
+// $Id: RateTransposer.h 195 2014-04-06 15:57:21Z oparviai $
 //
 ////////////////////////////////////////////////////////////////////////////////
 //
@@ -55,51 +55,71 @@
 namespace soundtouch
 {
 
+/// Abstract base class for transposer implementations (linear, advanced vs integer, float etc)
+class TransposerBase
+{
+public:
+        enum ALGORITHM {
+        LINEAR = 0,
+        CUBIC,
+        SHANNON
+    };
+
+protected:
+    virtual void resetRegisters() = 0;
+
+    virtual int transposeMono(SAMPLETYPE *dest, 
+                        const SAMPLETYPE *src, 
+                        int &srcSamples)  = 0;
+    virtual int transposeStereo(SAMPLETYPE *dest, 
+                        const SAMPLETYPE *src, 
+                        int &srcSamples) = 0;
+    virtual int transposeMulti(SAMPLETYPE *dest, 
+                        const SAMPLETYPE *src, 
+                        int &srcSamples) = 0;
+
+    static ALGORITHM algorithm;
+
+public:
+    float rate;
+    int numChannels;
+
+    TransposerBase();
+    virtual ~TransposerBase();
+
+    virtual int transpose(FIFOSampleBuffer &dest, FIFOSampleBuffer &src);
+    virtual void setRate(float newRate);
+    virtual void setChannels(int channels);
+
+    // static factory function
+    static TransposerBase *newInstance();
+
+    // static function to set interpolation algorithm
+    static void setAlgorithm(ALGORITHM a);
+};
+
+
 /// A common linear samplerate transposer class.
 ///
-/// Note: Use function "RateTransposer::newInstance()" to create a new class 
-/// instance instead of the "new" operator; that function automatically 
-/// chooses a correct implementation depending on if integer or floating 
-/// arithmetics are to be used.
 class RateTransposer : public FIFOProcessor
 {
 protected:
     /// Anti-alias filter object
     AAFilter *pAAFilter;
-
-    float fRate;
-
-    int numChannels;
+    TransposerBase *pTransposer;
 
     /// Buffer for collecting samples to feed the anti-alias filter between
     /// two batches
-    FIFOSampleBuffer storeBuffer;
+    FIFOSampleBuffer inputBuffer;
 
     /// Buffer for keeping samples between transposing & anti-alias filter
-    FIFOSampleBuffer tempBuffer;
+    FIFOSampleBuffer midBuffer;
 
     /// Output sample buffer
     FIFOSampleBuffer outputBuffer;
 
-    BOOL bUseAAFilter;
+    bool bUseAAFilter;
 
-    virtual void resetRegisters() = 0;
-
-    virtual int transposeStereo(SAMPLETYPE *dest, 
-                         const SAMPLETYPE *src, 
-                         uint numSamples) = 0;
-    virtual int transposeMono(SAMPLETYPE *dest, 
-                       const SAMPLETYPE *src, 
-                       uint numSamples) = 0;
-    virtual int transposeMulti(SAMPLETYPE *dest, const SAMPLETYPE *src, uint nSamples) = 0;
-    inline int transpose(SAMPLETYPE *dest, 
-                   const SAMPLETYPE *src, 
-                   uint numSamples);
-
-    void downsample(const SAMPLETYPE *src, 
-                    uint numSamples);
-    void upsample(const SAMPLETYPE *src, 
-                 uint numSamples);
 
     /// Transposes sample rate by applying anti-alias filter to prevent folding. 
     /// Returns amount of samples returned in the "dest" buffer.
@@ -108,34 +128,33 @@ protected:
     void processSamples(const SAMPLETYPE *src, 
                         uint numSamples);
 
-
 public:
     RateTransposer();
     virtual ~RateTransposer();
 
     /// Operator 'new' is overloaded so that it automatically creates a suitable instance 
     /// depending on if we're to use integer or floating point arithmetics.
-    static void *operator new(size_t s);
+//    static void *operator new(size_t s);
 
     /// Use this function instead of "new" operator to create a new instance of this class. 
     /// This function automatically chooses a correct implementation, depending on if 
     /// integer ot floating point arithmetics are to be used.
-    static RateTransposer *newInstance();
+//    static RateTransposer *newInstance();
 
     /// Returns the output buffer object
     FIFOSamplePipe *getOutput() { return &outputBuffer; };
 
     /// Returns the store buffer object
-    FIFOSamplePipe *getStore() { return &storeBuffer; };
+//    FIFOSamplePipe *getStore() { return &storeBuffer; };
 
     /// Return anti-alias filter object
     AAFilter *getAAFilter();
 
     /// Enables/disables the anti-alias filter. Zero to disable, nonzero to enable
-    void enableAAFilter(BOOL newMode);
+    void enableAAFilter(bool newMode);
 
     /// Returns nonzero if anti-alias filter is enabled.
-    BOOL isAAFilterEnabled() const;
+    bool isAAFilterEnabled() const;
 
     /// Sets new target rate. Normal rate = 1.0, smaller values represent slower 
     /// rate, larger faster rates.