From 63002027dec72c79317001da18c8cc7accf48102 Mon Sep 17 00:00:00 2001 From: Olli Date: Fri, 29 Mar 2024 19:32:39 +0200 Subject: [PATCH] dos2unix:ify line endings, source code formatter --- Makefile.am | 6 +- README.html | 3 + bootstrap | 2 +- include/BPMDetect.h | 410 ++-- include/FIFOSampleBuffer.h | 360 ++-- include/FIFOSamplePipe.h | 460 ++--- include/Makefile.am | 44 +- include/STTypes.h | 380 ++-- include/SoundTouch.h | 696 +++---- soundtouch.m4 | 8 +- source/Android-lib/jni/soundtouch-jni.cpp | 516 ++--- source/Makefile.am | 48 +- source/SoundStretch/Makefile.am | 100 +- source/SoundStretch/RunParameters.cpp | 584 +++--- source/SoundStretch/RunParameters.h | 140 +- source/SoundStretch/SS_CharTypes.h | 104 +- source/SoundStretch/WavFile.cpp | 1968 +++++++++---------- source/SoundStretch/WavFile.h | 562 +++--- source/SoundStretch/main.cpp | 622 +++--- source/SoundTouch/AAFilter.cpp | 444 ++--- source/SoundTouch/AAFilter.h | 186 +- source/SoundTouch/BPMDetect.cpp | 1142 +++++------ source/SoundTouch/FIFOSampleBuffer.cpp | 550 +++--- source/SoundTouch/FIRFilter.cpp | 630 +++--- source/SoundTouch/FIRFilter.h | 280 +-- source/SoundTouch/InterpolateCubic.cpp | 392 ++-- source/SoundTouch/InterpolateCubic.h | 138 +- source/SoundTouch/InterpolateLinear.cpp | 592 +++--- source/SoundTouch/InterpolateLinear.h | 196 +- source/SoundTouch/InterpolateShannon.cpp | 362 ++-- source/SoundTouch/InterpolateShannon.h | 148 +- source/SoundTouch/Makefile.am | 148 +- source/SoundTouch/PeakFinder.cpp | 554 +++--- source/SoundTouch/PeakFinder.h | 180 +- source/SoundTouch/RateTransposer.cpp | 626 +++--- source/SoundTouch/RateTransposer.h | 328 ++-- source/SoundTouch/SoundTouch.cpp | 1076 +++++----- source/SoundTouch/TDStretch.cpp | 2176 ++++++++++----------- source/SoundTouch/TDStretch.h | 558 +++--- source/SoundTouch/cpu_detect.h | 110 +- source/SoundTouch/cpu_detect_x86.cpp | 260 +-- source/SoundTouch/mmx_optimized.cpp | 792 ++++---- source/SoundTouch/sse_optimized.cpp | 730 +++---- source/SoundTouchDLL/DllTest/DllTest.cpp | 230 +-- source/SoundTouchDLL/Makefile.am | 94 +- source/SoundTouchDLL/SoundTouchDLL.cpp | 1164 +++++------ source/SoundTouchDLL/SoundTouchDLL.h | 480 ++--- source/SoundTouchDLL/SoundTouchDLL.rc | 6 +- source/SoundTouchDLL/resource.h | 30 +- 49 files changed, 10809 insertions(+), 10806 deletions(-) diff --git a/Makefile.am b/Makefile.am index 1394ce6..3cea8b6 100644 --- a/Makefile.am +++ b/Makefile.am @@ -1,16 +1,16 @@ ## Process this file with automake to create Makefile.in ## ## This file is part of SoundTouch, an audio processing library for pitch/time adjustments -## +## ## SoundTouch 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. -## +## ## SoundTouch is distributed in the hope that it will be useful, but WITHOUT ANY ## WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR ## A PARTICULAR PURPOSE. See the GNU General Public License for more details. -## +## ## You should have received a copy of the GNU General Public License along with ## this program; if not, write to the Free Software Foundation, Inc., 59 Temple ## Place - Suite 330, Boston, MA 02111-1307, USA diff --git a/README.html b/README.html index 132e658..33ca2b5 100644 --- a/README.html +++ b/README.html @@ -147,6 +147,9 @@ cmake . make -j make install +

To list available build options:

+ 
+    cmake -LH

To compile the additional portable Shared Library / DLL version with the native C-language API:

     cmake . -DSOUNDTOUCH_DLL=ON
diff --git a/bootstrap b/bootstrap
index 7534e44..b12b3e8 100755
--- a/bootstrap
+++ b/bootstrap
@@ -10,7 +10,7 @@ then
 	elif [ -a configure ]
 	then
 		configure && $0 --clean
-	else 
+	else
 		bootstrap && configure && $0 --clean
 	fi
 
diff --git a/include/BPMDetect.h b/include/BPMDetect.h
index 763266f..bf596a1 100644
--- a/include/BPMDetect.h
+++ b/include/BPMDetect.h
@@ -1,205 +1,205 @@
-////////////////////////////////////////////////////////////////////////////////
-///
-/// Beats-per-minute (BPM) detection routine.
-///
-/// The beat detection algorithm works as follows:
-/// - Use function 'inputSamples' to input a chunks of samples to the class for
-///   analysis. It's a good idea to enter a large sound file or stream in smallish
-///   chunks of around few kilosamples in order not to extinguish too much RAM memory.
-/// - Input sound data is decimated to approx 500 Hz to reduce calculation burden,
-///   which is basically ok as low (bass) frequencies mostly determine the beat rate.
-///   Simple averaging is used for anti-alias filtering because the resulting signal
-///   quality isn't of that high importance.
-/// - Decimated sound data is enveloped, i.e. the amplitude shape is detected by
-///   taking absolute value that's smoothed by sliding average. Signal levels that
-///   are below a couple of times the general RMS amplitude level are cut away to
-///   leave only notable peaks there.
-/// - Repeating sound patterns (e.g. beats) are detected by calculating short-term 
-///   autocorrelation function of the enveloped signal.
-/// - After whole sound data file has been analyzed as above, the bpm level is 
-///   detected by function 'getBpm' that finds the highest peak of the autocorrelation 
-///   function, calculates it's precise location and converts this reading to bpm's.
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef _BPMDetect_H_
-#define _BPMDetect_H_
-
-#include 
-#include "STTypes.h"
-#include "FIFOSampleBuffer.h"
-
-namespace soundtouch
-{
-
-    /// Minimum allowed BPM rate. Used to restrict accepted result above a reasonable limit.
-    #define MIN_BPM 45
-
-    /// Maximum allowed BPM rate range. Used for calculating algorithm parametrs
-    #define MAX_BPM_RANGE 200
-
-    /// Maximum allowed BPM rate range. Used to restrict accepted result below a reasonable limit.
-    #define MAX_BPM_VALID 190
-
-////////////////////////////////////////////////////////////////////////////////
-
-    typedef struct
-    {
-        float pos;
-        float strength;
-    } BEAT;
-
-
-    class IIR2_filter
-    {
-        double coeffs[5];
-        double prev[5];
-
-    public:
-        IIR2_filter(const double *lpf_coeffs);
-        float update(float x);
-    };
-
-
-    /// Class for calculating BPM rate for audio data.
-    class BPMDetect
-    {
-    protected:
-        /// Auto-correlation accumulator bins.
-        float *xcorr;
-
-        /// Sample average counter.
-        int decimateCount;
-
-        /// Sample average accumulator for FIFO-like decimation.
-        soundtouch::LONG_SAMPLETYPE decimateSum;
-
-        /// Decimate sound by this coefficient to reach approx. 500 Hz.
-        int decimateBy;
-
-        /// Auto-correlation window length
-        int windowLen;
-
-        /// Number of channels (1 = mono, 2 = stereo)
-        int channels;
-
-        /// sample rate
-        int sampleRate;
-
-        /// Beginning of auto-correlation window: Autocorrelation isn't being updated for
-        /// the first these many correlation bins.
-        int windowStart;
-
-        /// window functions for data preconditioning
-        float *hamw;
-        float *hamw2;
-
-        // beat detection variables
-        int pos;
-        int peakPos;
-        int beatcorr_ringbuffpos;
-        int init_scaler;
-        float peakVal;
-        float *beatcorr_ringbuff;
-
-        /// FIFO-buffer for decimated processing samples.
-        soundtouch::FIFOSampleBuffer *buffer;
-
-        /// Collection of detected beat positions
-        //BeatCollection beats;
-        std::vector beats;
-
-        // 2nd order low-pass-filter
-        IIR2_filter beat_lpf;
-
-        /// Updates auto-correlation function for given number of decimated samples that 
-        /// are read from the internal 'buffer' pipe (samples aren't removed from the pipe 
-        /// though).
-        void updateXCorr(int process_samples      /// How many samples are processed.
-        );
-
-        /// Decimates samples to approx. 500 Hz.
-        ///
-        /// \return Number of output samples.
-        int decimate(soundtouch::SAMPLETYPE *dest,      ///< Destination buffer
-            const soundtouch::SAMPLETYPE *src, ///< Source sample buffer
-            int numsamples                     ///< Number of source samples.
-        );
-
-        /// Calculates amplitude envelope for the buffer of samples.
-        /// Result is output to 'samples'.
-        void calcEnvelope(soundtouch::SAMPLETYPE *samples,  ///< Pointer to input/output data buffer
-            int numsamples                    ///< Number of samples in buffer
-        );
-
-        /// remove constant bias from xcorr data
-        void removeBias();
-
-        // Detect individual beat positions
-        void updateBeatPos(int process_samples);
-
-
-    public:
-        /// Constructor.
-        BPMDetect(int numChannels,  ///< Number of channels in sample data.
-            int sampleRate    ///< Sample rate in Hz.
-        );
-
-        /// Destructor.
-        virtual ~BPMDetect();
-
-        /// Inputs a block of samples for analyzing: Envelopes the samples and then
-        /// updates the autocorrelation estimation. When whole song data has been input
-        /// in smaller blocks using this function, read the resulting bpm with 'getBpm' 
-        /// function. 
-        /// 
-        /// Notice that data in 'samples' array can be disrupted in processing.
-        void inputSamples(const soundtouch::SAMPLETYPE *samples,    ///< Pointer to input/working data buffer
-            int numSamples                            ///< Number of samples in buffer
-        );
-
-        /// Analyzes the results and returns the BPM rate. Use this function to read result
-        /// after whole song data has been input to the class by consecutive calls of
-        /// 'inputSamples' function.
-        ///
-        /// \return Beats-per-minute rate, or zero if detection failed.
-        float getBpm();
-
-        /// Get beat position arrays. Note: The array includes also really low beat detection values 
-        /// in absence of clear strong beats. Consumer may wish to filter low values away.
-        /// - "pos" receive array of beat positions
-        /// - "values" receive array of beat detection strengths
-        /// - max_num indicates max.size of "pos" and "values" array.  
-        ///
-        /// You can query a suitable array sized by calling this with nullptr in "pos" & "values".
-        ///
-        /// \return number of beats in the arrays.
-        int getBeats(float *pos, float *strength, int max_num);
-    };
-}
-#endif // _BPMDetect_H_
+////////////////////////////////////////////////////////////////////////////////
+///
+/// Beats-per-minute (BPM) detection routine.
+///
+/// The beat detection algorithm works as follows:
+/// - Use function 'inputSamples' to input a chunks of samples to the class for
+///   analysis. It's a good idea to enter a large sound file or stream in smallish
+///   chunks of around few kilosamples in order not to extinguish too much RAM memory.
+/// - Input sound data is decimated to approx 500 Hz to reduce calculation burden,
+///   which is basically ok as low (bass) frequencies mostly determine the beat rate.
+///   Simple averaging is used for anti-alias filtering because the resulting signal
+///   quality isn't of that high importance.
+/// - Decimated sound data is enveloped, i.e. the amplitude shape is detected by
+///   taking absolute value that's smoothed by sliding average. Signal levels that
+///   are below a couple of times the general RMS amplitude level are cut away to
+///   leave only notable peaks there.
+/// - Repeating sound patterns (e.g. beats) are detected by calculating short-term
+///   autocorrelation function of the enveloped signal.
+/// - After whole sound data file has been analyzed as above, the bpm level is
+///   detected by function 'getBpm' that finds the highest peak of the autocorrelation
+///   function, calculates it's precise location and converts this reading to bpm's.
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef _BPMDetect_H_
+#define _BPMDetect_H_
+
+#include 
+#include "STTypes.h"
+#include "FIFOSampleBuffer.h"
+
+namespace soundtouch
+{
+
+    /// Minimum allowed BPM rate. Used to restrict accepted result above a reasonable limit.
+    #define MIN_BPM 45
+
+    /// Maximum allowed BPM rate range. Used for calculating algorithm parametrs
+    #define MAX_BPM_RANGE 200
+
+    /// Maximum allowed BPM rate range. Used to restrict accepted result below a reasonable limit.
+    #define MAX_BPM_VALID 190
+
+////////////////////////////////////////////////////////////////////////////////
+
+    typedef struct
+    {
+        float pos;
+        float strength;
+    } BEAT;
+
+
+    class IIR2_filter
+    {
+        double coeffs[5];
+        double prev[5];
+
+    public:
+        IIR2_filter(const double *lpf_coeffs);
+        float update(float x);
+    };
+
+
+    /// Class for calculating BPM rate for audio data.
+    class BPMDetect
+    {
+    protected:
+        /// Auto-correlation accumulator bins.
+        float *xcorr;
+
+        /// Sample average counter.
+        int decimateCount;
+
+        /// Sample average accumulator for FIFO-like decimation.
+        soundtouch::LONG_SAMPLETYPE decimateSum;
+
+        /// Decimate sound by this coefficient to reach approx. 500 Hz.
+        int decimateBy;
+
+        /// Auto-correlation window length
+        int windowLen;
+
+        /// Number of channels (1 = mono, 2 = stereo)
+        int channels;
+
+        /// sample rate
+        int sampleRate;
+
+        /// Beginning of auto-correlation window: Autocorrelation isn't being updated for
+        /// the first these many correlation bins.
+        int windowStart;
+
+        /// window functions for data preconditioning
+        float *hamw;
+        float *hamw2;
+
+        // beat detection variables
+        int pos;
+        int peakPos;
+        int beatcorr_ringbuffpos;
+        int init_scaler;
+        float peakVal;
+        float *beatcorr_ringbuff;
+
+        /// FIFO-buffer for decimated processing samples.
+        soundtouch::FIFOSampleBuffer *buffer;
+
+        /// Collection of detected beat positions
+        //BeatCollection beats;
+        std::vector beats;
+
+        // 2nd order low-pass-filter
+        IIR2_filter beat_lpf;
+
+        /// Updates auto-correlation function for given number of decimated samples that
+        /// are read from the internal 'buffer' pipe (samples aren't removed from the pipe
+        /// though).
+        void updateXCorr(int process_samples      /// How many samples are processed.
+        );
+
+        /// Decimates samples to approx. 500 Hz.
+        ///
+        /// \return Number of output samples.
+        int decimate(soundtouch::SAMPLETYPE *dest,      ///< Destination buffer
+            const soundtouch::SAMPLETYPE *src, ///< Source sample buffer
+            int numsamples                     ///< Number of source samples.
+        );
+
+        /// Calculates amplitude envelope for the buffer of samples.
+        /// Result is output to 'samples'.
+        void calcEnvelope(soundtouch::SAMPLETYPE *samples,  ///< Pointer to input/output data buffer
+            int numsamples                    ///< Number of samples in buffer
+        );
+
+        /// remove constant bias from xcorr data
+        void removeBias();
+
+        // Detect individual beat positions
+        void updateBeatPos(int process_samples);
+
+
+    public:
+        /// Constructor.
+        BPMDetect(int numChannels,  ///< Number of channels in sample data.
+            int sampleRate    ///< Sample rate in Hz.
+        );
+
+        /// Destructor.
+        virtual ~BPMDetect();
+
+        /// Inputs a block of samples for analyzing: Envelopes the samples and then
+        /// updates the autocorrelation estimation. When whole song data has been input
+        /// in smaller blocks using this function, read the resulting bpm with 'getBpm'
+        /// function.
+        ///
+        /// Notice that data in 'samples' array can be disrupted in processing.
+        void inputSamples(const soundtouch::SAMPLETYPE *samples,    ///< Pointer to input/working data buffer
+            int numSamples                            ///< Number of samples in buffer
+        );
+
+        /// Analyzes the results and returns the BPM rate. Use this function to read result
+        /// after whole song data has been input to the class by consecutive calls of
+        /// 'inputSamples' function.
+        ///
+        /// \return Beats-per-minute rate, or zero if detection failed.
+        float getBpm();
+
+        /// Get beat position arrays. Note: The array includes also really low beat detection values
+        /// in absence of clear strong beats. Consumer may wish to filter low values away.
+        /// - "pos" receive array of beat positions
+        /// - "values" receive array of beat detection strengths
+        /// - max_num indicates max.size of "pos" and "values" array.
+        ///
+        /// You can query a suitable array sized by calling this with nullptr in "pos" & "values".
+        ///
+        /// \return number of beats in the arrays.
+        int getBeats(float *pos, float *strength, int max_num);
+    };
+}
+#endif // _BPMDetect_H_
diff --git a/include/FIFOSampleBuffer.h b/include/FIFOSampleBuffer.h
index 6c5785a..e7cdbed 100644
--- a/include/FIFOSampleBuffer.h
+++ b/include/FIFOSampleBuffer.h
@@ -1,180 +1,180 @@
-////////////////////////////////////////////////////////////////////////////////
-///
-/// A buffer class for temporarily storaging sound samples, operates as a 
-/// first-in-first-out pipe.
-///
-/// Samples are added to the end of the sample buffer with the 'putSamples' 
-/// function, and are received from the beginning of the buffer by calling
-/// the 'receiveSamples' function. The class automatically removes the 
-/// output samples from the buffer as well as grows the storage size 
-/// whenever necessary.
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef FIFOSampleBuffer_H
-#define FIFOSampleBuffer_H
-
-#include "FIFOSamplePipe.h"
-
-namespace soundtouch
-{
-
-/// Sample buffer working in FIFO (first-in-first-out) principle. The class takes
-/// care of storage size adjustment and data moving during input/output operations.
-///
-/// Notice that in case of stereo audio, one sample is considered to consist of 
-/// both channel data.
-class FIFOSampleBuffer : public FIFOSamplePipe
-{
-private:
-    /// Sample buffer.
-    SAMPLETYPE *buffer;
-
-    // Raw unaligned buffer memory. 'buffer' is made aligned by pointing it to first
-    // 16-byte aligned location of this buffer
-    SAMPLETYPE *bufferUnaligned;
-
-    /// Sample buffer size in bytes
-    uint sizeInBytes;
-
-    /// How many samples are currently in buffer.
-    uint samplesInBuffer;
-
-    /// Channels, 1=mono, 2=stereo.
-    uint channels;
-
-    /// Current position pointer to the buffer. This pointer is increased when samples are 
-    /// removed from the pipe so that it's necessary to actually rewind buffer (move data)
-    /// only new data when is put to the pipe.
-    uint bufferPos;
-
-    /// Rewind the buffer by moving data from position pointed by 'bufferPos' to real 
-    /// beginning of the buffer.
-    void rewind();
-
-    /// Ensures that the buffer has capacity for at least this many samples.
-    void ensureCapacity(uint capacityRequirement);
-
-    /// Returns current capacity.
-    uint getCapacity() const;
-
-public:
-
-    /// Constructor
-    FIFOSampleBuffer(int numChannels = 2     ///< Number of channels, 1=mono, 2=stereo.
-                                              ///< Default is stereo.
-                     );
-
-    /// destructor
-    ~FIFOSampleBuffer() override;
-
-    /// Returns a pointer to the beginning of the output samples. 
-    /// This function is provided for accessing the output samples directly. 
-    /// Please be careful for not to corrupt the book-keeping!
-    ///
-    /// When using this function to output samples, also remember to 'remove' the
-    /// output samples from the buffer by calling the 
-    /// 'receiveSamples(numSamples)' function
-    virtual SAMPLETYPE *ptrBegin() override;
-
-    /// Returns a pointer to the end of the used part of the sample buffer (i.e. 
-    /// where the new samples are to be inserted). This function may be used for 
-    /// inserting new samples into the sample buffer directly. Please be careful
-    /// not corrupt the book-keeping!
-    ///
-    /// When using this function as means for inserting new samples, also remember 
-    /// to increase the sample count afterwards, by calling  the 
-    /// 'putSamples(numSamples)' function.
-    SAMPLETYPE *ptrEnd(
-                uint slackCapacity   ///< How much free capacity (in samples) there _at least_ 
-                                     ///< should be so that the caller can successfully insert the 
-                                     ///< desired samples to the buffer. If necessary, the function 
-                                     ///< grows the buffer size to comply with this requirement.
-                );
-
-    /// Adds 'numSamples' pcs of samples from the 'samples' memory position to
-    /// the sample buffer.
-    virtual void putSamples(const SAMPLETYPE *samples,  ///< Pointer to samples.
-                            uint numSamples                         ///< Number of samples to insert.
-                            ) override;
-
-    /// Adjusts the book-keeping to increase number of samples in the buffer without 
-    /// copying any actual samples.
-    ///
-    /// This function is used to update the number of samples in the sample buffer
-    /// when accessing the buffer directly with 'ptrEnd' function. Please be 
-    /// careful though!
-    virtual void putSamples(uint numSamples   ///< Number of samples been inserted.
-                            );
-
-    /// Output samples from beginning of the sample buffer. Copies requested samples to 
-    /// output buffer and removes them from the sample buffer. If there are less than 
-    /// 'numsample' samples in the buffer, returns all that available.
-    ///
-    /// \return Number of samples returned.
-    virtual uint receiveSamples(SAMPLETYPE *output, ///< Buffer where to copy output samples.
-                                uint maxSamples                 ///< How many samples to receive at max.
-                                ) override;
-
-    /// Adjusts book-keeping so that given number of samples are removed from beginning of the 
-    /// sample buffer without copying them anywhere. 
-    ///
-    /// Used to reduce the number of samples in the buffer when accessing the sample buffer directly
-    /// with 'ptrBegin' function.
-    virtual uint receiveSamples(uint maxSamples   ///< Remove this many samples from the beginning of pipe.
-                                ) override;
-
-    /// Returns number of samples currently available.
-    virtual uint numSamples() const override;
-
-    /// Sets number of channels, 1 = mono, 2 = stereo.
-    void setChannels(int numChannels);
-
-    /// Get number of channels
-    int getChannels() 
-    {
-        return channels;
-    }
-
-    /// Returns nonzero if there aren't any samples available for outputting.
-    virtual int isEmpty() const override;
-
-    /// Clears all the samples.
-    virtual void clear() override;
-
-    /// allow trimming (downwards) amount of samples in pipeline.
-    /// Returns adjusted amount of samples
-    uint adjustAmountOfSamples(uint numSamples) override;
-
-    /// Add silence to end of buffer
-    void addSilent(uint nSamples);
-};
-
-}
-
-#endif
+////////////////////////////////////////////////////////////////////////////////
+///
+/// A buffer class for temporarily storaging sound samples, operates as a
+/// first-in-first-out pipe.
+///
+/// Samples are added to the end of the sample buffer with the 'putSamples'
+/// function, and are received from the beginning of the buffer by calling
+/// the 'receiveSamples' function. The class automatically removes the
+/// output samples from the buffer as well as grows the storage size
+/// whenever necessary.
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef FIFOSampleBuffer_H
+#define FIFOSampleBuffer_H
+
+#include "FIFOSamplePipe.h"
+
+namespace soundtouch
+{
+
+/// Sample buffer working in FIFO (first-in-first-out) principle. The class takes
+/// care of storage size adjustment and data moving during input/output operations.
+///
+/// Notice that in case of stereo audio, one sample is considered to consist of
+/// both channel data.
+class FIFOSampleBuffer : public FIFOSamplePipe
+{
+private:
+    /// Sample buffer.
+    SAMPLETYPE *buffer;
+
+    // Raw unaligned buffer memory. 'buffer' is made aligned by pointing it to first
+    // 16-byte aligned location of this buffer
+    SAMPLETYPE *bufferUnaligned;
+
+    /// Sample buffer size in bytes
+    uint sizeInBytes;
+
+    /// How many samples are currently in buffer.
+    uint samplesInBuffer;
+
+    /// Channels, 1=mono, 2=stereo.
+    uint channels;
+
+    /// Current position pointer to the buffer. This pointer is increased when samples are
+    /// removed from the pipe so that it's necessary to actually rewind buffer (move data)
+    /// only new data when is put to the pipe.
+    uint bufferPos;
+
+    /// Rewind the buffer by moving data from position pointed by 'bufferPos' to real
+    /// beginning of the buffer.
+    void rewind();
+
+    /// Ensures that the buffer has capacity for at least this many samples.
+    void ensureCapacity(uint capacityRequirement);
+
+    /// Returns current capacity.
+    uint getCapacity() const;
+
+public:
+
+    /// Constructor
+    FIFOSampleBuffer(int numChannels = 2     ///< Number of channels, 1=mono, 2=stereo.
+                                              ///< Default is stereo.
+                     );
+
+    /// destructor
+    ~FIFOSampleBuffer() override;
+
+    /// Returns a pointer to the beginning of the output samples.
+    /// This function is provided for accessing the output samples directly.
+    /// Please be careful for not to corrupt the book-keeping!
+    ///
+    /// When using this function to output samples, also remember to 'remove' the
+    /// output samples from the buffer by calling the
+    /// 'receiveSamples(numSamples)' function
+    virtual SAMPLETYPE *ptrBegin() override;
+
+    /// Returns a pointer to the end of the used part of the sample buffer (i.e.
+    /// where the new samples are to be inserted). This function may be used for
+    /// inserting new samples into the sample buffer directly. Please be careful
+    /// not corrupt the book-keeping!
+    ///
+    /// When using this function as means for inserting new samples, also remember
+    /// to increase the sample count afterwards, by calling  the
+    /// 'putSamples(numSamples)' function.
+    SAMPLETYPE *ptrEnd(
+                uint slackCapacity   ///< How much free capacity (in samples) there _at least_
+                                     ///< should be so that the caller can successfully insert the
+                                     ///< desired samples to the buffer. If necessary, the function
+                                     ///< grows the buffer size to comply with this requirement.
+                );
+
+    /// Adds 'numSamples' pcs of samples from the 'samples' memory position to
+    /// the sample buffer.
+    virtual void putSamples(const SAMPLETYPE *samples,  ///< Pointer to samples.
+                            uint numSamples                         ///< Number of samples to insert.
+                            ) override;
+
+    /// Adjusts the book-keeping to increase number of samples in the buffer without
+    /// copying any actual samples.
+    ///
+    /// This function is used to update the number of samples in the sample buffer
+    /// when accessing the buffer directly with 'ptrEnd' function. Please be
+    /// careful though!
+    virtual void putSamples(uint numSamples   ///< Number of samples been inserted.
+                            );
+
+    /// Output samples from beginning of the sample buffer. Copies requested samples to
+    /// output buffer and removes them from the sample buffer. If there are less than
+    /// 'numsample' samples in the buffer, returns all that available.
+    ///
+    /// \return Number of samples returned.
+    virtual uint receiveSamples(SAMPLETYPE *output, ///< Buffer where to copy output samples.
+                                uint maxSamples                 ///< How many samples to receive at max.
+                                ) override;
+
+    /// Adjusts book-keeping so that given number of samples are removed from beginning of the
+    /// sample buffer without copying them anywhere.
+    ///
+    /// Used to reduce the number of samples in the buffer when accessing the sample buffer directly
+    /// with 'ptrBegin' function.
+    virtual uint receiveSamples(uint maxSamples   ///< Remove this many samples from the beginning of pipe.
+                                ) override;
+
+    /// Returns number of samples currently available.
+    virtual uint numSamples() const override;
+
+    /// Sets number of channels, 1 = mono, 2 = stereo.
+    void setChannels(int numChannels);
+
+    /// Get number of channels
+    int getChannels()
+    {
+        return channels;
+    }
+
+    /// Returns nonzero if there aren't any samples available for outputting.
+    virtual int isEmpty() const override;
+
+    /// Clears all the samples.
+    virtual void clear() override;
+
+    /// allow trimming (downwards) amount of samples in pipeline.
+    /// Returns adjusted amount of samples
+    uint adjustAmountOfSamples(uint numSamples) override;
+
+    /// Add silence to end of buffer
+    void addSilent(uint nSamples);
+};
+
+}
+
+#endif
diff --git a/include/FIFOSamplePipe.h b/include/FIFOSamplePipe.h
index 0664951..93b6bf4 100644
--- a/include/FIFOSamplePipe.h
+++ b/include/FIFOSamplePipe.h
@@ -1,230 +1,230 @@
-////////////////////////////////////////////////////////////////////////////////
-///
-/// 'FIFOSamplePipe' : An abstract base class for classes that manipulate sound
-/// samples by operating like a first-in-first-out pipe: New samples are fed
-/// into one end of the pipe with the 'putSamples' function, and the processed
-/// samples are received from the other end with the 'receiveSamples' function.
-///
-/// 'FIFOProcessor' : A base class for classes the do signal processing with 
-/// the samples while operating like a first-in-first-out pipe. When samples
-/// are input with the 'putSamples' function, the class processes them
-/// and moves the processed samples to the given 'output' pipe object, which
-/// may be either another processing stage, or a fifo sample buffer object.
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef FIFOSamplePipe_H
-#define FIFOSamplePipe_H
-
-#include 
-#include 
-#include "STTypes.h"
-
-namespace soundtouch
-{
-
-/// Abstract base class for FIFO (first-in-first-out) sample processing classes.
-class FIFOSamplePipe
-{
-protected:
-
-    bool verifyNumberOfChannels(int nChannels) const
-    {
-        if ((nChannels > 0) && (nChannels <= SOUNDTOUCH_MAX_CHANNELS))
-        {
-            return true;
-        }
-        ST_THROW_RT_ERROR("Error: Illegal number of channels");
-        return false;
-    }
-
-public:
-    // virtual default destructor
-    virtual ~FIFOSamplePipe() {}
-
-
-    /// Returns a pointer to the beginning of the output samples. 
-    /// This function is provided for accessing the output samples directly. 
-    /// Please be careful for not to corrupt the book-keeping!
-    ///
-    /// When using this function to output samples, also remember to 'remove' the
-    /// output samples from the buffer by calling the 
-    /// 'receiveSamples(numSamples)' function
-    virtual SAMPLETYPE *ptrBegin() = 0;
-
-    /// Adds 'numSamples' pcs of samples from the 'samples' memory position to
-    /// the sample buffer.
-    virtual void putSamples(const SAMPLETYPE *samples,  ///< Pointer to samples.
-                            uint numSamples             ///< Number of samples to insert.
-                            ) = 0;
-
-
-    // Moves samples from the 'other' pipe instance to this instance.
-    void moveSamples(FIFOSamplePipe &other  ///< Other pipe instance where from the receive the data.
-         )
-    {
-        const uint oNumSamples = other.numSamples();
-
-        putSamples(other.ptrBegin(), oNumSamples);
-        other.receiveSamples(oNumSamples);
-    }
-
-    /// Output samples from beginning of the sample buffer. Copies requested samples to 
-    /// output buffer and removes them from the sample buffer. If there are less than 
-    /// 'numsample' samples in the buffer, returns all that available.
-    ///
-    /// \return Number of samples returned.
-    virtual uint receiveSamples(SAMPLETYPE *output, ///< Buffer where to copy output samples.
-                                uint maxSamples                 ///< How many samples to receive at max.
-                                ) = 0;
-
-    /// Adjusts book-keeping so that given number of samples are removed from beginning of the 
-    /// sample buffer without copying them anywhere. 
-    ///
-    /// Used to reduce the number of samples in the buffer when accessing the sample buffer directly
-    /// with 'ptrBegin' function.
-    virtual uint receiveSamples(uint maxSamples   ///< Remove this many samples from the beginning of pipe.
-                                ) = 0;
-
-    /// Returns number of samples currently available.
-    virtual uint numSamples() const = 0;
-
-    // Returns nonzero if there aren't any samples available for outputting.
-    virtual int isEmpty() const = 0;
-
-    /// Clears all the samples.
-    virtual void clear() = 0;
-
-    /// allow trimming (downwards) amount of samples in pipeline.
-    /// Returns adjusted amount of samples
-    virtual uint adjustAmountOfSamples(uint numSamples) = 0;
-
-};
-
-
-/// Base-class for sound processing routines working in FIFO principle. With this base 
-/// class it's easy to implement sound processing stages that can be chained together,
-/// so that samples that are fed into beginning of the pipe automatically go through 
-/// all the processing stages.
-///
-/// When samples are input to this class, they're first processed and then put to 
-/// the FIFO pipe that's defined as output of this class. This output pipe can be
-/// either other processing stage or a FIFO sample buffer.
-class FIFOProcessor :public FIFOSamplePipe
-{
-protected:
-    /// Internal pipe where processed samples are put.
-    FIFOSamplePipe *output;
-
-    /// Sets output pipe.
-    void setOutPipe(FIFOSamplePipe *pOutput)
-    {
-        assert(output == nullptr);
-        assert(pOutput != nullptr);
-        output = pOutput;
-    }
-
-    /// Constructor. Doesn't define output pipe; it has to be set be 
-    /// 'setOutPipe' function.
-    FIFOProcessor()
-    {
-        output = nullptr;
-    }
-
-    /// Constructor. Configures output pipe.
-    FIFOProcessor(FIFOSamplePipe *pOutput   ///< Output pipe.
-                 )
-    {
-        output = pOutput;
-    }
-
-    /// Destructor.
-    virtual ~FIFOProcessor() override
-    {
-    }
-
-    /// Returns a pointer to the beginning of the output samples. 
-    /// This function is provided for accessing the output samples directly. 
-    /// Please be careful for not to corrupt the book-keeping!
-    ///
-    /// When using this function to output samples, also remember to 'remove' the
-    /// output samples from the buffer by calling the 
-    /// 'receiveSamples(numSamples)' function
-    virtual SAMPLETYPE *ptrBegin() override
-    {
-        return output->ptrBegin();
-    }
-
-public:
-
-    /// Output samples from beginning of the sample buffer. Copies requested samples to 
-    /// output buffer and removes them from the sample buffer. If there are less than 
-    /// 'numsample' samples in the buffer, returns all that available.
-    ///
-    /// \return Number of samples returned.
-    virtual uint receiveSamples(SAMPLETYPE *outBuffer, ///< Buffer where to copy output samples.
-                                uint maxSamples                    ///< How many samples to receive at max.
-                                ) override
-    {
-        return output->receiveSamples(outBuffer, maxSamples);
-    }
-
-    /// Adjusts book-keeping so that given number of samples are removed from beginning of the 
-    /// sample buffer without copying them anywhere. 
-    ///
-    /// Used to reduce the number of samples in the buffer when accessing the sample buffer directly
-    /// with 'ptrBegin' function.
-    virtual uint receiveSamples(uint maxSamples   ///< Remove this many samples from the beginning of pipe.
-                                ) override
-    {
-        return output->receiveSamples(maxSamples);
-    }
-
-    /// Returns number of samples currently available.
-    virtual uint numSamples() const override
-    {
-        return output->numSamples();
-    }
-
-    /// Returns nonzero if there aren't any samples available for outputting.
-    virtual int isEmpty() const override
-    {
-        return output->isEmpty();
-    }
-
-    /// allow trimming (downwards) amount of samples in pipeline.
-    /// Returns adjusted amount of samples
-    virtual uint adjustAmountOfSamples(uint numSamples) override
-    {
-        return output->adjustAmountOfSamples(numSamples);
-    }
-};
-
-}
-
-#endif
+////////////////////////////////////////////////////////////////////////////////
+///
+/// 'FIFOSamplePipe' : An abstract base class for classes that manipulate sound
+/// samples by operating like a first-in-first-out pipe: New samples are fed
+/// into one end of the pipe with the 'putSamples' function, and the processed
+/// samples are received from the other end with the 'receiveSamples' function.
+///
+/// 'FIFOProcessor' : A base class for classes the do signal processing with
+/// the samples while operating like a first-in-first-out pipe. When samples
+/// are input with the 'putSamples' function, the class processes them
+/// and moves the processed samples to the given 'output' pipe object, which
+/// may be either another processing stage, or a fifo sample buffer object.
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef FIFOSamplePipe_H
+#define FIFOSamplePipe_H
+
+#include 
+#include 
+#include "STTypes.h"
+
+namespace soundtouch
+{
+
+/// Abstract base class for FIFO (first-in-first-out) sample processing classes.
+class FIFOSamplePipe
+{
+protected:
+
+    bool verifyNumberOfChannels(int nChannels) const
+    {
+        if ((nChannels > 0) && (nChannels <= SOUNDTOUCH_MAX_CHANNELS))
+        {
+            return true;
+        }
+        ST_THROW_RT_ERROR("Error: Illegal number of channels");
+        return false;
+    }
+
+public:
+    // virtual default destructor
+    virtual ~FIFOSamplePipe() {}
+
+
+    /// Returns a pointer to the beginning of the output samples.
+    /// This function is provided for accessing the output samples directly.
+    /// Please be careful for not to corrupt the book-keeping!
+    ///
+    /// When using this function to output samples, also remember to 'remove' the
+    /// output samples from the buffer by calling the
+    /// 'receiveSamples(numSamples)' function
+    virtual SAMPLETYPE *ptrBegin() = 0;
+
+    /// Adds 'numSamples' pcs of samples from the 'samples' memory position to
+    /// the sample buffer.
+    virtual void putSamples(const SAMPLETYPE *samples,  ///< Pointer to samples.
+                            uint numSamples             ///< Number of samples to insert.
+                            ) = 0;
+
+
+    // Moves samples from the 'other' pipe instance to this instance.
+    void moveSamples(FIFOSamplePipe &other  ///< Other pipe instance where from the receive the data.
+         )
+    {
+        const uint oNumSamples = other.numSamples();
+
+        putSamples(other.ptrBegin(), oNumSamples);
+        other.receiveSamples(oNumSamples);
+    }
+
+    /// Output samples from beginning of the sample buffer. Copies requested samples to
+    /// output buffer and removes them from the sample buffer. If there are less than
+    /// 'numsample' samples in the buffer, returns all that available.
+    ///
+    /// \return Number of samples returned.
+    virtual uint receiveSamples(SAMPLETYPE *output, ///< Buffer where to copy output samples.
+                                uint maxSamples                 ///< How many samples to receive at max.
+                                ) = 0;
+
+    /// Adjusts book-keeping so that given number of samples are removed from beginning of the
+    /// sample buffer without copying them anywhere.
+    ///
+    /// Used to reduce the number of samples in the buffer when accessing the sample buffer directly
+    /// with 'ptrBegin' function.
+    virtual uint receiveSamples(uint maxSamples   ///< Remove this many samples from the beginning of pipe.
+                                ) = 0;
+
+    /// Returns number of samples currently available.
+    virtual uint numSamples() const = 0;
+
+    // Returns nonzero if there aren't any samples available for outputting.
+    virtual int isEmpty() const = 0;
+
+    /// Clears all the samples.
+    virtual void clear() = 0;
+
+    /// allow trimming (downwards) amount of samples in pipeline.
+    /// Returns adjusted amount of samples
+    virtual uint adjustAmountOfSamples(uint numSamples) = 0;
+
+};
+
+
+/// Base-class for sound processing routines working in FIFO principle. With this base
+/// class it's easy to implement sound processing stages that can be chained together,
+/// so that samples that are fed into beginning of the pipe automatically go through
+/// all the processing stages.
+///
+/// When samples are input to this class, they're first processed and then put to
+/// the FIFO pipe that's defined as output of this class. This output pipe can be
+/// either other processing stage or a FIFO sample buffer.
+class FIFOProcessor :public FIFOSamplePipe
+{
+protected:
+    /// Internal pipe where processed samples are put.
+    FIFOSamplePipe *output;
+
+    /// Sets output pipe.
+    void setOutPipe(FIFOSamplePipe *pOutput)
+    {
+        assert(output == nullptr);
+        assert(pOutput != nullptr);
+        output = pOutput;
+    }
+
+    /// Constructor. Doesn't define output pipe; it has to be set be
+    /// 'setOutPipe' function.
+    FIFOProcessor()
+    {
+        output = nullptr;
+    }
+
+    /// Constructor. Configures output pipe.
+    FIFOProcessor(FIFOSamplePipe *pOutput   ///< Output pipe.
+                 )
+    {
+        output = pOutput;
+    }
+
+    /// Destructor.
+    virtual ~FIFOProcessor() override
+    {
+    }
+
+    /// Returns a pointer to the beginning of the output samples.
+    /// This function is provided for accessing the output samples directly.
+    /// Please be careful for not to corrupt the book-keeping!
+    ///
+    /// When using this function to output samples, also remember to 'remove' the
+    /// output samples from the buffer by calling the
+    /// 'receiveSamples(numSamples)' function
+    virtual SAMPLETYPE *ptrBegin() override
+    {
+        return output->ptrBegin();
+    }
+
+public:
+
+    /// Output samples from beginning of the sample buffer. Copies requested samples to
+    /// output buffer and removes them from the sample buffer. If there are less than
+    /// 'numsample' samples in the buffer, returns all that available.
+    ///
+    /// \return Number of samples returned.
+    virtual uint receiveSamples(SAMPLETYPE *outBuffer, ///< Buffer where to copy output samples.
+                                uint maxSamples                    ///< How many samples to receive at max.
+                                ) override
+    {
+        return output->receiveSamples(outBuffer, maxSamples);
+    }
+
+    /// Adjusts book-keeping so that given number of samples are removed from beginning of the
+    /// sample buffer without copying them anywhere.
+    ///
+    /// Used to reduce the number of samples in the buffer when accessing the sample buffer directly
+    /// with 'ptrBegin' function.
+    virtual uint receiveSamples(uint maxSamples   ///< Remove this many samples from the beginning of pipe.
+                                ) override
+    {
+        return output->receiveSamples(maxSamples);
+    }
+
+    /// Returns number of samples currently available.
+    virtual uint numSamples() const override
+    {
+        return output->numSamples();
+    }
+
+    /// Returns nonzero if there aren't any samples available for outputting.
+    virtual int isEmpty() const override
+    {
+        return output->isEmpty();
+    }
+
+    /// allow trimming (downwards) amount of samples in pipeline.
+    /// Returns adjusted amount of samples
+    virtual uint adjustAmountOfSamples(uint numSamples) override
+    {
+        return output->adjustAmountOfSamples(numSamples);
+    }
+};
+
+}
+
+#endif
diff --git a/include/Makefile.am b/include/Makefile.am
index d1b8238..79adaeb 100644
--- a/include/Makefile.am
+++ b/include/Makefile.am
@@ -1,22 +1,22 @@
-## Process this file with automake to create Makefile.in
-##
-## This file is part of SoundTouch, an audio processing library for pitch/time adjustments
-## 
-## SoundTouch 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.
-## 
-## SoundTouch is distributed in the hope that it will be useful, but WITHOUT ANY
-## WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-## A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-## 
-## You should have received a copy of the GNU General Public License along with
-## this program; if not, write to the Free Software Foundation, Inc., 59 Temple
-## Place - Suite 330, Boston, MA  02111-1307, USA
-
-## I used config/am_include.mk for common definitions
-include $(top_srcdir)/config/am_include.mk
-
-pkginclude_HEADERS=FIFOSampleBuffer.h FIFOSamplePipe.h SoundTouch.h STTypes.h BPMDetect.h soundtouch_config.h
-
+## Process this file with automake to create Makefile.in
+##
+## This file is part of SoundTouch, an audio processing library for pitch/time adjustments
+##
+## SoundTouch 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.
+##
+## SoundTouch is distributed in the hope that it will be useful, but WITHOUT ANY
+## WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+## A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+##
+## You should have received a copy of the GNU General Public License along with
+## this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+## Place - Suite 330, Boston, MA  02111-1307, USA
+
+## I used config/am_include.mk for common definitions
+include $(top_srcdir)/config/am_include.mk
+
+pkginclude_HEADERS=FIFOSampleBuffer.h FIFOSamplePipe.h SoundTouch.h STTypes.h BPMDetect.h soundtouch_config.h
+
diff --git a/include/STTypes.h b/include/STTypes.h
index 71dd0eb..03dea9e 100644
--- a/include/STTypes.h
+++ b/include/STTypes.h
@@ -1,190 +1,190 @@
-////////////////////////////////////////////////////////////////////////////////
-///
-/// Common type definitions for SoundTouch audio processing library.
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef STTypes_H
-#define STTypes_H
-
-typedef unsigned int    uint;
-typedef unsigned long   ulong;
-
-// Patch for MinGW: on Win64 long is 32-bit
-#ifdef _WIN64
-    typedef unsigned long long ulongptr;
-#else
-    typedef ulong ulongptr;
-#endif
-
-
-// Helper macro for aligning pointer up to next 16-byte boundary
-#define SOUNDTOUCH_ALIGN_POINTER_16(x)      ( ( (ulongptr)(x) + 15 ) & ~(ulongptr)15 )
-
-
-#if (defined(__GNUC__) && !defined(ANDROID))
-    // In GCC, include soundtouch_config.h made by config scritps.
-    // Skip this in Android compilation that uses GCC but without configure scripts.
-    #include "soundtouch_config.h"
-#endif
-
-
-namespace soundtouch
-{
-    /// Max allowed number of channels
-    #define SOUNDTOUCH_MAX_CHANNELS     16
-
-    /// Activate these undef's to overrule the possible sampletype 
-    /// setting inherited from some other header file:
-    //#undef SOUNDTOUCH_INTEGER_SAMPLES
-    //#undef SOUNDTOUCH_FLOAT_SAMPLES
-
-    /// If following flag is defined, always uses multichannel processing 
-    /// routines also for mono and stero sound. This is for routine testing 
-    /// purposes; output should be same with either routines, yet disabling 
-    /// the dedicated mono/stereo processing routines will result in slower 
-    /// runtime performance so recommendation is to keep this off.
-    // #define USE_MULTICH_ALWAYS
-
-    #if (defined(__SOFTFP__) && defined(ANDROID))
-        // For Android compilation: Force use of Integer samples in case that
-        // compilation uses soft-floating point emulation - soft-fp is way too slow
-        #undef  SOUNDTOUCH_FLOAT_SAMPLES
-        #define SOUNDTOUCH_INTEGER_SAMPLES      1
-    #endif
-
-    #if !(SOUNDTOUCH_INTEGER_SAMPLES || SOUNDTOUCH_FLOAT_SAMPLES)
-       
-        /// Choose either 32bit floating point or 16bit integer sampletype
-        /// by choosing one of the following defines, unless this selection 
-        /// has already been done in some other file.
-        ////
-        /// Notes:
-        /// - In Windows environment, choose the sample format with the
-        ///   following defines.
-        /// - In GNU environment, the floating point samples are used by 
-        ///   default, but integer samples can be chosen by giving the 
-        ///   following switch to the configure script:
-        ///       ./configure --enable-integer-samples
-        ///   However, if you still prefer to select the sample format here 
-        ///   also in GNU environment, then please #undef the INTEGER_SAMPLE
-        ///   and FLOAT_SAMPLE defines first as in comments above.
-        //#define SOUNDTOUCH_INTEGER_SAMPLES     1    //< 16bit integer samples
-        #define SOUNDTOUCH_FLOAT_SAMPLES       1    //< 32bit float samples
-     
-    #endif
-
-    #if (_M_IX86 || __i386__ || __x86_64__ || _M_X64)
-        /// Define this to allow X86-specific assembler/intrinsic optimizations. 
-        /// Notice that library contains also usual C++ versions of each of these
-        /// these routines, so if you're having difficulties getting the optimized 
-        /// routines compiled for whatever reason, you may disable these optimizations 
-        /// to make the library compile.
-
-        #define SOUNDTOUCH_ALLOW_X86_OPTIMIZATIONS     1
-
-        /// In GNU environment, allow the user to override this setting by
-        /// giving the following switch to the configure script:
-        /// ./configure --disable-x86-optimizations
-        /// ./configure --enable-x86-optimizations=no
-        #ifdef SOUNDTOUCH_DISABLE_X86_OPTIMIZATIONS
-            #undef SOUNDTOUCH_ALLOW_X86_OPTIMIZATIONS
-        #endif
-    #else
-        /// Always disable optimizations when not using a x86 systems.
-        #undef SOUNDTOUCH_ALLOW_X86_OPTIMIZATIONS
-
-    #endif
-
-    // If defined, allows the SIMD-optimized routines to skip unevenly aligned
-    // memory offsets that can cause performance penalty in some SIMD implementations.
-    // Causes slight compromise in sound quality.
-    // #define SOUNDTOUCH_ALLOW_NONEXACT_SIMD_OPTIMIZATION    1
-
-
-    #ifdef SOUNDTOUCH_INTEGER_SAMPLES
-        // 16bit integer sample type
-        typedef short SAMPLETYPE;
-        // data type for sample accumulation: Use 32bit integer to prevent overflows
-        typedef long  LONG_SAMPLETYPE;
-
-        #ifdef SOUNDTOUCH_FLOAT_SAMPLES
-            // check that only one sample type is defined
-            #error "conflicting sample types defined"
-        #endif // SOUNDTOUCH_FLOAT_SAMPLES
-
-        #ifdef SOUNDTOUCH_ALLOW_X86_OPTIMIZATIONS
-            // Allow MMX optimizations (not available in X64 mode)
-            #if (!_M_X64)
-                #define SOUNDTOUCH_ALLOW_MMX   1
-            #endif
-        #endif
-
-    #else
-
-        // floating point samples
-        typedef float  SAMPLETYPE;
-        // data type for sample accumulation: Use float also here to enable
-        // efficient autovectorization
-        typedef float LONG_SAMPLETYPE;
-
-        #ifdef SOUNDTOUCH_ALLOW_X86_OPTIMIZATIONS
-            // Allow SSE optimizations
-            #define SOUNDTOUCH_ALLOW_SSE       1
-        #endif
-
-    #endif  // SOUNDTOUCH_INTEGER_SAMPLES
-
-    #if ((SOUNDTOUCH_ALLOW_SSE) || (__SSE__) || (SOUNDTOUCH_USE_NEON))
-        #if SOUNDTOUCH_ALLOW_NONEXACT_SIMD_OPTIMIZATION
-            #define ST_SIMD_AVOID_UNALIGNED
-        #endif
-    #endif
-
-}
-
-// define ST_NO_EXCEPTION_HANDLING switch to disable throwing std exceptions:
-// #define ST_NO_EXCEPTION_HANDLING    1
-#ifdef ST_NO_EXCEPTION_HANDLING
-    // Exceptions disabled. Throw asserts instead if enabled.
-    #include 
-    #define ST_THROW_RT_ERROR(x)    {assert((const char *)x);}
-#else
-    // use c++ standard exceptions
-    #include 
-    #include 
-    #define ST_THROW_RT_ERROR(x)    {throw std::runtime_error(x);}
-#endif
-
-// When this #define is active, eliminates a clicking sound when the "rate" or "pitch" 
-// parameter setting crosses from value <1 to >=1 or vice versa during processing. 
-// Default is off as such crossover is untypical case and involves a slight sound 
-// quality compromise.
-//#define SOUNDTOUCH_PREVENT_CLICK_AT_RATE_CROSSOVER   1
-
-#endif
+////////////////////////////////////////////////////////////////////////////////
+///
+/// Common type definitions for SoundTouch audio processing library.
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef STTypes_H
+#define STTypes_H
+
+typedef unsigned int    uint;
+typedef unsigned long   ulong;
+
+// Patch for MinGW: on Win64 long is 32-bit
+#ifdef _WIN64
+    typedef unsigned long long ulongptr;
+#else
+    typedef ulong ulongptr;
+#endif
+
+
+// Helper macro for aligning pointer up to next 16-byte boundary
+#define SOUNDTOUCH_ALIGN_POINTER_16(x)      ( ( (ulongptr)(x) + 15 ) & ~(ulongptr)15 )
+
+
+#if (defined(__GNUC__) && !defined(ANDROID))
+    // In GCC, include soundtouch_config.h made by config scritps.
+    // Skip this in Android compilation that uses GCC but without configure scripts.
+    #include "soundtouch_config.h"
+#endif
+
+
+namespace soundtouch
+{
+    /// Max allowed number of channels
+    #define SOUNDTOUCH_MAX_CHANNELS     16
+
+    /// Activate these undef's to overrule the possible sampletype
+    /// setting inherited from some other header file:
+    //#undef SOUNDTOUCH_INTEGER_SAMPLES
+    //#undef SOUNDTOUCH_FLOAT_SAMPLES
+
+    /// If following flag is defined, always uses multichannel processing
+    /// routines also for mono and stero sound. This is for routine testing
+    /// purposes; output should be same with either routines, yet disabling
+    /// the dedicated mono/stereo processing routines will result in slower
+    /// runtime performance so recommendation is to keep this off.
+    // #define USE_MULTICH_ALWAYS
+
+    #if (defined(__SOFTFP__) && defined(ANDROID))
+        // For Android compilation: Force use of Integer samples in case that
+        // compilation uses soft-floating point emulation - soft-fp is way too slow
+        #undef  SOUNDTOUCH_FLOAT_SAMPLES
+        #define SOUNDTOUCH_INTEGER_SAMPLES      1
+    #endif
+
+    #if !(SOUNDTOUCH_INTEGER_SAMPLES || SOUNDTOUCH_FLOAT_SAMPLES)
+
+        /// Choose either 32bit floating point or 16bit integer sampletype
+        /// by choosing one of the following defines, unless this selection
+        /// has already been done in some other file.
+        ////
+        /// Notes:
+        /// - In Windows environment, choose the sample format with the
+        ///   following defines.
+        /// - In GNU environment, the floating point samples are used by
+        ///   default, but integer samples can be chosen by giving the
+        ///   following switch to the configure script:
+        ///       ./configure --enable-integer-samples
+        ///   However, if you still prefer to select the sample format here
+        ///   also in GNU environment, then please #undef the INTEGER_SAMPLE
+        ///   and FLOAT_SAMPLE defines first as in comments above.
+        //#define SOUNDTOUCH_INTEGER_SAMPLES     1    //< 16bit integer samples
+        #define SOUNDTOUCH_FLOAT_SAMPLES       1    //< 32bit float samples
+
+    #endif
+
+    #if (_M_IX86 || __i386__ || __x86_64__ || _M_X64)
+        /// Define this to allow X86-specific assembler/intrinsic optimizations.
+        /// Notice that library contains also usual C++ versions of each of these
+        /// these routines, so if you're having difficulties getting the optimized
+        /// routines compiled for whatever reason, you may disable these optimizations
+        /// to make the library compile.
+
+        #define SOUNDTOUCH_ALLOW_X86_OPTIMIZATIONS     1
+
+        /// In GNU environment, allow the user to override this setting by
+        /// giving the following switch to the configure script:
+        /// ./configure --disable-x86-optimizations
+        /// ./configure --enable-x86-optimizations=no
+        #ifdef SOUNDTOUCH_DISABLE_X86_OPTIMIZATIONS
+            #undef SOUNDTOUCH_ALLOW_X86_OPTIMIZATIONS
+        #endif
+    #else
+        /// Always disable optimizations when not using a x86 systems.
+        #undef SOUNDTOUCH_ALLOW_X86_OPTIMIZATIONS
+
+    #endif
+
+    // If defined, allows the SIMD-optimized routines to skip unevenly aligned
+    // memory offsets that can cause performance penalty in some SIMD implementations.
+    // Causes slight compromise in sound quality.
+    // #define SOUNDTOUCH_ALLOW_NONEXACT_SIMD_OPTIMIZATION    1
+
+
+    #ifdef SOUNDTOUCH_INTEGER_SAMPLES
+        // 16bit integer sample type
+        typedef short SAMPLETYPE;
+        // data type for sample accumulation: Use 32bit integer to prevent overflows
+        typedef long  LONG_SAMPLETYPE;
+
+        #ifdef SOUNDTOUCH_FLOAT_SAMPLES
+            // check that only one sample type is defined
+            #error "conflicting sample types defined"
+        #endif // SOUNDTOUCH_FLOAT_SAMPLES
+
+        #ifdef SOUNDTOUCH_ALLOW_X86_OPTIMIZATIONS
+            // Allow MMX optimizations (not available in X64 mode)
+            #if (!_M_X64)
+                #define SOUNDTOUCH_ALLOW_MMX   1
+            #endif
+        #endif
+
+    #else
+
+        // floating point samples
+        typedef float  SAMPLETYPE;
+        // data type for sample accumulation: Use float also here to enable
+        // efficient autovectorization
+        typedef float LONG_SAMPLETYPE;
+
+        #ifdef SOUNDTOUCH_ALLOW_X86_OPTIMIZATIONS
+            // Allow SSE optimizations
+            #define SOUNDTOUCH_ALLOW_SSE       1
+        #endif
+
+    #endif  // SOUNDTOUCH_INTEGER_SAMPLES
+
+    #if ((SOUNDTOUCH_ALLOW_SSE) || (__SSE__) || (SOUNDTOUCH_USE_NEON))
+        #if SOUNDTOUCH_ALLOW_NONEXACT_SIMD_OPTIMIZATION
+            #define ST_SIMD_AVOID_UNALIGNED
+        #endif
+    #endif
+
+}
+
+// define ST_NO_EXCEPTION_HANDLING switch to disable throwing std exceptions:
+// #define ST_NO_EXCEPTION_HANDLING    1
+#ifdef ST_NO_EXCEPTION_HANDLING
+    // Exceptions disabled. Throw asserts instead if enabled.
+    #include 
+    #define ST_THROW_RT_ERROR(x)    {assert((const char *)x);}
+#else
+    // use c++ standard exceptions
+    #include 
+    #include 
+    #define ST_THROW_RT_ERROR(x)    {throw std::runtime_error(x);}
+#endif
+
+// When this #define is active, eliminates a clicking sound when the "rate" or "pitch"
+// parameter setting crosses from value <1 to >=1 or vice versa during processing.
+// Default is off as such crossover is untypical case and involves a slight sound
+// quality compromise.
+//#define SOUNDTOUCH_PREVENT_CLICK_AT_RATE_CROSSOVER   1
+
+#endif
diff --git a/include/SoundTouch.h b/include/SoundTouch.h
index 3337dad..7045209 100644
--- a/include/SoundTouch.h
+++ b/include/SoundTouch.h
@@ -1,348 +1,348 @@
-//////////////////////////////////////////////////////////////////////////////
-///
-/// SoundTouch - main class for tempo/pitch/rate adjusting routines.
-///
-/// Notes:
-/// - Initialize the SoundTouch object instance by setting up the sound stream
-///   parameters with functions 'setSampleRate' and 'setChannels', then set
-///   desired tempo/pitch/rate settings with the corresponding functions.
-///
-/// - The SoundTouch class behaves like a first-in-first-out pipeline: The
-///   samples that are to be processed are fed into one of the pipe by calling
-///   function 'putSamples', while the ready processed samples can be read
-///   from the other end of the pipeline with function 'receiveSamples'.
-///
-/// - The SoundTouch processing classes require certain sized 'batches' of
-///   samples in order to process the sound. For this reason the classes buffer
-///   incoming samples until there are enough of samples available for
-///   processing, then they carry out the processing step and consequently
-///   make the processed samples available for outputting.
-///
-/// - For the above reason, the processing routines introduce a certain
-///   'latency' between the input and output, so that the samples input to
-///   SoundTouch may not be immediately available in the output, and neither
-///   the amount of outputtable samples may not immediately be in direct
-///   relationship with the amount of previously input samples.
-///
-/// - The tempo/pitch/rate control parameters can be altered during processing.
-///   Please notice though that they aren't currently protected by semaphores,
-///   so in multi-thread application external semaphore protection may be
-///   required.
-///
-/// - This class utilizes classes 'TDStretch' for tempo change (without modifying
-///   pitch) and 'RateTransposer' for changing the playback rate (that is, both
-///   tempo and pitch in the same ratio) of the sound. The third available control
-///   'pitch' (change pitch but maintain tempo) is produced by a combination of
-///   combining the two other controls.
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef SoundTouch_H
-#define SoundTouch_H
-
-#include "FIFOSamplePipe.h"
-#include "STTypes.h"
-
-namespace soundtouch
-{
-
-/// Soundtouch library version string
-#define SOUNDTOUCH_VERSION          "2.3.3"
-
-/// SoundTouch library version id
-#define SOUNDTOUCH_VERSION_ID       (20303)
-
-//
-// Available setting IDs for the 'setSetting' & 'get_setting' functions:
-
-/// Enable/disable anti-alias filter in pitch transposer (0 = disable)
-#define SETTING_USE_AA_FILTER       0
-
-/// Pitch transposer anti-alias filter length (8 .. 128 taps, default = 32)
-#define SETTING_AA_FILTER_LENGTH    1
-
-/// Enable/disable quick seeking algorithm in tempo changer routine
-/// (enabling quick seeking lowers CPU utilization but causes a minor sound
-///  quality compromising)
-#define SETTING_USE_QUICKSEEK       2
-
-/// Time-stretch algorithm single processing sequence length in milliseconds. This determines
-/// to how long sequences the original sound is chopped in the time-stretch algorithm.
-/// See "STTypes.h" or README for more information.
-#define SETTING_SEQUENCE_MS         3
-
-/// Time-stretch algorithm seeking window length in milliseconds for algorithm that finds the
-/// best possible overlapping location. This determines from how wide window the algorithm
-/// may look for an optimal joining location when mixing the sound sequences back together.
-/// See "STTypes.h" or README for more information.
-#define SETTING_SEEKWINDOW_MS       4
-
-/// Time-stretch algorithm overlap length in milliseconds. When the chopped sound sequences
-/// are mixed back together, to form a continuous sound stream, this parameter defines over
-/// how long period the two consecutive sequences are let to overlap each other.
-/// See "STTypes.h" or README for more information.
-#define SETTING_OVERLAP_MS          5
-
-
-/// Call "getSetting" with this ID to query processing sequence size in samples.
-/// This value gives approximate value of how many input samples you'll need to
-/// feed into SoundTouch after initial buffering to get out a new batch of
-/// output samples.
-///
-/// This value does not include initial buffering at beginning of a new processing
-/// stream, use SETTING_INITIAL_LATENCY to get the initial buffering size.
-///
-/// Notices:
-/// - This is read-only parameter, i.e. setSetting ignores this parameter
-/// - This parameter value is not constant but change depending on
-///   tempo/pitch/rate/samplerate settings.
-#define SETTING_NOMINAL_INPUT_SEQUENCE      6
-
-
-/// Call "getSetting" with this ID to query nominal average processing output
-/// size in samples. This value tells approcimate value how many output samples
-/// SoundTouch outputs once it does DSP processing run for a batch of input samples.
-///
-/// Notices:
-/// - This is read-only parameter, i.e. setSetting ignores this parameter
-/// - This parameter value is not constant but change depending on
-///   tempo/pitch/rate/samplerate settings.
-#define SETTING_NOMINAL_OUTPUT_SEQUENCE     7
-
-
-/// Call "getSetting" with this ID to query initial processing latency, i.e.
-/// approx. how many samples you'll need to enter to SoundTouch pipeline before
-/// you can expect to get first batch of ready output samples out.
-///
-/// After the first output batch, you can then expect to get approx.
-/// SETTING_NOMINAL_OUTPUT_SEQUENCE ready samples out for every
-/// SETTING_NOMINAL_INPUT_SEQUENCE samples that you enter into SoundTouch.
-///
-/// Example:
-///     processing with parameter -tempo=5
-///     => initial latency = 5509 samples
-///        input sequence  = 4167 samples
-///        output sequence = 3969 samples
-///
-/// Accordingly, you can expect to feed in approx. 5509 samples at beginning of
-/// the stream, and then you'll get out the first 3969 samples. After that, for
-/// every approx. 4167 samples that you'll put in, you'll receive again approx.
-/// 3969 samples out.
-///
-/// This also means that average latency during stream processing is
-/// INITIAL_LATENCY-OUTPUT_SEQUENCE/2, in the above example case 5509-3969/2
-/// = 3524 samples
-///
-/// Notices:
-/// - This is read-only parameter, i.e. setSetting ignores this parameter
-/// - This parameter value is not constant but change depending on
-///   tempo/pitch/rate/samplerate settings.
-#define SETTING_INITIAL_LATENCY             8
-
-
-class SoundTouch : public FIFOProcessor
-{
-private:
-    /// Rate transposer class instance
-    class RateTransposer *pRateTransposer;
-
-    /// Time-stretch class instance
-    class TDStretch *pTDStretch;
-
-    /// Virtual pitch parameter. Effective rate & tempo are calculated from these parameters.
-    double virtualRate;
-
-    /// Virtual pitch parameter. Effective rate & tempo are calculated from these parameters.
-    double virtualTempo;
-
-    /// Virtual pitch parameter. Effective rate & tempo are calculated from these parameters.
-    double virtualPitch;
-
-    /// Flag: Has sample rate been set?
-    bool  bSrateSet;
-
-    /// Accumulator for how many samples in total will be expected as output vs. samples put in,
-    /// considering current processing settings.
-    double samplesExpectedOut;
-
-    /// Accumulator for how many samples in total have been read out from the processing so far
-    long   samplesOutput;
-
-    /// Calculates effective rate & tempo valuescfrom 'virtualRate', 'virtualTempo' and
-    /// 'virtualPitch' parameters.
-    void calcEffectiveRateAndTempo();
-
-protected :
-    /// Number of channels
-    uint  channels;
-
-    /// Effective 'rate' value calculated from 'virtualRate', 'virtualTempo' and 'virtualPitch'
-    double rate;
-
-    /// Effective 'tempo' value calculated from 'virtualRate', 'virtualTempo' and 'virtualPitch'
-    double tempo;
-
-public:
-    SoundTouch();
-    virtual ~SoundTouch() override;
-
-    /// Get SoundTouch library version string
-    static const char *getVersionString();
-
-    /// Get SoundTouch library version Id
-    static uint getVersionId();
-
-    /// Sets new rate control value. Normal rate = 1.0, smaller values
-    /// represent slower rate, larger faster rates.
-    void setRate(double newRate);
-
-    /// Sets new tempo control value. Normal tempo = 1.0, smaller values
-    /// represent slower tempo, larger faster tempo.
-    void setTempo(double newTempo);
-
-    /// Sets new rate control value as a difference in percents compared
-    /// to the original rate (-50 .. +100 %)
-    void setRateChange(double newRate);
-
-    /// Sets new tempo control value as a difference in percents compared
-    /// to the original tempo (-50 .. +100 %)
-    void setTempoChange(double newTempo);
-
-    /// Sets new pitch control value. Original pitch = 1.0, smaller values
-    /// represent lower pitches, larger values higher pitch.
-    void setPitch(double newPitch);
-
-    /// Sets pitch change in octaves compared to the original pitch
-    /// (-1.00 .. +1.00)
-    void setPitchOctaves(double newPitch);
-
-    /// Sets pitch change in semi-tones compared to the original pitch
-    /// (-12 .. +12)
-    void setPitchSemiTones(int newPitch);
-    void setPitchSemiTones(double newPitch);
-
-    /// Sets the number of channels, 1 = mono, 2 = stereo
-    void setChannels(uint numChannels);
-
-    /// Sets sample rate.
-    void setSampleRate(uint srate);
-
-    /// Get ratio between input and output audio durations, useful for calculating
-    /// processed output duration: if you'll process a stream of N samples, then
-    /// you can expect to get out N * getInputOutputSampleRatio() samples.
-    ///
-    /// This ratio will give accurate target duration ratio for a full audio track,
-    /// given that the the whole track is processed with same processing parameters.
-    ///
-    /// If this ratio is applied to calculate intermediate offsets inside a processing
-    /// stream, then this ratio is approximate and can deviate +- some tens of milliseconds
-    /// from ideal offset, yet by end of the audio stream the duration ratio will become
-    /// exact.
-    ///
-    /// Example: if processing with parameters "-tempo=15 -pitch=-3", the function
-    /// will return value 0.8695652... Now, if processing an audio stream whose duration
-    /// is exactly one million audio samples, then you can expect the processed
-    /// output duration  be 0.869565 * 1000000 = 869565 samples.
-    double getInputOutputSampleRatio();
-
-    /// Flushes the last samples from the processing pipeline to the output.
-    /// Clears also the internal processing buffers.
-    //
-    /// Note: This function is meant for extracting the last samples of a sound
-    /// stream. This function may introduce additional blank samples in the end
-    /// of the sound stream, and thus it's not recommended to call this function
-    /// in the middle of a sound stream.
-    void flush();
-
-    /// Adds 'numSamples' pcs of samples from the 'samples' memory position into
-    /// the input of the object. Notice that sample rate _has_to_ be set before
-    /// calling this function, otherwise throws a runtime_error exception.
-    virtual void putSamples(
-            const SAMPLETYPE *samples,  ///< Pointer to sample buffer.
-            uint numSamples                         ///< Number of samples in buffer. Notice
-                                                    ///< that in case of stereo-sound a single sample
-                                                    ///< contains data for both channels.
-            ) override;
-
-    /// Output samples from beginning of the sample buffer. Copies requested samples to
-    /// output buffer and removes them from the sample buffer. If there are less than
-    /// 'numsample' samples in the buffer, returns all that available.
-    ///
-    /// \return Number of samples returned.
-    virtual uint receiveSamples(SAMPLETYPE *output, ///< Buffer where to copy output samples.
-        uint maxSamples                 ///< How many samples to receive at max.
-        ) override;
-
-    /// Adjusts book-keeping so that given number of samples are removed from beginning of the
-    /// sample buffer without copying them anywhere.
-    ///
-    /// Used to reduce the number of samples in the buffer when accessing the sample buffer directly
-    /// with 'ptrBegin' function.
-    virtual uint receiveSamples(uint maxSamples   ///< Remove this many samples from the beginning of pipe.
-        ) override;
-
-    /// Clears all the samples in the object's output and internal processing
-    /// buffers.
-    virtual void clear() override;
-
-    /// Changes a setting controlling the processing system behaviour. See the
-    /// 'SETTING_...' defines for available setting ID's.
-    ///
-    /// \return 'true' if the setting was successfully changed
-    bool setSetting(int settingId,   ///< Setting ID number. see SETTING_... defines.
-                    int value        ///< New setting value.
-                    );
-
-    /// Reads a setting controlling the processing system behaviour. See the
-    /// 'SETTING_...' defines for available setting ID's.
-    ///
-    /// \return the setting value.
-    int getSetting(int settingId    ///< Setting ID number, see SETTING_... defines.
-                   ) const;
-
-    /// Returns number of samples currently unprocessed.
-    virtual uint numUnprocessedSamples() const;
-
-    /// Return number of channels
-    uint numChannels() const
-    {
-        return channels;
-    }
-
-    /// Other handy functions that are implemented in the ancestor classes (see
-    /// classes 'FIFOProcessor' and 'FIFOSamplePipe')
-    ///
-    /// - receiveSamples() : Use this function to receive 'ready' processed samples from SoundTouch.
-    /// - numSamples()     : Get number of 'ready' samples that can be received with
-    ///                      function 'receiveSamples()'
-    /// - isEmpty()        : Returns nonzero if there aren't any 'ready' samples.
-    /// - clear()          : Clears all samples from ready/processing buffers.
-};
-
-}
-#endif
+//////////////////////////////////////////////////////////////////////////////
+///
+/// SoundTouch - main class for tempo/pitch/rate adjusting routines.
+///
+/// Notes:
+/// - Initialize the SoundTouch object instance by setting up the sound stream
+///   parameters with functions 'setSampleRate' and 'setChannels', then set
+///   desired tempo/pitch/rate settings with the corresponding functions.
+///
+/// - The SoundTouch class behaves like a first-in-first-out pipeline: The
+///   samples that are to be processed are fed into one of the pipe by calling
+///   function 'putSamples', while the ready processed samples can be read
+///   from the other end of the pipeline with function 'receiveSamples'.
+///
+/// - The SoundTouch processing classes require certain sized 'batches' of
+///   samples in order to process the sound. For this reason the classes buffer
+///   incoming samples until there are enough of samples available for
+///   processing, then they carry out the processing step and consequently
+///   make the processed samples available for outputting.
+///
+/// - For the above reason, the processing routines introduce a certain
+///   'latency' between the input and output, so that the samples input to
+///   SoundTouch may not be immediately available in the output, and neither
+///   the amount of outputtable samples may not immediately be in direct
+///   relationship with the amount of previously input samples.
+///
+/// - The tempo/pitch/rate control parameters can be altered during processing.
+///   Please notice though that they aren't currently protected by semaphores,
+///   so in multi-thread application external semaphore protection may be
+///   required.
+///
+/// - This class utilizes classes 'TDStretch' for tempo change (without modifying
+///   pitch) and 'RateTransposer' for changing the playback rate (that is, both
+///   tempo and pitch in the same ratio) of the sound. The third available control
+///   'pitch' (change pitch but maintain tempo) is produced by a combination of
+///   combining the two other controls.
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef SoundTouch_H
+#define SoundTouch_H
+
+#include "FIFOSamplePipe.h"
+#include "STTypes.h"
+
+namespace soundtouch
+{
+
+/// Soundtouch library version string
+#define SOUNDTOUCH_VERSION          "2.3.3"
+
+/// SoundTouch library version id
+#define SOUNDTOUCH_VERSION_ID       (20303)
+
+//
+// Available setting IDs for the 'setSetting' & 'get_setting' functions:
+
+/// Enable/disable anti-alias filter in pitch transposer (0 = disable)
+#define SETTING_USE_AA_FILTER       0
+
+/// Pitch transposer anti-alias filter length (8 .. 128 taps, default = 32)
+#define SETTING_AA_FILTER_LENGTH    1
+
+/// Enable/disable quick seeking algorithm in tempo changer routine
+/// (enabling quick seeking lowers CPU utilization but causes a minor sound
+///  quality compromising)
+#define SETTING_USE_QUICKSEEK       2
+
+/// Time-stretch algorithm single processing sequence length in milliseconds. This determines
+/// to how long sequences the original sound is chopped in the time-stretch algorithm.
+/// See "STTypes.h" or README for more information.
+#define SETTING_SEQUENCE_MS         3
+
+/// Time-stretch algorithm seeking window length in milliseconds for algorithm that finds the
+/// best possible overlapping location. This determines from how wide window the algorithm
+/// may look for an optimal joining location when mixing the sound sequences back together.
+/// See "STTypes.h" or README for more information.
+#define SETTING_SEEKWINDOW_MS       4
+
+/// Time-stretch algorithm overlap length in milliseconds. When the chopped sound sequences
+/// are mixed back together, to form a continuous sound stream, this parameter defines over
+/// how long period the two consecutive sequences are let to overlap each other.
+/// See "STTypes.h" or README for more information.
+#define SETTING_OVERLAP_MS          5
+
+
+/// Call "getSetting" with this ID to query processing sequence size in samples.
+/// This value gives approximate value of how many input samples you'll need to
+/// feed into SoundTouch after initial buffering to get out a new batch of
+/// output samples.
+///
+/// This value does not include initial buffering at beginning of a new processing
+/// stream, use SETTING_INITIAL_LATENCY to get the initial buffering size.
+///
+/// Notices:
+/// - This is read-only parameter, i.e. setSetting ignores this parameter
+/// - This parameter value is not constant but change depending on
+///   tempo/pitch/rate/samplerate settings.
+#define SETTING_NOMINAL_INPUT_SEQUENCE      6
+
+
+/// Call "getSetting" with this ID to query nominal average processing output
+/// size in samples. This value tells approcimate value how many output samples
+/// SoundTouch outputs once it does DSP processing run for a batch of input samples.
+///
+/// Notices:
+/// - This is read-only parameter, i.e. setSetting ignores this parameter
+/// - This parameter value is not constant but change depending on
+///   tempo/pitch/rate/samplerate settings.
+#define SETTING_NOMINAL_OUTPUT_SEQUENCE     7
+
+
+/// Call "getSetting" with this ID to query initial processing latency, i.e.
+/// approx. how many samples you'll need to enter to SoundTouch pipeline before
+/// you can expect to get first batch of ready output samples out.
+///
+/// After the first output batch, you can then expect to get approx.
+/// SETTING_NOMINAL_OUTPUT_SEQUENCE ready samples out for every
+/// SETTING_NOMINAL_INPUT_SEQUENCE samples that you enter into SoundTouch.
+///
+/// Example:
+///     processing with parameter -tempo=5
+///     => initial latency = 5509 samples
+///        input sequence  = 4167 samples
+///        output sequence = 3969 samples
+///
+/// Accordingly, you can expect to feed in approx. 5509 samples at beginning of
+/// the stream, and then you'll get out the first 3969 samples. After that, for
+/// every approx. 4167 samples that you'll put in, you'll receive again approx.
+/// 3969 samples out.
+///
+/// This also means that average latency during stream processing is
+/// INITIAL_LATENCY-OUTPUT_SEQUENCE/2, in the above example case 5509-3969/2
+/// = 3524 samples
+///
+/// Notices:
+/// - This is read-only parameter, i.e. setSetting ignores this parameter
+/// - This parameter value is not constant but change depending on
+///   tempo/pitch/rate/samplerate settings.
+#define SETTING_INITIAL_LATENCY             8
+
+
+class SoundTouch : public FIFOProcessor
+{
+private:
+    /// Rate transposer class instance
+    class RateTransposer *pRateTransposer;
+
+    /// Time-stretch class instance
+    class TDStretch *pTDStretch;
+
+    /// Virtual pitch parameter. Effective rate & tempo are calculated from these parameters.
+    double virtualRate;
+
+    /// Virtual pitch parameter. Effective rate & tempo are calculated from these parameters.
+    double virtualTempo;
+
+    /// Virtual pitch parameter. Effective rate & tempo are calculated from these parameters.
+    double virtualPitch;
+
+    /// Flag: Has sample rate been set?
+    bool  bSrateSet;
+
+    /// Accumulator for how many samples in total will be expected as output vs. samples put in,
+    /// considering current processing settings.
+    double samplesExpectedOut;
+
+    /// Accumulator for how many samples in total have been read out from the processing so far
+    long   samplesOutput;
+
+    /// Calculates effective rate & tempo valuescfrom 'virtualRate', 'virtualTempo' and
+    /// 'virtualPitch' parameters.
+    void calcEffectiveRateAndTempo();
+
+protected :
+    /// Number of channels
+    uint  channels;
+
+    /// Effective 'rate' value calculated from 'virtualRate', 'virtualTempo' and 'virtualPitch'
+    double rate;
+
+    /// Effective 'tempo' value calculated from 'virtualRate', 'virtualTempo' and 'virtualPitch'
+    double tempo;
+
+public:
+    SoundTouch();
+    virtual ~SoundTouch() override;
+
+    /// Get SoundTouch library version string
+    static const char *getVersionString();
+
+    /// Get SoundTouch library version Id
+    static uint getVersionId();
+
+    /// Sets new rate control value. Normal rate = 1.0, smaller values
+    /// represent slower rate, larger faster rates.
+    void setRate(double newRate);
+
+    /// Sets new tempo control value. Normal tempo = 1.0, smaller values
+    /// represent slower tempo, larger faster tempo.
+    void setTempo(double newTempo);
+
+    /// Sets new rate control value as a difference in percents compared
+    /// to the original rate (-50 .. +100 %)
+    void setRateChange(double newRate);
+
+    /// Sets new tempo control value as a difference in percents compared
+    /// to the original tempo (-50 .. +100 %)
+    void setTempoChange(double newTempo);
+
+    /// Sets new pitch control value. Original pitch = 1.0, smaller values
+    /// represent lower pitches, larger values higher pitch.
+    void setPitch(double newPitch);
+
+    /// Sets pitch change in octaves compared to the original pitch
+    /// (-1.00 .. +1.00)
+    void setPitchOctaves(double newPitch);
+
+    /// Sets pitch change in semi-tones compared to the original pitch
+    /// (-12 .. +12)
+    void setPitchSemiTones(int newPitch);
+    void setPitchSemiTones(double newPitch);
+
+    /// Sets the number of channels, 1 = mono, 2 = stereo
+    void setChannels(uint numChannels);
+
+    /// Sets sample rate.
+    void setSampleRate(uint srate);
+
+    /// Get ratio between input and output audio durations, useful for calculating
+    /// processed output duration: if you'll process a stream of N samples, then
+    /// you can expect to get out N * getInputOutputSampleRatio() samples.
+    ///
+    /// This ratio will give accurate target duration ratio for a full audio track,
+    /// given that the the whole track is processed with same processing parameters.
+    ///
+    /// If this ratio is applied to calculate intermediate offsets inside a processing
+    /// stream, then this ratio is approximate and can deviate +- some tens of milliseconds
+    /// from ideal offset, yet by end of the audio stream the duration ratio will become
+    /// exact.
+    ///
+    /// Example: if processing with parameters "-tempo=15 -pitch=-3", the function
+    /// will return value 0.8695652... Now, if processing an audio stream whose duration
+    /// is exactly one million audio samples, then you can expect the processed
+    /// output duration  be 0.869565 * 1000000 = 869565 samples.
+    double getInputOutputSampleRatio();
+
+    /// Flushes the last samples from the processing pipeline to the output.
+    /// Clears also the internal processing buffers.
+    //
+    /// Note: This function is meant for extracting the last samples of a sound
+    /// stream. This function may introduce additional blank samples in the end
+    /// of the sound stream, and thus it's not recommended to call this function
+    /// in the middle of a sound stream.
+    void flush();
+
+    /// Adds 'numSamples' pcs of samples from the 'samples' memory position into
+    /// the input of the object. Notice that sample rate _has_to_ be set before
+    /// calling this function, otherwise throws a runtime_error exception.
+    virtual void putSamples(
+            const SAMPLETYPE *samples,  ///< Pointer to sample buffer.
+            uint numSamples                         ///< Number of samples in buffer. Notice
+                                                    ///< that in case of stereo-sound a single sample
+                                                    ///< contains data for both channels.
+            ) override;
+
+    /// Output samples from beginning of the sample buffer. Copies requested samples to
+    /// output buffer and removes them from the sample buffer. If there are less than
+    /// 'numsample' samples in the buffer, returns all that available.
+    ///
+    /// \return Number of samples returned.
+    virtual uint receiveSamples(SAMPLETYPE *output, ///< Buffer where to copy output samples.
+        uint maxSamples                 ///< How many samples to receive at max.
+        ) override;
+
+    /// Adjusts book-keeping so that given number of samples are removed from beginning of the
+    /// sample buffer without copying them anywhere.
+    ///
+    /// Used to reduce the number of samples in the buffer when accessing the sample buffer directly
+    /// with 'ptrBegin' function.
+    virtual uint receiveSamples(uint maxSamples   ///< Remove this many samples from the beginning of pipe.
+        ) override;
+
+    /// Clears all the samples in the object's output and internal processing
+    /// buffers.
+    virtual void clear() override;
+
+    /// Changes a setting controlling the processing system behaviour. See the
+    /// 'SETTING_...' defines for available setting ID's.
+    ///
+    /// \return 'true' if the setting was successfully changed
+    bool setSetting(int settingId,   ///< Setting ID number. see SETTING_... defines.
+                    int value        ///< New setting value.
+                    );
+
+    /// Reads a setting controlling the processing system behaviour. See the
+    /// 'SETTING_...' defines for available setting ID's.
+    ///
+    /// \return the setting value.
+    int getSetting(int settingId    ///< Setting ID number, see SETTING_... defines.
+                   ) const;
+
+    /// Returns number of samples currently unprocessed.
+    virtual uint numUnprocessedSamples() const;
+
+    /// Return number of channels
+    uint numChannels() const
+    {
+        return channels;
+    }
+
+    /// Other handy functions that are implemented in the ancestor classes (see
+    /// classes 'FIFOProcessor' and 'FIFOSamplePipe')
+    ///
+    /// - receiveSamples() : Use this function to receive 'ready' processed samples from SoundTouch.
+    /// - numSamples()     : Get number of 'ready' samples that can be received with
+    ///                      function 'receiveSamples()'
+    /// - isEmpty()        : Returns nonzero if there aren't any 'ready' samples.
+    /// - clear()          : Clears all samples from ready/processing buffers.
+};
+
+}
+#endif
diff --git a/soundtouch.m4 b/soundtouch.m4
index 7e7589b..2931663 100644
--- a/soundtouch.m4
+++ b/soundtouch.m4
@@ -8,7 +8,7 @@
 # It also defines some flags to the configure script for specifying
 # the location to search for libSoundTouch
 #
-# A user of libSoundTouch should add @SOUNDTOUCH_LIBS@ and 
+# A user of libSoundTouch should add @SOUNDTOUCH_LIBS@ and
 # @SOUNDTOUCH_CXXFLAGS@ to the appropriate variables in his
 # Makefile.am files
 #
@@ -32,10 +32,10 @@ AC_DEFUN([AM_PATH_SOUNDTOUCH],[
 	then
 		saved_CPPFLAGS="$CPPFLAGS"
 		saved_LDFLAGS="$LDFLAGS"
-	   
+
 		CPPFLAGS="$CPPFLAGS -I$soundtouch_prefix/include"
 		LDFLAGS="$LDFLAGS -L$soundtouch_prefix/lib"
-   
+
 		dnl make sure SoundTouch.h header file exists
 			dnl could use AC_CHECK_HEADERS to check for all of them, but the supporting .h file names may change later
 		AC_CHECK_HEADER([soundtouch/SoundTouch.h],[
@@ -49,7 +49,7 @@ AC_DEFUN([AM_PATH_SOUNDTOUCH],[
 
 					dnl run action-if-found
 					ifelse([$2], , :, [$2])
-				],[ 
+				],[
 					dnl run action-if-not-found
 					ifelse([$3], , :, [$3])
 				])
diff --git a/source/Android-lib/jni/soundtouch-jni.cpp b/source/Android-lib/jni/soundtouch-jni.cpp
index 01fdab0..c026cc8 100644
--- a/source/Android-lib/jni/soundtouch-jni.cpp
+++ b/source/Android-lib/jni/soundtouch-jni.cpp
@@ -1,258 +1,258 @@
-////////////////////////////////////////////////////////////////////////////////
-///
-/// Example Interface class for SoundTouch native compilation
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// WWW           : http://www.surina.net
-///
-////////////////////////////////////////////////////////////////////////////////
-
-#include 
-#include 
-#include 
-#include 
-
-using namespace std;
-
-#include "../../../include/SoundTouch.h"
-#include "../source/SoundStretch/WavFile.h"
-
-#define LOGV(...)   __android_log_print((int)ANDROID_LOG_INFO, "SOUNDTOUCH", __VA_ARGS__)
-//#define LOGV(...)
-
-
-// String for keeping possible c++ exception error messages. Notice that this isn't
-// thread-safe but it's expected that exceptions are special situations that won't
-// occur in several threads in parallel.
-static string _errMsg = "";
-
-
-#define DLL_PUBLIC __attribute__ ((visibility ("default")))
-#define BUFF_SIZE 4096
-
-
-using namespace soundtouch;
-
-
-// Set error message to return
-static void _setErrmsg(const char *msg)
-{
-	_errMsg = msg;
-}
-
-#if 0   // apparently following workaround not needed any more with concurrent Android SDKs
-#ifdef _OPENMP
-
-#include 
-extern pthread_key_t gomp_tls_key;
-static void * _p_gomp_tls = nullptr;
-
-/// Function to initialize threading for OpenMP.
-///
-/// This is a workaround for bug in Android NDK v10 regarding OpenMP: OpenMP works only if
-/// called from the Android App main thread because in the main thread the gomp_tls storage is
-/// properly set, however, Android does not properly initialize gomp_tls storage for other threads.
-/// Thus if OpenMP routines are invoked from some other thread than the main thread,
-/// the OpenMP routine will crash the application due to nullptr access on uninitialized storage.
-///
-/// This workaround stores the gomp_tls storage from main thread, and copies to other threads.
-/// In order this to work, the Application main thread needws to call at least "getVersionString"
-/// routine.
-static int _init_threading(bool warn)
-{
-	void *ptr = pthread_getspecific(gomp_tls_key);
-	LOGV("JNI thread-specific TLS storage %ld", (long)ptr);
-	if (ptr == nullptr)
-	{
-		LOGV("JNI set missing TLS storage to %ld", (long)_p_gomp_tls);
-		pthread_setspecific(gomp_tls_key, _p_gomp_tls);
-	}
-	else
-	{
-		LOGV("JNI store this TLS storage");
-		_p_gomp_tls = ptr;
-	}
-	// Where critical, show warning if storage still not properly initialized
-	if ((warn) && (_p_gomp_tls == nullptr))
-	{
-		_setErrmsg("Error - OpenMP threading not properly initialized: Call SoundTouch.getVersionString() from the App main thread!");
-		return -1;
-	}
-	return 0;
-}
-
-#else
-static int _init_threading(bool warn)
-{
-	// do nothing if not OpenMP build
-	return 0;
-}
-#endif
-
-#endif
-
-// Processes the sound file
-static void _processFile(SoundTouch *pSoundTouch, const char *inFileName, const char *outFileName)
-{
-    int nSamples;
-    int nChannels;
-    int buffSizeSamples;
-    SAMPLETYPE sampleBuffer[BUFF_SIZE];
-
-    // open input file
-    WavInFile inFile(inFileName);
-    int sampleRate = inFile.getSampleRate();
-    int bits = inFile.getNumBits();
-    nChannels = inFile.getNumChannels();
-
-    // create output file
-    WavOutFile outFile(outFileName, sampleRate, bits, nChannels);
-
-    pSoundTouch->setSampleRate(sampleRate);
-    pSoundTouch->setChannels(nChannels);
-
-    assert(nChannels > 0);
-    buffSizeSamples = BUFF_SIZE / nChannels;
-
-    // Process samples read from the input file
-    while (inFile.eof() == 0)
-    {
-        int num;
-
-        // Read a chunk of samples from the input file
-        num = inFile.read(sampleBuffer, BUFF_SIZE);
-        nSamples = num / nChannels;
-
-        // Feed the samples into SoundTouch processor
-        pSoundTouch->putSamples(sampleBuffer, nSamples);
-
-        // Read ready samples from SoundTouch processor & write them output file.
-        // NOTES:
-        // - 'receiveSamples' doesn't necessarily return any samples at all
-        //   during some rounds!
-        // - On the other hand, during some round 'receiveSamples' may have more
-        //   ready samples than would fit into 'sampleBuffer', and for this reason
-        //   the 'receiveSamples' call is iterated for as many times as it
-        //   outputs samples.
-        do
-        {
-            nSamples = pSoundTouch->receiveSamples(sampleBuffer, buffSizeSamples);
-            outFile.write(sampleBuffer, nSamples * nChannels);
-        } while (nSamples != 0);
-    }
-
-    // Now the input file is processed, yet 'flush' few last samples that are
-    // hiding in the SoundTouch's internal processing pipeline.
-    pSoundTouch->flush();
-    do
-    {
-        nSamples = pSoundTouch->receiveSamples(sampleBuffer, buffSizeSamples);
-        outFile.write(sampleBuffer, nSamples * nChannels);
-    } while (nSamples != 0);
-}
-
-
-
-extern "C" DLL_PUBLIC jstring Java_net_surina_soundtouch_SoundTouch_getVersionString(JNIEnv *env, jobject thiz)
-{
-    const char *verStr;
-
-    LOGV("JNI call SoundTouch.getVersionString");
-
-    // Call example SoundTouch routine
-    verStr = SoundTouch::getVersionString();
-
-    // gomp_tls storage bug workaround - see comments in _init_threading() function!
-    // update: apparently this is not needed any more with concurrent Android SDKs
-    // _init_threading(false);
-
-    int threads = 0;
-	#pragma omp parallel
-    {
-		#pragma omp atomic
-    	threads ++;
-    }
-    LOGV("JNI thread count %d", threads);
-
-    // return version as string
-    return env->NewStringUTF(verStr);
-}
-
-
-
-extern "C" DLL_PUBLIC jlong Java_net_surina_soundtouch_SoundTouch_newInstance(JNIEnv *env, jobject thiz)
-{
-	return (jlong)(new SoundTouch());
-}
-
-
-extern "C" DLL_PUBLIC void Java_net_surina_soundtouch_SoundTouch_deleteInstance(JNIEnv *env, jobject thiz, jlong handle)
-{
-	SoundTouch *ptr = (SoundTouch*)handle;
-	delete ptr;
-}
-
-
-extern "C" DLL_PUBLIC void Java_net_surina_soundtouch_SoundTouch_setTempo(JNIEnv *env, jobject thiz, jlong handle, jfloat tempo)
-{
-	SoundTouch *ptr = (SoundTouch*)handle;
-	ptr->setTempo(tempo);
-}
-
-
-extern "C" DLL_PUBLIC void Java_net_surina_soundtouch_SoundTouch_setPitchSemiTones(JNIEnv *env, jobject thiz, jlong handle, jfloat pitch)
-{
-	SoundTouch *ptr = (SoundTouch*)handle;
-	ptr->setPitchSemiTones(pitch);
-}
-
-
-extern "C" DLL_PUBLIC void Java_net_surina_soundtouch_SoundTouch_setSpeed(JNIEnv *env, jobject thiz, jlong handle, jfloat speed)
-{
-	SoundTouch *ptr = (SoundTouch*)handle;
-	ptr->setRate(speed);
-}
-
-
-extern "C" DLL_PUBLIC jstring Java_net_surina_soundtouch_SoundTouch_getErrorString(JNIEnv *env, jobject thiz)
-{
-	jstring result = env->NewStringUTF(_errMsg.c_str());
-	_errMsg.clear();
-
-	return result;
-}
-
-
-extern "C" DLL_PUBLIC int Java_net_surina_soundtouch_SoundTouch_processFile(JNIEnv *env, jobject thiz, jlong handle, jstring jinputFile, jstring joutputFile)
-{
-	SoundTouch *ptr = (SoundTouch*)handle;
-
-	const char *inputFile = env->GetStringUTFChars(jinputFile, 0);
-	const char *outputFile = env->GetStringUTFChars(joutputFile, 0);
-
-	LOGV("JNI process file %s", inputFile);
-
-    /// gomp_tls storage bug workaround - see comments in _init_threading() function!
-    // update: apparently this is not needed any more with concurrent Android SDKs
-    // if (_init_threading(true)) return -1;
-
-	try
-	{
-		_processFile(ptr, inputFile, outputFile);
-	}
-	catch (const runtime_error &e)
-    {
-		const char *err = e.what();
-        // An exception occurred during processing, return the error message
-    	LOGV("JNI exception in SoundTouch::processFile: %s", err);
-        _setErrmsg(err);
-        return -1;
-    }
-
-
-	env->ReleaseStringUTFChars(jinputFile, inputFile);
-	env->ReleaseStringUTFChars(joutputFile, outputFile);
-
-	return 0;
-}
+////////////////////////////////////////////////////////////////////////////////
+///
+/// Example Interface class for SoundTouch native compilation
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// WWW           : http://www.surina.net
+///
+////////////////////////////////////////////////////////////////////////////////
+
+#include 
+#include 
+#include 
+#include 
+
+using namespace std;
+
+#include "../../../include/SoundTouch.h"
+#include "../source/SoundStretch/WavFile.h"
+
+#define LOGV(...)   __android_log_print((int)ANDROID_LOG_INFO, "SOUNDTOUCH", __VA_ARGS__)
+//#define LOGV(...)
+
+
+// String for keeping possible c++ exception error messages. Notice that this isn't
+// thread-safe but it's expected that exceptions are special situations that won't
+// occur in several threads in parallel.
+static string _errMsg = "";
+
+
+#define DLL_PUBLIC __attribute__ ((visibility ("default")))
+#define BUFF_SIZE 4096
+
+
+using namespace soundtouch;
+
+
+// Set error message to return
+static void _setErrmsg(const char *msg)
+{
+	_errMsg = msg;
+}
+
+#if 0   // apparently following workaround not needed any more with concurrent Android SDKs
+#ifdef _OPENMP
+
+#include 
+extern pthread_key_t gomp_tls_key;
+static void * _p_gomp_tls = nullptr;
+
+/// Function to initialize threading for OpenMP.
+///
+/// This is a workaround for bug in Android NDK v10 regarding OpenMP: OpenMP works only if
+/// called from the Android App main thread because in the main thread the gomp_tls storage is
+/// properly set, however, Android does not properly initialize gomp_tls storage for other threads.
+/// Thus if OpenMP routines are invoked from some other thread than the main thread,
+/// the OpenMP routine will crash the application due to nullptr access on uninitialized storage.
+///
+/// This workaround stores the gomp_tls storage from main thread, and copies to other threads.
+/// In order this to work, the Application main thread needws to call at least "getVersionString"
+/// routine.
+static int _init_threading(bool warn)
+{
+	void *ptr = pthread_getspecific(gomp_tls_key);
+	LOGV("JNI thread-specific TLS storage %ld", (long)ptr);
+	if (ptr == nullptr)
+	{
+		LOGV("JNI set missing TLS storage to %ld", (long)_p_gomp_tls);
+		pthread_setspecific(gomp_tls_key, _p_gomp_tls);
+	}
+	else
+	{
+		LOGV("JNI store this TLS storage");
+		_p_gomp_tls = ptr;
+	}
+	// Where critical, show warning if storage still not properly initialized
+	if ((warn) && (_p_gomp_tls == nullptr))
+	{
+		_setErrmsg("Error - OpenMP threading not properly initialized: Call SoundTouch.getVersionString() from the App main thread!");
+		return -1;
+	}
+	return 0;
+}
+
+#else
+static int _init_threading(bool warn)
+{
+	// do nothing if not OpenMP build
+	return 0;
+}
+#endif
+
+#endif
+
+// Processes the sound file
+static void _processFile(SoundTouch *pSoundTouch, const char *inFileName, const char *outFileName)
+{
+    int nSamples;
+    int nChannels;
+    int buffSizeSamples;
+    SAMPLETYPE sampleBuffer[BUFF_SIZE];
+
+    // open input file
+    WavInFile inFile(inFileName);
+    int sampleRate = inFile.getSampleRate();
+    int bits = inFile.getNumBits();
+    nChannels = inFile.getNumChannels();
+
+    // create output file
+    WavOutFile outFile(outFileName, sampleRate, bits, nChannels);
+
+    pSoundTouch->setSampleRate(sampleRate);
+    pSoundTouch->setChannels(nChannels);
+
+    assert(nChannels > 0);
+    buffSizeSamples = BUFF_SIZE / nChannels;
+
+    // Process samples read from the input file
+    while (inFile.eof() == 0)
+    {
+        int num;
+
+        // Read a chunk of samples from the input file
+        num = inFile.read(sampleBuffer, BUFF_SIZE);
+        nSamples = num / nChannels;
+
+        // Feed the samples into SoundTouch processor
+        pSoundTouch->putSamples(sampleBuffer, nSamples);
+
+        // Read ready samples from SoundTouch processor & write them output file.
+        // NOTES:
+        // - 'receiveSamples' doesn't necessarily return any samples at all
+        //   during some rounds!
+        // - On the other hand, during some round 'receiveSamples' may have more
+        //   ready samples than would fit into 'sampleBuffer', and for this reason
+        //   the 'receiveSamples' call is iterated for as many times as it
+        //   outputs samples.
+        do
+        {
+            nSamples = pSoundTouch->receiveSamples(sampleBuffer, buffSizeSamples);
+            outFile.write(sampleBuffer, nSamples * nChannels);
+        } while (nSamples != 0);
+    }
+
+    // Now the input file is processed, yet 'flush' few last samples that are
+    // hiding in the SoundTouch's internal processing pipeline.
+    pSoundTouch->flush();
+    do
+    {
+        nSamples = pSoundTouch->receiveSamples(sampleBuffer, buffSizeSamples);
+        outFile.write(sampleBuffer, nSamples * nChannels);
+    } while (nSamples != 0);
+}
+
+
+
+extern "C" DLL_PUBLIC jstring Java_net_surina_soundtouch_SoundTouch_getVersionString(JNIEnv *env, jobject thiz)
+{
+    const char *verStr;
+
+    LOGV("JNI call SoundTouch.getVersionString");
+
+    // Call example SoundTouch routine
+    verStr = SoundTouch::getVersionString();
+
+    // gomp_tls storage bug workaround - see comments in _init_threading() function!
+    // update: apparently this is not needed any more with concurrent Android SDKs
+    // _init_threading(false);
+
+    int threads = 0;
+	#pragma omp parallel
+    {
+		#pragma omp atomic
+    	threads ++;
+    }
+    LOGV("JNI thread count %d", threads);
+
+    // return version as string
+    return env->NewStringUTF(verStr);
+}
+
+
+
+extern "C" DLL_PUBLIC jlong Java_net_surina_soundtouch_SoundTouch_newInstance(JNIEnv *env, jobject thiz)
+{
+	return (jlong)(new SoundTouch());
+}
+
+
+extern "C" DLL_PUBLIC void Java_net_surina_soundtouch_SoundTouch_deleteInstance(JNIEnv *env, jobject thiz, jlong handle)
+{
+	SoundTouch *ptr = (SoundTouch*)handle;
+	delete ptr;
+}
+
+
+extern "C" DLL_PUBLIC void Java_net_surina_soundtouch_SoundTouch_setTempo(JNIEnv *env, jobject thiz, jlong handle, jfloat tempo)
+{
+	SoundTouch *ptr = (SoundTouch*)handle;
+	ptr->setTempo(tempo);
+}
+
+
+extern "C" DLL_PUBLIC void Java_net_surina_soundtouch_SoundTouch_setPitchSemiTones(JNIEnv *env, jobject thiz, jlong handle, jfloat pitch)
+{
+	SoundTouch *ptr = (SoundTouch*)handle;
+	ptr->setPitchSemiTones(pitch);
+}
+
+
+extern "C" DLL_PUBLIC void Java_net_surina_soundtouch_SoundTouch_setSpeed(JNIEnv *env, jobject thiz, jlong handle, jfloat speed)
+{
+	SoundTouch *ptr = (SoundTouch*)handle;
+	ptr->setRate(speed);
+}
+
+
+extern "C" DLL_PUBLIC jstring Java_net_surina_soundtouch_SoundTouch_getErrorString(JNIEnv *env, jobject thiz)
+{
+	jstring result = env->NewStringUTF(_errMsg.c_str());
+	_errMsg.clear();
+
+	return result;
+}
+
+
+extern "C" DLL_PUBLIC int Java_net_surina_soundtouch_SoundTouch_processFile(JNIEnv *env, jobject thiz, jlong handle, jstring jinputFile, jstring joutputFile)
+{
+	SoundTouch *ptr = (SoundTouch*)handle;
+
+	const char *inputFile = env->GetStringUTFChars(jinputFile, 0);
+	const char *outputFile = env->GetStringUTFChars(joutputFile, 0);
+
+	LOGV("JNI process file %s", inputFile);
+
+    /// gomp_tls storage bug workaround - see comments in _init_threading() function!
+    // update: apparently this is not needed any more with concurrent Android SDKs
+    // if (_init_threading(true)) return -1;
+
+	try
+	{
+		_processFile(ptr, inputFile, outputFile);
+	}
+	catch (const runtime_error &e)
+    {
+		const char *err = e.what();
+        // An exception occurred during processing, return the error message
+    	LOGV("JNI exception in SoundTouch::processFile: %s", err);
+        _setErrmsg(err);
+        return -1;
+    }
+
+
+	env->ReleaseStringUTFChars(jinputFile, inputFile);
+	env->ReleaseStringUTFChars(joutputFile, outputFile);
+
+	return 0;
+}
diff --git a/source/Makefile.am b/source/Makefile.am
index 8463069..ce2b5dc 100644
--- a/source/Makefile.am
+++ b/source/Makefile.am
@@ -1,24 +1,24 @@
-## Process this file with automake to create Makefile.in
-##
-## This file is part of SoundTouch, an audio processing library for pitch/time adjustments
-##
-## SoundTouch 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.
-##
-## SoundTouch is distributed in the hope that it will be useful, but WITHOUT ANY
-## WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-## A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-##
-## You should have received a copy of the GNU General Public License along with
-## this program; if not, write to the Free Software Foundation, Inc., 59 Temple
-## Place - Suite 330, Boston, MA  02111-1307, USA
-
-include $(top_srcdir)/config/am_include.mk
-
-SUBDIRS=SoundTouch SoundStretch SoundTouchDLL
-
-# set to something if you want other stuff to be included in the distribution tarball
-#EXTRA_DIST=
-
+## Process this file with automake to create Makefile.in
+##
+## This file is part of SoundTouch, an audio processing library for pitch/time adjustments
+##
+## SoundTouch 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.
+##
+## SoundTouch is distributed in the hope that it will be useful, but WITHOUT ANY
+## WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+## A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+##
+## You should have received a copy of the GNU General Public License along with
+## this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+## Place - Suite 330, Boston, MA  02111-1307, USA
+
+include $(top_srcdir)/config/am_include.mk
+
+SUBDIRS=SoundTouch SoundStretch SoundTouchDLL
+
+# set to something if you want other stuff to be included in the distribution tarball
+#EXTRA_DIST=
+
diff --git a/source/SoundStretch/Makefile.am b/source/SoundStretch/Makefile.am
index a21d4dc..5c08155 100644
--- a/source/SoundStretch/Makefile.am
+++ b/source/SoundStretch/Makefile.am
@@ -1,50 +1,50 @@
-## Process this file with automake to create Makefile.in
-##
-## This file is part of SoundTouch, an audio processing library for pitch/time adjustments
-##
-## SoundTouch 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.
-##
-## SoundTouch is distributed in the hope that it will be useful, but WITHOUT ANY
-## WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-## A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-##
-## You should have received a copy of the GNU General Public License along with
-## this program; if not, write to the Free Software Foundation, Inc., 59 Temple
-## Place - Suite 330, Boston, MA  02111-1307, USA
-
-include $(top_srcdir)/config/am_include.mk
-
-
-## bin_PROGRAMS is the macro that tells automake the name of the programs to
-## install in the bin directory (/usr/local/bin) by default. By setting
-## --prefix= at configure time the user can change this (eg: ./configure
-## --prefix=/usr will install soundstretch under /usr/bin/soundstretch )
-bin_PROGRAMS=soundstretch
-
-noinst_HEADERS=RunParameters.h WavFile.h
-
-# extra files to include in distribution tarball
-EXTRA_DIST=soundstretch.sln soundstretch.vcxproj
-
-## for every name listed under bin_PROGRAMS, you have a _SOURCES. This lists
-## all the sources in the current directory that are used to build soundstretch.
-soundstretch_SOURCES=main.cpp RunParameters.cpp WavFile.cpp
-
-## soundstretch_LDADD is a list of extras to pass at link time. All the objects
-## created by the above soundstretch_SOURCES are automatically linked in, so here I
-## list object files from other directories as well as flags passed to the
-## linker.
-soundstretch_LDADD=../SoundTouch/libSoundTouch.la -lm
-
-## linker flags.
-# Linker flag -s disabled to prevent stripping symbols by default
-#soundstretch_LDFLAGS=-s
-
-## additional compiler flags
-soundstretch_CXXFLAGS=$(AM_CXXFLAGS)
-
-#clean-local:
-#	-rm -f additional-files-to-remove-on-make-clean
+## Process this file with automake to create Makefile.in
+##
+## This file is part of SoundTouch, an audio processing library for pitch/time adjustments
+##
+## SoundTouch 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.
+##
+## SoundTouch is distributed in the hope that it will be useful, but WITHOUT ANY
+## WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+## A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+##
+## You should have received a copy of the GNU General Public License along with
+## this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+## Place - Suite 330, Boston, MA  02111-1307, USA
+
+include $(top_srcdir)/config/am_include.mk
+
+
+## bin_PROGRAMS is the macro that tells automake the name of the programs to
+## install in the bin directory (/usr/local/bin) by default. By setting
+## --prefix= at configure time the user can change this (eg: ./configure
+## --prefix=/usr will install soundstretch under /usr/bin/soundstretch )
+bin_PROGRAMS=soundstretch
+
+noinst_HEADERS=RunParameters.h WavFile.h
+
+# extra files to include in distribution tarball
+EXTRA_DIST=soundstretch.sln soundstretch.vcxproj
+
+## for every name listed under bin_PROGRAMS, you have a _SOURCES. This lists
+## all the sources in the current directory that are used to build soundstretch.
+soundstretch_SOURCES=main.cpp RunParameters.cpp WavFile.cpp
+
+## soundstretch_LDADD is a list of extras to pass at link time. All the objects
+## created by the above soundstretch_SOURCES are automatically linked in, so here I
+## list object files from other directories as well as flags passed to the
+## linker.
+soundstretch_LDADD=../SoundTouch/libSoundTouch.la -lm
+
+## linker flags.
+# Linker flag -s disabled to prevent stripping symbols by default
+#soundstretch_LDFLAGS=-s
+
+## additional compiler flags
+soundstretch_CXXFLAGS=$(AM_CXXFLAGS)
+
+#clean-local:
+#	-rm -f additional-files-to-remove-on-make-clean
diff --git a/source/SoundStretch/RunParameters.cpp b/source/SoundStretch/RunParameters.cpp
index 0b8cb23..495478f 100644
--- a/source/SoundStretch/RunParameters.cpp
+++ b/source/SoundStretch/RunParameters.cpp
@@ -1,292 +1,292 @@
-////////////////////////////////////////////////////////////////////////////////
-///
-/// A class for parsing the 'soundstretch' application command line parameters
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include 
-#include 
-
-#include "RunParameters.h"
-
-using namespace std;
-
-namespace soundstretch
-{
-
-// Program usage instructions 
-
-static const char licenseText[] =
-    "    LICENSE:\n"
-    "    ========\n"
-    "    \n"
-    "    SoundTouch sound processing library\n"
-    "    Copyright (c) Olli Parviainen\n"
-    "    \n"
-    "    This library is free software; you can redistribute it and/or\n"
-    "    modify it under the terms of the GNU Lesser General Public\n"
-    "    License version 2.1 as published by the Free Software Foundation.\n"
-    "    \n"
-    "    This library is distributed in the hope that it will be useful,\n"
-    "    but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
-    "    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
-    "    Lesser General Public License for more details.\n"
-    "    \n"
-    "    You should have received a copy of the GNU Lesser General Public\n"
-    "    License along with this library; if not, write to the Free Software\n"
-    "    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
-    "    \n"
-    "This application is distributed with full source codes; however, if you\n"
-    "didn't receive them, please visit the author's homepage (see the link above).";
-
-static const char whatText[] =
-    "This application processes WAV audio files by modifying the sound tempo,\n"
-    "pitch and playback rate properties independently from each other.\n"
-    "\n";
-
-static const char usage[] =
-    "Usage :\n"
-    "    soundstretch infilename outfilename [switches]\n"
-    "\n"
-    "To use standard input/output pipes, give 'stdin' and 'stdout' as filenames.\n"
-    "\n"
-    "Available switches are:\n"
-    "  -tempo=n : Change sound tempo by n percents  (n=-95..+5000 %)\n"
-    "  -pitch=n : Change sound pitch by n semitones (n=-60..+60 semitones)\n"
-    "  -rate=n  : Change sound rate by n percents   (n=-95..+5000 %)\n"
-    "  -bpm=n   : Detect the BPM rate of sound and adjust tempo to meet 'n' BPMs.\n"
-    "             If '=n' is omitted, just detects the BPM rate.\n"
-    "  -quick   : Use quicker tempo change algorithm (gain speed, lose quality)\n"
-    "  -naa     : Don't use anti-alias filtering (gain speed, lose quality)\n"
-    "  -speech  : Tune algorithm for speech processing (default is for music)\n"
-    "  -license : Display the program license text (LGPL)\n";
-
-
-// Converts a char into lower case
-static int _toLowerCase(int c)
-{
-    if (c >= 'A' && c <= 'Z') 
-    {
-        c += 'a' - 'A';
-    }
-    return c;
-}
-
-// Constructor
-RunParameters::RunParameters(int nParams, const CHARTYPE* paramStr[])
-{
-    int i;
-    int nFirstParam;
-
-    if (nParams < 3) 
-    {
-        // Too few parameters
-        if (nParams > 1 && paramStr[1][0] == '-' && 
-            _toLowerCase(paramStr[1][1]) == 'l') 
-        {
-            // '-license' switch
-            throwLicense();
-        }
-        string msg = whatText;
-        msg += usage;
-        throw(msg);
-    }
-
-    // Get input & output file names
-    inFileName = paramStr[1];
-    outFileName = paramStr[2];
-
-    if (outFileName[0] == '-')
-    {
-        // outputfile name was omitted but other parameter switches given instead
-        outFileName = STRING_CONST("");
-        nFirstParam = 2;
-    }
-    else
-    {
-        nFirstParam = 3;
-    }
-
-    // parse switch parameters
-    for (i = nFirstParam; i < nParams; i ++) 
-    {
-        parseSwitchParam(paramStr[i]);
-    }
-
-    checkLimits();
-}
-
-
-// Checks parameter limits
-void RunParameters::checkLimits()
-{
-    if (tempoDelta < -95.0f) 
-    {
-        tempoDelta = -95.0f;
-    } 
-    else if (tempoDelta > 5000.0f) 
-    {
-        tempoDelta = 5000.0f;
-    }
-
-    if (pitchDelta < -60.0f) 
-    {
-        pitchDelta = -60.0f;
-    } 
-    else if (pitchDelta > 60.0f) 
-    {
-        pitchDelta = 60.0f;
-    }
-
-    if (rateDelta < -95.0f) 
-    {
-        rateDelta = -95.0f;
-    } 
-    else if (rateDelta > 5000.0f) 
-    {
-        rateDelta = 5000.0f;
-    }
-}
-
-// Convert STRING to std::string. Actually needed only if STRING is std::wstring, but conversion penalty is negligible
-std::string convertString(const STRING& str)
-{
-    std::string res;
-    for (auto c : str)
-    {
-        res += (char)c;
-    }
-    return res;
-}
-
-// Unknown switch parameter -- throws an exception with an error message
-void RunParameters::throwIllegalParamExp(const STRING &str) const
-{
-    string msg = "ERROR : Illegal parameter \"";
-    msg += convertString(str);
-    msg += "\".\n\n";
-    msg += usage;
-    ST_THROW_RT_ERROR(msg);
-}
-
-void RunParameters::throwLicense() const
-{
-    ST_THROW_RT_ERROR(licenseText);
-}
-
-float RunParameters::parseSwitchValue(const STRING& str) const
-{
-    int pos;
-
-    pos = (int)str.find_first_of('=');
-    if (pos < 0) 
-    {
-        // '=' missing
-        throwIllegalParamExp(str);
-    }
-
-    // Read numerical parameter value after '='
-    return (float)stof(str.substr(pos + 1).c_str());
-}
-
-
-// Interprets a single switch parameter string of format "-switch=xx"
-// Valid switches are "-tempo=xx", "-pitch=xx" and "-rate=xx". Stores
-// switch values into 'params' structure.
-void RunParameters::parseSwitchParam(const STRING& str)
-{
-    int upS;
-
-    if (str[0] != '-') 
-    {
-        // leading hyphen missing => not a valid parameter
-        throwIllegalParamExp(str);
-    }
-
-    // Take the first character of switch name & change to lower case
-    upS = _toLowerCase(str[1]);
-
-    // interpret the switch name & operate accordingly
-    switch (upS) 
-    {
-        case 't' :
-            // switch '-tempo=xx'
-            tempoDelta = parseSwitchValue(str);
-            break;
-
-        case 'p' :
-            // switch '-pitch=xx'
-            pitchDelta = parseSwitchValue(str);
-            break;
-
-        case 'r' :
-            // switch '-rate=xx'
-            rateDelta = parseSwitchValue(str);
-            break;
-
-        case 'b' :
-            // switch '-bpm=xx'
-            detectBPM = true;
-            try
-            {
-                goalBPM = parseSwitchValue(str);
-            } 
-            catch (const runtime_error &)
-            {
-                // illegal or missing bpm value => just calculate bpm
-                goalBPM = 0;
-            }
-            break;
-
-        case 'q' :
-            // switch '-quick'
-            quick = 1;
-            break;
-
-        case 'n' :
-            // switch '-naa'
-            noAntiAlias = 1;
-            break;
-
-        case 'l' :
-            // switch '-license'
-            throwLicense();
-            break;
-
-        case 's' :
-            // switch '-speech'
-            speech = true;
-            break;
-
-        default:
-            // unknown switch
-            throwIllegalParamExp(str);
-    }
-}
-
-}
+////////////////////////////////////////////////////////////////////////////////
+///
+/// A class for parsing the 'soundstretch' application command line parameters
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#include 
+#include 
+
+#include "RunParameters.h"
+
+using namespace std;
+
+namespace soundstretch
+{
+
+// Program usage instructions
+
+static const char licenseText[] =
+    "    LICENSE:\n"
+    "    ========\n"
+    "    \n"
+    "    SoundTouch sound processing library\n"
+    "    Copyright (c) Olli Parviainen\n"
+    "    \n"
+    "    This library is free software; you can redistribute it and/or\n"
+    "    modify it under the terms of the GNU Lesser General Public\n"
+    "    License version 2.1 as published by the Free Software Foundation.\n"
+    "    \n"
+    "    This library is distributed in the hope that it will be useful,\n"
+    "    but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
+    "    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
+    "    Lesser General Public License for more details.\n"
+    "    \n"
+    "    You should have received a copy of the GNU Lesser General Public\n"
+    "    License along with this library; if not, write to the Free Software\n"
+    "    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n"
+    "    \n"
+    "This application is distributed with full source codes; however, if you\n"
+    "didn't receive them, please visit the author's homepage (see the link above).";
+
+static const char whatText[] =
+    "This application processes WAV audio files by modifying the sound tempo,\n"
+    "pitch and playback rate properties independently from each other.\n"
+    "\n";
+
+static const char usage[] =
+    "Usage :\n"
+    "    soundstretch infilename outfilename [switches]\n"
+    "\n"
+    "To use standard input/output pipes, give 'stdin' and 'stdout' as filenames.\n"
+    "\n"
+    "Available switches are:\n"
+    "  -tempo=n : Change sound tempo by n percents  (n=-95..+5000 %)\n"
+    "  -pitch=n : Change sound pitch by n semitones (n=-60..+60 semitones)\n"
+    "  -rate=n  : Change sound rate by n percents   (n=-95..+5000 %)\n"
+    "  -bpm=n   : Detect the BPM rate of sound and adjust tempo to meet 'n' BPMs.\n"
+    "             If '=n' is omitted, just detects the BPM rate.\n"
+    "  -quick   : Use quicker tempo change algorithm (gain speed, lose quality)\n"
+    "  -naa     : Don't use anti-alias filtering (gain speed, lose quality)\n"
+    "  -speech  : Tune algorithm for speech processing (default is for music)\n"
+    "  -license : Display the program license text (LGPL)\n";
+
+
+// Converts a char into lower case
+static int _toLowerCase(int c)
+{
+    if (c >= 'A' && c <= 'Z')
+    {
+        c += 'a' - 'A';
+    }
+    return c;
+}
+
+// Constructor
+RunParameters::RunParameters(int nParams, const CHARTYPE* paramStr[])
+{
+    int i;
+    int nFirstParam;
+
+    if (nParams < 3)
+    {
+        // Too few parameters
+        if (nParams > 1 && paramStr[1][0] == '-' &&
+            _toLowerCase(paramStr[1][1]) == 'l')
+        {
+            // '-license' switch
+            throwLicense();
+        }
+        string msg = whatText;
+        msg += usage;
+        throw(msg);
+    }
+
+    // Get input & output file names
+    inFileName = paramStr[1];
+    outFileName = paramStr[2];
+
+    if (outFileName[0] == '-')
+    {
+        // outputfile name was omitted but other parameter switches given instead
+        outFileName = STRING_CONST("");
+        nFirstParam = 2;
+    }
+    else
+    {
+        nFirstParam = 3;
+    }
+
+    // parse switch parameters
+    for (i = nFirstParam; i < nParams; i ++)
+    {
+        parseSwitchParam(paramStr[i]);
+    }
+
+    checkLimits();
+}
+
+
+// Checks parameter limits
+void RunParameters::checkLimits()
+{
+    if (tempoDelta < -95.0f)
+    {
+        tempoDelta = -95.0f;
+    }
+    else if (tempoDelta > 5000.0f)
+    {
+        tempoDelta = 5000.0f;
+    }
+
+    if (pitchDelta < -60.0f)
+    {
+        pitchDelta = -60.0f;
+    }
+    else if (pitchDelta > 60.0f)
+    {
+        pitchDelta = 60.0f;
+    }
+
+    if (rateDelta < -95.0f)
+    {
+        rateDelta = -95.0f;
+    }
+    else if (rateDelta > 5000.0f)
+    {
+        rateDelta = 5000.0f;
+    }
+}
+
+// Convert STRING to std::string. Actually needed only if STRING is std::wstring, but conversion penalty is negligible
+std::string convertString(const STRING& str)
+{
+    std::string res;
+    for (auto c : str)
+    {
+        res += (char)c;
+    }
+    return res;
+}
+
+// Unknown switch parameter -- throws an exception with an error message
+void RunParameters::throwIllegalParamExp(const STRING &str) const
+{
+    string msg = "ERROR : Illegal parameter \"";
+    msg += convertString(str);
+    msg += "\".\n\n";
+    msg += usage;
+    ST_THROW_RT_ERROR(msg);
+}
+
+void RunParameters::throwLicense() const
+{
+    ST_THROW_RT_ERROR(licenseText);
+}
+
+float RunParameters::parseSwitchValue(const STRING& str) const
+{
+    int pos;
+
+    pos = (int)str.find_first_of('=');
+    if (pos < 0)
+    {
+        // '=' missing
+        throwIllegalParamExp(str);
+    }
+
+    // Read numerical parameter value after '='
+    return (float)stof(str.substr(pos + 1).c_str());
+}
+
+
+// Interprets a single switch parameter string of format "-switch=xx"
+// Valid switches are "-tempo=xx", "-pitch=xx" and "-rate=xx". Stores
+// switch values into 'params' structure.
+void RunParameters::parseSwitchParam(const STRING& str)
+{
+    int upS;
+
+    if (str[0] != '-')
+    {
+        // leading hyphen missing => not a valid parameter
+        throwIllegalParamExp(str);
+    }
+
+    // Take the first character of switch name & change to lower case
+    upS = _toLowerCase(str[1]);
+
+    // interpret the switch name & operate accordingly
+    switch (upS)
+    {
+        case 't' :
+            // switch '-tempo=xx'
+            tempoDelta = parseSwitchValue(str);
+            break;
+
+        case 'p' :
+            // switch '-pitch=xx'
+            pitchDelta = parseSwitchValue(str);
+            break;
+
+        case 'r' :
+            // switch '-rate=xx'
+            rateDelta = parseSwitchValue(str);
+            break;
+
+        case 'b' :
+            // switch '-bpm=xx'
+            detectBPM = true;
+            try
+            {
+                goalBPM = parseSwitchValue(str);
+            }
+            catch (const runtime_error &)
+            {
+                // illegal or missing bpm value => just calculate bpm
+                goalBPM = 0;
+            }
+            break;
+
+        case 'q' :
+            // switch '-quick'
+            quick = 1;
+            break;
+
+        case 'n' :
+            // switch '-naa'
+            noAntiAlias = 1;
+            break;
+
+        case 'l' :
+            // switch '-license'
+            throwLicense();
+            break;
+
+        case 's' :
+            // switch '-speech'
+            speech = true;
+            break;
+
+        default:
+            // unknown switch
+            throwIllegalParamExp(str);
+    }
+}
+
+}
diff --git a/source/SoundStretch/RunParameters.h b/source/SoundStretch/RunParameters.h
index 839d27f..2db36b4 100644
--- a/source/SoundStretch/RunParameters.h
+++ b/source/SoundStretch/RunParameters.h
@@ -1,70 +1,70 @@
-////////////////////////////////////////////////////////////////////////////////
-///
-/// A class for parsing the 'soundstretch' application command line parameters
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef RUNPARAMETERS_H
-#define RUNPARAMETERS_H
-
-#include 
-#include "STTypes.h"
-#include "SS_CharTypes.h"
-#include "WavFile.h"
-
-namespace soundstretch
-{
-
-/// Parses command line parameters into program parameters
-class RunParameters
-{
-private:
-    void throwIllegalParamExp(const STRING& str) const;
-    void throwLicense() const;
-    void parseSwitchParam(const STRING& str);
-    void checkLimits();
-    float parseSwitchValue(const STRING& tr) const;
-
-public:
-    STRING inFileName;
-    STRING outFileName;
-    float tempoDelta{ 0 };
-    float pitchDelta{ 0 };
-    float rateDelta{ 0 };
-    int   quick{ 0 };
-    int   noAntiAlias{ 0 };
-    float goalBPM{ 0 };
-    bool  detectBPM{ false };
-    bool  speech{ false };
-
-    RunParameters(int nParams, const CHARTYPE* paramStr[]);
-};
-
-}
-
-#endif
+////////////////////////////////////////////////////////////////////////////////
+///
+/// A class for parsing the 'soundstretch' application command line parameters
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef RUNPARAMETERS_H
+#define RUNPARAMETERS_H
+
+#include 
+#include "STTypes.h"
+#include "SS_CharTypes.h"
+#include "WavFile.h"
+
+namespace soundstretch
+{
+
+/// Parses command line parameters into program parameters
+class RunParameters
+{
+private:
+    void throwIllegalParamExp(const STRING& str) const;
+    void throwLicense() const;
+    void parseSwitchParam(const STRING& str);
+    void checkLimits();
+    float parseSwitchValue(const STRING& tr) const;
+
+public:
+    STRING inFileName;
+    STRING outFileName;
+    float tempoDelta{ 0 };
+    float pitchDelta{ 0 };
+    float rateDelta{ 0 };
+    int   quick{ 0 };
+    int   noAntiAlias{ 0 };
+    float goalBPM{ 0 };
+    bool  detectBPM{ false };
+    bool  speech{ false };
+
+    RunParameters(int nParams, const CHARTYPE* paramStr[]);
+};
+
+}
+
+#endif
diff --git a/source/SoundStretch/SS_CharTypes.h b/source/SoundStretch/SS_CharTypes.h
index ad4ce4a..e720819 100644
--- a/source/SoundStretch/SS_CharTypes.h
+++ b/source/SoundStretch/SS_CharTypes.h
@@ -1,52 +1,52 @@
-////////////////////////////////////////////////////////////////////////////////
-///
-/// Char type for SoundStretch
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef SS_CHARTYPE_H
-#define SS_CHARTYPE_H
-
-#include 
-
-namespace soundstretch
-{
-#if _WIN32
-    // wide-char types for supporting non-latin file paths in Windows
-    using CHARTYPE = wchar_t;
-    using STRING = std::wstring;
-    #define STRING_CONST(x) (L"" x)
-#else
-    // gnu platform can natively support UTF-8 paths using "char*" set
-    using CHARTYPE = char;
-    using STRING = std::string;
-    #define STRING_CONST(x) (x)
-#endif
-}
-
-#endif //SS_CHARTYPE_H
+////////////////////////////////////////////////////////////////////////////////
+///
+/// Char type for SoundStretch
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef SS_CHARTYPE_H
+#define SS_CHARTYPE_H
+
+#include 
+
+namespace soundstretch
+{
+#if _WIN32
+    // wide-char types for supporting non-latin file paths in Windows
+    using CHARTYPE = wchar_t;
+    using STRING = std::wstring;
+    #define STRING_CONST(x) (L"" x)
+#else
+    // gnu platform can natively support UTF-8 paths using "char*" set
+    using CHARTYPE = char;
+    using STRING = std::string;
+    #define STRING_CONST(x) (x)
+#endif
+}
+
+#endif //SS_CHARTYPE_H
diff --git a/source/SoundStretch/WavFile.cpp b/source/SoundStretch/WavFile.cpp
index 0880668..3ed2077 100644
--- a/source/SoundStretch/WavFile.cpp
+++ b/source/SoundStretch/WavFile.cpp
@@ -1,984 +1,984 @@
- ////////////////////////////////////////////////////////////////////////////////
-///
-/// Classes for easy reading & writing of WAV sound files. 
-///
-/// For big-endian CPU, define _BIG_ENDIAN_ during compile-time to correctly
-/// parse the WAV files with such processors.
-/// 
-/// Admittingly, more complete WAV reader routines may exist in public domain,
-/// but the reason for 'yet another' one is that those generic WAV reader 
-/// libraries are exhaustingly large and cumbersome! Wanted to have something
-/// simpler here, i.e. something that's not already larger than rest of the
-/// SoundTouch/SoundStretch program...
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include 
-#include 
-#include 
-#include 
-#include 
-#include 
-
-#include "WavFile.h"
-#include "STTypes.h"
-
-using namespace std;
-
-namespace soundstretch
-{
-
-#if _WIN32
-#define FOPEN(name, mode) _wfopen(name, STRING_CONST(mode))
-#else
-#define FOPEN(name, mode) fopen(name, mode)
-#endif
-
-static const char riffStr[] = "RIFF";
-static const char waveStr[] = "WAVE";
-static const char fmtStr[] = "fmt ";
-static const char factStr[] = "fact";
-static const char dataStr[] = "data";
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// Helper functions for swapping byte order to correctly read/write WAV files 
-// with big-endian CPU's: Define compile-time definition _BIG_ENDIAN_ to
-// turn-on the conversion if it appears necessary. 
-//
-// For example, Intel x86 is little-endian and doesn't require conversion,
-// while PowerPC of Mac's and many other RISC cpu's are big-endian.
-
-#ifdef BYTE_ORDER
-// In gcc compiler detect the byte order automatically
-#if BYTE_ORDER == BIG_ENDIAN
-// big-endian platform.
-#define _BIG_ENDIAN_
-#endif
-#endif
-
-#ifdef _BIG_ENDIAN_
-// big-endian CPU, swap bytes in 16 & 32 bit words
-
-// helper-function to swap byte-order of 32bit integer
-static inline int _swap32(int& dwData)
-{
-    dwData = ((dwData >> 24) & 0x000000FF) |
-        ((dwData >> 8) & 0x0000FF00) |
-        ((dwData << 8) & 0x00FF0000) |
-        ((dwData << 24) & 0xFF000000);
-    return dwData;
-}
-
-// helper-function to swap byte-order of 16bit integer
-static inline short _swap16(short& wData)
-{
-    wData = ((wData >> 8) & 0x00FF) |
-        ((wData << 8) & 0xFF00);
-    return wData;
-}
-
-// helper-function to swap byte-order of buffer of 16bit integers
-static inline void _swap16Buffer(short* pData, int numWords)
-{
-    int i;
-
-    for (i = 0; i < numWords; i++)
-    {
-        pData[i] = _swap16(pData[i]);
-    }
-}
-
-#else   // BIG_ENDIAN
-// little-endian CPU, WAV file is ok as such
-
-// dummy helper-function
-static inline int _swap32(int& dwData)
-{
-    // do nothing
-    return dwData;
-}
-
-// dummy helper-function
-static inline short _swap16(short& wData)
-{
-    // do nothing
-    return wData;
-}
-
-// dummy helper-function
-static inline void _swap16Buffer(short*, int)
-{
-    // do nothing
-}
-
-#endif  // BIG_ENDIAN
-
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// Class WavFileBase
-//
-
-WavFileBase::WavFileBase()
-{
-    convBuff = nullptr;
-    convBuffSize = 0;
-}
-
-
-WavFileBase::~WavFileBase()
-{
-    delete[] convBuff;
-    convBuffSize = 0;
-}
-
-
-/// Get pointer to conversion buffer of at min. given size
-void* WavFileBase::getConvBuffer(int sizeBytes)
-{
-    if (convBuffSize < sizeBytes)
-    {
-        delete[] convBuff;
-
-        convBuffSize = (sizeBytes + 15) & -8;   // round up to following 8-byte bounday
-        convBuff = new char[convBuffSize];
-    }
-    return convBuff;
-}
-
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// Class WavInFile
-//
-
-WavInFile::WavInFile(const STRING& fileName)
-{
-    // Try to open the file for reading
-    fptr = FOPEN(fileName.c_str(), "rb");
-    if (fptr == nullptr)
-    {
-        ST_THROW_RT_ERROR("Error : Unable to open file for reading.");
-    }
-
-    init();
-}
-
-
-WavInFile::WavInFile(FILE* file)
-{
-    // Try to open the file for reading
-    fptr = file;
-    if (!file)
-    {
-        ST_THROW_RT_ERROR("Error : Unable to access input stream for reading");
-    }
-
-    init();
-}
-
-
-/// Init the WAV file stream
-void WavInFile::init()
-{
-    int hdrsOk;
-
-    // assume file stream is already open
-    assert(fptr);
-
-    // Read the file headers
-    hdrsOk = readWavHeaders();
-    if (hdrsOk != 0)
-    {
-        ST_THROW_RT_ERROR("Input file is corrupt or not a WAV file");
-    }
-
-    // sanity check for format parameters
-    if ((header.format.channel_number < 1) || (header.format.channel_number > 9) ||
-        (header.format.sample_rate < 4000) || (header.format.sample_rate > 192000) ||
-        (header.format.byte_per_sample < 1) || (header.format.byte_per_sample > 320) ||
-        (header.format.bits_per_sample < 8) || (header.format.bits_per_sample > 32))
-    {
-        ST_THROW_RT_ERROR("Error: Illegal wav file header format parameters.");
-    }
-
-    dataRead = 0;
-}
-
-
-WavInFile::~WavInFile()
-{
-    if (fptr) fclose(fptr);
-    fptr = nullptr;
-}
-
-
-void WavInFile::rewind()
-{
-    int hdrsOk;
-
-    fseek(fptr, 0, SEEK_SET);
-    hdrsOk = readWavHeaders();
-    assert(hdrsOk == 0);
-    dataRead = 0;
-}
-
-
-int WavInFile::checkCharTags() const
-{
-    // header.format.fmt should equal to 'fmt '
-    if (memcmp(fmtStr, header.format.fmt, 4) != 0) return -1;
-    // header.data.data_field should equal to 'data'
-    if (memcmp(dataStr, header.data.data_field, 4) != 0) return -1;
-
-    return 0;
-}
-
-
-int WavInFile::read(unsigned char* buffer, int maxElems)
-{
-    int numBytes;
-    uint afterDataRead;
-
-    // ensure it's 8 bit format
-    if (header.format.bits_per_sample != 8)
-    {
-        ST_THROW_RT_ERROR("Error: WavInFile::read(char*, int) works only with 8bit samples.");
-    }
-    assert(sizeof(char) == 1);
-
-    numBytes = maxElems;
-    afterDataRead = dataRead + numBytes;
-    if (afterDataRead > header.data.data_len)
-    {
-        // Don't read more samples than are marked available in header
-        numBytes = (int)header.data.data_len - (int)dataRead;
-        assert(numBytes >= 0);
-    }
-
-    assert(buffer);
-    numBytes = (int)fread(buffer, 1, numBytes, fptr);
-    dataRead += numBytes;
-
-    return numBytes;
-}
-
-
-int WavInFile::read(short* buffer, int maxElems)
-{
-    unsigned int afterDataRead;
-    int numBytes;
-    int numElems;
-
-    assert(buffer);
-    switch (header.format.bits_per_sample)
-    {
-    case 8:
-    {
-        // 8 bit format
-        unsigned char* temp = (unsigned char*)getConvBuffer(maxElems);
-        int i;
-
-        numElems = read(temp, maxElems);
-        // convert from 8 to 16 bit
-        for (i = 0; i < numElems; i++)
-        {
-            buffer[i] = (short)(((short)temp[i] - 128) * 256);
-        }
-        break;
-    }
-
-    case 16:
-    {
-        // 16 bit format
-
-        assert(sizeof(short) == 2);
-
-        numBytes = maxElems * 2;
-        afterDataRead = dataRead + numBytes;
-        if (afterDataRead > header.data.data_len)
-        {
-            // Don't read more samples than are marked available in header
-            numBytes = (int)header.data.data_len - (int)dataRead;
-            assert(numBytes >= 0);
-        }
-
-        numBytes = (int)fread(buffer, 1, numBytes, fptr);
-        dataRead += numBytes;
-        numElems = numBytes / 2;
-
-        // 16bit samples, swap byte order if necessary
-        _swap16Buffer((short*)buffer, numElems);
-        break;
-    }
-
-    default:
-    {
-        stringstream ss;
-        ss << "\nOnly 8/16 bit sample WAV files supported in integer compilation. Can't open WAV file with ";
-        ss << (int)header.format.bits_per_sample;
-        ss << " bit sample format. ";
-        ST_THROW_RT_ERROR(ss.str().c_str());
-    }
-    };
-
-    return numElems;
-}
-
-
-/// Read data in float format. Notice that when reading in float format 
-/// 8/16/24/32 bit sample formats are supported
-int WavInFile::read(float* buffer, int maxElems)
-{
-    unsigned int afterDataRead;
-    int numBytes;
-    int numElems;
-    int bytesPerSample;
-
-    assert(buffer);
-
-    bytesPerSample = header.format.bits_per_sample / 8;
-    if ((bytesPerSample < 1) || (bytesPerSample > 4))
-    {
-        stringstream ss;
-        ss << "\nOnly 8/16/24/32 bit sample WAV files supported. Can't open WAV file with ";
-        ss << (int)header.format.bits_per_sample;
-        ss << " bit sample format. ";
-        ST_THROW_RT_ERROR(ss.str().c_str());
-    }
-
-    numBytes = maxElems * bytesPerSample;
-    afterDataRead = dataRead + numBytes;
-    if (afterDataRead > header.data.data_len)
-    {
-        // Don't read more samples than are marked available in header
-        numBytes = (int)header.data.data_len - (int)dataRead;
-        assert(numBytes >= 0);
-    }
-
-    // read raw data into temporary buffer
-    char* temp = (char*)getConvBuffer(numBytes);
-    numBytes = (int)fread(temp, 1, numBytes, fptr);
-    dataRead += numBytes;
-
-    numElems = numBytes / bytesPerSample;
-
-    // swap byte ordert & convert to float, depending on sample format
-    switch (bytesPerSample)
-    {
-    case 1:
-    {
-        unsigned char* temp2 = (unsigned char*)temp;
-        double conv = 1.0 / 128.0;
-        for (int i = 0; i < numElems; i++)
-        {
-            buffer[i] = (float)(temp2[i] * conv - 1.0);
-        }
-        break;
-    }
-
-    case 2:
-    {
-        short* temp2 = (short*)temp;
-        double conv = 1.0 / 32768.0;
-        for (int i = 0; i < numElems; i++)
-        {
-            short value = temp2[i];
-            buffer[i] = (float)(_swap16(value) * conv);
-        }
-        break;
-    }
-
-    case 3:
-    {
-        char* temp2 = (char*)temp;
-        double conv = 1.0 / 8388608.0;
-        for (int i = 0; i < numElems; i++)
-        {
-            int value = *((int*)temp2);
-            value = _swap32(value) & 0x00ffffff;             // take 24 bits
-            value |= (value & 0x00800000) ? 0xff000000 : 0;  // extend minus sign bits
-            buffer[i] = (float)(value * conv);
-            temp2 += 3;
-        }
-        break;
-    }
-
-    case 4:
-    {
-        int* temp2 = (int*)temp;
-        double conv = 1.0 / 2147483648.0;
-        assert(sizeof(int) == 4);
-        for (int i = 0; i < numElems; i++)
-        {
-            int value = temp2[i];
-            buffer[i] = (float)(_swap32(value) * conv);
-        }
-        break;
-    }
-    }
-
-    return numElems;
-}
-
-
-int WavInFile::eof() const
-{
-    // return true if all data has been read or file eof has reached
-    return ((uint)dataRead == header.data.data_len || feof(fptr));
-}
-
-
-// test if character code is between a white space ' ' and little 'z'
-static int isAlpha(char c)
-{
-    return (c >= ' ' && c <= 'z') ? 1 : 0;
-}
-
-
-// test if all characters are between a white space ' ' and little 'z'
-static int isAlphaStr(const char* str)
-{
-    char c;
-
-    c = str[0];
-    while (c)
-    {
-        if (isAlpha(c) == 0) return 0;
-        str++;
-        c = str[0];
-    }
-
-    return 1;
-}
-
-
-int WavInFile::readRIFFBlock()
-{
-    if (fread(&(header.riff), sizeof(WavRiff), 1, fptr) != 1) return -1;
-
-    // swap 32bit data byte order if necessary
-    _swap32((int&)header.riff.package_len);
-
-    // header.riff.riff_char should equal to 'RIFF');
-    if (memcmp(riffStr, header.riff.riff_char, 4) != 0) return -1;
-    // header.riff.wave should equal to 'WAVE'
-    if (memcmp(waveStr, header.riff.wave, 4) != 0) return -1;
-
-    return 0;
-}
-
-
-int WavInFile::readHeaderBlock()
-{
-    char label[5];
-    string sLabel;
-
-    // lead label string
-    if (fread(label, 1, 4, fptr) != 4) return -1;
-    label[4] = 0;
-
-    if (isAlphaStr(label) == 0) return -1;    // not a valid label
-
-    // Decode blocks according to their label
-    if (strcmp(label, fmtStr) == 0)
-    {
-        int nLen, nDump;
-
-        // 'fmt ' block 
-        memcpy(header.format.fmt, fmtStr, 4);
-
-        // read length of the format field
-        if (fread(&nLen, sizeof(int), 1, fptr) != 1) return -1;
-        // swap byte order if necessary
-        _swap32(nLen);
-
-        // calculate how much length differs from expected 
-        nDump = nLen - ((int)sizeof(header.format) - 8);
-
-        // verify that header length isn't smaller than expected structure
-        if ((nLen < 0) || (nDump < 0)) return -1;
-
-        header.format.format_len = nLen;
-
-        // if format_len is larger than expected, read only as much data as we've space for
-        if (nDump > 0)
-        {
-            nLen = sizeof(header.format) - 8;
-        }
-
-        // read data
-        if (fread(&(header.format.fixed), nLen, 1, fptr) != 1) return -1;
-
-        // swap byte order if necessary
-        _swap16((short&)header.format.fixed);            // short int fixed;
-        _swap16((short&)header.format.channel_number);   // short int channel_number;
-        _swap32((int&)header.format.sample_rate);        // int sample_rate;
-        _swap32((int&)header.format.byte_rate);          // int byte_rate;
-        _swap16((short&)header.format.byte_per_sample);  // short int byte_per_sample;
-        _swap16((short&)header.format.bits_per_sample);  // short int bits_per_sample;
-
-        // if format_len is larger than expected, skip the extra data
-        if (nDump > 0)
-        {
-            fseek(fptr, nDump, SEEK_CUR);
-        }
-
-        return 0;
-    }
-    else if (strcmp(label, factStr) == 0)
-    {
-        int nLen, nDump;
-
-        // 'fact' block 
-        memcpy(header.fact.fact_field, factStr, 4);
-
-        // read length of the fact field
-        if (fread(&nLen, sizeof(int), 1, fptr) != 1) return -1;
-        // swap byte order if necessary
-        _swap32(nLen);
-
-        // calculate how much length differs from expected
-        nDump = nLen - ((int)sizeof(header.fact) - 8);
-
-        // verify that fact length isn't smaller than expected structure
-        if ((nLen < 0) || (nDump < 0)) return -1;
-
-        header.fact.fact_len = nLen;
-
-        // if format_len is larger than expected, read only as much data as we've space for
-        if (nDump > 0)
-        {
-            nLen = sizeof(header.fact) - 8;
-        }
-
-        // read data
-        if (fread(&(header.fact.fact_sample_len), nLen, 1, fptr) != 1) return -1;
-
-        // swap byte order if necessary
-        _swap32((int&)header.fact.fact_sample_len);    // int sample_length;
-
-        // if fact_len is larger than expected, skip the extra data
-        if (nDump > 0)
-        {
-            fseek(fptr, nDump, SEEK_CUR);
-        }
-
-        return 0;
-    }
-    else if (strcmp(label, dataStr) == 0)
-    {
-        // 'data' block
-        memcpy(header.data.data_field, dataStr, 4);
-        if (fread(&(header.data.data_len), sizeof(uint), 1, fptr) != 1) return -1;
-
-        // swap byte order if necessary
-        _swap32((int&)header.data.data_len);
-
-        return 1;
-    }
-    else
-    {
-        uint len, i;
-        uint temp;
-        // unknown block
-
-        // read length
-        if (fread(&len, sizeof(len), 1, fptr) != 1) return -1;
-        // scan through the block
-        for (i = 0; i < len; i++)
-        {
-            if (fread(&temp, 1, 1, fptr) != 1) return -1;
-            if (feof(fptr)) return -1;   // unexpected eof
-        }
-    }
-    return 0;
-}
-
-
-int WavInFile::readWavHeaders()
-{
-    int res;
-
-    memset(&header, 0, sizeof(header));
-
-    res = readRIFFBlock();
-    if (res) return 1;
-    // read header blocks until data block is found
-    do
-    {
-        // read header blocks
-        res = readHeaderBlock();
-        if (res < 0) return 1;  // error in file structure
-    } while (res == 0);
-    // check that all required tags are legal
-    return checkCharTags();
-}
-
-
-uint WavInFile::getNumChannels() const
-{
-    return header.format.channel_number;
-}
-
-
-uint WavInFile::getNumBits() const
-{
-    return header.format.bits_per_sample;
-}
-
-
-uint WavInFile::getBytesPerSample() const
-{
-    return getNumChannels() * getNumBits() / 8;
-}
-
-
-uint WavInFile::getSampleRate() const
-{
-    return header.format.sample_rate;
-}
-
-
-uint WavInFile::getDataSizeInBytes() const
-{
-    return header.data.data_len;
-}
-
-
-uint WavInFile::getNumSamples() const
-{
-    if (header.format.byte_per_sample == 0) return 0;
-    if (header.format.fixed > 1) return header.fact.fact_sample_len;
-    return header.data.data_len / (unsigned short)header.format.byte_per_sample;
-}
-
-
-uint WavInFile::getLengthMS() const
-{
-    double numSamples;
-    double sampleRate;
-
-    numSamples = (double)getNumSamples();
-    sampleRate = (double)getSampleRate();
-
-    return (uint)(1000.0 * numSamples / sampleRate + 0.5);
-}
-
-
-/// Returns how many milliseconds of audio have so far been read from the file
-uint WavInFile::getElapsedMS() const
-{
-    return (uint)(1000.0 * (double)dataRead / (double)header.format.byte_rate);
-}
-
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// Class WavOutFile
-//
-
-WavOutFile::WavOutFile(const STRING& fileName, int sampleRate, int bits, int channels)
-{
-    bytesWritten = 0;
-    fptr = FOPEN(fileName.c_str(), "wb");
-    if (fptr == nullptr)
-    {
-        ST_THROW_RT_ERROR("Error : Unable to open file for writing.");
-    }
-
-    fillInHeader(sampleRate, bits, channels);
-    writeHeader();
-}
-
-
-WavOutFile::WavOutFile(FILE* file, int sampleRate, int bits, int channels)
-{
-    bytesWritten = 0;
-    fptr = file;
-    if (fptr == nullptr)
-    {
-        ST_THROW_RT_ERROR("Error : Unable to access output file stream.");
-    }
-
-    fillInHeader(sampleRate, bits, channels);
-    writeHeader();
-}
-
-
-WavOutFile::~WavOutFile()
-{
-    finishHeader();
-    if (fptr) fclose(fptr);
-    fptr = nullptr;
-}
-
-
-void WavOutFile::fillInHeader(uint sampleRate, uint bits, uint channels)
-{
-    // fill in the 'riff' part..
-
-    // copy string 'RIFF' to riff_char
-    memcpy(&(header.riff.riff_char), riffStr, 4);
-    // package_len unknown so far
-    header.riff.package_len = 0;
-    // copy string 'WAVE' to wave
-    memcpy(&(header.riff.wave), waveStr, 4);
-
-    // fill in the 'format' part..
-
-    // copy string 'fmt ' to fmt
-    memcpy(&(header.format.fmt), fmtStr, 4);
-
-    header.format.format_len = 0x10;
-    header.format.fixed = 1;
-    header.format.channel_number = (short)channels;
-    header.format.sample_rate = (int)sampleRate;
-    header.format.bits_per_sample = (short)bits;
-    header.format.byte_per_sample = (short)(bits * channels / 8);
-    header.format.byte_rate = header.format.byte_per_sample * (int)sampleRate;
-    header.format.sample_rate = (int)sampleRate;
-
-    // fill in the 'fact' part...
-    memcpy(&(header.fact.fact_field), factStr, 4);
-    header.fact.fact_len = 4;
-    header.fact.fact_sample_len = 0;
-
-    // fill in the 'data' part..
-
-    // copy string 'data' to data_field
-    memcpy(&(header.data.data_field), dataStr, 4);
-    // data_len unknown so far
-    header.data.data_len = 0;
-}
-
-
-void WavOutFile::finishHeader()
-{
-    // supplement the file length into the header structure
-    header.riff.package_len = bytesWritten + sizeof(WavHeader) - sizeof(WavRiff) + 4;
-    header.data.data_len = bytesWritten;
-    header.fact.fact_sample_len = bytesWritten / header.format.byte_per_sample;
-
-    writeHeader();
-}
-
-
-void WavOutFile::writeHeader()
-{
-    WavHeader hdrTemp;
-    int res;
-
-    // swap byte order if necessary
-    hdrTemp = header;
-    _swap32((int&)hdrTemp.riff.package_len);
-    _swap32((int&)hdrTemp.format.format_len);
-    _swap16((short&)hdrTemp.format.fixed);
-    _swap16((short&)hdrTemp.format.channel_number);
-    _swap32((int&)hdrTemp.format.sample_rate);
-    _swap32((int&)hdrTemp.format.byte_rate);
-    _swap16((short&)hdrTemp.format.byte_per_sample);
-    _swap16((short&)hdrTemp.format.bits_per_sample);
-    _swap32((int&)hdrTemp.data.data_len);
-    _swap32((int&)hdrTemp.fact.fact_len);
-    _swap32((int&)hdrTemp.fact.fact_sample_len);
-
-    // write the supplemented header in the beginning of the file
-    fseek(fptr, 0, SEEK_SET);
-    res = (int)fwrite(&hdrTemp, sizeof(hdrTemp), 1, fptr);
-    if (res != 1)
-    {
-        ST_THROW_RT_ERROR("Error while writing to a wav file.");
-    }
-
-    // jump back to the end of the file
-    fseek(fptr, 0, SEEK_END);
-}
-
-
-void WavOutFile::write(const unsigned char* buffer, int numElems)
-{
-    int res;
-
-    if (header.format.bits_per_sample != 8)
-    {
-        ST_THROW_RT_ERROR("Error: WavOutFile::write(const char*, int) accepts only 8bit samples.");
-    }
-    assert(sizeof(char) == 1);
-
-    res = (int)fwrite(buffer, 1, numElems, fptr);
-    if (res != numElems)
-    {
-        ST_THROW_RT_ERROR("Error while writing to a wav file.");
-    }
-
-    bytesWritten += numElems;
-}
-
-
-void WavOutFile::write(const short* buffer, int numElems)
-{
-    int res;
-
-    // 16 bit samples
-    if (numElems < 1) return;   // nothing to do
-
-    switch (header.format.bits_per_sample)
-    {
-    case 8:
-    {
-        int i;
-        unsigned char* temp = (unsigned char*)getConvBuffer(numElems);
-        // convert from 16bit format to 8bit format
-        for (i = 0; i < numElems; i++)
-        {
-            temp[i] = (unsigned char)(buffer[i] / 256 + 128);
-        }
-        // write in 8bit format
-        write(temp, numElems);
-        break;
-    }
-
-    case 16:
-    {
-        // 16bit format
-
-        // use temp buffer to swap byte order if necessary
-        short* pTemp = (short*)getConvBuffer(numElems * sizeof(short));
-        memcpy(pTemp, buffer, (size_t)numElems * 2L);
-        _swap16Buffer(pTemp, numElems);
-
-        res = (int)fwrite(pTemp, 2, numElems, fptr);
-
-        if (res != numElems)
-        {
-            ST_THROW_RT_ERROR("Error while writing to a wav file.");
-        }
-        bytesWritten += 2 * numElems;
-        break;
-    }
-
-    default:
-    {
-        stringstream ss;
-        ss << "\nOnly 8/16 bit sample WAV files supported in integer compilation. Can't open WAV file with ";
-        ss << (int)header.format.bits_per_sample;
-        ss << " bit sample format. ";
-        ST_THROW_RT_ERROR(ss.str().c_str());
-    }
-    }
-}
-
-
-/// Convert from float to integer and saturate
-inline int saturate(float fvalue, float minval, float maxval)
-{
-    if (fvalue > maxval)
-    {
-        fvalue = maxval;
-    }
-    else if (fvalue < minval)
-    {
-        fvalue = minval;
-    }
-    return (int)fvalue;
-}
-
-
-void WavOutFile::write(const float* buffer, int numElems)
-{
-    int numBytes;
-    int bytesPerSample;
-
-    if (numElems == 0) return;
-
-    bytesPerSample = header.format.bits_per_sample / 8;
-    numBytes = numElems * bytesPerSample;
-    void* temp = getConvBuffer(numBytes + 7);   // round bit up to avoid buffer overrun with 24bit-value assignment
-
-    switch (bytesPerSample)
-    {
-    case 1:
-    {
-        unsigned char* temp2 = (unsigned char*)temp;
-        for (int i = 0; i < numElems; i++)
-        {
-            temp2[i] = (unsigned char)saturate(buffer[i] * 128.0f + 128.0f, 0.0f, 255.0f);
-        }
-        break;
-    }
-
-    case 2:
-    {
-        short* temp2 = (short*)temp;
-        for (int i = 0; i < numElems; i++)
-        {
-            short value = (short)saturate(buffer[i] * 32768.0f, -32768.0f, 32767.0f);
-            temp2[i] = _swap16(value);
-        }
-        break;
-    }
-
-    case 3:
-    {
-        char* temp2 = (char*)temp;
-        for (int i = 0; i < numElems; i++)
-        {
-            int value = saturate(buffer[i] * 8388608.0f, -8388608.0f, 8388607.0f);
-            *((int*)temp2) = _swap32(value);
-            temp2 += 3;
-        }
-        break;
-    }
-
-    case 4:
-    {
-        int* temp2 = (int*)temp;
-        for (int i = 0; i < numElems; i++)
-        {
-            int value = saturate(buffer[i] * 2147483648.0f, -2147483648.0f, 2147483647.0f);
-            temp2[i] = _swap32(value);
-        }
-        break;
-    }
-
-    default:
-        assert(false);
-    }
-
-    int res = (int)fwrite(temp, 1, numBytes, fptr);
-
-    if (res != numBytes)
-    {
-        ST_THROW_RT_ERROR("Error while writing to a wav file.");
-    }
-    bytesWritten += numBytes;
-}
-
-}
+ ////////////////////////////////////////////////////////////////////////////////
+///
+/// Classes for easy reading & writing of WAV sound files.
+///
+/// For big-endian CPU, define _BIG_ENDIAN_ during compile-time to correctly
+/// parse the WAV files with such processors.
+///
+/// Admittingly, more complete WAV reader routines may exist in public domain,
+/// but the reason for 'yet another' one is that those generic WAV reader
+/// libraries are exhaustingly large and cumbersome! Wanted to have something
+/// simpler here, i.e. something that's not already larger than rest of the
+/// SoundTouch/SoundStretch program...
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+
+#include "WavFile.h"
+#include "STTypes.h"
+
+using namespace std;
+
+namespace soundstretch
+{
+
+#if _WIN32
+#define FOPEN(name, mode) _wfopen(name, STRING_CONST(mode))
+#else
+#define FOPEN(name, mode) fopen(name, mode)
+#endif
+
+static const char riffStr[] = "RIFF";
+static const char waveStr[] = "WAVE";
+static const char fmtStr[] = "fmt ";
+static const char factStr[] = "fact";
+static const char dataStr[] = "data";
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Helper functions for swapping byte order to correctly read/write WAV files
+// with big-endian CPU's: Define compile-time definition _BIG_ENDIAN_ to
+// turn-on the conversion if it appears necessary.
+//
+// For example, Intel x86 is little-endian and doesn't require conversion,
+// while PowerPC of Mac's and many other RISC cpu's are big-endian.
+
+#ifdef BYTE_ORDER
+// In gcc compiler detect the byte order automatically
+#if BYTE_ORDER == BIG_ENDIAN
+// big-endian platform.
+#define _BIG_ENDIAN_
+#endif
+#endif
+
+#ifdef _BIG_ENDIAN_
+// big-endian CPU, swap bytes in 16 & 32 bit words
+
+// helper-function to swap byte-order of 32bit integer
+static inline int _swap32(int& dwData)
+{
+    dwData = ((dwData >> 24) & 0x000000FF) |
+        ((dwData >> 8) & 0x0000FF00) |
+        ((dwData << 8) & 0x00FF0000) |
+        ((dwData << 24) & 0xFF000000);
+    return dwData;
+}
+
+// helper-function to swap byte-order of 16bit integer
+static inline short _swap16(short& wData)
+{
+    wData = ((wData >> 8) & 0x00FF) |
+        ((wData << 8) & 0xFF00);
+    return wData;
+}
+
+// helper-function to swap byte-order of buffer of 16bit integers
+static inline void _swap16Buffer(short* pData, int numWords)
+{
+    int i;
+
+    for (i = 0; i < numWords; i++)
+    {
+        pData[i] = _swap16(pData[i]);
+    }
+}
+
+#else   // BIG_ENDIAN
+// little-endian CPU, WAV file is ok as such
+
+// dummy helper-function
+static inline int _swap32(int& dwData)
+{
+    // do nothing
+    return dwData;
+}
+
+// dummy helper-function
+static inline short _swap16(short& wData)
+{
+    // do nothing
+    return wData;
+}
+
+// dummy helper-function
+static inline void _swap16Buffer(short*, int)
+{
+    // do nothing
+}
+
+#endif  // BIG_ENDIAN
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Class WavFileBase
+//
+
+WavFileBase::WavFileBase()
+{
+    convBuff = nullptr;
+    convBuffSize = 0;
+}
+
+
+WavFileBase::~WavFileBase()
+{
+    delete[] convBuff;
+    convBuffSize = 0;
+}
+
+
+/// Get pointer to conversion buffer of at min. given size
+void* WavFileBase::getConvBuffer(int sizeBytes)
+{
+    if (convBuffSize < sizeBytes)
+    {
+        delete[] convBuff;
+
+        convBuffSize = (sizeBytes + 15) & -8;   // round up to following 8-byte bounday
+        convBuff = new char[convBuffSize];
+    }
+    return convBuff;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Class WavInFile
+//
+
+WavInFile::WavInFile(const STRING& fileName)
+{
+    // Try to open the file for reading
+    fptr = FOPEN(fileName.c_str(), "rb");
+    if (fptr == nullptr)
+    {
+        ST_THROW_RT_ERROR("Error : Unable to open file for reading.");
+    }
+
+    init();
+}
+
+
+WavInFile::WavInFile(FILE* file)
+{
+    // Try to open the file for reading
+    fptr = file;
+    if (!file)
+    {
+        ST_THROW_RT_ERROR("Error : Unable to access input stream for reading");
+    }
+
+    init();
+}
+
+
+/// Init the WAV file stream
+void WavInFile::init()
+{
+    int hdrsOk;
+
+    // assume file stream is already open
+    assert(fptr);
+
+    // Read the file headers
+    hdrsOk = readWavHeaders();
+    if (hdrsOk != 0)
+    {
+        ST_THROW_RT_ERROR("Input file is corrupt or not a WAV file");
+    }
+
+    // sanity check for format parameters
+    if ((header.format.channel_number < 1) || (header.format.channel_number > 9) ||
+        (header.format.sample_rate < 4000) || (header.format.sample_rate > 192000) ||
+        (header.format.byte_per_sample < 1) || (header.format.byte_per_sample > 320) ||
+        (header.format.bits_per_sample < 8) || (header.format.bits_per_sample > 32))
+    {
+        ST_THROW_RT_ERROR("Error: Illegal wav file header format parameters.");
+    }
+
+    dataRead = 0;
+}
+
+
+WavInFile::~WavInFile()
+{
+    if (fptr) fclose(fptr);
+    fptr = nullptr;
+}
+
+
+void WavInFile::rewind()
+{
+    int hdrsOk;
+
+    fseek(fptr, 0, SEEK_SET);
+    hdrsOk = readWavHeaders();
+    assert(hdrsOk == 0);
+    dataRead = 0;
+}
+
+
+int WavInFile::checkCharTags() const
+{
+    // header.format.fmt should equal to 'fmt '
+    if (memcmp(fmtStr, header.format.fmt, 4) != 0) return -1;
+    // header.data.data_field should equal to 'data'
+    if (memcmp(dataStr, header.data.data_field, 4) != 0) return -1;
+
+    return 0;
+}
+
+
+int WavInFile::read(unsigned char* buffer, int maxElems)
+{
+    int numBytes;
+    uint afterDataRead;
+
+    // ensure it's 8 bit format
+    if (header.format.bits_per_sample != 8)
+    {
+        ST_THROW_RT_ERROR("Error: WavInFile::read(char*, int) works only with 8bit samples.");
+    }
+    assert(sizeof(char) == 1);
+
+    numBytes = maxElems;
+    afterDataRead = dataRead + numBytes;
+    if (afterDataRead > header.data.data_len)
+    {
+        // Don't read more samples than are marked available in header
+        numBytes = (int)header.data.data_len - (int)dataRead;
+        assert(numBytes >= 0);
+    }
+
+    assert(buffer);
+    numBytes = (int)fread(buffer, 1, numBytes, fptr);
+    dataRead += numBytes;
+
+    return numBytes;
+}
+
+
+int WavInFile::read(short* buffer, int maxElems)
+{
+    unsigned int afterDataRead;
+    int numBytes;
+    int numElems;
+
+    assert(buffer);
+    switch (header.format.bits_per_sample)
+    {
+    case 8:
+    {
+        // 8 bit format
+        unsigned char* temp = (unsigned char*)getConvBuffer(maxElems);
+        int i;
+
+        numElems = read(temp, maxElems);
+        // convert from 8 to 16 bit
+        for (i = 0; i < numElems; i++)
+        {
+            buffer[i] = (short)(((short)temp[i] - 128) * 256);
+        }
+        break;
+    }
+
+    case 16:
+    {
+        // 16 bit format
+
+        assert(sizeof(short) == 2);
+
+        numBytes = maxElems * 2;
+        afterDataRead = dataRead + numBytes;
+        if (afterDataRead > header.data.data_len)
+        {
+            // Don't read more samples than are marked available in header
+            numBytes = (int)header.data.data_len - (int)dataRead;
+            assert(numBytes >= 0);
+        }
+
+        numBytes = (int)fread(buffer, 1, numBytes, fptr);
+        dataRead += numBytes;
+        numElems = numBytes / 2;
+
+        // 16bit samples, swap byte order if necessary
+        _swap16Buffer((short*)buffer, numElems);
+        break;
+    }
+
+    default:
+    {
+        stringstream ss;
+        ss << "\nOnly 8/16 bit sample WAV files supported in integer compilation. Can't open WAV file with ";
+        ss << (int)header.format.bits_per_sample;
+        ss << " bit sample format. ";
+        ST_THROW_RT_ERROR(ss.str().c_str());
+    }
+    };
+
+    return numElems;
+}
+
+
+/// Read data in float format. Notice that when reading in float format
+/// 8/16/24/32 bit sample formats are supported
+int WavInFile::read(float* buffer, int maxElems)
+{
+    unsigned int afterDataRead;
+    int numBytes;
+    int numElems;
+    int bytesPerSample;
+
+    assert(buffer);
+
+    bytesPerSample = header.format.bits_per_sample / 8;
+    if ((bytesPerSample < 1) || (bytesPerSample > 4))
+    {
+        stringstream ss;
+        ss << "\nOnly 8/16/24/32 bit sample WAV files supported. Can't open WAV file with ";
+        ss << (int)header.format.bits_per_sample;
+        ss << " bit sample format. ";
+        ST_THROW_RT_ERROR(ss.str().c_str());
+    }
+
+    numBytes = maxElems * bytesPerSample;
+    afterDataRead = dataRead + numBytes;
+    if (afterDataRead > header.data.data_len)
+    {
+        // Don't read more samples than are marked available in header
+        numBytes = (int)header.data.data_len - (int)dataRead;
+        assert(numBytes >= 0);
+    }
+
+    // read raw data into temporary buffer
+    char* temp = (char*)getConvBuffer(numBytes);
+    numBytes = (int)fread(temp, 1, numBytes, fptr);
+    dataRead += numBytes;
+
+    numElems = numBytes / bytesPerSample;
+
+    // swap byte ordert & convert to float, depending on sample format
+    switch (bytesPerSample)
+    {
+    case 1:
+    {
+        unsigned char* temp2 = (unsigned char*)temp;
+        double conv = 1.0 / 128.0;
+        for (int i = 0; i < numElems; i++)
+        {
+            buffer[i] = (float)(temp2[i] * conv - 1.0);
+        }
+        break;
+    }
+
+    case 2:
+    {
+        short* temp2 = (short*)temp;
+        double conv = 1.0 / 32768.0;
+        for (int i = 0; i < numElems; i++)
+        {
+            short value = temp2[i];
+            buffer[i] = (float)(_swap16(value) * conv);
+        }
+        break;
+    }
+
+    case 3:
+    {
+        char* temp2 = (char*)temp;
+        double conv = 1.0 / 8388608.0;
+        for (int i = 0; i < numElems; i++)
+        {
+            int value = *((int*)temp2);
+            value = _swap32(value) & 0x00ffffff;             // take 24 bits
+            value |= (value & 0x00800000) ? 0xff000000 : 0;  // extend minus sign bits
+            buffer[i] = (float)(value * conv);
+            temp2 += 3;
+        }
+        break;
+    }
+
+    case 4:
+    {
+        int* temp2 = (int*)temp;
+        double conv = 1.0 / 2147483648.0;
+        assert(sizeof(int) == 4);
+        for (int i = 0; i < numElems; i++)
+        {
+            int value = temp2[i];
+            buffer[i] = (float)(_swap32(value) * conv);
+        }
+        break;
+    }
+    }
+
+    return numElems;
+}
+
+
+int WavInFile::eof() const
+{
+    // return true if all data has been read or file eof has reached
+    return ((uint)dataRead == header.data.data_len || feof(fptr));
+}
+
+
+// test if character code is between a white space ' ' and little 'z'
+static int isAlpha(char c)
+{
+    return (c >= ' ' && c <= 'z') ? 1 : 0;
+}
+
+
+// test if all characters are between a white space ' ' and little 'z'
+static int isAlphaStr(const char* str)
+{
+    char c;
+
+    c = str[0];
+    while (c)
+    {
+        if (isAlpha(c) == 0) return 0;
+        str++;
+        c = str[0];
+    }
+
+    return 1;
+}
+
+
+int WavInFile::readRIFFBlock()
+{
+    if (fread(&(header.riff), sizeof(WavRiff), 1, fptr) != 1) return -1;
+
+    // swap 32bit data byte order if necessary
+    _swap32((int&)header.riff.package_len);
+
+    // header.riff.riff_char should equal to 'RIFF');
+    if (memcmp(riffStr, header.riff.riff_char, 4) != 0) return -1;
+    // header.riff.wave should equal to 'WAVE'
+    if (memcmp(waveStr, header.riff.wave, 4) != 0) return -1;
+
+    return 0;
+}
+
+
+int WavInFile::readHeaderBlock()
+{
+    char label[5];
+    string sLabel;
+
+    // lead label string
+    if (fread(label, 1, 4, fptr) != 4) return -1;
+    label[4] = 0;
+
+    if (isAlphaStr(label) == 0) return -1;    // not a valid label
+
+    // Decode blocks according to their label
+    if (strcmp(label, fmtStr) == 0)
+    {
+        int nLen, nDump;
+
+        // 'fmt ' block
+        memcpy(header.format.fmt, fmtStr, 4);
+
+        // read length of the format field
+        if (fread(&nLen, sizeof(int), 1, fptr) != 1) return -1;
+        // swap byte order if necessary
+        _swap32(nLen);
+
+        // calculate how much length differs from expected
+        nDump = nLen - ((int)sizeof(header.format) - 8);
+
+        // verify that header length isn't smaller than expected structure
+        if ((nLen < 0) || (nDump < 0)) return -1;
+
+        header.format.format_len = nLen;
+
+        // if format_len is larger than expected, read only as much data as we've space for
+        if (nDump > 0)
+        {
+            nLen = sizeof(header.format) - 8;
+        }
+
+        // read data
+        if (fread(&(header.format.fixed), nLen, 1, fptr) != 1) return -1;
+
+        // swap byte order if necessary
+        _swap16((short&)header.format.fixed);            // short int fixed;
+        _swap16((short&)header.format.channel_number);   // short int channel_number;
+        _swap32((int&)header.format.sample_rate);        // int sample_rate;
+        _swap32((int&)header.format.byte_rate);          // int byte_rate;
+        _swap16((short&)header.format.byte_per_sample);  // short int byte_per_sample;
+        _swap16((short&)header.format.bits_per_sample);  // short int bits_per_sample;
+
+        // if format_len is larger than expected, skip the extra data
+        if (nDump > 0)
+        {
+            fseek(fptr, nDump, SEEK_CUR);
+        }
+
+        return 0;
+    }
+    else if (strcmp(label, factStr) == 0)
+    {
+        int nLen, nDump;
+
+        // 'fact' block
+        memcpy(header.fact.fact_field, factStr, 4);
+
+        // read length of the fact field
+        if (fread(&nLen, sizeof(int), 1, fptr) != 1) return -1;
+        // swap byte order if necessary
+        _swap32(nLen);
+
+        // calculate how much length differs from expected
+        nDump = nLen - ((int)sizeof(header.fact) - 8);
+
+        // verify that fact length isn't smaller than expected structure
+        if ((nLen < 0) || (nDump < 0)) return -1;
+
+        header.fact.fact_len = nLen;
+
+        // if format_len is larger than expected, read only as much data as we've space for
+        if (nDump > 0)
+        {
+            nLen = sizeof(header.fact) - 8;
+        }
+
+        // read data
+        if (fread(&(header.fact.fact_sample_len), nLen, 1, fptr) != 1) return -1;
+
+        // swap byte order if necessary
+        _swap32((int&)header.fact.fact_sample_len);    // int sample_length;
+
+        // if fact_len is larger than expected, skip the extra data
+        if (nDump > 0)
+        {
+            fseek(fptr, nDump, SEEK_CUR);
+        }
+
+        return 0;
+    }
+    else if (strcmp(label, dataStr) == 0)
+    {
+        // 'data' block
+        memcpy(header.data.data_field, dataStr, 4);
+        if (fread(&(header.data.data_len), sizeof(uint), 1, fptr) != 1) return -1;
+
+        // swap byte order if necessary
+        _swap32((int&)header.data.data_len);
+
+        return 1;
+    }
+    else
+    {
+        uint len, i;
+        uint temp;
+        // unknown block
+
+        // read length
+        if (fread(&len, sizeof(len), 1, fptr) != 1) return -1;
+        // scan through the block
+        for (i = 0; i < len; i++)
+        {
+            if (fread(&temp, 1, 1, fptr) != 1) return -1;
+            if (feof(fptr)) return -1;   // unexpected eof
+        }
+    }
+    return 0;
+}
+
+
+int WavInFile::readWavHeaders()
+{
+    int res;
+
+    memset(&header, 0, sizeof(header));
+
+    res = readRIFFBlock();
+    if (res) return 1;
+    // read header blocks until data block is found
+    do
+    {
+        // read header blocks
+        res = readHeaderBlock();
+        if (res < 0) return 1;  // error in file structure
+    } while (res == 0);
+    // check that all required tags are legal
+    return checkCharTags();
+}
+
+
+uint WavInFile::getNumChannels() const
+{
+    return header.format.channel_number;
+}
+
+
+uint WavInFile::getNumBits() const
+{
+    return header.format.bits_per_sample;
+}
+
+
+uint WavInFile::getBytesPerSample() const
+{
+    return getNumChannels() * getNumBits() / 8;
+}
+
+
+uint WavInFile::getSampleRate() const
+{
+    return header.format.sample_rate;
+}
+
+
+uint WavInFile::getDataSizeInBytes() const
+{
+    return header.data.data_len;
+}
+
+
+uint WavInFile::getNumSamples() const
+{
+    if (header.format.byte_per_sample == 0) return 0;
+    if (header.format.fixed > 1) return header.fact.fact_sample_len;
+    return header.data.data_len / (unsigned short)header.format.byte_per_sample;
+}
+
+
+uint WavInFile::getLengthMS() const
+{
+    double numSamples;
+    double sampleRate;
+
+    numSamples = (double)getNumSamples();
+    sampleRate = (double)getSampleRate();
+
+    return (uint)(1000.0 * numSamples / sampleRate + 0.5);
+}
+
+
+/// Returns how many milliseconds of audio have so far been read from the file
+uint WavInFile::getElapsedMS() const
+{
+    return (uint)(1000.0 * (double)dataRead / (double)header.format.byte_rate);
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Class WavOutFile
+//
+
+WavOutFile::WavOutFile(const STRING& fileName, int sampleRate, int bits, int channels)
+{
+    bytesWritten = 0;
+    fptr = FOPEN(fileName.c_str(), "wb");
+    if (fptr == nullptr)
+    {
+        ST_THROW_RT_ERROR("Error : Unable to open file for writing.");
+    }
+
+    fillInHeader(sampleRate, bits, channels);
+    writeHeader();
+}
+
+
+WavOutFile::WavOutFile(FILE* file, int sampleRate, int bits, int channels)
+{
+    bytesWritten = 0;
+    fptr = file;
+    if (fptr == nullptr)
+    {
+        ST_THROW_RT_ERROR("Error : Unable to access output file stream.");
+    }
+
+    fillInHeader(sampleRate, bits, channels);
+    writeHeader();
+}
+
+
+WavOutFile::~WavOutFile()
+{
+    finishHeader();
+    if (fptr) fclose(fptr);
+    fptr = nullptr;
+}
+
+
+void WavOutFile::fillInHeader(uint sampleRate, uint bits, uint channels)
+{
+    // fill in the 'riff' part..
+
+    // copy string 'RIFF' to riff_char
+    memcpy(&(header.riff.riff_char), riffStr, 4);
+    // package_len unknown so far
+    header.riff.package_len = 0;
+    // copy string 'WAVE' to wave
+    memcpy(&(header.riff.wave), waveStr, 4);
+
+    // fill in the 'format' part..
+
+    // copy string 'fmt ' to fmt
+    memcpy(&(header.format.fmt), fmtStr, 4);
+
+    header.format.format_len = 0x10;
+    header.format.fixed = 1;
+    header.format.channel_number = (short)channels;
+    header.format.sample_rate = (int)sampleRate;
+    header.format.bits_per_sample = (short)bits;
+    header.format.byte_per_sample = (short)(bits * channels / 8);
+    header.format.byte_rate = header.format.byte_per_sample * (int)sampleRate;
+    header.format.sample_rate = (int)sampleRate;
+
+    // fill in the 'fact' part...
+    memcpy(&(header.fact.fact_field), factStr, 4);
+    header.fact.fact_len = 4;
+    header.fact.fact_sample_len = 0;
+
+    // fill in the 'data' part..
+
+    // copy string 'data' to data_field
+    memcpy(&(header.data.data_field), dataStr, 4);
+    // data_len unknown so far
+    header.data.data_len = 0;
+}
+
+
+void WavOutFile::finishHeader()
+{
+    // supplement the file length into the header structure
+    header.riff.package_len = bytesWritten + sizeof(WavHeader) - sizeof(WavRiff) + 4;
+    header.data.data_len = bytesWritten;
+    header.fact.fact_sample_len = bytesWritten / header.format.byte_per_sample;
+
+    writeHeader();
+}
+
+
+void WavOutFile::writeHeader()
+{
+    WavHeader hdrTemp;
+    int res;
+
+    // swap byte order if necessary
+    hdrTemp = header;
+    _swap32((int&)hdrTemp.riff.package_len);
+    _swap32((int&)hdrTemp.format.format_len);
+    _swap16((short&)hdrTemp.format.fixed);
+    _swap16((short&)hdrTemp.format.channel_number);
+    _swap32((int&)hdrTemp.format.sample_rate);
+    _swap32((int&)hdrTemp.format.byte_rate);
+    _swap16((short&)hdrTemp.format.byte_per_sample);
+    _swap16((short&)hdrTemp.format.bits_per_sample);
+    _swap32((int&)hdrTemp.data.data_len);
+    _swap32((int&)hdrTemp.fact.fact_len);
+    _swap32((int&)hdrTemp.fact.fact_sample_len);
+
+    // write the supplemented header in the beginning of the file
+    fseek(fptr, 0, SEEK_SET);
+    res = (int)fwrite(&hdrTemp, sizeof(hdrTemp), 1, fptr);
+    if (res != 1)
+    {
+        ST_THROW_RT_ERROR("Error while writing to a wav file.");
+    }
+
+    // jump back to the end of the file
+    fseek(fptr, 0, SEEK_END);
+}
+
+
+void WavOutFile::write(const unsigned char* buffer, int numElems)
+{
+    int res;
+
+    if (header.format.bits_per_sample != 8)
+    {
+        ST_THROW_RT_ERROR("Error: WavOutFile::write(const char*, int) accepts only 8bit samples.");
+    }
+    assert(sizeof(char) == 1);
+
+    res = (int)fwrite(buffer, 1, numElems, fptr);
+    if (res != numElems)
+    {
+        ST_THROW_RT_ERROR("Error while writing to a wav file.");
+    }
+
+    bytesWritten += numElems;
+}
+
+
+void WavOutFile::write(const short* buffer, int numElems)
+{
+    int res;
+
+    // 16 bit samples
+    if (numElems < 1) return;   // nothing to do
+
+    switch (header.format.bits_per_sample)
+    {
+    case 8:
+    {
+        int i;
+        unsigned char* temp = (unsigned char*)getConvBuffer(numElems);
+        // convert from 16bit format to 8bit format
+        for (i = 0; i < numElems; i++)
+        {
+            temp[i] = (unsigned char)(buffer[i] / 256 + 128);
+        }
+        // write in 8bit format
+        write(temp, numElems);
+        break;
+    }
+
+    case 16:
+    {
+        // 16bit format
+
+        // use temp buffer to swap byte order if necessary
+        short* pTemp = (short*)getConvBuffer(numElems * sizeof(short));
+        memcpy(pTemp, buffer, (size_t)numElems * 2L);
+        _swap16Buffer(pTemp, numElems);
+
+        res = (int)fwrite(pTemp, 2, numElems, fptr);
+
+        if (res != numElems)
+        {
+            ST_THROW_RT_ERROR("Error while writing to a wav file.");
+        }
+        bytesWritten += 2 * numElems;
+        break;
+    }
+
+    default:
+    {
+        stringstream ss;
+        ss << "\nOnly 8/16 bit sample WAV files supported in integer compilation. Can't open WAV file with ";
+        ss << (int)header.format.bits_per_sample;
+        ss << " bit sample format. ";
+        ST_THROW_RT_ERROR(ss.str().c_str());
+    }
+    }
+}
+
+
+/// Convert from float to integer and saturate
+inline int saturate(float fvalue, float minval, float maxval)
+{
+    if (fvalue > maxval)
+    {
+        fvalue = maxval;
+    }
+    else if (fvalue < minval)
+    {
+        fvalue = minval;
+    }
+    return (int)fvalue;
+}
+
+
+void WavOutFile::write(const float* buffer, int numElems)
+{
+    int numBytes;
+    int bytesPerSample;
+
+    if (numElems == 0) return;
+
+    bytesPerSample = header.format.bits_per_sample / 8;
+    numBytes = numElems * bytesPerSample;
+    void* temp = getConvBuffer(numBytes + 7);   // round bit up to avoid buffer overrun with 24bit-value assignment
+
+    switch (bytesPerSample)
+    {
+    case 1:
+    {
+        unsigned char* temp2 = (unsigned char*)temp;
+        for (int i = 0; i < numElems; i++)
+        {
+            temp2[i] = (unsigned char)saturate(buffer[i] * 128.0f + 128.0f, 0.0f, 255.0f);
+        }
+        break;
+    }
+
+    case 2:
+    {
+        short* temp2 = (short*)temp;
+        for (int i = 0; i < numElems; i++)
+        {
+            short value = (short)saturate(buffer[i] * 32768.0f, -32768.0f, 32767.0f);
+            temp2[i] = _swap16(value);
+        }
+        break;
+    }
+
+    case 3:
+    {
+        char* temp2 = (char*)temp;
+        for (int i = 0; i < numElems; i++)
+        {
+            int value = saturate(buffer[i] * 8388608.0f, -8388608.0f, 8388607.0f);
+            *((int*)temp2) = _swap32(value);
+            temp2 += 3;
+        }
+        break;
+    }
+
+    case 4:
+    {
+        int* temp2 = (int*)temp;
+        for (int i = 0; i < numElems; i++)
+        {
+            int value = saturate(buffer[i] * 2147483648.0f, -2147483648.0f, 2147483647.0f);
+            temp2[i] = _swap32(value);
+        }
+        break;
+    }
+
+    default:
+        assert(false);
+    }
+
+    int res = (int)fwrite(temp, 1, numBytes, fptr);
+
+    if (res != numBytes)
+    {
+        ST_THROW_RT_ERROR("Error while writing to a wav file.");
+    }
+    bytesWritten += numBytes;
+}
+
+}
diff --git a/source/SoundStretch/WavFile.h b/source/SoundStretch/WavFile.h
index 57fedef..812b034 100644
--- a/source/SoundStretch/WavFile.h
+++ b/source/SoundStretch/WavFile.h
@@ -1,281 +1,281 @@
-////////////////////////////////////////////////////////////////////////////////
-///
-/// Classes for easy reading & writing of WAV sound files.
-///
-/// For big-endian CPU, define BIG_ENDIAN during compile-time to correctly
-/// parse the WAV files with such processors.
-/// 
-/// Admittingly, more complete WAV reader routines may exist in public domain, but 
-/// the reason for 'yet another' one is that those generic WAV reader libraries are
-/// exhaustingly large and cumbersome! Wanted to have something simpler here, i.e. 
-/// something that's not already larger than rest of the SoundTouch/SoundStretch program...
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef WAVFILE_H
-#define WAVFILE_H
-
-#include 
-#include 
-#include "SS_CharTypes.h"
-
-namespace soundstretch
-{
-
-#ifndef uint
-typedef unsigned int uint;
-#endif           
-
-
-/// WAV audio file 'riff' section header
-typedef struct 
-{
-    char riff_char[4];
-    uint package_len;
-    char wave[4];
-} WavRiff;
-
-/// WAV audio file 'format' section header
-typedef struct 
-{
-    char  fmt[4];
-    unsigned int   format_len;
-    unsigned short fixed;
-    unsigned short channel_number;
-    unsigned int   sample_rate;
-    unsigned int   byte_rate;
-    unsigned short byte_per_sample;
-    unsigned short bits_per_sample;
-} WavFormat;
-
-/// WAV audio file 'fact' section header
-typedef struct 
-{
-    char fact_field[4];
-    uint fact_len;
-    uint fact_sample_len;
-} WavFact;
-
-/// WAV audio file 'data' section header
-typedef struct 
-{
-    char  data_field[4];
-    uint  data_len;
-} WavData;
-
-
-/// WAV audio file header
-typedef struct 
-{
-    WavRiff   riff;
-    WavFormat format;
-    WavFact   fact;
-    WavData   data;
-} WavHeader;
-
-
-/// Base class for processing WAV audio files.
-class WavFileBase
-{
-private:
-    /// Conversion working buffer;
-    char *convBuff;
-    int convBuffSize;
-
-protected:
-    WavFileBase();
-    virtual ~WavFileBase();
-
-    /// Get pointer to conversion buffer of at min. given size
-    void *getConvBuffer(int sizeByte);
-};
-
-
-/// Class for reading WAV audio files.
-class WavInFile : protected WavFileBase
-{
-private:
-    /// File pointer.
-    FILE *fptr;
-
-    /// Counter of how many bytes of sample data have been read from the file.
-    long dataRead;
-
-    /// WAV header information
-    WavHeader header;
-
-    /// Init the WAV file stream
-    void init();
-
-    /// Read WAV file headers.
-    /// \return zero if all ok, nonzero if file format is invalid.
-    int readWavHeaders();
-
-    /// Checks WAV file header tags.
-    /// \return zero if all ok, nonzero if file format is invalid.
-    int checkCharTags() const;
-
-    /// Reads a single WAV file header block.
-    /// \return zero if all ok, nonzero if file format is invalid.
-    int readHeaderBlock();
-
-    /// Reads WAV file 'riff' block
-    int readRIFFBlock();
-
-public:
-    /// Constructor: Opens the given WAV file. If the file can't be opened,
-    /// throws 'runtime_error' exception.
-    WavInFile(const STRING& filename);
-
-    WavInFile(FILE *file);
-
-    /// Destructor: Closes the file.
-    ~WavInFile();
-
-    /// Rewind to beginning of the file
-    void rewind();
-
-    /// Get sample rate.
-    uint getSampleRate() const;
-
-    /// Get number of bits per sample, i.e. 8 or 16.
-    uint getNumBits() const;
-
-    /// Get sample data size in bytes. Ahem, this should return same information as 
-    /// 'getBytesPerSample'...
-    uint getDataSizeInBytes() const;
-
-    /// Get total number of samples in file.
-    uint getNumSamples() const;
-
-    /// Get number of bytes per audio sample (e.g. 16bit stereo = 4 bytes/sample)
-    uint getBytesPerSample() const;
-    
-    /// Get number of audio channels in the file (1=mono, 2=stereo)
-    uint getNumChannels() const;
-
-    /// Get the audio file length in milliseconds
-    uint getLengthMS() const;
-
-    /// Returns how many milliseconds of audio have so far been read from the file
-    ///
-    /// \return elapsed duration in milliseconds
-    uint getElapsedMS() const;
-
-    /// Reads audio samples from the WAV file. This routine works only for 8 bit samples.
-    /// Reads given number of elements from the file or if end-of-file reached, as many 
-    /// elements as are left in the file.
-    ///
-    /// \return Number of 8-bit integers read from the file.
-    int read(unsigned char *buffer, int maxElems);
-
-    /// Reads audio samples from the WAV file to 16 bit integer format. Reads given number 
-    /// of elements from the file or if end-of-file reached, as many elements as are 
-    /// left in the file.
-    ///
-    /// \return Number of 16-bit integers read from the file.
-    int read(short *buffer,     ///< Pointer to buffer where to read data.
-             int maxElems       ///< Size of 'buffer' array (number of array elements).
-             );
-
-    /// Reads audio samples from the WAV file to floating point format, converting 
-    /// sample values to range [-1,1[. Reads given number of elements from the file
-    /// or if end-of-file reached, as many elements as are left in the file.
-    /// Notice that reading in float format supports 8/16/24/32bit sample formats.
-    ///
-    /// \return Number of elements read from the file.
-    int read(float *buffer,     ///< Pointer to buffer where to read data.
-             int maxElems       ///< Size of 'buffer' array (number of array elements).
-             );
-
-    /// Check end-of-file.
-    ///
-    /// \return Nonzero if end-of-file reached.
-    int eof() const;
-};
-
-
-/// Class for writing WAV audio files.
-class WavOutFile : protected WavFileBase
-{
-private:
-    /// Pointer to the WAV file
-    FILE *fptr;
-
-    /// WAV file header data.
-    WavHeader header;
-
-    /// Counter of how many bytes have been written to the file so far.
-    int bytesWritten;
-
-    /// Fills in WAV file header information.
-    void fillInHeader(const uint sampleRate, const uint bits, const uint channels);
-
-    /// Finishes the WAV file header by supplementing information of amount of
-    /// data written to file etc
-    void finishHeader();
-
-    /// Writes the WAV file header.
-    void writeHeader();
-
-public:
-    /// Constructor: Creates a new WAV file. Throws a 'runtime_error' exception 
-    /// if file creation fails.
-    WavOutFile(const STRING& fileName,  ///< Filename
-               int sampleRate,          ///< Sample rate (e.g. 44100 etc)
-               int bits,                ///< Bits per sample (8 or 16 bits)
-               int channels             ///< Number of channels (1=mono, 2=stereo)
-               );
-
-    WavOutFile(FILE *file, int sampleRate, int bits, int channels);
-
-    /// Destructor: Finalizes & closes the WAV file.
-    ~WavOutFile();
-
-    /// Write data to WAV file. This function works only with 8bit samples. 
-    /// Throws a 'runtime_error' exception if writing to file fails.
-    void write(const unsigned char *buffer, ///< Pointer to sample data buffer.
-               int numElems                 ///< How many array items are to be written to file.
-               );
-
-    /// Write data to WAV file. Throws a 'runtime_error' exception if writing to
-    /// file fails.
-    void write(const short *buffer,     ///< Pointer to sample data buffer.
-               int numElems             ///< How many array items are to be written to file.
-               );
-
-    /// Write data to WAV file in floating point format, saturating sample values to range
-    /// [-1..+1[. Throws a 'runtime_error' exception if writing to file fails.
-    void write(const float *buffer,     ///< Pointer to sample data buffer.
-               int numElems             ///< How many array items are to be written to file.
-               );
-};
-
- }
-
-#endif
+////////////////////////////////////////////////////////////////////////////////
+///
+/// Classes for easy reading & writing of WAV sound files.
+///
+/// For big-endian CPU, define BIG_ENDIAN during compile-time to correctly
+/// parse the WAV files with such processors.
+///
+/// Admittingly, more complete WAV reader routines may exist in public domain, but
+/// the reason for 'yet another' one is that those generic WAV reader libraries are
+/// exhaustingly large and cumbersome! Wanted to have something simpler here, i.e.
+/// something that's not already larger than rest of the SoundTouch/SoundStretch program...
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef WAVFILE_H
+#define WAVFILE_H
+
+#include 
+#include 
+#include "SS_CharTypes.h"
+
+namespace soundstretch
+{
+
+#ifndef uint
+typedef unsigned int uint;
+#endif
+
+
+/// WAV audio file 'riff' section header
+typedef struct
+{
+    char riff_char[4];
+    uint package_len;
+    char wave[4];
+} WavRiff;
+
+/// WAV audio file 'format' section header
+typedef struct
+{
+    char  fmt[4];
+    unsigned int   format_len;
+    unsigned short fixed;
+    unsigned short channel_number;
+    unsigned int   sample_rate;
+    unsigned int   byte_rate;
+    unsigned short byte_per_sample;
+    unsigned short bits_per_sample;
+} WavFormat;
+
+/// WAV audio file 'fact' section header
+typedef struct
+{
+    char fact_field[4];
+    uint fact_len;
+    uint fact_sample_len;
+} WavFact;
+
+/// WAV audio file 'data' section header
+typedef struct
+{
+    char  data_field[4];
+    uint  data_len;
+} WavData;
+
+
+/// WAV audio file header
+typedef struct
+{
+    WavRiff   riff;
+    WavFormat format;
+    WavFact   fact;
+    WavData   data;
+} WavHeader;
+
+
+/// Base class for processing WAV audio files.
+class WavFileBase
+{
+private:
+    /// Conversion working buffer;
+    char *convBuff;
+    int convBuffSize;
+
+protected:
+    WavFileBase();
+    virtual ~WavFileBase();
+
+    /// Get pointer to conversion buffer of at min. given size
+    void *getConvBuffer(int sizeByte);
+};
+
+
+/// Class for reading WAV audio files.
+class WavInFile : protected WavFileBase
+{
+private:
+    /// File pointer.
+    FILE *fptr;
+
+    /// Counter of how many bytes of sample data have been read from the file.
+    long dataRead;
+
+    /// WAV header information
+    WavHeader header;
+
+    /// Init the WAV file stream
+    void init();
+
+    /// Read WAV file headers.
+    /// \return zero if all ok, nonzero if file format is invalid.
+    int readWavHeaders();
+
+    /// Checks WAV file header tags.
+    /// \return zero if all ok, nonzero if file format is invalid.
+    int checkCharTags() const;
+
+    /// Reads a single WAV file header block.
+    /// \return zero if all ok, nonzero if file format is invalid.
+    int readHeaderBlock();
+
+    /// Reads WAV file 'riff' block
+    int readRIFFBlock();
+
+public:
+    /// Constructor: Opens the given WAV file. If the file can't be opened,
+    /// throws 'runtime_error' exception.
+    WavInFile(const STRING& filename);
+
+    WavInFile(FILE *file);
+
+    /// Destructor: Closes the file.
+    ~WavInFile();
+
+    /// Rewind to beginning of the file
+    void rewind();
+
+    /// Get sample rate.
+    uint getSampleRate() const;
+
+    /// Get number of bits per sample, i.e. 8 or 16.
+    uint getNumBits() const;
+
+    /// Get sample data size in bytes. Ahem, this should return same information as
+    /// 'getBytesPerSample'...
+    uint getDataSizeInBytes() const;
+
+    /// Get total number of samples in file.
+    uint getNumSamples() const;
+
+    /// Get number of bytes per audio sample (e.g. 16bit stereo = 4 bytes/sample)
+    uint getBytesPerSample() const;
+
+    /// Get number of audio channels in the file (1=mono, 2=stereo)
+    uint getNumChannels() const;
+
+    /// Get the audio file length in milliseconds
+    uint getLengthMS() const;
+
+    /// Returns how many milliseconds of audio have so far been read from the file
+    ///
+    /// \return elapsed duration in milliseconds
+    uint getElapsedMS() const;
+
+    /// Reads audio samples from the WAV file. This routine works only for 8 bit samples.
+    /// Reads given number of elements from the file or if end-of-file reached, as many
+    /// elements as are left in the file.
+    ///
+    /// \return Number of 8-bit integers read from the file.
+    int read(unsigned char *buffer, int maxElems);
+
+    /// Reads audio samples from the WAV file to 16 bit integer format. Reads given number
+    /// of elements from the file or if end-of-file reached, as many elements as are
+    /// left in the file.
+    ///
+    /// \return Number of 16-bit integers read from the file.
+    int read(short *buffer,     ///< Pointer to buffer where to read data.
+             int maxElems       ///< Size of 'buffer' array (number of array elements).
+             );
+
+    /// Reads audio samples from the WAV file to floating point format, converting
+    /// sample values to range [-1,1[. Reads given number of elements from the file
+    /// or if end-of-file reached, as many elements as are left in the file.
+    /// Notice that reading in float format supports 8/16/24/32bit sample formats.
+    ///
+    /// \return Number of elements read from the file.
+    int read(float *buffer,     ///< Pointer to buffer where to read data.
+             int maxElems       ///< Size of 'buffer' array (number of array elements).
+             );
+
+    /// Check end-of-file.
+    ///
+    /// \return Nonzero if end-of-file reached.
+    int eof() const;
+};
+
+
+/// Class for writing WAV audio files.
+class WavOutFile : protected WavFileBase
+{
+private:
+    /// Pointer to the WAV file
+    FILE *fptr;
+
+    /// WAV file header data.
+    WavHeader header;
+
+    /// Counter of how many bytes have been written to the file so far.
+    int bytesWritten;
+
+    /// Fills in WAV file header information.
+    void fillInHeader(const uint sampleRate, const uint bits, const uint channels);
+
+    /// Finishes the WAV file header by supplementing information of amount of
+    /// data written to file etc
+    void finishHeader();
+
+    /// Writes the WAV file header.
+    void writeHeader();
+
+public:
+    /// Constructor: Creates a new WAV file. Throws a 'runtime_error' exception
+    /// if file creation fails.
+    WavOutFile(const STRING& fileName,  ///< Filename
+               int sampleRate,          ///< Sample rate (e.g. 44100 etc)
+               int bits,                ///< Bits per sample (8 or 16 bits)
+               int channels             ///< Number of channels (1=mono, 2=stereo)
+               );
+
+    WavOutFile(FILE *file, int sampleRate, int bits, int channels);
+
+    /// Destructor: Finalizes & closes the WAV file.
+    ~WavOutFile();
+
+    /// Write data to WAV file. This function works only with 8bit samples.
+    /// Throws a 'runtime_error' exception if writing to file fails.
+    void write(const unsigned char *buffer, ///< Pointer to sample data buffer.
+               int numElems                 ///< How many array items are to be written to file.
+               );
+
+    /// Write data to WAV file. Throws a 'runtime_error' exception if writing to
+    /// file fails.
+    void write(const short *buffer,     ///< Pointer to sample data buffer.
+               int numElems             ///< How many array items are to be written to file.
+               );
+
+    /// Write data to WAV file in floating point format, saturating sample values to range
+    /// [-1..+1[. Throws a 'runtime_error' exception if writing to file fails.
+    void write(const float *buffer,     ///< Pointer to sample data buffer.
+               int numElems             ///< How many array items are to be written to file.
+               );
+};
+
+ }
+
+#endif
diff --git a/source/SoundStretch/main.cpp b/source/SoundStretch/main.cpp
index 8ae71fa..d443060 100644
--- a/source/SoundStretch/main.cpp
+++ b/source/SoundStretch/main.cpp
@@ -1,311 +1,311 @@
-////////////////////////////////////////////////////////////////////////////////
-///
-/// SoundStretch main routine.
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include 
-#include 
-#include 
-#include 
-#include 
-#include 
-#include "RunParameters.h"
-#include "WavFile.h"
-#include "SoundTouch.h"
-#include "BPMDetect.h"
-
-using namespace soundtouch;
-using namespace std;
-
-namespace soundstretch
-{
-
-// Processing chunk size (size chosen to be divisible by 2, 4, 6, 8, 10, 12, 14, 16 channels ...)
-#define BUFF_SIZE           6720
-
-#if _WIN32
-#include 
-#include 
-
-// Macro for Win32 standard input/output stream support: Sets a file stream into binary mode
-#define SET_STREAM_TO_BIN_MODE(f) (_setmode(_fileno(f), _O_BINARY))
-#else
-    // Not needed for GNU environment... 
-#define SET_STREAM_TO_BIN_MODE(f) {}
-#endif
-
-
-static const char _helloText[] =
-    "\n"
-    "   SoundStretch v%s -  Copyright (c) Olli Parviainen\n"
-    "=========================================================\n"
-    "author e-mail:  - WWW: http://www.surina.net/soundtouch\n"
-    "\n"
-    "This program is subject to (L)GPL license. Run \"soundstretch -license\" for\n"
-    "more information.\n"
-    "\n";
-
-static void openFiles(unique_ptr& inFile, unique_ptr& outFile, const RunParameters& params)
-{
-    if (params.inFileName == STRING_CONST("stdin"))
-    {
-        // used 'stdin' as input file
-        SET_STREAM_TO_BIN_MODE(stdin);
-        inFile = make_unique(stdin);
-    }
-    else
-    {
-        // open input file...
-        inFile = make_unique(params.inFileName.c_str());
-    }
-
-    // ... open output file with same sound parameters
-    const int bits = (int)inFile->getNumBits();
-    const int samplerate = (int)inFile->getSampleRate();
-    const int channels = (int)inFile->getNumChannels();
-
-    if (!params.outFileName.empty())
-    {
-        if (params.outFileName == STRING_CONST("stdout"))
-        {
-            SET_STREAM_TO_BIN_MODE(stdout);
-            outFile = make_unique(stdout, samplerate, bits, channels);
-        }
-        else
-        {
-            outFile = make_unique(params.outFileName.c_str(), samplerate, bits, channels);
-        }
-    }
-}
-
-
-// Sets the 'SoundTouch' object up according to input file sound format & 
-// command line parameters
-static void setup(SoundTouch& soundTouch, const WavInFile& inFile, const RunParameters& params)
-{
-    const int sampleRate = (int)inFile.getSampleRate();
-    const int channels = (int)inFile.getNumChannels();
-    soundTouch.setSampleRate(sampleRate);
-    soundTouch.setChannels(channels);
-
-    soundTouch.setTempoChange(params.tempoDelta);
-    soundTouch.setPitchSemiTones(params.pitchDelta);
-    soundTouch.setRateChange(params.rateDelta);
-
-    soundTouch.setSetting(SETTING_USE_QUICKSEEK, params.quick);
-    soundTouch.setSetting(SETTING_USE_AA_FILTER, !(params.noAntiAlias));
-
-    if (params.speech)
-    {
-        // use settings for speech processing
-        soundTouch.setSetting(SETTING_SEQUENCE_MS, 40);
-        soundTouch.setSetting(SETTING_SEEKWINDOW_MS, 15);
-        soundTouch.setSetting(SETTING_OVERLAP_MS, 8);
-        fprintf(stderr, "Tune processing parameters for speech processing.\n");
-    }
-
-    // print processing information
-    if (!params.outFileName.empty())
-    {
-#ifdef SOUNDTOUCH_INTEGER_SAMPLES
-        fprintf(stderr, "Uses 16bit integer sample type in processing.\n\n");
-#else
-#ifndef SOUNDTOUCH_FLOAT_SAMPLES
-#error "Sampletype not defined"
-#endif
-        fprintf(stderr, "Uses 32bit floating point sample type in processing.\n\n");
-#endif
-        // print processing information only if outFileName given i.e. some processing will happen
-        fprintf(stderr, "Processing the file with the following changes:\n");
-        fprintf(stderr, "  tempo change = %+g %%\n", params.tempoDelta);
-        fprintf(stderr, "  pitch change = %+g semitones\n", params.pitchDelta);
-        fprintf(stderr, "  rate change  = %+g %%\n\n", params.rateDelta);
-        fprintf(stderr, "Working...");
-    }
-    else
-    {
-        // outFileName not given
-        fprintf(stderr, "Warning: output file name missing, won't output anything.\n\n");
-    }
-
-    fflush(stderr);
-}
-
-
-// Processes the sound
-static void process(SoundTouch& soundTouch, WavInFile& inFile, WavOutFile& outFile)
-{
-    SAMPLETYPE sampleBuffer[BUFF_SIZE];
-    int nSamples;
-
-    const int nChannels = (int)inFile.getNumChannels();
-    assert(nChannels > 0);
-    const int buffSizeSamples = BUFF_SIZE / nChannels;
-
-    // Process samples read from the input file
-    while (inFile.eof() == 0)
-    {
-        // Read a chunk of samples from the input file
-        const int num = inFile.read(sampleBuffer, BUFF_SIZE);
-        int nSamples = num / (int)inFile.getNumChannels();
-
-        // Feed the samples into SoundTouch processor
-        soundTouch.putSamples(sampleBuffer, nSamples);
-
-        // Read ready samples from SoundTouch processor & write them output file.
-        // NOTES:
-        // - 'receiveSamples' doesn't necessarily return any samples at all
-        //   during some rounds!
-        // - On the other hand, during some round 'receiveSamples' may have more
-        //   ready samples than would fit into 'sampleBuffer', and for this reason 
-        //   the 'receiveSamples' call is iterated for as many times as it
-        //   outputs samples.
-        do
-        {
-            nSamples = soundTouch.receiveSamples(sampleBuffer, buffSizeSamples);
-            outFile.write(sampleBuffer, nSamples * nChannels);
-        } while (nSamples != 0);
-    }
-
-    // Now the input file is processed, yet 'flush' few last samples that are
-    // hiding in the SoundTouch's internal processing pipeline.
-    soundTouch.flush();
-    do
-    {
-        nSamples = soundTouch.receiveSamples(sampleBuffer, buffSizeSamples);
-        outFile.write(sampleBuffer, nSamples * nChannels);
-    } while (nSamples != 0);
-}
-
-
-// Detect BPM rate of inFile and adjust tempo setting accordingly if necessary
-static void detectBPM(WavInFile& inFile, RunParameters& params)
-{
-    BPMDetect bpm(inFile.getNumChannels(), inFile.getSampleRate());
-    SAMPLETYPE sampleBuffer[BUFF_SIZE];
-
-    // detect bpm rate
-    fprintf(stderr, "Detecting BPM rate...");
-    fflush(stderr);
-
-    const int nChannels = (int)inFile.getNumChannels();
-    int readSize = BUFF_SIZE - BUFF_SIZE % nChannels;   // round read size down to multiple of num.channels 
-
-    // Process the 'inFile' in small blocks, repeat until whole file has 
-    // been processed
-    while (inFile.eof() == 0)
-    {
-        // Read sample data from input file
-        const int num = inFile.read(sampleBuffer, readSize);
-
-        // Enter the new samples to the bpm analyzer class
-        const int samples = num / nChannels;
-        bpm.inputSamples(sampleBuffer, samples);
-    }
-
-    // Now the whole song data has been analyzed. Read the resulting bpm.
-    const float bpmValue = bpm.getBpm();
-    fprintf(stderr, "Done!\n");
-
-    // rewind the file after bpm detection
-    inFile.rewind();
-
-    if (bpmValue > 0)
-    {
-        fprintf(stderr, "Detected BPM rate %.1f\n\n", bpmValue);
-    }
-    else
-    {
-        fprintf(stderr, "Couldn't detect BPM rate.\n\n");
-        return;
-    }
-
-    if (params.goalBPM > 0)
-    {
-        // adjust tempo to given bpm
-        params.tempoDelta = (params.goalBPM / bpmValue - 1.0f) * 100.0f;
-        fprintf(stderr, "The file will be converted to %.1f BPM\n\n", params.goalBPM);
-    }
-}
-
-void ss_main(RunParameters& params)
-{
-    unique_ptr inFile;
-    unique_ptr outFile;
-    SoundTouch soundTouch;
-
-    fprintf(stderr, _helloText, soundTouch.getVersionString());
-
-    // Open input & output files
-    openFiles(inFile, outFile, params);
-
-    if (params.detectBPM == true)
-    {
-        // detect sound BPM (and adjust processing parameters
-        //  accordingly if necessary)
-        detectBPM(*inFile, params);
-    }
-
-    // Setup the 'SoundTouch' object for processing the sound
-    setup(soundTouch, *inFile, params);
-
-    // clock_t cs = clock();    // for benchmarking processing duration
-    // Process the sound
-    if (inFile && outFile)
-    {
-        process(soundTouch, *inFile, *outFile);
-    }
-    // clock_t ce = clock();    // for benchmarking processing duration
-    // printf("duration: %lf\n", (double)(ce-cs)/CLOCKS_PER_SEC);
-
-    fprintf(stderr, "Done!\n");
-}
-
-}
-
-#if _WIN32
-int wmain(int argc, const wchar_t* args[])
-#else
-int main(int argc, const char* args[])
-#endif
-{
-    try
-    {
-        soundstretch::RunParameters params(argc, args);
-        soundstretch::ss_main(params);
-    }
-    catch (const runtime_error& e)
-    {
-        fprintf(stderr, "%s\n", e.what());
-        return -1;
-    }
-    return 0;
-}
+////////////////////////////////////////////////////////////////////////////////
+///
+/// SoundStretch main routine.
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include "RunParameters.h"
+#include "WavFile.h"
+#include "SoundTouch.h"
+#include "BPMDetect.h"
+
+using namespace soundtouch;
+using namespace std;
+
+namespace soundstretch
+{
+
+// Processing chunk size (size chosen to be divisible by 2, 4, 6, 8, 10, 12, 14, 16 channels ...)
+#define BUFF_SIZE           6720
+
+#if _WIN32
+#include 
+#include 
+
+// Macro for Win32 standard input/output stream support: Sets a file stream into binary mode
+#define SET_STREAM_TO_BIN_MODE(f) (_setmode(_fileno(f), _O_BINARY))
+#else
+    // Not needed for GNU environment...
+#define SET_STREAM_TO_BIN_MODE(f) {}
+#endif
+
+
+static const char _helloText[] =
+    "\n"
+    "   SoundStretch v%s -  Copyright (c) Olli Parviainen\n"
+    "=========================================================\n"
+    "author e-mail:  - WWW: http://www.surina.net/soundtouch\n"
+    "\n"
+    "This program is subject to (L)GPL license. Run \"soundstretch -license\" for\n"
+    "more information.\n"
+    "\n";
+
+static void openFiles(unique_ptr& inFile, unique_ptr& outFile, const RunParameters& params)
+{
+    if (params.inFileName == STRING_CONST("stdin"))
+    {
+        // used 'stdin' as input file
+        SET_STREAM_TO_BIN_MODE(stdin);
+        inFile = make_unique(stdin);
+    }
+    else
+    {
+        // open input file...
+        inFile = make_unique(params.inFileName.c_str());
+    }
+
+    // ... open output file with same sound parameters
+    const int bits = (int)inFile->getNumBits();
+    const int samplerate = (int)inFile->getSampleRate();
+    const int channels = (int)inFile->getNumChannels();
+
+    if (!params.outFileName.empty())
+    {
+        if (params.outFileName == STRING_CONST("stdout"))
+        {
+            SET_STREAM_TO_BIN_MODE(stdout);
+            outFile = make_unique(stdout, samplerate, bits, channels);
+        }
+        else
+        {
+            outFile = make_unique(params.outFileName.c_str(), samplerate, bits, channels);
+        }
+    }
+}
+
+
+// Sets the 'SoundTouch' object up according to input file sound format &
+// command line parameters
+static void setup(SoundTouch& soundTouch, const WavInFile& inFile, const RunParameters& params)
+{
+    const int sampleRate = (int)inFile.getSampleRate();
+    const int channels = (int)inFile.getNumChannels();
+    soundTouch.setSampleRate(sampleRate);
+    soundTouch.setChannels(channels);
+
+    soundTouch.setTempoChange(params.tempoDelta);
+    soundTouch.setPitchSemiTones(params.pitchDelta);
+    soundTouch.setRateChange(params.rateDelta);
+
+    soundTouch.setSetting(SETTING_USE_QUICKSEEK, params.quick);
+    soundTouch.setSetting(SETTING_USE_AA_FILTER, !(params.noAntiAlias));
+
+    if (params.speech)
+    {
+        // use settings for speech processing
+        soundTouch.setSetting(SETTING_SEQUENCE_MS, 40);
+        soundTouch.setSetting(SETTING_SEEKWINDOW_MS, 15);
+        soundTouch.setSetting(SETTING_OVERLAP_MS, 8);
+        fprintf(stderr, "Tune processing parameters for speech processing.\n");
+    }
+
+    // print processing information
+    if (!params.outFileName.empty())
+    {
+#ifdef SOUNDTOUCH_INTEGER_SAMPLES
+        fprintf(stderr, "Uses 16bit integer sample type in processing.\n\n");
+#else
+#ifndef SOUNDTOUCH_FLOAT_SAMPLES
+#error "Sampletype not defined"
+#endif
+        fprintf(stderr, "Uses 32bit floating point sample type in processing.\n\n");
+#endif
+        // print processing information only if outFileName given i.e. some processing will happen
+        fprintf(stderr, "Processing the file with the following changes:\n");
+        fprintf(stderr, "  tempo change = %+g %%\n", params.tempoDelta);
+        fprintf(stderr, "  pitch change = %+g semitones\n", params.pitchDelta);
+        fprintf(stderr, "  rate change  = %+g %%\n\n", params.rateDelta);
+        fprintf(stderr, "Working...");
+    }
+    else
+    {
+        // outFileName not given
+        fprintf(stderr, "Warning: output file name missing, won't output anything.\n\n");
+    }
+
+    fflush(stderr);
+}
+
+
+// Processes the sound
+static void process(SoundTouch& soundTouch, WavInFile& inFile, WavOutFile& outFile)
+{
+    SAMPLETYPE sampleBuffer[BUFF_SIZE];
+    int nSamples;
+
+    const int nChannels = (int)inFile.getNumChannels();
+    assert(nChannels > 0);
+    const int buffSizeSamples = BUFF_SIZE / nChannels;
+
+    // Process samples read from the input file
+    while (inFile.eof() == 0)
+    {
+        // Read a chunk of samples from the input file
+        const int num = inFile.read(sampleBuffer, BUFF_SIZE);
+        int nSamples = num / (int)inFile.getNumChannels();
+
+        // Feed the samples into SoundTouch processor
+        soundTouch.putSamples(sampleBuffer, nSamples);
+
+        // Read ready samples from SoundTouch processor & write them output file.
+        // NOTES:
+        // - 'receiveSamples' doesn't necessarily return any samples at all
+        //   during some rounds!
+        // - On the other hand, during some round 'receiveSamples' may have more
+        //   ready samples than would fit into 'sampleBuffer', and for this reason
+        //   the 'receiveSamples' call is iterated for as many times as it
+        //   outputs samples.
+        do
+        {
+            nSamples = soundTouch.receiveSamples(sampleBuffer, buffSizeSamples);
+            outFile.write(sampleBuffer, nSamples * nChannels);
+        } while (nSamples != 0);
+    }
+
+    // Now the input file is processed, yet 'flush' few last samples that are
+    // hiding in the SoundTouch's internal processing pipeline.
+    soundTouch.flush();
+    do
+    {
+        nSamples = soundTouch.receiveSamples(sampleBuffer, buffSizeSamples);
+        outFile.write(sampleBuffer, nSamples * nChannels);
+    } while (nSamples != 0);
+}
+
+
+// Detect BPM rate of inFile and adjust tempo setting accordingly if necessary
+static void detectBPM(WavInFile& inFile, RunParameters& params)
+{
+    BPMDetect bpm(inFile.getNumChannels(), inFile.getSampleRate());
+    SAMPLETYPE sampleBuffer[BUFF_SIZE];
+
+    // detect bpm rate
+    fprintf(stderr, "Detecting BPM rate...");
+    fflush(stderr);
+
+    const int nChannels = (int)inFile.getNumChannels();
+    int readSize = BUFF_SIZE - BUFF_SIZE % nChannels;   // round read size down to multiple of num.channels
+
+    // Process the 'inFile' in small blocks, repeat until whole file has
+    // been processed
+    while (inFile.eof() == 0)
+    {
+        // Read sample data from input file
+        const int num = inFile.read(sampleBuffer, readSize);
+
+        // Enter the new samples to the bpm analyzer class
+        const int samples = num / nChannels;
+        bpm.inputSamples(sampleBuffer, samples);
+    }
+
+    // Now the whole song data has been analyzed. Read the resulting bpm.
+    const float bpmValue = bpm.getBpm();
+    fprintf(stderr, "Done!\n");
+
+    // rewind the file after bpm detection
+    inFile.rewind();
+
+    if (bpmValue > 0)
+    {
+        fprintf(stderr, "Detected BPM rate %.1f\n\n", bpmValue);
+    }
+    else
+    {
+        fprintf(stderr, "Couldn't detect BPM rate.\n\n");
+        return;
+    }
+
+    if (params.goalBPM > 0)
+    {
+        // adjust tempo to given bpm
+        params.tempoDelta = (params.goalBPM / bpmValue - 1.0f) * 100.0f;
+        fprintf(stderr, "The file will be converted to %.1f BPM\n\n", params.goalBPM);
+    }
+}
+
+void ss_main(RunParameters& params)
+{
+    unique_ptr inFile;
+    unique_ptr outFile;
+    SoundTouch soundTouch;
+
+    fprintf(stderr, _helloText, soundTouch.getVersionString());
+
+    // Open input & output files
+    openFiles(inFile, outFile, params);
+
+    if (params.detectBPM == true)
+    {
+        // detect sound BPM (and adjust processing parameters
+        //  accordingly if necessary)
+        detectBPM(*inFile, params);
+    }
+
+    // Setup the 'SoundTouch' object for processing the sound
+    setup(soundTouch, *inFile, params);
+
+    // clock_t cs = clock();    // for benchmarking processing duration
+    // Process the sound
+    if (inFile && outFile)
+    {
+        process(soundTouch, *inFile, *outFile);
+    }
+    // clock_t ce = clock();    // for benchmarking processing duration
+    // printf("duration: %lf\n", (double)(ce-cs)/CLOCKS_PER_SEC);
+
+    fprintf(stderr, "Done!\n");
+}
+
+}
+
+#if _WIN32
+int wmain(int argc, const wchar_t* args[])
+#else
+int main(int argc, const char* args[])
+#endif
+{
+    try
+    {
+        soundstretch::RunParameters params(argc, args);
+        soundstretch::ss_main(params);
+    }
+    catch (const runtime_error& e)
+    {
+        fprintf(stderr, "%s\n", e.what());
+        return -1;
+    }
+    return 0;
+}
diff --git a/source/SoundTouch/AAFilter.cpp b/source/SoundTouch/AAFilter.cpp
index 89c54cc..f097200 100644
--- a/source/SoundTouch/AAFilter.cpp
+++ b/source/SoundTouch/AAFilter.cpp
@@ -1,222 +1,222 @@
-////////////////////////////////////////////////////////////////////////////////
-///
-/// FIR low-pass (anti-alias) filter with filter coefficient design routine and
-/// MMX optimization. 
-/// 
-/// Anti-alias filter is used to prevent folding of high frequencies when 
-/// transposing the sample rate with interpolation.
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include 
-#include 
-#include 
-#include 
-#include "AAFilter.h"
-#include "FIRFilter.h"
-
-using namespace soundtouch;
-
-#define PI       3.14159265358979323846
-#define TWOPI    (2 * PI)
-
-// define this to save AA filter coefficients to a file
-// #define _DEBUG_SAVE_AAFILTER_COEFFICIENTS   1
-
-#ifdef _DEBUG_SAVE_AAFILTER_COEFFICIENTS
-    #include 
-
-    static void _DEBUG_SAVE_AAFIR_COEFFS(SAMPLETYPE *coeffs, int len)
-    {
-        FILE *fptr = fopen("aa_filter_coeffs.txt", "wt");
-        if (fptr == nullptr) return;
-
-        for (int i = 0; i < len; i ++)
-        {
-            double temp = coeffs[i];
-            fprintf(fptr, "%lf\n", temp);
-        }
-        fclose(fptr);
-    }
-
-#else
-    #define _DEBUG_SAVE_AAFIR_COEFFS(x, y)
-#endif
-
-/*****************************************************************************
- *
- * Implementation of the class 'AAFilter'
- *
- *****************************************************************************/
-
-AAFilter::AAFilter(uint len)
-{
-    pFIR = FIRFilter::newInstance();
-    cutoffFreq = 0.5;
-    setLength(len);
-}
-
-
-AAFilter::~AAFilter()
-{
-    delete pFIR;
-}
-
-
-// Sets new anti-alias filter cut-off edge frequency, scaled to
-// sampling frequency (nyquist frequency = 0.5).
-// The filter will cut frequencies higher than the given frequency.
-void AAFilter::setCutoffFreq(double newCutoffFreq)
-{
-    cutoffFreq = newCutoffFreq;
-    calculateCoeffs();
-}
-
-
-// Sets number of FIR filter taps
-void AAFilter::setLength(uint newLength)
-{
-    length = newLength;
-    calculateCoeffs();
-}
-
-
-// Calculates coefficients for a low-pass FIR filter using Hamming window
-void AAFilter::calculateCoeffs()
-{
-    uint i;
-    double cntTemp, temp, tempCoeff,h, w;
-    double wc;
-    double scaleCoeff, sum;
-    double *work;
-    SAMPLETYPE *coeffs;
-
-    assert(length >= 2);
-    assert(length % 4 == 0);
-    assert(cutoffFreq >= 0);
-    assert(cutoffFreq <= 0.5);
-
-    work = new double[length];
-    coeffs = new SAMPLETYPE[length];
-
-    wc = 2.0 * PI * cutoffFreq;
-    tempCoeff = TWOPI / (double)length;
-
-    sum = 0;
-    for (i = 0; i < length; i ++) 
-    {
-        cntTemp = (double)i - (double)(length / 2);
-
-        temp = cntTemp * wc;
-        if (temp != 0) 
-        {
-            h = sin(temp) / temp;                     // sinc function
-        } 
-        else 
-        {
-            h = 1.0;
-        }
-        w = 0.54 + 0.46 * cos(tempCoeff * cntTemp);       // hamming window
-
-        temp = w * h;
-        work[i] = temp;
-
-        // calc net sum of coefficients 
-        sum += temp;
-    }
-
-    // ensure the sum of coefficients is larger than zero
-    assert(sum > 0);
-
-    // ensure we've really designed a lowpass filter...
-    assert(work[length/2] > 0);
-    assert(work[length/2 + 1] > -1e-6);
-    assert(work[length/2 - 1] > -1e-6);
-
-    // Calculate a scaling coefficient in such a way that the result can be
-    // divided by 16384
-    scaleCoeff = 16384.0f / sum;
-
-    for (i = 0; i < length; i ++) 
-    {
-        temp = work[i] * scaleCoeff;
-        // scale & round to nearest integer
-        temp += (temp >= 0) ? 0.5 : -0.5;
-        // ensure no overfloods
-        assert(temp >= -32768 && temp <= 32767);
-        coeffs[i] = (SAMPLETYPE)temp;
-    }
-
-    // Set coefficients. Use divide factor 14 => divide result by 2^14 = 16384
-    pFIR->setCoefficients(coeffs, length, 14);
-
-    _DEBUG_SAVE_AAFIR_COEFFS(coeffs, length);
-
-    delete[] work;
-    delete[] coeffs;
-}
-
-
-// Applies the filter to the given sequence of samples. 
-// Note : The amount of outputted samples is by value of 'filter length' 
-// smaller than the amount of input samples.
-uint AAFilter::evaluate(SAMPLETYPE *dest, const SAMPLETYPE *src, uint numSamples, uint numChannels) const
-{
-    return pFIR->evaluate(dest, src, numSamples, numChannels);
-}
-
-
-/// Applies the filter to the given src & dest pipes, so that processed amount of
-/// samples get removed from src, and produced amount added to dest 
-/// Note : The amount of outputted samples is by value of 'filter length' 
-/// smaller than the amount of input samples.
-uint AAFilter::evaluate(FIFOSampleBuffer &dest, FIFOSampleBuffer &src) const
-{
-    SAMPLETYPE *pdest;
-    const SAMPLETYPE *psrc;
-    uint numSrcSamples;
-    uint result;
-    int numChannels = src.getChannels();
-
-    assert(numChannels == dest.getChannels());
-
-    numSrcSamples = src.numSamples();
-    psrc = src.ptrBegin();
-    pdest = dest.ptrEnd(numSrcSamples);
-    result = pFIR->evaluate(pdest, psrc, numSrcSamples, numChannels);
-    src.receiveSamples(result);
-    dest.putSamples(result);
-
-    return result;
-}
-
-
-uint AAFilter::getLength() const
-{
-    return pFIR->getLength();
-}
+////////////////////////////////////////////////////////////////////////////////
+///
+/// FIR low-pass (anti-alias) filter with filter coefficient design routine and
+/// MMX optimization.
+///
+/// Anti-alias filter is used to prevent folding of high frequencies when
+/// transposing the sample rate with interpolation.
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#include 
+#include 
+#include 
+#include 
+#include "AAFilter.h"
+#include "FIRFilter.h"
+
+using namespace soundtouch;
+
+#define PI       3.14159265358979323846
+#define TWOPI    (2 * PI)
+
+// define this to save AA filter coefficients to a file
+// #define _DEBUG_SAVE_AAFILTER_COEFFICIENTS   1
+
+#ifdef _DEBUG_SAVE_AAFILTER_COEFFICIENTS
+    #include 
+
+    static void _DEBUG_SAVE_AAFIR_COEFFS(SAMPLETYPE *coeffs, int len)
+    {
+        FILE *fptr = fopen("aa_filter_coeffs.txt", "wt");
+        if (fptr == nullptr) return;
+
+        for (int i = 0; i < len; i ++)
+        {
+            double temp = coeffs[i];
+            fprintf(fptr, "%lf\n", temp);
+        }
+        fclose(fptr);
+    }
+
+#else
+    #define _DEBUG_SAVE_AAFIR_COEFFS(x, y)
+#endif
+
+/*****************************************************************************
+ *
+ * Implementation of the class 'AAFilter'
+ *
+ *****************************************************************************/
+
+AAFilter::AAFilter(uint len)
+{
+    pFIR = FIRFilter::newInstance();
+    cutoffFreq = 0.5;
+    setLength(len);
+}
+
+
+AAFilter::~AAFilter()
+{
+    delete pFIR;
+}
+
+
+// Sets new anti-alias filter cut-off edge frequency, scaled to
+// sampling frequency (nyquist frequency = 0.5).
+// The filter will cut frequencies higher than the given frequency.
+void AAFilter::setCutoffFreq(double newCutoffFreq)
+{
+    cutoffFreq = newCutoffFreq;
+    calculateCoeffs();
+}
+
+
+// Sets number of FIR filter taps
+void AAFilter::setLength(uint newLength)
+{
+    length = newLength;
+    calculateCoeffs();
+}
+
+
+// Calculates coefficients for a low-pass FIR filter using Hamming window
+void AAFilter::calculateCoeffs()
+{
+    uint i;
+    double cntTemp, temp, tempCoeff,h, w;
+    double wc;
+    double scaleCoeff, sum;
+    double *work;
+    SAMPLETYPE *coeffs;
+
+    assert(length >= 2);
+    assert(length % 4 == 0);
+    assert(cutoffFreq >= 0);
+    assert(cutoffFreq <= 0.5);
+
+    work = new double[length];
+    coeffs = new SAMPLETYPE[length];
+
+    wc = 2.0 * PI * cutoffFreq;
+    tempCoeff = TWOPI / (double)length;
+
+    sum = 0;
+    for (i = 0; i < length; i ++)
+    {
+        cntTemp = (double)i - (double)(length / 2);
+
+        temp = cntTemp * wc;
+        if (temp != 0)
+        {
+            h = sin(temp) / temp;                     // sinc function
+        }
+        else
+        {
+            h = 1.0;
+        }
+        w = 0.54 + 0.46 * cos(tempCoeff * cntTemp);       // hamming window
+
+        temp = w * h;
+        work[i] = temp;
+
+        // calc net sum of coefficients
+        sum += temp;
+    }
+
+    // ensure the sum of coefficients is larger than zero
+    assert(sum > 0);
+
+    // ensure we've really designed a lowpass filter...
+    assert(work[length/2] > 0);
+    assert(work[length/2 + 1] > -1e-6);
+    assert(work[length/2 - 1] > -1e-6);
+
+    // Calculate a scaling coefficient in such a way that the result can be
+    // divided by 16384
+    scaleCoeff = 16384.0f / sum;
+
+    for (i = 0; i < length; i ++)
+    {
+        temp = work[i] * scaleCoeff;
+        // scale & round to nearest integer
+        temp += (temp >= 0) ? 0.5 : -0.5;
+        // ensure no overfloods
+        assert(temp >= -32768 && temp <= 32767);
+        coeffs[i] = (SAMPLETYPE)temp;
+    }
+
+    // Set coefficients. Use divide factor 14 => divide result by 2^14 = 16384
+    pFIR->setCoefficients(coeffs, length, 14);
+
+    _DEBUG_SAVE_AAFIR_COEFFS(coeffs, length);
+
+    delete[] work;
+    delete[] coeffs;
+}
+
+
+// Applies the filter to the given sequence of samples.
+// Note : The amount of outputted samples is by value of 'filter length'
+// smaller than the amount of input samples.
+uint AAFilter::evaluate(SAMPLETYPE *dest, const SAMPLETYPE *src, uint numSamples, uint numChannels) const
+{
+    return pFIR->evaluate(dest, src, numSamples, numChannels);
+}
+
+
+/// Applies the filter to the given src & dest pipes, so that processed amount of
+/// samples get removed from src, and produced amount added to dest
+/// Note : The amount of outputted samples is by value of 'filter length'
+/// smaller than the amount of input samples.
+uint AAFilter::evaluate(FIFOSampleBuffer &dest, FIFOSampleBuffer &src) const
+{
+    SAMPLETYPE *pdest;
+    const SAMPLETYPE *psrc;
+    uint numSrcSamples;
+    uint result;
+    int numChannels = src.getChannels();
+
+    assert(numChannels == dest.getChannels());
+
+    numSrcSamples = src.numSamples();
+    psrc = src.ptrBegin();
+    pdest = dest.ptrEnd(numSrcSamples);
+    result = pFIR->evaluate(pdest, psrc, numSrcSamples, numChannels);
+    src.receiveSamples(result);
+    dest.putSamples(result);
+
+    return result;
+}
+
+
+uint AAFilter::getLength() const
+{
+    return pFIR->getLength();
+}
diff --git a/source/SoundTouch/AAFilter.h b/source/SoundTouch/AAFilter.h
index 8e5697f..5b63ed6 100644
--- a/source/SoundTouch/AAFilter.h
+++ b/source/SoundTouch/AAFilter.h
@@ -1,93 +1,93 @@
-////////////////////////////////////////////////////////////////////////////////
-///
-/// Sampled sound tempo changer/time stretch algorithm. Changes the sound tempo 
-/// while maintaining the original pitch by using a time domain WSOLA-like method 
-/// with several performance-increasing tweaks.
-///
-/// Anti-alias filter is used to prevent folding of high frequencies when 
-/// transposing the sample rate with interpolation.
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef AAFilter_H
-#define AAFilter_H
-
-#include "STTypes.h"
-#include "FIFOSampleBuffer.h"
-
-namespace soundtouch
-{
-
-class AAFilter
-{
-protected:
-    class FIRFilter *pFIR;
-
-    /// Low-pass filter cut-off frequency, negative = invalid
-    double cutoffFreq;
-
-    /// num of filter taps
-    uint length;
-
-    /// Calculate the FIR coefficients realizing the given cutoff-frequency
-    void calculateCoeffs();
-public:
-    AAFilter(uint length);
-
-    ~AAFilter();
-
-    /// Sets new anti-alias filter cut-off edge frequency, scaled to sampling 
-    /// frequency (nyquist frequency = 0.5). The filter will cut off the 
-    /// frequencies than that.
-    void setCutoffFreq(double newCutoffFreq);
-
-    /// Sets number of FIR filter taps, i.e. ~filter complexity
-    void setLength(uint newLength);
-
-    uint getLength() const;
-
-    /// Applies the filter to the given sequence of samples. 
-    /// Note : The amount of outputted samples is by value of 'filter length' 
-    /// smaller than the amount of input samples.
-    uint evaluate(SAMPLETYPE *dest, 
-                  const SAMPLETYPE *src, 
-                  uint numSamples, 
-                  uint numChannels) const;
-
-    /// Applies the filter to the given src & dest pipes, so that processed amount of
-    /// samples get removed from src, and produced amount added to dest 
-    /// Note : The amount of outputted samples is by value of 'filter length' 
-    /// smaller than the amount of input samples.
-    uint evaluate(FIFOSampleBuffer &dest, 
-                  FIFOSampleBuffer &src) const;
-
-};
-
-}
-
-#endif
+////////////////////////////////////////////////////////////////////////////////
+///
+/// Sampled sound tempo changer/time stretch algorithm. Changes the sound tempo
+/// while maintaining the original pitch by using a time domain WSOLA-like method
+/// with several performance-increasing tweaks.
+///
+/// Anti-alias filter is used to prevent folding of high frequencies when
+/// transposing the sample rate with interpolation.
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef AAFilter_H
+#define AAFilter_H
+
+#include "STTypes.h"
+#include "FIFOSampleBuffer.h"
+
+namespace soundtouch
+{
+
+class AAFilter
+{
+protected:
+    class FIRFilter *pFIR;
+
+    /// Low-pass filter cut-off frequency, negative = invalid
+    double cutoffFreq;
+
+    /// num of filter taps
+    uint length;
+
+    /// Calculate the FIR coefficients realizing the given cutoff-frequency
+    void calculateCoeffs();
+public:
+    AAFilter(uint length);
+
+    ~AAFilter();
+
+    /// Sets new anti-alias filter cut-off edge frequency, scaled to sampling
+    /// frequency (nyquist frequency = 0.5). The filter will cut off the
+    /// frequencies than that.
+    void setCutoffFreq(double newCutoffFreq);
+
+    /// Sets number of FIR filter taps, i.e. ~filter complexity
+    void setLength(uint newLength);
+
+    uint getLength() const;
+
+    /// Applies the filter to the given sequence of samples.
+    /// Note : The amount of outputted samples is by value of 'filter length'
+    /// smaller than the amount of input samples.
+    uint evaluate(SAMPLETYPE *dest,
+                  const SAMPLETYPE *src,
+                  uint numSamples,
+                  uint numChannels) const;
+
+    /// Applies the filter to the given src & dest pipes, so that processed amount of
+    /// samples get removed from src, and produced amount added to dest
+    /// Note : The amount of outputted samples is by value of 'filter length'
+    /// smaller than the amount of input samples.
+    uint evaluate(FIFOSampleBuffer &dest,
+                  FIFOSampleBuffer &src) const;
+
+};
+
+}
+
+#endif
diff --git a/source/SoundTouch/BPMDetect.cpp b/source/SoundTouch/BPMDetect.cpp
index 4c11a2e..f7995c8 100644
--- a/source/SoundTouch/BPMDetect.cpp
+++ b/source/SoundTouch/BPMDetect.cpp
@@ -1,571 +1,571 @@
-////////////////////////////////////////////////////////////////////////////////
-///
-/// Beats-per-minute (BPM) detection routine.
-///
-/// The beat detection algorithm works as follows:
-/// - Use function 'inputSamples' to input a chunks of samples to the class for
-///   analysis. It's a good idea to enter a large sound file or stream in smallish
-///   chunks of around few kilosamples in order not to extinguish too much RAM memory.
-/// - Inputted sound data is decimated to approx 500 Hz to reduce calculation burden,
-///   which is basically ok as low (bass) frequencies mostly determine the beat rate.
-///   Simple averaging is used for anti-alias filtering because the resulting signal
-///   quality isn't of that high importance.
-/// - Decimated sound data is enveloped, i.e. the amplitude shape is detected by
-///   taking absolute value that's smoothed by sliding average. Signal levels that
-///   are below a couple of times the general RMS amplitude level are cut away to
-///   leave only notable peaks there.
-/// - Repeating sound patterns (e.g. beats) are detected by calculating short-term 
-///   autocorrelation function of the enveloped signal.
-/// - After whole sound data file has been analyzed as above, the bpm level is 
-///   detected by function 'getBpm' that finds the highest peak of the autocorrelation 
-///   function, calculates it's precise location and converts this reading to bpm's.
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#define _USE_MATH_DEFINES
-
-#include 
-#include 
-#include 
-#include 
-#include 
-#include "FIFOSampleBuffer.h"
-#include "PeakFinder.h"
-#include "BPMDetect.h"
-
-using namespace soundtouch;
-
-// algorithm input sample block size
-static const int INPUT_BLOCK_SIZE = 2048;
-
-// decimated sample block size
-static const int DECIMATED_BLOCK_SIZE = 256;
-
-/// Target sample rate after decimation
-static const int TARGET_SRATE = 1000;
-
-/// XCorr update sequence size, update in about 200msec chunks
-static const int XCORR_UPDATE_SEQUENCE = (int)(TARGET_SRATE / 5);
-
-/// Moving average N size
-static const int MOVING_AVERAGE_N = 15;
-
-/// XCorr decay time constant, decay to half in 30 seconds
-/// If it's desired to have the system adapt quicker to beat rate 
-/// changes within a continuing music stream, then the 
-/// 'xcorr_decay_time_constant' value can be reduced, yet that
-/// can increase possibility of glitches in bpm detection.
-static const double XCORR_DECAY_TIME_CONSTANT = 30.0;
-
-/// Data overlap factor for beat detection algorithm
-static const int OVERLAP_FACTOR = 4;
-
-static const double TWOPI = (2 * M_PI);
-
-////////////////////////////////////////////////////////////////////////////////
-
-// Enable following define to create bpm analysis file:
-
-//#define _CREATE_BPM_DEBUG_FILE
-
-#ifdef _CREATE_BPM_DEBUG_FILE
-
-    static void _SaveDebugData(const char *name, const float *data, int minpos, int maxpos, double coeff)
-    {
-        FILE *fptr = fopen(name, "wt");
-        int i;
-
-        if (fptr)
-        {
-            printf("\nWriting BPM debug data into file %s\n", name);
-            for (i = minpos; i < maxpos; i ++)
-            {
-                fprintf(fptr, "%d\t%.1lf\t%f\n", i, coeff / (double)i, data[i]);
-            }
-            fclose(fptr);
-        }
-    }
-
-    void _SaveDebugBeatPos(const char *name, const std::vector &beats)
-    {
-        printf("\nWriting beat detections data into file %s\n", name);
-
-        FILE *fptr = fopen(name, "wt");
-        if (fptr)
-        {
-            for (uint i = 0; i < beats.size(); i++)
-            {
-                BEAT b = beats[i];
-                fprintf(fptr, "%lf\t%lf\n", b.pos, b.strength);
-            }
-            fclose(fptr);
-        }
-    }
-#else
-    #define _SaveDebugData(name, a,b,c,d)
-    #define _SaveDebugBeatPos(name, b)
-#endif
-
-// Hamming window
-void hamming(float *w, int N)
-{
-    for (int i = 0; i < N; i++)
-    {
-        w[i] = (float)(0.54 - 0.46 * cos(TWOPI * i / (N - 1)));
-    }
-
-}
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// IIR2_filter - 2nd order IIR filter
-
-IIR2_filter::IIR2_filter(const double *lpf_coeffs)
-{
-    memcpy(coeffs, lpf_coeffs, 5 * sizeof(double));
-    memset(prev, 0, sizeof(prev));
-}
-
-
-float IIR2_filter::update(float x)
-{
-    prev[0] = x;
-    double y = x * coeffs[0];
-
-    for (int i = 4; i >= 1; i--)
-    {
-        y += coeffs[i] * prev[i];
-        prev[i] = prev[i - 1];
-    }
-
-    prev[3] = y;
-    return (float)y;
-}
-
-
-// IIR low-pass filter coefficients, calculated with matlab/octave cheby2(2,40,0.05)
-const double _LPF_coeffs[5] = { 0.00996655391939, -0.01944529148401, 0.00996655391939, 1.96867605796247, -0.96916387431724 };
-
-////////////////////////////////////////////////////////////////////////////////
-
-BPMDetect::BPMDetect(int numChannels, int aSampleRate) :
-    beat_lpf(_LPF_coeffs)
-{
-    beats.reserve(250); // initial reservation to prevent frequent reallocation
-
-    this->sampleRate = aSampleRate;
-    this->channels = numChannels;
-
-    decimateSum = 0;
-    decimateCount = 0;
-
-    // choose decimation factor so that result is approx. 1000 Hz
-    decimateBy = sampleRate / TARGET_SRATE;
-    if ((decimateBy <= 0) || (decimateBy * DECIMATED_BLOCK_SIZE < INPUT_BLOCK_SIZE))
-    {
-        ST_THROW_RT_ERROR("Too small samplerate");
-    }
-
-    // Calculate window length & starting item according to desired min & max bpms
-    windowLen = (60 * sampleRate) / (decimateBy * MIN_BPM);
-    windowStart = (60 * sampleRate) / (decimateBy * MAX_BPM_RANGE);
-
-    assert(windowLen > windowStart);
-
-    // allocate new working objects
-    xcorr = new float[windowLen];
-    memset(xcorr, 0, windowLen * sizeof(float));
-
-    pos = 0;
-    peakPos = 0;
-    peakVal = 0;
-    init_scaler = 1;
-    beatcorr_ringbuffpos = 0;
-    beatcorr_ringbuff = new float[windowLen];
-    memset(beatcorr_ringbuff, 0, windowLen * sizeof(float));
-
-    // allocate processing buffer
-    buffer = new FIFOSampleBuffer();
-    // we do processing in mono mode
-    buffer->setChannels(1);
-    buffer->clear();
-
-    // calculate hamming windows
-    hamw = new float[XCORR_UPDATE_SEQUENCE];
-    hamming(hamw, XCORR_UPDATE_SEQUENCE);
-    hamw2 = new float[XCORR_UPDATE_SEQUENCE / 2];
-    hamming(hamw2, XCORR_UPDATE_SEQUENCE / 2);
-}
-
-
-BPMDetect::~BPMDetect()
-{
-    delete[] xcorr;
-    delete[] beatcorr_ringbuff;
-    delete[] hamw;
-    delete[] hamw2;
-    delete buffer;
-}
-
-
-/// convert to mono, low-pass filter & decimate to about 500 Hz. 
-/// return number of outputted samples.
-///
-/// Decimation is used to remove the unnecessary frequencies and thus to reduce 
-/// the amount of data needed to be processed as calculating autocorrelation 
-/// function is a very-very heavy operation.
-///
-/// Anti-alias filtering is done simply by averaging the samples. This is really a 
-/// poor-man's anti-alias filtering, but it's not so critical in this kind of application
-/// (it'd also be difficult to design a high-quality filter with steep cut-off at very 
-/// narrow band)
-int BPMDetect::decimate(SAMPLETYPE *dest, const SAMPLETYPE *src, int numsamples)
-{
-    int count, outcount;
-    LONG_SAMPLETYPE out;
-
-    assert(channels > 0);
-    assert(decimateBy > 0);
-    outcount = 0;
-    for (count = 0; count < numsamples; count ++) 
-    {
-        int j;
-
-        // convert to mono and accumulate
-        for (j = 0; j < channels; j ++)
-        {
-            decimateSum += src[j];
-        }
-        src += j;
-
-        decimateCount ++;
-        if (decimateCount >= decimateBy) 
-        {
-            // Store every Nth sample only
-            out = (LONG_SAMPLETYPE)(decimateSum / (decimateBy * channels));
-            decimateSum = 0;
-            decimateCount = 0;
-#ifdef SOUNDTOUCH_INTEGER_SAMPLES
-            // check ranges for sure (shouldn't actually be necessary)
-            if (out > 32767) 
-            {
-                out = 32767;
-            } 
-            else if (out < -32768) 
-            {
-                out = -32768;
-            }
-#endif // SOUNDTOUCH_INTEGER_SAMPLES
-            dest[outcount] = (SAMPLETYPE)out;
-            outcount ++;
-        }
-    }
-    return outcount;
-}
-
-
-// Calculates autocorrelation function of the sample history buffer
-void BPMDetect::updateXCorr(int process_samples)
-{
-    int offs;
-    SAMPLETYPE *pBuffer;
-    
-    assert(buffer->numSamples() >= (uint)(process_samples + windowLen));
-    assert(process_samples == XCORR_UPDATE_SEQUENCE);
-
-    pBuffer = buffer->ptrBegin();
-
-    // calculate decay factor for xcorr filtering
-    float xcorr_decay = (float)pow(0.5, 1.0 / (XCORR_DECAY_TIME_CONSTANT * TARGET_SRATE / process_samples));
-
-    // prescale pbuffer
-    float tmp[XCORR_UPDATE_SEQUENCE];
-    for (int i = 0; i < process_samples; i++)
-    {
-        tmp[i] = hamw[i] * hamw[i] * pBuffer[i];
-    }
-
-    #pragma omp parallel for
-    for (offs = windowStart; offs < windowLen; offs ++) 
-    {
-        float sum;
-        int i;
-
-        sum = 0;
-        for (i = 0; i < process_samples; i ++) 
-        {
-            sum += tmp[i] * pBuffer[i + offs];  // scaling the sub-result shouldn't be necessary
-        }
-        xcorr[offs] *= xcorr_decay;   // decay 'xcorr' here with suitable time constant.
-
-        xcorr[offs] += (float)fabs(sum);
-    }
-}
-
-
-// Detect individual beat positions
-void BPMDetect::updateBeatPos(int process_samples)
-{
-    SAMPLETYPE *pBuffer;
-
-    assert(buffer->numSamples() >= (uint)(process_samples + windowLen));
-
-    pBuffer = buffer->ptrBegin();
-    assert(process_samples == XCORR_UPDATE_SEQUENCE / 2);
-
-    //    static double thr = 0.0003;
-    double posScale = (double)this->decimateBy / (double)this->sampleRate;
-    int resetDur = (int)(0.12 / posScale + 0.5);
-
-    // prescale pbuffer
-    float tmp[XCORR_UPDATE_SEQUENCE / 2];
-    for (int i = 0; i < process_samples; i++)
-    {
-        tmp[i] = hamw2[i] * hamw2[i] * pBuffer[i];
-    }
-
-    #pragma omp parallel for
-    for (int offs = windowStart; offs < windowLen; offs++)
-    {
-        float sum = 0;
-        for (int i = 0; i < process_samples; i++)
-        {
-            sum += tmp[i] * pBuffer[offs + i];
-        }
-        beatcorr_ringbuff[(beatcorr_ringbuffpos + offs) % windowLen] += (float)((sum > 0) ? sum : 0); // accumulate only positive correlations
-    }
-
-    int skipstep = XCORR_UPDATE_SEQUENCE / OVERLAP_FACTOR;
-
-    // compensate empty buffer at beginning by scaling coefficient
-    float scale = (float)windowLen / (float)(skipstep * init_scaler);
-    if (scale > 1.0f)
-    {
-        init_scaler++;
-    }
-    else
-    {
-        scale = 1.0f;
-    }
-
-    // detect beats
-    for (int i = 0; i < skipstep; i++)
-    {
-        float sum = beatcorr_ringbuff[beatcorr_ringbuffpos];
-        sum -= beat_lpf.update(sum);
-
-        if (sum > peakVal)
-        {
-            // found new local largest value
-            peakVal = sum;
-            peakPos = pos;
-        }
-        if (pos > peakPos + resetDur)
-        {
-            // largest value not updated for 200msec => accept as beat
-            peakPos += skipstep;
-            if (peakVal > 0)
-            {
-                // add detected beat to end of "beats" vector
-                BEAT temp = { (float)(peakPos * posScale), (float)(peakVal * scale) };
-                beats.push_back(temp);
-            }
-
-            peakVal = 0;
-            peakPos = pos;
-        }
-
-        beatcorr_ringbuff[beatcorr_ringbuffpos] = 0;
-        pos++;
-        beatcorr_ringbuffpos = (beatcorr_ringbuffpos + 1) % windowLen;
-    }
-}
-
-
-#define max(x,y) ((x) > (y) ? (x) : (y))
-
-void BPMDetect::inputSamples(const SAMPLETYPE *samples, int numSamples)
-{
-    SAMPLETYPE decimated[DECIMATED_BLOCK_SIZE];
-
-    // iterate so that max INPUT_BLOCK_SAMPLES processed per iteration
-    while (numSamples > 0)
-    {
-        int block;
-        int decSamples;
-
-        block = (numSamples > INPUT_BLOCK_SIZE) ? INPUT_BLOCK_SIZE : numSamples;
-
-        // decimate. note that converts to mono at the same time
-        decSamples = decimate(decimated, samples, block);
-        samples += block * channels;
-        numSamples -= block;
-
-        buffer->putSamples(decimated, decSamples);
-    }
-
-    // when the buffer has enough samples for processing...
-    int req = max(windowLen + XCORR_UPDATE_SEQUENCE, 2 * XCORR_UPDATE_SEQUENCE);
-    while ((int)buffer->numSamples() >= req) 
-    {
-        // ... update autocorrelations...
-        updateXCorr(XCORR_UPDATE_SEQUENCE);
-        // ...update beat position calculation...
-        updateBeatPos(XCORR_UPDATE_SEQUENCE / 2);
-        // ... and remove proceessed samples from the buffer
-        int n = XCORR_UPDATE_SEQUENCE / OVERLAP_FACTOR;
-        buffer->receiveSamples(n);
-    }
-}
-
-
-void BPMDetect::removeBias()
-{
-    int i;
-
-    // Remove linear bias: calculate linear regression coefficient
-    // 1. calc mean of 'xcorr' and 'i'
-    double mean_i = 0;
-    double mean_x = 0;
-    for (i = windowStart; i < windowLen; i++)
-    {
-        mean_x += xcorr[i];
-    }
-    mean_x /= (windowLen - windowStart);
-    mean_i = 0.5 * (windowLen - 1 + windowStart);
-
-    // 2. calculate linear regression coefficient
-    double b = 0;
-    double div = 0;
-    for (i = windowStart; i < windowLen; i++)
-    {
-        double xt = xcorr[i] - mean_x;
-        double xi = i - mean_i;
-        b += xt * xi;
-        div += xi * xi;
-    }
-    b /= div;
-
-    // subtract linear regression and resolve min. value bias
-    float minval = FLT_MAX;   // arbitrary large number
-    for (i = windowStart; i < windowLen; i ++)
-    {
-        xcorr[i] -= (float)(b * i);
-        if (xcorr[i] < minval)
-        {
-            minval = xcorr[i];
-        }
-    }
-
-    // subtract min.value
-    for (i = windowStart; i < windowLen; i ++)
-    {
-        xcorr[i] -= minval;
-    }
-}
-
-
-// Calculate N-point moving average for "source" values
-void MAFilter(float *dest, const float *source, int start, int end, int N)
-{
-    for (int i = start; i < end; i++)
-    {
-        int i1 = i - N / 2;
-        int i2 = i + N / 2 + 1;
-        if (i1 < start) i1 = start;
-        if (i2 > end)   i2 = end;
-
-        double sum = 0;
-        for (int j = i1; j < i2; j ++)
-        { 
-            sum += source[j];
-        }
-        dest[i] = (float)(sum / (i2 - i1));
-    }
-}
-
-
-float BPMDetect::getBpm()
-{
-    double peakPos;
-    double coeff;
-    PeakFinder peakFinder;
-
-    // remove bias from xcorr data
-    removeBias();
-
-    coeff = 60.0 * ((double)sampleRate / (double)decimateBy);
-
-    // save bpm debug data if debug data writing enabled
-    _SaveDebugData("soundtouch-bpm-xcorr.txt", xcorr, windowStart, windowLen, coeff);
-
-    // Smoothen by N-point moving-average
-    float *data = new float[windowLen];
-    memset(data, 0, sizeof(float) * windowLen);
-    MAFilter(data, xcorr, windowStart, windowLen, MOVING_AVERAGE_N);
-
-    // find peak position
-    peakPos = peakFinder.detectPeak(data, windowStart, windowLen);
-
-    // save bpm debug data if debug data writing enabled
-    _SaveDebugData("soundtouch-bpm-smoothed.txt", data, windowStart, windowLen, coeff);
-
-    delete[] data;
-
-    assert(decimateBy != 0);
-    if (peakPos < 1e-9) return 0.0; // detection failed.
-
-    _SaveDebugBeatPos("soundtouch-detected-beats.txt", beats);
-
-    // calculate BPM
-    float bpm = (float)(coeff / peakPos);
-    return (bpm >= MIN_BPM && bpm <= MAX_BPM_VALID) ? bpm : 0;
-}
-
-
-/// Get beat position arrays. Note: The array includes also really low beat detection values 
-/// in absence of clear strong beats. Consumer may wish to filter low values away.
-/// - "pos" receive array of beat positions
-/// - "values" receive array of beat detection strengths
-/// - max_num indicates max.size of "pos" and "values" array.  
-///
-/// You can query a suitable array sized by calling this with nullptr in "pos" & "values".
-///
-/// \return number of beats in the arrays.
-int BPMDetect::getBeats(float *pos, float *values, int max_num)
-{
-    int num = (int)beats.size();
-    if ((!pos) || (!values)) return num;    // pos or values nullptr, return just size
-
-    for (int i = 0; (i < num) && (i < max_num); i++)
-    {
-        pos[i] = beats[i].pos;
-        values[i] = beats[i].strength;
-    }
-    return num;
-}
+////////////////////////////////////////////////////////////////////////////////
+///
+/// Beats-per-minute (BPM) detection routine.
+///
+/// The beat detection algorithm works as follows:
+/// - Use function 'inputSamples' to input a chunks of samples to the class for
+///   analysis. It's a good idea to enter a large sound file or stream in smallish
+///   chunks of around few kilosamples in order not to extinguish too much RAM memory.
+/// - Inputted sound data is decimated to approx 500 Hz to reduce calculation burden,
+///   which is basically ok as low (bass) frequencies mostly determine the beat rate.
+///   Simple averaging is used for anti-alias filtering because the resulting signal
+///   quality isn't of that high importance.
+/// - Decimated sound data is enveloped, i.e. the amplitude shape is detected by
+///   taking absolute value that's smoothed by sliding average. Signal levels that
+///   are below a couple of times the general RMS amplitude level are cut away to
+///   leave only notable peaks there.
+/// - Repeating sound patterns (e.g. beats) are detected by calculating short-term
+///   autocorrelation function of the enveloped signal.
+/// - After whole sound data file has been analyzed as above, the bpm level is
+///   detected by function 'getBpm' that finds the highest peak of the autocorrelation
+///   function, calculates it's precise location and converts this reading to bpm's.
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#define _USE_MATH_DEFINES
+
+#include 
+#include 
+#include 
+#include 
+#include 
+#include "FIFOSampleBuffer.h"
+#include "PeakFinder.h"
+#include "BPMDetect.h"
+
+using namespace soundtouch;
+
+// algorithm input sample block size
+static const int INPUT_BLOCK_SIZE = 2048;
+
+// decimated sample block size
+static const int DECIMATED_BLOCK_SIZE = 256;
+
+/// Target sample rate after decimation
+static const int TARGET_SRATE = 1000;
+
+/// XCorr update sequence size, update in about 200msec chunks
+static const int XCORR_UPDATE_SEQUENCE = (int)(TARGET_SRATE / 5);
+
+/// Moving average N size
+static const int MOVING_AVERAGE_N = 15;
+
+/// XCorr decay time constant, decay to half in 30 seconds
+/// If it's desired to have the system adapt quicker to beat rate
+/// changes within a continuing music stream, then the
+/// 'xcorr_decay_time_constant' value can be reduced, yet that
+/// can increase possibility of glitches in bpm detection.
+static const double XCORR_DECAY_TIME_CONSTANT = 30.0;
+
+/// Data overlap factor for beat detection algorithm
+static const int OVERLAP_FACTOR = 4;
+
+static const double TWOPI = (2 * M_PI);
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Enable following define to create bpm analysis file:
+
+//#define _CREATE_BPM_DEBUG_FILE
+
+#ifdef _CREATE_BPM_DEBUG_FILE
+
+    static void _SaveDebugData(const char *name, const float *data, int minpos, int maxpos, double coeff)
+    {
+        FILE *fptr = fopen(name, "wt");
+        int i;
+
+        if (fptr)
+        {
+            printf("\nWriting BPM debug data into file %s\n", name);
+            for (i = minpos; i < maxpos; i ++)
+            {
+                fprintf(fptr, "%d\t%.1lf\t%f\n", i, coeff / (double)i, data[i]);
+            }
+            fclose(fptr);
+        }
+    }
+
+    void _SaveDebugBeatPos(const char *name, const std::vector &beats)
+    {
+        printf("\nWriting beat detections data into file %s\n", name);
+
+        FILE *fptr = fopen(name, "wt");
+        if (fptr)
+        {
+            for (uint i = 0; i < beats.size(); i++)
+            {
+                BEAT b = beats[i];
+                fprintf(fptr, "%lf\t%lf\n", b.pos, b.strength);
+            }
+            fclose(fptr);
+        }
+    }
+#else
+    #define _SaveDebugData(name, a,b,c,d)
+    #define _SaveDebugBeatPos(name, b)
+#endif
+
+// Hamming window
+void hamming(float *w, int N)
+{
+    for (int i = 0; i < N; i++)
+    {
+        w[i] = (float)(0.54 - 0.46 * cos(TWOPI * i / (N - 1)));
+    }
+
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// IIR2_filter - 2nd order IIR filter
+
+IIR2_filter::IIR2_filter(const double *lpf_coeffs)
+{
+    memcpy(coeffs, lpf_coeffs, 5 * sizeof(double));
+    memset(prev, 0, sizeof(prev));
+}
+
+
+float IIR2_filter::update(float x)
+{
+    prev[0] = x;
+    double y = x * coeffs[0];
+
+    for (int i = 4; i >= 1; i--)
+    {
+        y += coeffs[i] * prev[i];
+        prev[i] = prev[i - 1];
+    }
+
+    prev[3] = y;
+    return (float)y;
+}
+
+
+// IIR low-pass filter coefficients, calculated with matlab/octave cheby2(2,40,0.05)
+const double _LPF_coeffs[5] = { 0.00996655391939, -0.01944529148401, 0.00996655391939, 1.96867605796247, -0.96916387431724 };
+
+////////////////////////////////////////////////////////////////////////////////
+
+BPMDetect::BPMDetect(int numChannels, int aSampleRate) :
+    beat_lpf(_LPF_coeffs)
+{
+    beats.reserve(250); // initial reservation to prevent frequent reallocation
+
+    this->sampleRate = aSampleRate;
+    this->channels = numChannels;
+
+    decimateSum = 0;
+    decimateCount = 0;
+
+    // choose decimation factor so that result is approx. 1000 Hz
+    decimateBy = sampleRate / TARGET_SRATE;
+    if ((decimateBy <= 0) || (decimateBy * DECIMATED_BLOCK_SIZE < INPUT_BLOCK_SIZE))
+    {
+        ST_THROW_RT_ERROR("Too small samplerate");
+    }
+
+    // Calculate window length & starting item according to desired min & max bpms
+    windowLen = (60 * sampleRate) / (decimateBy * MIN_BPM);
+    windowStart = (60 * sampleRate) / (decimateBy * MAX_BPM_RANGE);
+
+    assert(windowLen > windowStart);
+
+    // allocate new working objects
+    xcorr = new float[windowLen];
+    memset(xcorr, 0, windowLen * sizeof(float));
+
+    pos = 0;
+    peakPos = 0;
+    peakVal = 0;
+    init_scaler = 1;
+    beatcorr_ringbuffpos = 0;
+    beatcorr_ringbuff = new float[windowLen];
+    memset(beatcorr_ringbuff, 0, windowLen * sizeof(float));
+
+    // allocate processing buffer
+    buffer = new FIFOSampleBuffer();
+    // we do processing in mono mode
+    buffer->setChannels(1);
+    buffer->clear();
+
+    // calculate hamming windows
+    hamw = new float[XCORR_UPDATE_SEQUENCE];
+    hamming(hamw, XCORR_UPDATE_SEQUENCE);
+    hamw2 = new float[XCORR_UPDATE_SEQUENCE / 2];
+    hamming(hamw2, XCORR_UPDATE_SEQUENCE / 2);
+}
+
+
+BPMDetect::~BPMDetect()
+{
+    delete[] xcorr;
+    delete[] beatcorr_ringbuff;
+    delete[] hamw;
+    delete[] hamw2;
+    delete buffer;
+}
+
+
+/// convert to mono, low-pass filter & decimate to about 500 Hz.
+/// return number of outputted samples.
+///
+/// Decimation is used to remove the unnecessary frequencies and thus to reduce
+/// the amount of data needed to be processed as calculating autocorrelation
+/// function is a very-very heavy operation.
+///
+/// Anti-alias filtering is done simply by averaging the samples. This is really a
+/// poor-man's anti-alias filtering, but it's not so critical in this kind of application
+/// (it'd also be difficult to design a high-quality filter with steep cut-off at very
+/// narrow band)
+int BPMDetect::decimate(SAMPLETYPE *dest, const SAMPLETYPE *src, int numsamples)
+{
+    int count, outcount;
+    LONG_SAMPLETYPE out;
+
+    assert(channels > 0);
+    assert(decimateBy > 0);
+    outcount = 0;
+    for (count = 0; count < numsamples; count ++)
+    {
+        int j;
+
+        // convert to mono and accumulate
+        for (j = 0; j < channels; j ++)
+        {
+            decimateSum += src[j];
+        }
+        src += j;
+
+        decimateCount ++;
+        if (decimateCount >= decimateBy)
+        {
+            // Store every Nth sample only
+            out = (LONG_SAMPLETYPE)(decimateSum / (decimateBy * channels));
+            decimateSum = 0;
+            decimateCount = 0;
+#ifdef SOUNDTOUCH_INTEGER_SAMPLES
+            // check ranges for sure (shouldn't actually be necessary)
+            if (out > 32767)
+            {
+                out = 32767;
+            }
+            else if (out < -32768)
+            {
+                out = -32768;
+            }
+#endif // SOUNDTOUCH_INTEGER_SAMPLES
+            dest[outcount] = (SAMPLETYPE)out;
+            outcount ++;
+        }
+    }
+    return outcount;
+}
+
+
+// Calculates autocorrelation function of the sample history buffer
+void BPMDetect::updateXCorr(int process_samples)
+{
+    int offs;
+    SAMPLETYPE *pBuffer;
+
+    assert(buffer->numSamples() >= (uint)(process_samples + windowLen));
+    assert(process_samples == XCORR_UPDATE_SEQUENCE);
+
+    pBuffer = buffer->ptrBegin();
+
+    // calculate decay factor for xcorr filtering
+    float xcorr_decay = (float)pow(0.5, 1.0 / (XCORR_DECAY_TIME_CONSTANT * TARGET_SRATE / process_samples));
+
+    // prescale pbuffer
+    float tmp[XCORR_UPDATE_SEQUENCE];
+    for (int i = 0; i < process_samples; i++)
+    {
+        tmp[i] = hamw[i] * hamw[i] * pBuffer[i];
+    }
+
+    #pragma omp parallel for
+    for (offs = windowStart; offs < windowLen; offs ++)
+    {
+        float sum;
+        int i;
+
+        sum = 0;
+        for (i = 0; i < process_samples; i ++)
+        {
+            sum += tmp[i] * pBuffer[i + offs];  // scaling the sub-result shouldn't be necessary
+        }
+        xcorr[offs] *= xcorr_decay;   // decay 'xcorr' here with suitable time constant.
+
+        xcorr[offs] += (float)fabs(sum);
+    }
+}
+
+
+// Detect individual beat positions
+void BPMDetect::updateBeatPos(int process_samples)
+{
+    SAMPLETYPE *pBuffer;
+
+    assert(buffer->numSamples() >= (uint)(process_samples + windowLen));
+
+    pBuffer = buffer->ptrBegin();
+    assert(process_samples == XCORR_UPDATE_SEQUENCE / 2);
+
+    //    static double thr = 0.0003;
+    double posScale = (double)this->decimateBy / (double)this->sampleRate;
+    int resetDur = (int)(0.12 / posScale + 0.5);
+
+    // prescale pbuffer
+    float tmp[XCORR_UPDATE_SEQUENCE / 2];
+    for (int i = 0; i < process_samples; i++)
+    {
+        tmp[i] = hamw2[i] * hamw2[i] * pBuffer[i];
+    }
+
+    #pragma omp parallel for
+    for (int offs = windowStart; offs < windowLen; offs++)
+    {
+        float sum = 0;
+        for (int i = 0; i < process_samples; i++)
+        {
+            sum += tmp[i] * pBuffer[offs + i];
+        }
+        beatcorr_ringbuff[(beatcorr_ringbuffpos + offs) % windowLen] += (float)((sum > 0) ? sum : 0); // accumulate only positive correlations
+    }
+
+    int skipstep = XCORR_UPDATE_SEQUENCE / OVERLAP_FACTOR;
+
+    // compensate empty buffer at beginning by scaling coefficient
+    float scale = (float)windowLen / (float)(skipstep * init_scaler);
+    if (scale > 1.0f)
+    {
+        init_scaler++;
+    }
+    else
+    {
+        scale = 1.0f;
+    }
+
+    // detect beats
+    for (int i = 0; i < skipstep; i++)
+    {
+        float sum = beatcorr_ringbuff[beatcorr_ringbuffpos];
+        sum -= beat_lpf.update(sum);
+
+        if (sum > peakVal)
+        {
+            // found new local largest value
+            peakVal = sum;
+            peakPos = pos;
+        }
+        if (pos > peakPos + resetDur)
+        {
+            // largest value not updated for 200msec => accept as beat
+            peakPos += skipstep;
+            if (peakVal > 0)
+            {
+                // add detected beat to end of "beats" vector
+                BEAT temp = { (float)(peakPos * posScale), (float)(peakVal * scale) };
+                beats.push_back(temp);
+            }
+
+            peakVal = 0;
+            peakPos = pos;
+        }
+
+        beatcorr_ringbuff[beatcorr_ringbuffpos] = 0;
+        pos++;
+        beatcorr_ringbuffpos = (beatcorr_ringbuffpos + 1) % windowLen;
+    }
+}
+
+
+#define max(x,y) ((x) > (y) ? (x) : (y))
+
+void BPMDetect::inputSamples(const SAMPLETYPE *samples, int numSamples)
+{
+    SAMPLETYPE decimated[DECIMATED_BLOCK_SIZE];
+
+    // iterate so that max INPUT_BLOCK_SAMPLES processed per iteration
+    while (numSamples > 0)
+    {
+        int block;
+        int decSamples;
+
+        block = (numSamples > INPUT_BLOCK_SIZE) ? INPUT_BLOCK_SIZE : numSamples;
+
+        // decimate. note that converts to mono at the same time
+        decSamples = decimate(decimated, samples, block);
+        samples += block * channels;
+        numSamples -= block;
+
+        buffer->putSamples(decimated, decSamples);
+    }
+
+    // when the buffer has enough samples for processing...
+    int req = max(windowLen + XCORR_UPDATE_SEQUENCE, 2 * XCORR_UPDATE_SEQUENCE);
+    while ((int)buffer->numSamples() >= req)
+    {
+        // ... update autocorrelations...
+        updateXCorr(XCORR_UPDATE_SEQUENCE);
+        // ...update beat position calculation...
+        updateBeatPos(XCORR_UPDATE_SEQUENCE / 2);
+        // ... and remove proceessed samples from the buffer
+        int n = XCORR_UPDATE_SEQUENCE / OVERLAP_FACTOR;
+        buffer->receiveSamples(n);
+    }
+}
+
+
+void BPMDetect::removeBias()
+{
+    int i;
+
+    // Remove linear bias: calculate linear regression coefficient
+    // 1. calc mean of 'xcorr' and 'i'
+    double mean_i = 0;
+    double mean_x = 0;
+    for (i = windowStart; i < windowLen; i++)
+    {
+        mean_x += xcorr[i];
+    }
+    mean_x /= (windowLen - windowStart);
+    mean_i = 0.5 * (windowLen - 1 + windowStart);
+
+    // 2. calculate linear regression coefficient
+    double b = 0;
+    double div = 0;
+    for (i = windowStart; i < windowLen; i++)
+    {
+        double xt = xcorr[i] - mean_x;
+        double xi = i - mean_i;
+        b += xt * xi;
+        div += xi * xi;
+    }
+    b /= div;
+
+    // subtract linear regression and resolve min. value bias
+    float minval = FLT_MAX;   // arbitrary large number
+    for (i = windowStart; i < windowLen; i ++)
+    {
+        xcorr[i] -= (float)(b * i);
+        if (xcorr[i] < minval)
+        {
+            minval = xcorr[i];
+        }
+    }
+
+    // subtract min.value
+    for (i = windowStart; i < windowLen; i ++)
+    {
+        xcorr[i] -= minval;
+    }
+}
+
+
+// Calculate N-point moving average for "source" values
+void MAFilter(float *dest, const float *source, int start, int end, int N)
+{
+    for (int i = start; i < end; i++)
+    {
+        int i1 = i - N / 2;
+        int i2 = i + N / 2 + 1;
+        if (i1 < start) i1 = start;
+        if (i2 > end)   i2 = end;
+
+        double sum = 0;
+        for (int j = i1; j < i2; j ++)
+        {
+            sum += source[j];
+        }
+        dest[i] = (float)(sum / (i2 - i1));
+    }
+}
+
+
+float BPMDetect::getBpm()
+{
+    double peakPos;
+    double coeff;
+    PeakFinder peakFinder;
+
+    // remove bias from xcorr data
+    removeBias();
+
+    coeff = 60.0 * ((double)sampleRate / (double)decimateBy);
+
+    // save bpm debug data if debug data writing enabled
+    _SaveDebugData("soundtouch-bpm-xcorr.txt", xcorr, windowStart, windowLen, coeff);
+
+    // Smoothen by N-point moving-average
+    float *data = new float[windowLen];
+    memset(data, 0, sizeof(float) * windowLen);
+    MAFilter(data, xcorr, windowStart, windowLen, MOVING_AVERAGE_N);
+
+    // find peak position
+    peakPos = peakFinder.detectPeak(data, windowStart, windowLen);
+
+    // save bpm debug data if debug data writing enabled
+    _SaveDebugData("soundtouch-bpm-smoothed.txt", data, windowStart, windowLen, coeff);
+
+    delete[] data;
+
+    assert(decimateBy != 0);
+    if (peakPos < 1e-9) return 0.0; // detection failed.
+
+    _SaveDebugBeatPos("soundtouch-detected-beats.txt", beats);
+
+    // calculate BPM
+    float bpm = (float)(coeff / peakPos);
+    return (bpm >= MIN_BPM && bpm <= MAX_BPM_VALID) ? bpm : 0;
+}
+
+
+/// Get beat position arrays. Note: The array includes also really low beat detection values
+/// in absence of clear strong beats. Consumer may wish to filter low values away.
+/// - "pos" receive array of beat positions
+/// - "values" receive array of beat detection strengths
+/// - max_num indicates max.size of "pos" and "values" array.
+///
+/// You can query a suitable array sized by calling this with nullptr in "pos" & "values".
+///
+/// \return number of beats in the arrays.
+int BPMDetect::getBeats(float *pos, float *values, int max_num)
+{
+    int num = (int)beats.size();
+    if ((!pos) || (!values)) return num;    // pos or values nullptr, return just size
+
+    for (int i = 0; (i < num) && (i < max_num); i++)
+    {
+        pos[i] = beats[i].pos;
+        values[i] = beats[i].strength;
+    }
+    return num;
+}
diff --git a/source/SoundTouch/FIFOSampleBuffer.cpp b/source/SoundTouch/FIFOSampleBuffer.cpp
index 420e0d7..9e0d5b2 100644
--- a/source/SoundTouch/FIFOSampleBuffer.cpp
+++ b/source/SoundTouch/FIFOSampleBuffer.cpp
@@ -1,275 +1,275 @@
-////////////////////////////////////////////////////////////////////////////////
-///
-/// A buffer class for temporarily storaging sound samples, operates as a 
-/// first-in-first-out pipe.
-///
-/// Samples are added to the end of the sample buffer with the 'putSamples' 
-/// function, and are received from the beginning of the buffer by calling
-/// the 'receiveSamples' function. The class automatically removes the 
-/// outputted samples from the buffer, as well as grows the buffer size 
-/// whenever necessary.
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include 
-#include 
-#include 
-#include 
-
-#include "FIFOSampleBuffer.h"
-
-using namespace soundtouch;
-
-// Constructor
-FIFOSampleBuffer::FIFOSampleBuffer(int numChannels)
-{
-    assert(numChannels > 0);
-    sizeInBytes = 0; // reasonable initial value
-    buffer = nullptr;
-    bufferUnaligned = nullptr;
-    samplesInBuffer = 0;
-    bufferPos = 0;
-    channels = (uint)numChannels;
-    ensureCapacity(32);     // allocate initial capacity 
-}
-
-
-// destructor
-FIFOSampleBuffer::~FIFOSampleBuffer()
-{
-    delete[] bufferUnaligned;
-    bufferUnaligned = nullptr;
-    buffer = nullptr;
-}
-
-
-// Sets number of channels, 1 = mono, 2 = stereo
-void FIFOSampleBuffer::setChannels(int numChannels)
-{
-    uint usedBytes;
-
-    if (!verifyNumberOfChannels(numChannels)) return;
-
-    usedBytes = channels * samplesInBuffer;
-    channels = (uint)numChannels;
-    samplesInBuffer = usedBytes / channels;
-}
-
-
-// if output location pointer 'bufferPos' isn't zero, 'rewinds' the buffer and
-// zeroes this pointer by copying samples from the 'bufferPos' pointer 
-// location on to the beginning of the buffer.
-void FIFOSampleBuffer::rewind()
-{
-    if (buffer && bufferPos) 
-    {
-        memmove(buffer, ptrBegin(), sizeof(SAMPLETYPE) * channels * samplesInBuffer);
-        bufferPos = 0;
-    }
-}
-
-
-// Adds 'numSamples' pcs of samples from the 'samples' memory position to 
-// the sample buffer.
-void FIFOSampleBuffer::putSamples(const SAMPLETYPE *samples, uint nSamples)
-{
-    memcpy(ptrEnd(nSamples), samples, sizeof(SAMPLETYPE) * nSamples * channels);
-    samplesInBuffer += nSamples;
-}
-
-
-// Increases the number of samples in the buffer without copying any actual
-// samples.
-//
-// This function is used to update the number of samples in the sample buffer
-// when accessing the buffer directly with 'ptrEnd' function. Please be 
-// careful though!
-void FIFOSampleBuffer::putSamples(uint nSamples)
-{
-    uint req;
-
-    req = samplesInBuffer + nSamples;
-    ensureCapacity(req);
-    samplesInBuffer += nSamples;
-}
-
-
-// Returns a pointer to the end of the used part of the sample buffer (i.e. 
-// where the new samples are to be inserted). This function may be used for 
-// inserting new samples into the sample buffer directly. Please be careful! 
-//
-// Parameter 'slackCapacity' tells the function how much free capacity (in
-// terms of samples) there _at least_ should be, in order to the caller to
-// successfully insert all the required samples to the buffer. When necessary, 
-// the function grows the buffer size to comply with this requirement.
-//
-// When using this function as means for inserting new samples, also remember 
-// to increase the sample count afterwards, by calling  the 
-// 'putSamples(numSamples)' function.
-SAMPLETYPE *FIFOSampleBuffer::ptrEnd(uint slackCapacity) 
-{
-    ensureCapacity(samplesInBuffer + slackCapacity);
-    return buffer + samplesInBuffer * channels;
-}
-
-
-// Returns a pointer to the beginning of the currently non-outputted samples. 
-// This function is provided for accessing the output samples directly. 
-// Please be careful!
-//
-// When using this function to output samples, also remember to 'remove' the
-// outputted samples from the buffer by calling the 
-// 'receiveSamples(numSamples)' function
-SAMPLETYPE *FIFOSampleBuffer::ptrBegin()
-{
-    assert(buffer);
-    return buffer + bufferPos * channels;
-}
-
-
-// Ensures that the buffer has enough capacity, i.e. space for _at least_
-// 'capacityRequirement' number of samples. The buffer is grown in steps of
-// 4 kilobytes to eliminate the need for frequently growing up the buffer,
-// as well as to round the buffer size up to the virtual memory page size.
-void FIFOSampleBuffer::ensureCapacity(uint capacityRequirement)
-{
-    SAMPLETYPE *tempUnaligned, *temp;
-
-    if (capacityRequirement > getCapacity()) 
-    {
-        // enlarge the buffer in 4kbyte steps (round up to next 4k boundary)
-        sizeInBytes = (capacityRequirement * channels * sizeof(SAMPLETYPE) + 4095) & (uint)-4096;
-        assert(sizeInBytes % 2 == 0);
-        tempUnaligned = new SAMPLETYPE[sizeInBytes / sizeof(SAMPLETYPE) + 16 / sizeof(SAMPLETYPE)];
-        if (tempUnaligned == nullptr)
-        {
-            ST_THROW_RT_ERROR("Couldn't allocate memory!\n");
-        }
-        // Align the buffer to begin at 16byte cache line boundary for optimal performance
-        temp = (SAMPLETYPE *)SOUNDTOUCH_ALIGN_POINTER_16(tempUnaligned);
-        if (samplesInBuffer)
-        {
-            memcpy(temp, ptrBegin(), samplesInBuffer * channels * sizeof(SAMPLETYPE));
-        }
-        delete[] bufferUnaligned;
-        buffer = temp;
-        bufferUnaligned = tempUnaligned;
-        bufferPos = 0;
-    } 
-    else 
-    {
-        // simply rewind the buffer (if necessary)
-        rewind();
-    }
-}
-
-
-// Returns the current buffer capacity in terms of samples
-uint FIFOSampleBuffer::getCapacity() const
-{
-    return sizeInBytes / (channels * sizeof(SAMPLETYPE));
-}
-
-
-// Returns the number of samples currently in the buffer
-uint FIFOSampleBuffer::numSamples() const
-{
-    return samplesInBuffer;
-}
-
-
-// Output samples from beginning of the sample buffer. Copies demanded number
-// of samples to output and removes them from the sample buffer. If there
-// are less than 'numsample' samples in the buffer, returns all available.
-//
-// Returns number of samples copied.
-uint FIFOSampleBuffer::receiveSamples(SAMPLETYPE *output, uint maxSamples)
-{
-    uint num;
-
-    num = (maxSamples > samplesInBuffer) ? samplesInBuffer : maxSamples;
-
-    memcpy(output, ptrBegin(), channels * sizeof(SAMPLETYPE) * num);
-    return receiveSamples(num);
-}
-
-
-// Removes samples from the beginning of the sample buffer without copying them
-// anywhere. Used to reduce the number of samples in the buffer, when accessing
-// the sample buffer with the 'ptrBegin' function.
-uint FIFOSampleBuffer::receiveSamples(uint maxSamples)
-{
-    if (maxSamples >= samplesInBuffer)
-    {
-        uint temp;
-
-        temp = samplesInBuffer;
-        samplesInBuffer = 0;
-        return temp;
-    }
-
-    samplesInBuffer -= maxSamples;
-    bufferPos += maxSamples;
-
-    return maxSamples;
-}
-
-
-// Returns nonzero if the sample buffer is empty
-int FIFOSampleBuffer::isEmpty() const
-{
-    return (samplesInBuffer == 0) ? 1 : 0;
-}
-
-
-// Clears the sample buffer
-void FIFOSampleBuffer::clear()
-{
-    samplesInBuffer = 0;
-    bufferPos = 0;
-}
-
-
-/// allow trimming (downwards) amount of samples in pipeline.
-/// Returns adjusted amount of samples
-uint FIFOSampleBuffer::adjustAmountOfSamples(uint numSamples)
-{
-    if (numSamples < samplesInBuffer)
-    {
-        samplesInBuffer = numSamples;
-    }
-    return samplesInBuffer;
-}
-
-
-/// Add silence to end of buffer
-void FIFOSampleBuffer::addSilent(uint nSamples)
-{
-    memset(ptrEnd(nSamples), 0, sizeof(SAMPLETYPE) * nSamples * channels);
-    samplesInBuffer += nSamples;
-}
+////////////////////////////////////////////////////////////////////////////////
+///
+/// A buffer class for temporarily storaging sound samples, operates as a
+/// first-in-first-out pipe.
+///
+/// Samples are added to the end of the sample buffer with the 'putSamples'
+/// function, and are received from the beginning of the buffer by calling
+/// the 'receiveSamples' function. The class automatically removes the
+/// outputted samples from the buffer, as well as grows the buffer size
+/// whenever necessary.
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#include 
+#include 
+#include 
+#include 
+
+#include "FIFOSampleBuffer.h"
+
+using namespace soundtouch;
+
+// Constructor
+FIFOSampleBuffer::FIFOSampleBuffer(int numChannels)
+{
+    assert(numChannels > 0);
+    sizeInBytes = 0; // reasonable initial value
+    buffer = nullptr;
+    bufferUnaligned = nullptr;
+    samplesInBuffer = 0;
+    bufferPos = 0;
+    channels = (uint)numChannels;
+    ensureCapacity(32);     // allocate initial capacity
+}
+
+
+// destructor
+FIFOSampleBuffer::~FIFOSampleBuffer()
+{
+    delete[] bufferUnaligned;
+    bufferUnaligned = nullptr;
+    buffer = nullptr;
+}
+
+
+// Sets number of channels, 1 = mono, 2 = stereo
+void FIFOSampleBuffer::setChannels(int numChannels)
+{
+    uint usedBytes;
+
+    if (!verifyNumberOfChannels(numChannels)) return;
+
+    usedBytes = channels * samplesInBuffer;
+    channels = (uint)numChannels;
+    samplesInBuffer = usedBytes / channels;
+}
+
+
+// if output location pointer 'bufferPos' isn't zero, 'rewinds' the buffer and
+// zeroes this pointer by copying samples from the 'bufferPos' pointer
+// location on to the beginning of the buffer.
+void FIFOSampleBuffer::rewind()
+{
+    if (buffer && bufferPos)
+    {
+        memmove(buffer, ptrBegin(), sizeof(SAMPLETYPE) * channels * samplesInBuffer);
+        bufferPos = 0;
+    }
+}
+
+
+// Adds 'numSamples' pcs of samples from the 'samples' memory position to
+// the sample buffer.
+void FIFOSampleBuffer::putSamples(const SAMPLETYPE *samples, uint nSamples)
+{
+    memcpy(ptrEnd(nSamples), samples, sizeof(SAMPLETYPE) * nSamples * channels);
+    samplesInBuffer += nSamples;
+}
+
+
+// Increases the number of samples in the buffer without copying any actual
+// samples.
+//
+// This function is used to update the number of samples in the sample buffer
+// when accessing the buffer directly with 'ptrEnd' function. Please be
+// careful though!
+void FIFOSampleBuffer::putSamples(uint nSamples)
+{
+    uint req;
+
+    req = samplesInBuffer + nSamples;
+    ensureCapacity(req);
+    samplesInBuffer += nSamples;
+}
+
+
+// Returns a pointer to the end of the used part of the sample buffer (i.e.
+// where the new samples are to be inserted). This function may be used for
+// inserting new samples into the sample buffer directly. Please be careful!
+//
+// Parameter 'slackCapacity' tells the function how much free capacity (in
+// terms of samples) there _at least_ should be, in order to the caller to
+// successfully insert all the required samples to the buffer. When necessary,
+// the function grows the buffer size to comply with this requirement.
+//
+// When using this function as means for inserting new samples, also remember
+// to increase the sample count afterwards, by calling  the
+// 'putSamples(numSamples)' function.
+SAMPLETYPE *FIFOSampleBuffer::ptrEnd(uint slackCapacity)
+{
+    ensureCapacity(samplesInBuffer + slackCapacity);
+    return buffer + samplesInBuffer * channels;
+}
+
+
+// Returns a pointer to the beginning of the currently non-outputted samples.
+// This function is provided for accessing the output samples directly.
+// Please be careful!
+//
+// When using this function to output samples, also remember to 'remove' the
+// outputted samples from the buffer by calling the
+// 'receiveSamples(numSamples)' function
+SAMPLETYPE *FIFOSampleBuffer::ptrBegin()
+{
+    assert(buffer);
+    return buffer + bufferPos * channels;
+}
+
+
+// Ensures that the buffer has enough capacity, i.e. space for _at least_
+// 'capacityRequirement' number of samples. The buffer is grown in steps of
+// 4 kilobytes to eliminate the need for frequently growing up the buffer,
+// as well as to round the buffer size up to the virtual memory page size.
+void FIFOSampleBuffer::ensureCapacity(uint capacityRequirement)
+{
+    SAMPLETYPE *tempUnaligned, *temp;
+
+    if (capacityRequirement > getCapacity())
+    {
+        // enlarge the buffer in 4kbyte steps (round up to next 4k boundary)
+        sizeInBytes = (capacityRequirement * channels * sizeof(SAMPLETYPE) + 4095) & (uint)-4096;
+        assert(sizeInBytes % 2 == 0);
+        tempUnaligned = new SAMPLETYPE[sizeInBytes / sizeof(SAMPLETYPE) + 16 / sizeof(SAMPLETYPE)];
+        if (tempUnaligned == nullptr)
+        {
+            ST_THROW_RT_ERROR("Couldn't allocate memory!\n");
+        }
+        // Align the buffer to begin at 16byte cache line boundary for optimal performance
+        temp = (SAMPLETYPE *)SOUNDTOUCH_ALIGN_POINTER_16(tempUnaligned);
+        if (samplesInBuffer)
+        {
+            memcpy(temp, ptrBegin(), samplesInBuffer * channels * sizeof(SAMPLETYPE));
+        }
+        delete[] bufferUnaligned;
+        buffer = temp;
+        bufferUnaligned = tempUnaligned;
+        bufferPos = 0;
+    }
+    else
+    {
+        // simply rewind the buffer (if necessary)
+        rewind();
+    }
+}
+
+
+// Returns the current buffer capacity in terms of samples
+uint FIFOSampleBuffer::getCapacity() const
+{
+    return sizeInBytes / (channels * sizeof(SAMPLETYPE));
+}
+
+
+// Returns the number of samples currently in the buffer
+uint FIFOSampleBuffer::numSamples() const
+{
+    return samplesInBuffer;
+}
+
+
+// Output samples from beginning of the sample buffer. Copies demanded number
+// of samples to output and removes them from the sample buffer. If there
+// are less than 'numsample' samples in the buffer, returns all available.
+//
+// Returns number of samples copied.
+uint FIFOSampleBuffer::receiveSamples(SAMPLETYPE *output, uint maxSamples)
+{
+    uint num;
+
+    num = (maxSamples > samplesInBuffer) ? samplesInBuffer : maxSamples;
+
+    memcpy(output, ptrBegin(), channels * sizeof(SAMPLETYPE) * num);
+    return receiveSamples(num);
+}
+
+
+// Removes samples from the beginning of the sample buffer without copying them
+// anywhere. Used to reduce the number of samples in the buffer, when accessing
+// the sample buffer with the 'ptrBegin' function.
+uint FIFOSampleBuffer::receiveSamples(uint maxSamples)
+{
+    if (maxSamples >= samplesInBuffer)
+    {
+        uint temp;
+
+        temp = samplesInBuffer;
+        samplesInBuffer = 0;
+        return temp;
+    }
+
+    samplesInBuffer -= maxSamples;
+    bufferPos += maxSamples;
+
+    return maxSamples;
+}
+
+
+// Returns nonzero if the sample buffer is empty
+int FIFOSampleBuffer::isEmpty() const
+{
+    return (samplesInBuffer == 0) ? 1 : 0;
+}
+
+
+// Clears the sample buffer
+void FIFOSampleBuffer::clear()
+{
+    samplesInBuffer = 0;
+    bufferPos = 0;
+}
+
+
+/// allow trimming (downwards) amount of samples in pipeline.
+/// Returns adjusted amount of samples
+uint FIFOSampleBuffer::adjustAmountOfSamples(uint numSamples)
+{
+    if (numSamples < samplesInBuffer)
+    {
+        samplesInBuffer = numSamples;
+    }
+    return samplesInBuffer;
+}
+
+
+/// Add silence to end of buffer
+void FIFOSampleBuffer::addSilent(uint nSamples)
+{
+    memset(ptrEnd(nSamples), 0, sizeof(SAMPLETYPE) * nSamples * channels);
+    samplesInBuffer += nSamples;
+}
diff --git a/source/SoundTouch/FIRFilter.cpp b/source/SoundTouch/FIRFilter.cpp
index 6656a58..4cd330e 100644
--- a/source/SoundTouch/FIRFilter.cpp
+++ b/source/SoundTouch/FIRFilter.cpp
@@ -1,315 +1,315 @@
-////////////////////////////////////////////////////////////////////////////////
-///
-/// General FIR digital filter routines with MMX optimization. 
-///
-/// Notes : MMX optimized functions reside in a separate, platform-specific file, 
-/// e.g. 'mmx_win.cpp' or 'mmx_gcc.cpp'
-///
-/// This source file contains OpenMP optimizations that allow speeding up the
-/// corss-correlation algorithm by executing it in several threads / CPU cores 
-/// in parallel. See the following article link for more detailed discussion 
-/// about SoundTouch OpenMP optimizations:
-/// http://www.softwarecoven.com/parallel-computing-in-embedded-mobile-devices
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include 
-#include 
-#include 
-#include 
-#include "FIRFilter.h"
-#include "cpu_detect.h"
-
-using namespace soundtouch;
-
-/*****************************************************************************
- *
- * Implementation of the class 'FIRFilter'
- *
- *****************************************************************************/
-
-FIRFilter::FIRFilter()
-{
-    resultDivFactor = 0;
-    resultDivider = 0;
-    length = 0;
-    lengthDiv8 = 0;
-    filterCoeffs = nullptr;
-    filterCoeffsStereo = nullptr;
-}
-
-
-FIRFilter::~FIRFilter()
-{
-    delete[] filterCoeffs;
-    delete[] filterCoeffsStereo;
-}
-
-
-// Usual C-version of the filter routine for stereo sound
-uint FIRFilter::evaluateFilterStereo(SAMPLETYPE *dest, const SAMPLETYPE *src, uint numSamples) const
-{
-    int j, end;
-    // hint compiler autovectorization that loop length is divisible by 8
-    uint ilength = length & -8;
-
-    assert((length != 0) && (length == ilength) && (src != nullptr) && (dest != nullptr) && (filterCoeffs != nullptr));
-    assert(numSamples > ilength);
-
-    end = 2 * (numSamples - ilength);
-
-    #pragma omp parallel for
-    for (j = 0; j < end; j += 2) 
-    {
-        const SAMPLETYPE *ptr;
-        LONG_SAMPLETYPE suml, sumr;
-
-        suml = sumr = 0;
-        ptr = src + j;
-
-        for (uint i = 0; i < ilength; i ++)
-        {
-            suml += ptr[2 * i] * filterCoeffsStereo[2 * i];
-            sumr += ptr[2 * i + 1] * filterCoeffsStereo[2 * i + 1];
-        }
-
-#ifdef SOUNDTOUCH_INTEGER_SAMPLES
-        suml >>= resultDivFactor;
-        sumr >>= resultDivFactor;
-        // saturate to 16 bit integer limits
-        suml = (suml < -32768) ? -32768 : (suml > 32767) ? 32767 : suml;
-        // saturate to 16 bit integer limits
-        sumr = (sumr < -32768) ? -32768 : (sumr > 32767) ? 32767 : sumr;
-#endif // SOUNDTOUCH_INTEGER_SAMPLES
-        dest[j] = (SAMPLETYPE)suml;
-        dest[j + 1] = (SAMPLETYPE)sumr;
-    }
-    return numSamples - ilength;
-}
-
-
-// Usual C-version of the filter routine for mono sound
-uint FIRFilter::evaluateFilterMono(SAMPLETYPE *dest, const SAMPLETYPE *src, uint numSamples) const
-{
-    int j, end;
-
-    // hint compiler autovectorization that loop length is divisible by 8
-    int ilength = length & -8;
-
-    assert(ilength != 0);
-
-    end = numSamples - ilength;
-    #pragma omp parallel for
-    for (j = 0; j < end; j ++)
-    {
-        const SAMPLETYPE *pSrc = src + j;
-        LONG_SAMPLETYPE sum;
-        int i;
-
-        sum = 0;
-        for (i = 0; i < ilength; i ++)
-        {
-            sum += pSrc[i] * filterCoeffs[i];
-        }
-#ifdef SOUNDTOUCH_INTEGER_SAMPLES
-        sum >>= resultDivFactor;
-        // saturate to 16 bit integer limits
-        sum = (sum < -32768) ? -32768 : (sum > 32767) ? 32767 : sum;
-#endif // SOUNDTOUCH_INTEGER_SAMPLES
-        dest[j] = (SAMPLETYPE)sum;
-    }
-    return end;
-}
-
-
-uint FIRFilter::evaluateFilterMulti(SAMPLETYPE *dest, const SAMPLETYPE *src, uint numSamples, uint numChannels)
-{
-    int j, end;
-
-    assert(length != 0);
-    assert(src != nullptr);
-    assert(dest != nullptr);
-    assert(filterCoeffs != nullptr);
-    assert(numChannels < 16);
-
-    // hint compiler autovectorization that loop length is divisible by 8
-    int ilength = length & -8;
-
-    end = numChannels * (numSamples - ilength);
-
-    #pragma omp parallel for
-    for (j = 0; j < end; j += numChannels)
-    {
-        const SAMPLETYPE *ptr;
-        LONG_SAMPLETYPE sums[16];
-        uint c;
-        int i;
-
-        for (c = 0; c < numChannels; c ++)
-        {
-            sums[c] = 0;
-        }
-
-        ptr = src + j;
-
-        for (i = 0; i < ilength; i ++)
-        {
-            SAMPLETYPE coef=filterCoeffs[i];
-            for (c = 0; c < numChannels; c ++)
-            {
-                sums[c] += ptr[0] * coef;
-                ptr ++;
-            }
-        }
-        
-        for (c = 0; c < numChannels; c ++)
-        {
-#ifdef SOUNDTOUCH_INTEGER_SAMPLES
-            sums[c] >>= resultDivFactor;
-#endif // SOUNDTOUCH_INTEGER_SAMPLES
-            dest[j+c] = (SAMPLETYPE)sums[c];
-        }
-    }
-    return numSamples - ilength;
-}
-
-
-// Set filter coeffiecients and length.
-//
-// Throws an exception if filter length isn't divisible by 8
-void FIRFilter::setCoefficients(const SAMPLETYPE *coeffs, uint newLength, uint uResultDivFactor)
-{
-    assert(newLength > 0);
-    if (newLength % 8) ST_THROW_RT_ERROR("FIR filter length not divisible by 8");
-
-    #ifdef SOUNDTOUCH_FLOAT_SAMPLES
-        // scale coefficients already here if using floating samples
-        double scale = 1.0 / resultDivider;
-    #else
-        short scale = 1;
-    #endif
-
-    lengthDiv8 = newLength / 8;
-    length = lengthDiv8 * 8;
-    assert(length == newLength);
-
-    resultDivFactor = uResultDivFactor;
-    resultDivider = (SAMPLETYPE)::pow(2.0, (int)resultDivFactor);
-
-    delete[] filterCoeffs;
-    filterCoeffs = new SAMPLETYPE[length];
-    delete[] filterCoeffsStereo;
-    filterCoeffsStereo = new SAMPLETYPE[length*2];
-    for (uint i = 0; i < length; i ++)
-    {
-        filterCoeffs[i] = (SAMPLETYPE)(coeffs[i] * scale);
-        // create also stereo set of filter coefficients: this allows compiler
-        // to autovectorize filter evaluation much more efficiently
-        filterCoeffsStereo[2 * i] = (SAMPLETYPE)(coeffs[i] * scale);
-        filterCoeffsStereo[2 * i + 1] = (SAMPLETYPE)(coeffs[i] * scale);
-    }
-}
-
-
-uint FIRFilter::getLength() const
-{
-    return length;
-}
-
-
-// Applies the filter to the given sequence of samples. 
-//
-// Note : The amount of outputted samples is by value of 'filter_length' 
-// smaller than the amount of input samples.
-uint FIRFilter::evaluate(SAMPLETYPE *dest, const SAMPLETYPE *src, uint numSamples, uint numChannels) 
-{
-    assert(length > 0);
-    assert(lengthDiv8 * 8 == length);
-
-    if (numSamples < length) return 0;
-
-#ifndef USE_MULTICH_ALWAYS
-    if (numChannels == 1)
-    {
-        return evaluateFilterMono(dest, src, numSamples);
-    } 
-    else if (numChannels == 2)
-    {
-        return evaluateFilterStereo(dest, src, numSamples);
-    }
-    else
-#endif // USE_MULTICH_ALWAYS
-    {
-        assert(numChannels > 0);
-        return evaluateFilterMulti(dest, src, numSamples, numChannels);
-    }
-}
-
-
-// Operator 'new' is overloaded so that it automatically creates a suitable instance 
-// depending on if we've a MMX-capable CPU available or not.
-void * FIRFilter::operator new(size_t)
-{
-    // Notice! don't use "new FIRFilter" directly, use "newInstance" to create a new instance instead!
-    ST_THROW_RT_ERROR("Error in FIRFilter::new: Don't use 'new FIRFilter', use 'newInstance' member instead!");
-    return newInstance();
-}
-
-
-FIRFilter * FIRFilter::newInstance()
-{
-    uint uExtensions;
-
-    uExtensions = detectCPUextensions();
-    (void)uExtensions;
-
-    // Check if MMX/SSE instruction set extensions supported by CPU
-
-#ifdef SOUNDTOUCH_ALLOW_MMX
-    // MMX routines available only with integer sample types
-    if (uExtensions & SUPPORT_MMX)
-    {
-        return ::new FIRFilterMMX;
-    }
-    else
-#endif // SOUNDTOUCH_ALLOW_MMX
-
-#ifdef SOUNDTOUCH_ALLOW_SSE
-    if (uExtensions & SUPPORT_SSE)
-    {
-        // SSE support
-        return ::new FIRFilterSSE;
-    }
-    else
-#endif // SOUNDTOUCH_ALLOW_SSE
-
-    {
-        // ISA optimizations not supported, use plain C version
-        return ::new FIRFilter;
-    }
-}
+////////////////////////////////////////////////////////////////////////////////
+///
+/// General FIR digital filter routines with MMX optimization.
+///
+/// Notes : MMX optimized functions reside in a separate, platform-specific file,
+/// e.g. 'mmx_win.cpp' or 'mmx_gcc.cpp'
+///
+/// This source file contains OpenMP optimizations that allow speeding up the
+/// corss-correlation algorithm by executing it in several threads / CPU cores
+/// in parallel. See the following article link for more detailed discussion
+/// about SoundTouch OpenMP optimizations:
+/// http://www.softwarecoven.com/parallel-computing-in-embedded-mobile-devices
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#include 
+#include 
+#include 
+#include 
+#include "FIRFilter.h"
+#include "cpu_detect.h"
+
+using namespace soundtouch;
+
+/*****************************************************************************
+ *
+ * Implementation of the class 'FIRFilter'
+ *
+ *****************************************************************************/
+
+FIRFilter::FIRFilter()
+{
+    resultDivFactor = 0;
+    resultDivider = 0;
+    length = 0;
+    lengthDiv8 = 0;
+    filterCoeffs = nullptr;
+    filterCoeffsStereo = nullptr;
+}
+
+
+FIRFilter::~FIRFilter()
+{
+    delete[] filterCoeffs;
+    delete[] filterCoeffsStereo;
+}
+
+
+// Usual C-version of the filter routine for stereo sound
+uint FIRFilter::evaluateFilterStereo(SAMPLETYPE *dest, const SAMPLETYPE *src, uint numSamples) const
+{
+    int j, end;
+    // hint compiler autovectorization that loop length is divisible by 8
+    uint ilength = length & -8;
+
+    assert((length != 0) && (length == ilength) && (src != nullptr) && (dest != nullptr) && (filterCoeffs != nullptr));
+    assert(numSamples > ilength);
+
+    end = 2 * (numSamples - ilength);
+
+    #pragma omp parallel for
+    for (j = 0; j < end; j += 2)
+    {
+        const SAMPLETYPE *ptr;
+        LONG_SAMPLETYPE suml, sumr;
+
+        suml = sumr = 0;
+        ptr = src + j;
+
+        for (uint i = 0; i < ilength; i ++)
+        {
+            suml += ptr[2 * i] * filterCoeffsStereo[2 * i];
+            sumr += ptr[2 * i + 1] * filterCoeffsStereo[2 * i + 1];
+        }
+
+#ifdef SOUNDTOUCH_INTEGER_SAMPLES
+        suml >>= resultDivFactor;
+        sumr >>= resultDivFactor;
+        // saturate to 16 bit integer limits
+        suml = (suml < -32768) ? -32768 : (suml > 32767) ? 32767 : suml;
+        // saturate to 16 bit integer limits
+        sumr = (sumr < -32768) ? -32768 : (sumr > 32767) ? 32767 : sumr;
+#endif // SOUNDTOUCH_INTEGER_SAMPLES
+        dest[j] = (SAMPLETYPE)suml;
+        dest[j + 1] = (SAMPLETYPE)sumr;
+    }
+    return numSamples - ilength;
+}
+
+
+// Usual C-version of the filter routine for mono sound
+uint FIRFilter::evaluateFilterMono(SAMPLETYPE *dest, const SAMPLETYPE *src, uint numSamples) const
+{
+    int j, end;
+
+    // hint compiler autovectorization that loop length is divisible by 8
+    int ilength = length & -8;
+
+    assert(ilength != 0);
+
+    end = numSamples - ilength;
+    #pragma omp parallel for
+    for (j = 0; j < end; j ++)
+    {
+        const SAMPLETYPE *pSrc = src + j;
+        LONG_SAMPLETYPE sum;
+        int i;
+
+        sum = 0;
+        for (i = 0; i < ilength; i ++)
+        {
+            sum += pSrc[i] * filterCoeffs[i];
+        }
+#ifdef SOUNDTOUCH_INTEGER_SAMPLES
+        sum >>= resultDivFactor;
+        // saturate to 16 bit integer limits
+        sum = (sum < -32768) ? -32768 : (sum > 32767) ? 32767 : sum;
+#endif // SOUNDTOUCH_INTEGER_SAMPLES
+        dest[j] = (SAMPLETYPE)sum;
+    }
+    return end;
+}
+
+
+uint FIRFilter::evaluateFilterMulti(SAMPLETYPE *dest, const SAMPLETYPE *src, uint numSamples, uint numChannels)
+{
+    int j, end;
+
+    assert(length != 0);
+    assert(src != nullptr);
+    assert(dest != nullptr);
+    assert(filterCoeffs != nullptr);
+    assert(numChannels < 16);
+
+    // hint compiler autovectorization that loop length is divisible by 8
+    int ilength = length & -8;
+
+    end = numChannels * (numSamples - ilength);
+
+    #pragma omp parallel for
+    for (j = 0; j < end; j += numChannels)
+    {
+        const SAMPLETYPE *ptr;
+        LONG_SAMPLETYPE sums[16];
+        uint c;
+        int i;
+
+        for (c = 0; c < numChannels; c ++)
+        {
+            sums[c] = 0;
+        }
+
+        ptr = src + j;
+
+        for (i = 0; i < ilength; i ++)
+        {
+            SAMPLETYPE coef=filterCoeffs[i];
+            for (c = 0; c < numChannels; c ++)
+            {
+                sums[c] += ptr[0] * coef;
+                ptr ++;
+            }
+        }
+
+        for (c = 0; c < numChannels; c ++)
+        {
+#ifdef SOUNDTOUCH_INTEGER_SAMPLES
+            sums[c] >>= resultDivFactor;
+#endif // SOUNDTOUCH_INTEGER_SAMPLES
+            dest[j+c] = (SAMPLETYPE)sums[c];
+        }
+    }
+    return numSamples - ilength;
+}
+
+
+// Set filter coeffiecients and length.
+//
+// Throws an exception if filter length isn't divisible by 8
+void FIRFilter::setCoefficients(const SAMPLETYPE *coeffs, uint newLength, uint uResultDivFactor)
+{
+    assert(newLength > 0);
+    if (newLength % 8) ST_THROW_RT_ERROR("FIR filter length not divisible by 8");
+
+    #ifdef SOUNDTOUCH_FLOAT_SAMPLES
+        // scale coefficients already here if using floating samples
+        double scale = 1.0 / resultDivider;
+    #else
+        short scale = 1;
+    #endif
+
+    lengthDiv8 = newLength / 8;
+    length = lengthDiv8 * 8;
+    assert(length == newLength);
+
+    resultDivFactor = uResultDivFactor;
+    resultDivider = (SAMPLETYPE)::pow(2.0, (int)resultDivFactor);
+
+    delete[] filterCoeffs;
+    filterCoeffs = new SAMPLETYPE[length];
+    delete[] filterCoeffsStereo;
+    filterCoeffsStereo = new SAMPLETYPE[length*2];
+    for (uint i = 0; i < length; i ++)
+    {
+        filterCoeffs[i] = (SAMPLETYPE)(coeffs[i] * scale);
+        // create also stereo set of filter coefficients: this allows compiler
+        // to autovectorize filter evaluation much more efficiently
+        filterCoeffsStereo[2 * i] = (SAMPLETYPE)(coeffs[i] * scale);
+        filterCoeffsStereo[2 * i + 1] = (SAMPLETYPE)(coeffs[i] * scale);
+    }
+}
+
+
+uint FIRFilter::getLength() const
+{
+    return length;
+}
+
+
+// Applies the filter to the given sequence of samples.
+//
+// Note : The amount of outputted samples is by value of 'filter_length'
+// smaller than the amount of input samples.
+uint FIRFilter::evaluate(SAMPLETYPE *dest, const SAMPLETYPE *src, uint numSamples, uint numChannels)
+{
+    assert(length > 0);
+    assert(lengthDiv8 * 8 == length);
+
+    if (numSamples < length) return 0;
+
+#ifndef USE_MULTICH_ALWAYS
+    if (numChannels == 1)
+    {
+        return evaluateFilterMono(dest, src, numSamples);
+    }
+    else if (numChannels == 2)
+    {
+        return evaluateFilterStereo(dest, src, numSamples);
+    }
+    else
+#endif // USE_MULTICH_ALWAYS
+    {
+        assert(numChannels > 0);
+        return evaluateFilterMulti(dest, src, numSamples, numChannels);
+    }
+}
+
+
+// Operator 'new' is overloaded so that it automatically creates a suitable instance
+// depending on if we've a MMX-capable CPU available or not.
+void * FIRFilter::operator new(size_t)
+{
+    // Notice! don't use "new FIRFilter" directly, use "newInstance" to create a new instance instead!
+    ST_THROW_RT_ERROR("Error in FIRFilter::new: Don't use 'new FIRFilter', use 'newInstance' member instead!");
+    return newInstance();
+}
+
+
+FIRFilter * FIRFilter::newInstance()
+{
+    uint uExtensions;
+
+    uExtensions = detectCPUextensions();
+    (void)uExtensions;
+
+    // Check if MMX/SSE instruction set extensions supported by CPU
+
+#ifdef SOUNDTOUCH_ALLOW_MMX
+    // MMX routines available only with integer sample types
+    if (uExtensions & SUPPORT_MMX)
+    {
+        return ::new FIRFilterMMX;
+    }
+    else
+#endif // SOUNDTOUCH_ALLOW_MMX
+
+#ifdef SOUNDTOUCH_ALLOW_SSE
+    if (uExtensions & SUPPORT_SSE)
+    {
+        // SSE support
+        return ::new FIRFilterSSE;
+    }
+    else
+#endif // SOUNDTOUCH_ALLOW_SSE
+
+    {
+        // ISA optimizations not supported, use plain C version
+        return ::new FIRFilter;
+    }
+}
diff --git a/source/SoundTouch/FIRFilter.h b/source/SoundTouch/FIRFilter.h
index 90b730f..0acb199 100644
--- a/source/SoundTouch/FIRFilter.h
+++ b/source/SoundTouch/FIRFilter.h
@@ -1,140 +1,140 @@
-////////////////////////////////////////////////////////////////////////////////
-///
-/// General FIR digital filter routines with MMX optimization. 
-///
-/// Note : MMX optimized functions reside in a separate, platform-specific file, 
-/// e.g. 'mmx_win.cpp' or 'mmx_gcc.cpp'
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef FIRFilter_H
-#define FIRFilter_H
-
-#include 
-#include "STTypes.h"
-
-namespace soundtouch
-{
-
-class FIRFilter 
-{
-protected:
-    // Number of FIR filter taps
-    uint length;    
-    // Number of FIR filter taps divided by 8
-    uint lengthDiv8;
-
-    // Result divider factor in 2^k format
-    uint resultDivFactor;
-
-    // Result divider value.
-    SAMPLETYPE resultDivider;
-
-    // Memory for filter coefficients
-    SAMPLETYPE *filterCoeffs;
-    SAMPLETYPE *filterCoeffsStereo;
-
-    virtual uint evaluateFilterStereo(SAMPLETYPE *dest, 
-                                      const SAMPLETYPE *src, 
-                                      uint numSamples) const;
-    virtual uint evaluateFilterMono(SAMPLETYPE *dest, 
-                                    const SAMPLETYPE *src, 
-                                    uint numSamples) const;
-    virtual uint evaluateFilterMulti(SAMPLETYPE *dest, const SAMPLETYPE *src, uint numSamples, uint numChannels);
-
-public:
-    FIRFilter();
-    virtual ~FIRFilter();
-
-    /// Operator 'new' is overloaded so that it automatically creates a suitable instance 
-    /// depending on if we've a MMX-capable CPU available or not.
-    static void * operator new(size_t s);
-
-    static FIRFilter *newInstance();
-
-    /// Applies the filter to the given sequence of samples. 
-    /// Note : The amount of outputted samples is by value of 'filter_length' 
-    /// smaller than the amount of input samples.
-    ///
-    /// \return Number of samples copied to 'dest'.
-    uint evaluate(SAMPLETYPE *dest, 
-                  const SAMPLETYPE *src, 
-                  uint numSamples, 
-                  uint numChannels);
-
-    uint getLength() const;
-
-    virtual void setCoefficients(const SAMPLETYPE *coeffs, 
-                                 uint newLength, 
-                                 uint uResultDivFactor);
-};
-
-
-// Optional subclasses that implement CPU-specific optimizations:
-
-#ifdef SOUNDTOUCH_ALLOW_MMX
-
-/// Class that implements MMX optimized functions exclusive for 16bit integer samples type.
-    class FIRFilterMMX : public FIRFilter
-    {
-    protected:
-        short *filterCoeffsUnalign;
-        short *filterCoeffsAlign;
-
-        virtual uint evaluateFilterStereo(short *dest, const short *src, uint numSamples) const override;
-    public:
-        FIRFilterMMX();
-        ~FIRFilterMMX();
-
-        virtual void setCoefficients(const short *coeffs, uint newLength, uint uResultDivFactor) override;
-    };
-
-#endif // SOUNDTOUCH_ALLOW_MMX
-
-
-#ifdef SOUNDTOUCH_ALLOW_SSE
-    /// Class that implements SSE optimized functions exclusive for floating point samples type.
-    class FIRFilterSSE : public FIRFilter
-    {
-    protected:
-        float *filterCoeffsUnalign;
-        float *filterCoeffsAlign;
-
-        virtual uint evaluateFilterStereo(float *dest, const float *src, uint numSamples) const override;
-    public:
-        FIRFilterSSE();
-        ~FIRFilterSSE();
-
-        virtual void setCoefficients(const float *coeffs, uint newLength, uint uResultDivFactor) override;
-    };
-
-#endif // SOUNDTOUCH_ALLOW_SSE
-
-}
-
-#endif  // FIRFilter_H
+////////////////////////////////////////////////////////////////////////////////
+///
+/// General FIR digital filter routines with MMX optimization.
+///
+/// Note : MMX optimized functions reside in a separate, platform-specific file,
+/// e.g. 'mmx_win.cpp' or 'mmx_gcc.cpp'
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef FIRFilter_H
+#define FIRFilter_H
+
+#include 
+#include "STTypes.h"
+
+namespace soundtouch
+{
+
+class FIRFilter
+{
+protected:
+    // Number of FIR filter taps
+    uint length;
+    // Number of FIR filter taps divided by 8
+    uint lengthDiv8;
+
+    // Result divider factor in 2^k format
+    uint resultDivFactor;
+
+    // Result divider value.
+    SAMPLETYPE resultDivider;
+
+    // Memory for filter coefficients
+    SAMPLETYPE *filterCoeffs;
+    SAMPLETYPE *filterCoeffsStereo;
+
+    virtual uint evaluateFilterStereo(SAMPLETYPE *dest,
+                                      const SAMPLETYPE *src,
+                                      uint numSamples) const;
+    virtual uint evaluateFilterMono(SAMPLETYPE *dest,
+                                    const SAMPLETYPE *src,
+                                    uint numSamples) const;
+    virtual uint evaluateFilterMulti(SAMPLETYPE *dest, const SAMPLETYPE *src, uint numSamples, uint numChannels);
+
+public:
+    FIRFilter();
+    virtual ~FIRFilter();
+
+    /// Operator 'new' is overloaded so that it automatically creates a suitable instance
+    /// depending on if we've a MMX-capable CPU available or not.
+    static void * operator new(size_t s);
+
+    static FIRFilter *newInstance();
+
+    /// Applies the filter to the given sequence of samples.
+    /// Note : The amount of outputted samples is by value of 'filter_length'
+    /// smaller than the amount of input samples.
+    ///
+    /// \return Number of samples copied to 'dest'.
+    uint evaluate(SAMPLETYPE *dest,
+                  const SAMPLETYPE *src,
+                  uint numSamples,
+                  uint numChannels);
+
+    uint getLength() const;
+
+    virtual void setCoefficients(const SAMPLETYPE *coeffs,
+                                 uint newLength,
+                                 uint uResultDivFactor);
+};
+
+
+// Optional subclasses that implement CPU-specific optimizations:
+
+#ifdef SOUNDTOUCH_ALLOW_MMX
+
+/// Class that implements MMX optimized functions exclusive for 16bit integer samples type.
+    class FIRFilterMMX : public FIRFilter
+    {
+    protected:
+        short *filterCoeffsUnalign;
+        short *filterCoeffsAlign;
+
+        virtual uint evaluateFilterStereo(short *dest, const short *src, uint numSamples) const override;
+    public:
+        FIRFilterMMX();
+        ~FIRFilterMMX();
+
+        virtual void setCoefficients(const short *coeffs, uint newLength, uint uResultDivFactor) override;
+    };
+
+#endif // SOUNDTOUCH_ALLOW_MMX
+
+
+#ifdef SOUNDTOUCH_ALLOW_SSE
+    /// Class that implements SSE optimized functions exclusive for floating point samples type.
+    class FIRFilterSSE : public FIRFilter
+    {
+    protected:
+        float *filterCoeffsUnalign;
+        float *filterCoeffsAlign;
+
+        virtual uint evaluateFilterStereo(float *dest, const float *src, uint numSamples) const override;
+    public:
+        FIRFilterSSE();
+        ~FIRFilterSSE();
+
+        virtual void setCoefficients(const float *coeffs, uint newLength, uint uResultDivFactor) override;
+    };
+
+#endif // SOUNDTOUCH_ALLOW_SSE
+
+}
+
+#endif  // FIRFilter_H
diff --git a/source/SoundTouch/InterpolateCubic.cpp b/source/SoundTouch/InterpolateCubic.cpp
index fe49684..fe4c98a 100644
--- a/source/SoundTouch/InterpolateCubic.cpp
+++ b/source/SoundTouch/InterpolateCubic.cpp
@@ -1,196 +1,196 @@
-////////////////////////////////////////////////////////////////////////////////
-/// 
-/// Cubic interpolation routine.
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include 
-#include 
-#include "InterpolateCubic.h"
-#include "STTypes.h"
-
-using namespace soundtouch;
-
-// cubic interpolation coefficients
-static const float _coeffs[]= 
-{ -0.5f,  1.0f, -0.5f, 0.0f,
-   1.5f, -2.5f,  0.0f, 1.0f,
-  -1.5f,  2.0f,  0.5f, 0.0f,
-   0.5f, -0.5f,  0.0f, 0.0f};
-
-
-InterpolateCubic::InterpolateCubic()
-{
-    fract = 0;
-}
-
-
-void InterpolateCubic::resetRegisters()
-{
-    fract = 0;
-}
-
-
-/// Transpose mono audio. Returns number of produced output samples, and 
-/// updates "srcSamples" to amount of consumed source samples
-int InterpolateCubic::transposeMono(SAMPLETYPE *pdest, 
-                    const SAMPLETYPE *psrc, 
-                    int &srcSamples)
-{
-    int i;
-    int srcSampleEnd = srcSamples - 4;
-    int srcCount = 0;
-
-    i = 0;
-    while (srcCount < srcSampleEnd)
-    {
-        float out;
-        const float x3 = 1.0f;
-        const float x2 = (float)fract;    // x
-        const float x1 = x2*x2;           // x^2
-        const float x0 = x1*x2;           // x^3
-        float y0, y1, y2, y3;
-
-        assert(fract < 1.0);
-
-        y0 =  _coeffs[0] * x0 +  _coeffs[1] * x1 +  _coeffs[2] * x2 +  _coeffs[3] * x3;
-        y1 =  _coeffs[4] * x0 +  _coeffs[5] * x1 +  _coeffs[6] * x2 +  _coeffs[7] * x3;
-        y2 =  _coeffs[8] * x0 +  _coeffs[9] * x1 + _coeffs[10] * x2 + _coeffs[11] * x3;
-        y3 = _coeffs[12] * x0 + _coeffs[13] * x1 + _coeffs[14] * x2 + _coeffs[15] * x3;
-
-        out = y0 * psrc[0] + y1 * psrc[1] + y2 * psrc[2] + y3 * psrc[3];
-
-        pdest[i] = (SAMPLETYPE)out;
-        i ++;
-
-        // update position fraction
-        fract += rate;
-        // update whole positions
-        int whole = (int)fract;
-        fract -= whole;
-        psrc += whole;
-        srcCount += whole;
-    }
-    srcSamples = srcCount;
-    return i;
-}
-
-
-/// Transpose stereo audio. Returns number of produced output samples, and 
-/// updates "srcSamples" to amount of consumed source samples
-int InterpolateCubic::transposeStereo(SAMPLETYPE *pdest, 
-                    const SAMPLETYPE *psrc, 
-                    int &srcSamples)
-{
-    int i;
-    int srcSampleEnd = srcSamples - 4;
-    int srcCount = 0;
-
-    i = 0;
-    while (srcCount < srcSampleEnd)
-    {
-        const float x3 = 1.0f;
-        const float x2 = (float)fract;    // x
-        const float x1 = x2*x2;           // x^2
-        const float x0 = x1*x2;           // x^3
-        float y0, y1, y2, y3;
-        float out0, out1;
-
-        assert(fract < 1.0);
-
-        y0 =  _coeffs[0] * x0 +  _coeffs[1] * x1 +  _coeffs[2] * x2 +  _coeffs[3] * x3;
-        y1 =  _coeffs[4] * x0 +  _coeffs[5] * x1 +  _coeffs[6] * x2 +  _coeffs[7] * x3;
-        y2 =  _coeffs[8] * x0 +  _coeffs[9] * x1 + _coeffs[10] * x2 + _coeffs[11] * x3;
-        y3 = _coeffs[12] * x0 + _coeffs[13] * x1 + _coeffs[14] * x2 + _coeffs[15] * x3;
-
-        out0 = y0 * psrc[0] + y1 * psrc[2] + y2 * psrc[4] + y3 * psrc[6];
-        out1 = y0 * psrc[1] + y1 * psrc[3] + y2 * psrc[5] + y3 * psrc[7];
-
-        pdest[2*i]   = (SAMPLETYPE)out0;
-        pdest[2*i+1] = (SAMPLETYPE)out1;
-        i ++;
-
-        // update position fraction
-        fract += rate;
-        // update whole positions
-        int whole = (int)fract;
-        fract -= whole;
-        psrc += 2*whole;
-        srcCount += whole;
-    }
-    srcSamples = srcCount;
-    return i;
-}
-
-
-/// Transpose multi-channel audio. Returns number of produced output samples, and 
-/// updates "srcSamples" to amount of consumed source samples
-int InterpolateCubic::transposeMulti(SAMPLETYPE *pdest, 
-                    const SAMPLETYPE *psrc, 
-                    int &srcSamples)
-{
-    int i;
-    int srcSampleEnd = srcSamples - 4;
-    int srcCount = 0;
-
-    i = 0;
-    while (srcCount < srcSampleEnd)
-    {
-        const float x3 = 1.0f;
-        const float x2 = (float)fract;    // x
-        const float x1 = x2*x2;           // x^2
-        const float x0 = x1*x2;           // x^3
-        float y0, y1, y2, y3;
-
-        assert(fract < 1.0);
-
-        y0 =  _coeffs[0] * x0 +  _coeffs[1] * x1 +  _coeffs[2] * x2 +  _coeffs[3] * x3;
-        y1 =  _coeffs[4] * x0 +  _coeffs[5] * x1 +  _coeffs[6] * x2 +  _coeffs[7] * x3;
-        y2 =  _coeffs[8] * x0 +  _coeffs[9] * x1 + _coeffs[10] * x2 + _coeffs[11] * x3;
-        y3 = _coeffs[12] * x0 + _coeffs[13] * x1 + _coeffs[14] * x2 + _coeffs[15] * x3;
-
-        for (int c = 0; c < numChannels; c ++)
-        {
-            float out;
-            out = y0 * psrc[c] + y1 * psrc[c + numChannels] + y2 * psrc[c + 2 * numChannels] + y3 * psrc[c + 3 * numChannels];
-            pdest[0] = (SAMPLETYPE)out;
-            pdest ++;
-        }
-        i ++;
-
-        // update position fraction
-        fract += rate;
-        // update whole positions
-        int whole = (int)fract;
-        fract -= whole;
-        psrc += numChannels*whole;
-        srcCount += whole;
-    }
-    srcSamples = srcCount;
-    return i;
-}
+////////////////////////////////////////////////////////////////////////////////
+///
+/// Cubic interpolation routine.
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#include 
+#include 
+#include "InterpolateCubic.h"
+#include "STTypes.h"
+
+using namespace soundtouch;
+
+// cubic interpolation coefficients
+static const float _coeffs[]=
+{ -0.5f,  1.0f, -0.5f, 0.0f,
+   1.5f, -2.5f,  0.0f, 1.0f,
+  -1.5f,  2.0f,  0.5f, 0.0f,
+   0.5f, -0.5f,  0.0f, 0.0f};
+
+
+InterpolateCubic::InterpolateCubic()
+{
+    fract = 0;
+}
+
+
+void InterpolateCubic::resetRegisters()
+{
+    fract = 0;
+}
+
+
+/// Transpose mono audio. Returns number of produced output samples, and
+/// updates "srcSamples" to amount of consumed source samples
+int InterpolateCubic::transposeMono(SAMPLETYPE *pdest,
+                    const SAMPLETYPE *psrc,
+                    int &srcSamples)
+{
+    int i;
+    int srcSampleEnd = srcSamples - 4;
+    int srcCount = 0;
+
+    i = 0;
+    while (srcCount < srcSampleEnd)
+    {
+        float out;
+        const float x3 = 1.0f;
+        const float x2 = (float)fract;    // x
+        const float x1 = x2*x2;           // x^2
+        const float x0 = x1*x2;           // x^3
+        float y0, y1, y2, y3;
+
+        assert(fract < 1.0);
+
+        y0 =  _coeffs[0] * x0 +  _coeffs[1] * x1 +  _coeffs[2] * x2 +  _coeffs[3] * x3;
+        y1 =  _coeffs[4] * x0 +  _coeffs[5] * x1 +  _coeffs[6] * x2 +  _coeffs[7] * x3;
+        y2 =  _coeffs[8] * x0 +  _coeffs[9] * x1 + _coeffs[10] * x2 + _coeffs[11] * x3;
+        y3 = _coeffs[12] * x0 + _coeffs[13] * x1 + _coeffs[14] * x2 + _coeffs[15] * x3;
+
+        out = y0 * psrc[0] + y1 * psrc[1] + y2 * psrc[2] + y3 * psrc[3];
+
+        pdest[i] = (SAMPLETYPE)out;
+        i ++;
+
+        // update position fraction
+        fract += rate;
+        // update whole positions
+        int whole = (int)fract;
+        fract -= whole;
+        psrc += whole;
+        srcCount += whole;
+    }
+    srcSamples = srcCount;
+    return i;
+}
+
+
+/// Transpose stereo audio. Returns number of produced output samples, and
+/// updates "srcSamples" to amount of consumed source samples
+int InterpolateCubic::transposeStereo(SAMPLETYPE *pdest,
+                    const SAMPLETYPE *psrc,
+                    int &srcSamples)
+{
+    int i;
+    int srcSampleEnd = srcSamples - 4;
+    int srcCount = 0;
+
+    i = 0;
+    while (srcCount < srcSampleEnd)
+    {
+        const float x3 = 1.0f;
+        const float x2 = (float)fract;    // x
+        const float x1 = x2*x2;           // x^2
+        const float x0 = x1*x2;           // x^3
+        float y0, y1, y2, y3;
+        float out0, out1;
+
+        assert(fract < 1.0);
+
+        y0 =  _coeffs[0] * x0 +  _coeffs[1] * x1 +  _coeffs[2] * x2 +  _coeffs[3] * x3;
+        y1 =  _coeffs[4] * x0 +  _coeffs[5] * x1 +  _coeffs[6] * x2 +  _coeffs[7] * x3;
+        y2 =  _coeffs[8] * x0 +  _coeffs[9] * x1 + _coeffs[10] * x2 + _coeffs[11] * x3;
+        y3 = _coeffs[12] * x0 + _coeffs[13] * x1 + _coeffs[14] * x2 + _coeffs[15] * x3;
+
+        out0 = y0 * psrc[0] + y1 * psrc[2] + y2 * psrc[4] + y3 * psrc[6];
+        out1 = y0 * psrc[1] + y1 * psrc[3] + y2 * psrc[5] + y3 * psrc[7];
+
+        pdest[2*i]   = (SAMPLETYPE)out0;
+        pdest[2*i+1] = (SAMPLETYPE)out1;
+        i ++;
+
+        // update position fraction
+        fract += rate;
+        // update whole positions
+        int whole = (int)fract;
+        fract -= whole;
+        psrc += 2*whole;
+        srcCount += whole;
+    }
+    srcSamples = srcCount;
+    return i;
+}
+
+
+/// Transpose multi-channel audio. Returns number of produced output samples, and
+/// updates "srcSamples" to amount of consumed source samples
+int InterpolateCubic::transposeMulti(SAMPLETYPE *pdest,
+                    const SAMPLETYPE *psrc,
+                    int &srcSamples)
+{
+    int i;
+    int srcSampleEnd = srcSamples - 4;
+    int srcCount = 0;
+
+    i = 0;
+    while (srcCount < srcSampleEnd)
+    {
+        const float x3 = 1.0f;
+        const float x2 = (float)fract;    // x
+        const float x1 = x2*x2;           // x^2
+        const float x0 = x1*x2;           // x^3
+        float y0, y1, y2, y3;
+
+        assert(fract < 1.0);
+
+        y0 =  _coeffs[0] * x0 +  _coeffs[1] * x1 +  _coeffs[2] * x2 +  _coeffs[3] * x3;
+        y1 =  _coeffs[4] * x0 +  _coeffs[5] * x1 +  _coeffs[6] * x2 +  _coeffs[7] * x3;
+        y2 =  _coeffs[8] * x0 +  _coeffs[9] * x1 + _coeffs[10] * x2 + _coeffs[11] * x3;
+        y3 = _coeffs[12] * x0 + _coeffs[13] * x1 + _coeffs[14] * x2 + _coeffs[15] * x3;
+
+        for (int c = 0; c < numChannels; c ++)
+        {
+            float out;
+            out = y0 * psrc[c] + y1 * psrc[c + numChannels] + y2 * psrc[c + 2 * numChannels] + y3 * psrc[c + 3 * numChannels];
+            pdest[0] = (SAMPLETYPE)out;
+            pdest ++;
+        }
+        i ++;
+
+        // update position fraction
+        fract += rate;
+        // update whole positions
+        int whole = (int)fract;
+        fract -= whole;
+        psrc += numChannels*whole;
+        srcCount += whole;
+    }
+    srcSamples = srcCount;
+    return i;
+}
diff --git a/source/SoundTouch/InterpolateCubic.h b/source/SoundTouch/InterpolateCubic.h
index 64faf64..4eae60a 100644
--- a/source/SoundTouch/InterpolateCubic.h
+++ b/source/SoundTouch/InterpolateCubic.h
@@ -1,69 +1,69 @@
-////////////////////////////////////////////////////////////////////////////////
-/// 
-/// Cubic interpolation routine.
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef _InterpolateCubic_H_
-#define _InterpolateCubic_H_
-
-#include "RateTransposer.h"
-#include "STTypes.h"
-
-namespace soundtouch
-{
-
-class InterpolateCubic : public TransposerBase
-{
-protected:
-    virtual int transposeMono(SAMPLETYPE *dest, 
-                        const SAMPLETYPE *src, 
-                        int &srcSamples) override;
-    virtual int transposeStereo(SAMPLETYPE *dest, 
-                        const SAMPLETYPE *src, 
-                        int &srcSamples) override;
-    virtual int transposeMulti(SAMPLETYPE *dest, 
-                        const SAMPLETYPE *src, 
-                        int &srcSamples) override;
-
-    double fract;
-
-public:
-    InterpolateCubic();
-
-    virtual void resetRegisters() override;
-
-    virtual int getLatency() const override
-    {
-        return 1;
-    }
-};
-
-}
-
-#endif
+////////////////////////////////////////////////////////////////////////////////
+///
+/// Cubic interpolation routine.
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef _InterpolateCubic_H_
+#define _InterpolateCubic_H_
+
+#include "RateTransposer.h"
+#include "STTypes.h"
+
+namespace soundtouch
+{
+
+class InterpolateCubic : public TransposerBase
+{
+protected:
+    virtual int transposeMono(SAMPLETYPE *dest,
+                        const SAMPLETYPE *src,
+                        int &srcSamples) override;
+    virtual int transposeStereo(SAMPLETYPE *dest,
+                        const SAMPLETYPE *src,
+                        int &srcSamples) override;
+    virtual int transposeMulti(SAMPLETYPE *dest,
+                        const SAMPLETYPE *src,
+                        int &srcSamples) override;
+
+    double fract;
+
+public:
+    InterpolateCubic();
+
+    virtual void resetRegisters() override;
+
+    virtual int getLatency() const override
+    {
+        return 1;
+    }
+};
+
+}
+
+#endif
diff --git a/source/SoundTouch/InterpolateLinear.cpp b/source/SoundTouch/InterpolateLinear.cpp
index a11a493..b4571d6 100644
--- a/source/SoundTouch/InterpolateLinear.cpp
+++ b/source/SoundTouch/InterpolateLinear.cpp
@@ -1,296 +1,296 @@
-////////////////////////////////////////////////////////////////////////////////
-/// 
-/// Linear interpolation algorithm.
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include 
-#include 
-#include "InterpolateLinear.h"
-
-using namespace soundtouch;
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// InterpolateLinearInteger - integer arithmetic implementation
-// 
-
-/// fixed-point interpolation routine precision
-#define SCALE    65536
-
-
-// Constructor
-InterpolateLinearInteger::InterpolateLinearInteger() : TransposerBase()
-{
-    // Notice: use local function calling syntax for sake of clarity, 
-    // to indicate the fact that C++ constructor can't call virtual functions.
-    resetRegisters();
-    setRate(1.0f);
-}
-
-
-void InterpolateLinearInteger::resetRegisters()
-{
-    iFract = 0;
-}
-
-
-// Transposes the sample rate of the given samples using linear interpolation. 
-// 'Mono' version of the routine. Returns the number of samples returned in 
-// the "dest" buffer
-int InterpolateLinearInteger::transposeMono(SAMPLETYPE *dest, const SAMPLETYPE *src, int &srcSamples)
-{
-    int i;
-    int srcSampleEnd = srcSamples - 1;
-    int srcCount = 0;
-
-    i = 0;
-    while (srcCount < srcSampleEnd)
-    {
-        LONG_SAMPLETYPE temp;
-    
-        assert(iFract < SCALE);
-
-        temp = (SCALE - iFract) * src[0] + iFract * src[1];
-        dest[i] = (SAMPLETYPE)(temp / SCALE);
-        i++;
-
-        iFract += iRate;
-
-        int iWhole = iFract / SCALE;
-        iFract -= iWhole * SCALE;
-        srcCount += iWhole;
-        src += iWhole;
-    }
-    srcSamples = srcCount;
-
-    return i;
-}
-
-
-// Transposes the sample rate of the given samples using linear interpolation. 
-// 'Stereo' version of the routine. Returns the number of samples returned in 
-// the "dest" buffer
-int InterpolateLinearInteger::transposeStereo(SAMPLETYPE *dest, const SAMPLETYPE *src, int &srcSamples)
-{
-    int i;
-    int srcSampleEnd = srcSamples - 1;
-    int srcCount = 0;
-
-    i = 0;
-    while (srcCount < srcSampleEnd)
-    {
-        LONG_SAMPLETYPE temp0;
-        LONG_SAMPLETYPE temp1;
-    
-        assert(iFract < SCALE);
-
-        temp0 = (SCALE - iFract) * src[0] + iFract * src[2];
-        temp1 = (SCALE - iFract) * src[1] + iFract * src[3];
-        dest[0] = (SAMPLETYPE)(temp0 / SCALE);
-        dest[1] = (SAMPLETYPE)(temp1 / SCALE);
-        dest += 2;
-        i++;
-
-        iFract += iRate;
-
-        int iWhole = iFract / SCALE;
-        iFract -= iWhole * SCALE;
-        srcCount += iWhole;
-        src += 2*iWhole;
-    }
-    srcSamples = srcCount;
-
-    return i;
-}
-
-
-int InterpolateLinearInteger::transposeMulti(SAMPLETYPE *dest, const SAMPLETYPE *src, int &srcSamples)
-{
-    int i;
-    int srcSampleEnd = srcSamples - 1;
-    int srcCount = 0;
-
-    i = 0;
-    while (srcCount < srcSampleEnd)
-    {
-        LONG_SAMPLETYPE temp, vol1;
-    
-        assert(iFract < SCALE);
-        vol1 = (LONG_SAMPLETYPE)(SCALE - iFract);
-        for (int c = 0; c < numChannels; c ++)
-        {
-            temp = vol1 * src[c] + iFract * src[c + numChannels];
-            dest[0] = (SAMPLETYPE)(temp / SCALE);
-            dest ++;
-        }
-        i++;
-
-        iFract += iRate;
-
-        int iWhole = iFract / SCALE;
-        iFract -= iWhole * SCALE;
-        srcCount += iWhole;
-        src += iWhole * numChannels;
-    }
-    srcSamples = srcCount;
-
-    return i;
-}
-
-
-// Sets new target iRate. Normal iRate = 1.0, smaller values represent slower 
-// iRate, larger faster iRates.
-void InterpolateLinearInteger::setRate(double newRate)
-{
-    iRate = (int)(newRate * SCALE + 0.5);
-    TransposerBase::setRate(newRate);
-}
-
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// InterpolateLinearFloat - floating point arithmetic implementation
-// 
-//////////////////////////////////////////////////////////////////////////////
-
-
-// Constructor
-InterpolateLinearFloat::InterpolateLinearFloat() : TransposerBase()
-{
-    // Notice: use local function calling syntax for sake of clarity, 
-    // to indicate the fact that C++ constructor can't call virtual functions.
-    resetRegisters();
-    setRate(1.0);
-}
-
-
-void InterpolateLinearFloat::resetRegisters()
-{
-    fract = 0;
-}
-
-
-// Transposes the sample rate of the given samples using linear interpolation. 
-// 'Mono' version of the routine. Returns the number of samples returned in 
-// the "dest" buffer
-int InterpolateLinearFloat::transposeMono(SAMPLETYPE *dest, const SAMPLETYPE *src, int &srcSamples)
-{
-    int i;
-    int srcSampleEnd = srcSamples - 1;
-    int srcCount = 0;
-
-    i = 0;
-    while (srcCount < srcSampleEnd)
-    {
-        double out;
-        assert(fract < 1.0);
-
-        out = (1.0 - fract) * src[0] + fract * src[1];
-        dest[i] = (SAMPLETYPE)out;
-        i ++;
-
-        // update position fraction
-        fract += rate;
-        // update whole positions
-        int whole = (int)fract;
-        fract -= whole;
-        src += whole;
-        srcCount += whole;
-    }
-    srcSamples = srcCount;
-    return i;
-}
-
-
-// Transposes the sample rate of the given samples using linear interpolation. 
-// 'Mono' version of the routine. Returns the number of samples returned in 
-// the "dest" buffer
-int InterpolateLinearFloat::transposeStereo(SAMPLETYPE *dest, const SAMPLETYPE *src, int &srcSamples)
-{
-    int i;
-    int srcSampleEnd = srcSamples - 1;
-    int srcCount = 0;
-
-    i = 0;
-    while (srcCount < srcSampleEnd)
-    {
-        double out0, out1;
-        assert(fract < 1.0);
-
-        out0 = (1.0 - fract) * src[0] + fract * src[2];
-        out1 = (1.0 - fract) * src[1] + fract * src[3];
-        dest[2*i]   = (SAMPLETYPE)out0;
-        dest[2*i+1] = (SAMPLETYPE)out1;
-        i ++;
-
-        // update position fraction
-        fract += rate;
-        // update whole positions
-        int whole = (int)fract;
-        fract -= whole;
-        src += 2*whole;
-        srcCount += whole;
-    }
-    srcSamples = srcCount;
-    return i;
-}
-
-
-int InterpolateLinearFloat::transposeMulti(SAMPLETYPE *dest, const SAMPLETYPE *src, int &srcSamples)
-{
-    int i;
-    int srcSampleEnd = srcSamples - 1;
-    int srcCount = 0;
-
-    i = 0;
-    while (srcCount < srcSampleEnd)
-    {
-        float temp, vol1, fract_float;
-    
-        vol1 = (float)(1.0 - fract);
-		fract_float = (float)fract;
-        for (int c = 0; c < numChannels; c ++)
-        {
-			temp = vol1 * src[c] + fract_float * src[c + numChannels];
-            *dest = (SAMPLETYPE)temp;
-            dest ++;
-        }
-        i++;
-
-        fract += rate;
-
-        int iWhole = (int)fract;
-        fract -= iWhole;
-        srcCount += iWhole;
-        src += iWhole * numChannels;
-    }
-    srcSamples = srcCount;
-
-    return i;
-}
+////////////////////////////////////////////////////////////////////////////////
+///
+/// Linear interpolation algorithm.
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#include 
+#include 
+#include "InterpolateLinear.h"
+
+using namespace soundtouch;
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// InterpolateLinearInteger - integer arithmetic implementation
+//
+
+/// fixed-point interpolation routine precision
+#define SCALE    65536
+
+
+// Constructor
+InterpolateLinearInteger::InterpolateLinearInteger() : TransposerBase()
+{
+    // Notice: use local function calling syntax for sake of clarity,
+    // to indicate the fact that C++ constructor can't call virtual functions.
+    resetRegisters();
+    setRate(1.0f);
+}
+
+
+void InterpolateLinearInteger::resetRegisters()
+{
+    iFract = 0;
+}
+
+
+// Transposes the sample rate of the given samples using linear interpolation.
+// 'Mono' version of the routine. Returns the number of samples returned in
+// the "dest" buffer
+int InterpolateLinearInteger::transposeMono(SAMPLETYPE *dest, const SAMPLETYPE *src, int &srcSamples)
+{
+    int i;
+    int srcSampleEnd = srcSamples - 1;
+    int srcCount = 0;
+
+    i = 0;
+    while (srcCount < srcSampleEnd)
+    {
+        LONG_SAMPLETYPE temp;
+
+        assert(iFract < SCALE);
+
+        temp = (SCALE - iFract) * src[0] + iFract * src[1];
+        dest[i] = (SAMPLETYPE)(temp / SCALE);
+        i++;
+
+        iFract += iRate;
+
+        int iWhole = iFract / SCALE;
+        iFract -= iWhole * SCALE;
+        srcCount += iWhole;
+        src += iWhole;
+    }
+    srcSamples = srcCount;
+
+    return i;
+}
+
+
+// Transposes the sample rate of the given samples using linear interpolation.
+// 'Stereo' version of the routine. Returns the number of samples returned in
+// the "dest" buffer
+int InterpolateLinearInteger::transposeStereo(SAMPLETYPE *dest, const SAMPLETYPE *src, int &srcSamples)
+{
+    int i;
+    int srcSampleEnd = srcSamples - 1;
+    int srcCount = 0;
+
+    i = 0;
+    while (srcCount < srcSampleEnd)
+    {
+        LONG_SAMPLETYPE temp0;
+        LONG_SAMPLETYPE temp1;
+
+        assert(iFract < SCALE);
+
+        temp0 = (SCALE - iFract) * src[0] + iFract * src[2];
+        temp1 = (SCALE - iFract) * src[1] + iFract * src[3];
+        dest[0] = (SAMPLETYPE)(temp0 / SCALE);
+        dest[1] = (SAMPLETYPE)(temp1 / SCALE);
+        dest += 2;
+        i++;
+
+        iFract += iRate;
+
+        int iWhole = iFract / SCALE;
+        iFract -= iWhole * SCALE;
+        srcCount += iWhole;
+        src += 2*iWhole;
+    }
+    srcSamples = srcCount;
+
+    return i;
+}
+
+
+int InterpolateLinearInteger::transposeMulti(SAMPLETYPE *dest, const SAMPLETYPE *src, int &srcSamples)
+{
+    int i;
+    int srcSampleEnd = srcSamples - 1;
+    int srcCount = 0;
+
+    i = 0;
+    while (srcCount < srcSampleEnd)
+    {
+        LONG_SAMPLETYPE temp, vol1;
+
+        assert(iFract < SCALE);
+        vol1 = (LONG_SAMPLETYPE)(SCALE - iFract);
+        for (int c = 0; c < numChannels; c ++)
+        {
+            temp = vol1 * src[c] + iFract * src[c + numChannels];
+            dest[0] = (SAMPLETYPE)(temp / SCALE);
+            dest ++;
+        }
+        i++;
+
+        iFract += iRate;
+
+        int iWhole = iFract / SCALE;
+        iFract -= iWhole * SCALE;
+        srcCount += iWhole;
+        src += iWhole * numChannels;
+    }
+    srcSamples = srcCount;
+
+    return i;
+}
+
+
+// Sets new target iRate. Normal iRate = 1.0, smaller values represent slower
+// iRate, larger faster iRates.
+void InterpolateLinearInteger::setRate(double newRate)
+{
+    iRate = (int)(newRate * SCALE + 0.5);
+    TransposerBase::setRate(newRate);
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// InterpolateLinearFloat - floating point arithmetic implementation
+//
+//////////////////////////////////////////////////////////////////////////////
+
+
+// Constructor
+InterpolateLinearFloat::InterpolateLinearFloat() : TransposerBase()
+{
+    // Notice: use local function calling syntax for sake of clarity,
+    // to indicate the fact that C++ constructor can't call virtual functions.
+    resetRegisters();
+    setRate(1.0);
+}
+
+
+void InterpolateLinearFloat::resetRegisters()
+{
+    fract = 0;
+}
+
+
+// Transposes the sample rate of the given samples using linear interpolation.
+// 'Mono' version of the routine. Returns the number of samples returned in
+// the "dest" buffer
+int InterpolateLinearFloat::transposeMono(SAMPLETYPE *dest, const SAMPLETYPE *src, int &srcSamples)
+{
+    int i;
+    int srcSampleEnd = srcSamples - 1;
+    int srcCount = 0;
+
+    i = 0;
+    while (srcCount < srcSampleEnd)
+    {
+        double out;
+        assert(fract < 1.0);
+
+        out = (1.0 - fract) * src[0] + fract * src[1];
+        dest[i] = (SAMPLETYPE)out;
+        i ++;
+
+        // update position fraction
+        fract += rate;
+        // update whole positions
+        int whole = (int)fract;
+        fract -= whole;
+        src += whole;
+        srcCount += whole;
+    }
+    srcSamples = srcCount;
+    return i;
+}
+
+
+// Transposes the sample rate of the given samples using linear interpolation.
+// 'Mono' version of the routine. Returns the number of samples returned in
+// the "dest" buffer
+int InterpolateLinearFloat::transposeStereo(SAMPLETYPE *dest, const SAMPLETYPE *src, int &srcSamples)
+{
+    int i;
+    int srcSampleEnd = srcSamples - 1;
+    int srcCount = 0;
+
+    i = 0;
+    while (srcCount < srcSampleEnd)
+    {
+        double out0, out1;
+        assert(fract < 1.0);
+
+        out0 = (1.0 - fract) * src[0] + fract * src[2];
+        out1 = (1.0 - fract) * src[1] + fract * src[3];
+        dest[2*i]   = (SAMPLETYPE)out0;
+        dest[2*i+1] = (SAMPLETYPE)out1;
+        i ++;
+
+        // update position fraction
+        fract += rate;
+        // update whole positions
+        int whole = (int)fract;
+        fract -= whole;
+        src += 2*whole;
+        srcCount += whole;
+    }
+    srcSamples = srcCount;
+    return i;
+}
+
+
+int InterpolateLinearFloat::transposeMulti(SAMPLETYPE *dest, const SAMPLETYPE *src, int &srcSamples)
+{
+    int i;
+    int srcSampleEnd = srcSamples - 1;
+    int srcCount = 0;
+
+    i = 0;
+    while (srcCount < srcSampleEnd)
+    {
+        float temp, vol1, fract_float;
+
+        vol1 = (float)(1.0 - fract);
+		fract_float = (float)fract;
+        for (int c = 0; c < numChannels; c ++)
+        {
+			temp = vol1 * src[c] + fract_float * src[c + numChannels];
+            *dest = (SAMPLETYPE)temp;
+            dest ++;
+        }
+        i++;
+
+        fract += rate;
+
+        int iWhole = (int)fract;
+        fract -= iWhole;
+        srcCount += iWhole;
+        src += iWhole * numChannels;
+    }
+    srcSamples = srcCount;
+
+    return i;
+}
diff --git a/source/SoundTouch/InterpolateLinear.h b/source/SoundTouch/InterpolateLinear.h
index 8034d76..d0e5c90 100644
--- a/source/SoundTouch/InterpolateLinear.h
+++ b/source/SoundTouch/InterpolateLinear.h
@@ -1,98 +1,98 @@
-////////////////////////////////////////////////////////////////////////////////
-/// 
-/// Linear interpolation routine.
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef _InterpolateLinear_H_
-#define _InterpolateLinear_H_
-
-#include "RateTransposer.h"
-#include "STTypes.h"
-
-namespace soundtouch
-{
-
-/// Linear transposer class that uses integer arithmetic
-class InterpolateLinearInteger : public TransposerBase
-{
-protected:
-    int iFract;
-    int iRate;
-
-    virtual int transposeMono(SAMPLETYPE *dest, 
-                       const SAMPLETYPE *src, 
-                       int &srcSamples) override;
-    virtual int transposeStereo(SAMPLETYPE *dest, 
-                         const SAMPLETYPE *src, 
-                         int &srcSamples) override;
-    virtual int transposeMulti(SAMPLETYPE *dest, const SAMPLETYPE *src, int &srcSamples) override;
-public:
-    InterpolateLinearInteger();
-
-    /// Sets new target rate. Normal rate = 1.0, smaller values represent slower 
-    /// rate, larger faster rates.
-    virtual void setRate(double newRate) override;
-
-    virtual void resetRegisters() override;
-
-    virtual int getLatency() const override
-    {
-        return 0;
-    }
-};
-
-
-/// Linear transposer class that uses floating point arithmetic
-class InterpolateLinearFloat : public TransposerBase
-{
-protected:
-    double fract;
-
-    virtual int transposeMono(SAMPLETYPE *dest, 
-                       const SAMPLETYPE *src, 
-                       int &srcSamples);
-    virtual int transposeStereo(SAMPLETYPE *dest, 
-                         const SAMPLETYPE *src, 
-                         int &srcSamples);
-    virtual int transposeMulti(SAMPLETYPE *dest, const SAMPLETYPE *src, int &srcSamples);
-
-public:
-    InterpolateLinearFloat();
-
-    virtual void resetRegisters();
-
-    int getLatency() const
-    {
-        return 0;
-    }
-};
-
-}
-
-#endif
+////////////////////////////////////////////////////////////////////////////////
+///
+/// Linear interpolation routine.
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef _InterpolateLinear_H_
+#define _InterpolateLinear_H_
+
+#include "RateTransposer.h"
+#include "STTypes.h"
+
+namespace soundtouch
+{
+
+/// Linear transposer class that uses integer arithmetic
+class InterpolateLinearInteger : public TransposerBase
+{
+protected:
+    int iFract;
+    int iRate;
+
+    virtual int transposeMono(SAMPLETYPE *dest,
+                       const SAMPLETYPE *src,
+                       int &srcSamples) override;
+    virtual int transposeStereo(SAMPLETYPE *dest,
+                         const SAMPLETYPE *src,
+                         int &srcSamples) override;
+    virtual int transposeMulti(SAMPLETYPE *dest, const SAMPLETYPE *src, int &srcSamples) override;
+public:
+    InterpolateLinearInteger();
+
+    /// Sets new target rate. Normal rate = 1.0, smaller values represent slower
+    /// rate, larger faster rates.
+    virtual void setRate(double newRate) override;
+
+    virtual void resetRegisters() override;
+
+    virtual int getLatency() const override
+    {
+        return 0;
+    }
+};
+
+
+/// Linear transposer class that uses floating point arithmetic
+class InterpolateLinearFloat : public TransposerBase
+{
+protected:
+    double fract;
+
+    virtual int transposeMono(SAMPLETYPE *dest,
+                       const SAMPLETYPE *src,
+                       int &srcSamples);
+    virtual int transposeStereo(SAMPLETYPE *dest,
+                         const SAMPLETYPE *src,
+                         int &srcSamples);
+    virtual int transposeMulti(SAMPLETYPE *dest, const SAMPLETYPE *src, int &srcSamples);
+
+public:
+    InterpolateLinearFloat();
+
+    virtual void resetRegisters();
+
+    int getLatency() const
+    {
+        return 0;
+    }
+};
+
+}
+
+#endif
diff --git a/source/SoundTouch/InterpolateShannon.cpp b/source/SoundTouch/InterpolateShannon.cpp
index 8d97613..ac0b81a 100644
--- a/source/SoundTouch/InterpolateShannon.cpp
+++ b/source/SoundTouch/InterpolateShannon.cpp
@@ -1,181 +1,181 @@
-////////////////////////////////////////////////////////////////////////////////
-/// 
-/// Sample interpolation routine using 8-tap band-limited Shannon interpolation 
-/// with kaiser window.
-///
-/// Notice. This algorithm is remarkably much heavier than linear or cubic
-/// interpolation, and not remarkably better than cubic algorithm. Thus mostly
-/// for experimental purposes
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include 
-#include "InterpolateShannon.h"
-#include "STTypes.h"
-
-using namespace soundtouch;
-
-
-/// Kaiser window with beta = 2.0
-/// Values scaled down by 5% to avoid overflows
-static const double _kaiser8[8] = 
-{
-   0.41778693317814,
-   0.64888025049173,
-   0.83508562409944,
-   0.93887857733412,
-   0.93887857733412,
-   0.83508562409944,
-   0.64888025049173,
-   0.41778693317814
-};
-
-
-InterpolateShannon::InterpolateShannon()
-{
-    fract = 0;
-}
-
-
-void InterpolateShannon::resetRegisters()
-{
-    fract = 0;
-}
-
-
-#define PI 3.1415926536
-#define sinc(x) (sin(PI * (x)) / (PI * (x)))
-
-/// Transpose mono audio. Returns number of produced output samples, and 
-/// updates "srcSamples" to amount of consumed source samples
-int InterpolateShannon::transposeMono(SAMPLETYPE *pdest, 
-                    const SAMPLETYPE *psrc, 
-                    int &srcSamples)
-{
-    int i;
-    int srcSampleEnd = srcSamples - 8;
-    int srcCount = 0;
-
-    i = 0;
-    while (srcCount < srcSampleEnd)
-    {
-        double out;
-        assert(fract < 1.0);
-
-        out  = psrc[0] * sinc(-3.0 - fract) * _kaiser8[0];
-        out += psrc[1] * sinc(-2.0 - fract) * _kaiser8[1];
-        out += psrc[2] * sinc(-1.0 - fract) * _kaiser8[2];
-        if (fract < 1e-6)
-        {
-            out += psrc[3] * _kaiser8[3];     // sinc(0) = 1
-        }
-        else
-        {
-            out += psrc[3] * sinc(- fract) * _kaiser8[3];
-        }
-        out += psrc[4] * sinc( 1.0 - fract) * _kaiser8[4];
-        out += psrc[5] * sinc( 2.0 - fract) * _kaiser8[5];
-        out += psrc[6] * sinc( 3.0 - fract) * _kaiser8[6];
-        out += psrc[7] * sinc( 4.0 - fract) * _kaiser8[7];
-
-        pdest[i] = (SAMPLETYPE)out;
-        i ++;
-
-        // update position fraction
-        fract += rate;
-        // update whole positions
-        int whole = (int)fract;
-        fract -= whole;
-        psrc += whole;
-        srcCount += whole;
-    }
-    srcSamples = srcCount;
-    return i;
-}
-
-
-/// Transpose stereo audio. Returns number of produced output samples, and 
-/// updates "srcSamples" to amount of consumed source samples
-int InterpolateShannon::transposeStereo(SAMPLETYPE *pdest, 
-                    const SAMPLETYPE *psrc, 
-                    int &srcSamples)
-{
-    int i;
-    int srcSampleEnd = srcSamples - 8;
-    int srcCount = 0;
-
-    i = 0;
-    while (srcCount < srcSampleEnd)
-    {
-        double out0, out1, w;
-        assert(fract < 1.0);
-
-        w = sinc(-3.0 - fract) * _kaiser8[0];
-        out0 = psrc[0] * w; out1 = psrc[1] * w;
-        w = sinc(-2.0 - fract) * _kaiser8[1];
-        out0 += psrc[2] * w; out1 += psrc[3] * w;
-        w = sinc(-1.0 - fract) * _kaiser8[2];
-        out0 += psrc[4] * w; out1 += psrc[5] * w;
-        w = _kaiser8[3] * ((fract < 1e-5) ? 1.0 : sinc(- fract));   // sinc(0) = 1
-        out0 += psrc[6] * w; out1 += psrc[7] * w;
-        w = sinc( 1.0 - fract) * _kaiser8[4];
-        out0 += psrc[8] * w; out1 += psrc[9] * w;
-        w = sinc( 2.0 - fract) * _kaiser8[5];
-        out0 += psrc[10] * w; out1 += psrc[11] * w;
-        w = sinc( 3.0 - fract) * _kaiser8[6];
-        out0 += psrc[12] * w; out1 += psrc[13] * w;
-        w = sinc( 4.0 - fract) * _kaiser8[7];
-        out0 += psrc[14] * w; out1 += psrc[15] * w;
-
-        pdest[2*i]   = (SAMPLETYPE)out0;
-        pdest[2*i+1] = (SAMPLETYPE)out1;
-        i ++;
-
-        // update position fraction
-        fract += rate;
-        // update whole positions
-        int whole = (int)fract;
-        fract -= whole;
-        psrc += 2*whole;
-        srcCount += whole;
-    }
-    srcSamples = srcCount;
-    return i;
-}
-
-
-/// Transpose stereo audio. Returns number of produced output samples, and 
-/// updates "srcSamples" to amount of consumed source samples
-int InterpolateShannon::transposeMulti(SAMPLETYPE *, 
-                    const SAMPLETYPE *, 
-                    int &)
-{
-    // not implemented
-    assert(false);
-    return 0;
-}
+////////////////////////////////////////////////////////////////////////////////
+///
+/// Sample interpolation routine using 8-tap band-limited Shannon interpolation
+/// with kaiser window.
+///
+/// Notice. This algorithm is remarkably much heavier than linear or cubic
+/// interpolation, and not remarkably better than cubic algorithm. Thus mostly
+/// for experimental purposes
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#include 
+#include "InterpolateShannon.h"
+#include "STTypes.h"
+
+using namespace soundtouch;
+
+
+/// Kaiser window with beta = 2.0
+/// Values scaled down by 5% to avoid overflows
+static const double _kaiser8[8] =
+{
+   0.41778693317814,
+   0.64888025049173,
+   0.83508562409944,
+   0.93887857733412,
+   0.93887857733412,
+   0.83508562409944,
+   0.64888025049173,
+   0.41778693317814
+};
+
+
+InterpolateShannon::InterpolateShannon()
+{
+    fract = 0;
+}
+
+
+void InterpolateShannon::resetRegisters()
+{
+    fract = 0;
+}
+
+
+#define PI 3.1415926536
+#define sinc(x) (sin(PI * (x)) / (PI * (x)))
+
+/// Transpose mono audio. Returns number of produced output samples, and
+/// updates "srcSamples" to amount of consumed source samples
+int InterpolateShannon::transposeMono(SAMPLETYPE *pdest,
+                    const SAMPLETYPE *psrc,
+                    int &srcSamples)
+{
+    int i;
+    int srcSampleEnd = srcSamples - 8;
+    int srcCount = 0;
+
+    i = 0;
+    while (srcCount < srcSampleEnd)
+    {
+        double out;
+        assert(fract < 1.0);
+
+        out  = psrc[0] * sinc(-3.0 - fract) * _kaiser8[0];
+        out += psrc[1] * sinc(-2.0 - fract) * _kaiser8[1];
+        out += psrc[2] * sinc(-1.0 - fract) * _kaiser8[2];
+        if (fract < 1e-6)
+        {
+            out += psrc[3] * _kaiser8[3];     // sinc(0) = 1
+        }
+        else
+        {
+            out += psrc[3] * sinc(- fract) * _kaiser8[3];
+        }
+        out += psrc[4] * sinc( 1.0 - fract) * _kaiser8[4];
+        out += psrc[5] * sinc( 2.0 - fract) * _kaiser8[5];
+        out += psrc[6] * sinc( 3.0 - fract) * _kaiser8[6];
+        out += psrc[7] * sinc( 4.0 - fract) * _kaiser8[7];
+
+        pdest[i] = (SAMPLETYPE)out;
+        i ++;
+
+        // update position fraction
+        fract += rate;
+        // update whole positions
+        int whole = (int)fract;
+        fract -= whole;
+        psrc += whole;
+        srcCount += whole;
+    }
+    srcSamples = srcCount;
+    return i;
+}
+
+
+/// Transpose stereo audio. Returns number of produced output samples, and
+/// updates "srcSamples" to amount of consumed source samples
+int InterpolateShannon::transposeStereo(SAMPLETYPE *pdest,
+                    const SAMPLETYPE *psrc,
+                    int &srcSamples)
+{
+    int i;
+    int srcSampleEnd = srcSamples - 8;
+    int srcCount = 0;
+
+    i = 0;
+    while (srcCount < srcSampleEnd)
+    {
+        double out0, out1, w;
+        assert(fract < 1.0);
+
+        w = sinc(-3.0 - fract) * _kaiser8[0];
+        out0 = psrc[0] * w; out1 = psrc[1] * w;
+        w = sinc(-2.0 - fract) * _kaiser8[1];
+        out0 += psrc[2] * w; out1 += psrc[3] * w;
+        w = sinc(-1.0 - fract) * _kaiser8[2];
+        out0 += psrc[4] * w; out1 += psrc[5] * w;
+        w = _kaiser8[3] * ((fract < 1e-5) ? 1.0 : sinc(- fract));   // sinc(0) = 1
+        out0 += psrc[6] * w; out1 += psrc[7] * w;
+        w = sinc( 1.0 - fract) * _kaiser8[4];
+        out0 += psrc[8] * w; out1 += psrc[9] * w;
+        w = sinc( 2.0 - fract) * _kaiser8[5];
+        out0 += psrc[10] * w; out1 += psrc[11] * w;
+        w = sinc( 3.0 - fract) * _kaiser8[6];
+        out0 += psrc[12] * w; out1 += psrc[13] * w;
+        w = sinc( 4.0 - fract) * _kaiser8[7];
+        out0 += psrc[14] * w; out1 += psrc[15] * w;
+
+        pdest[2*i]   = (SAMPLETYPE)out0;
+        pdest[2*i+1] = (SAMPLETYPE)out1;
+        i ++;
+
+        // update position fraction
+        fract += rate;
+        // update whole positions
+        int whole = (int)fract;
+        fract -= whole;
+        psrc += 2*whole;
+        srcCount += whole;
+    }
+    srcSamples = srcCount;
+    return i;
+}
+
+
+/// Transpose stereo audio. Returns number of produced output samples, and
+/// updates "srcSamples" to amount of consumed source samples
+int InterpolateShannon::transposeMulti(SAMPLETYPE *,
+                    const SAMPLETYPE *,
+                    int &)
+{
+    // not implemented
+    assert(false);
+    return 0;
+}
diff --git a/source/SoundTouch/InterpolateShannon.h b/source/SoundTouch/InterpolateShannon.h
index e0c6fa5..99bd7a6 100644
--- a/source/SoundTouch/InterpolateShannon.h
+++ b/source/SoundTouch/InterpolateShannon.h
@@ -1,74 +1,74 @@
-////////////////////////////////////////////////////////////////////////////////
-/// 
-/// Sample interpolation routine using 8-tap band-limited Shannon interpolation 
-/// with kaiser window.
-///
-/// Notice. This algorithm is remarkably much heavier than linear or cubic
-/// interpolation, and not remarkably better than cubic algorithm. Thus mostly
-/// for experimental purposes
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef _InterpolateShannon_H_
-#define _InterpolateShannon_H_
-
-#include "RateTransposer.h"
-#include "STTypes.h"
-
-namespace soundtouch
-{
-
-class InterpolateShannon : public TransposerBase
-{
-protected:
-    int transposeMono(SAMPLETYPE *dest, 
-                        const SAMPLETYPE *src, 
-                        int &srcSamples) override;
-    int transposeStereo(SAMPLETYPE *dest, 
-                        const SAMPLETYPE *src, 
-                        int &srcSamples) override;
-    int transposeMulti(SAMPLETYPE *dest, 
-                        const SAMPLETYPE *src, 
-                        int &srcSamples) override;
-
-    double fract;
-
-public:
-    InterpolateShannon();
-
-    void resetRegisters() override;
-
-    virtual int getLatency() const override
-    {
-        return 3;
-    }
-};
-
-}
-
-#endif
+////////////////////////////////////////////////////////////////////////////////
+///
+/// Sample interpolation routine using 8-tap band-limited Shannon interpolation
+/// with kaiser window.
+///
+/// Notice. This algorithm is remarkably much heavier than linear or cubic
+/// interpolation, and not remarkably better than cubic algorithm. Thus mostly
+/// for experimental purposes
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef _InterpolateShannon_H_
+#define _InterpolateShannon_H_
+
+#include "RateTransposer.h"
+#include "STTypes.h"
+
+namespace soundtouch
+{
+
+class InterpolateShannon : public TransposerBase
+{
+protected:
+    int transposeMono(SAMPLETYPE *dest,
+                        const SAMPLETYPE *src,
+                        int &srcSamples) override;
+    int transposeStereo(SAMPLETYPE *dest,
+                        const SAMPLETYPE *src,
+                        int &srcSamples) override;
+    int transposeMulti(SAMPLETYPE *dest,
+                        const SAMPLETYPE *src,
+                        int &srcSamples) override;
+
+    double fract;
+
+public:
+    InterpolateShannon();
+
+    void resetRegisters() override;
+
+    virtual int getLatency() const override
+    {
+        return 3;
+    }
+};
+
+}
+
+#endif
diff --git a/source/SoundTouch/Makefile.am b/source/SoundTouch/Makefile.am
index eac15a9..e0548f9 100644
--- a/source/SoundTouch/Makefile.am
+++ b/source/SoundTouch/Makefile.am
@@ -1,74 +1,74 @@
-## Process this file with automake to create Makefile.in
-##
-## This file is part of SoundTouch, an audio processing library for pitch/time adjustments
-## 
-## SoundTouch 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.
-## 
-## SoundTouch is distributed in the hope that it will be useful, but WITHOUT ANY
-## WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-## A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-## 
-## You should have received a copy of the GNU General Public License along with
-## this program; if not, write to the Free Software Foundation, Inc., 59 Temple
-## Place - Suite 330, Boston, MA  02111-1307, USA
-
-
-include $(top_srcdir)/config/am_include.mk
-
-
-# set to something if you want other stuff to be included in the distribution tarball
-EXTRA_DIST=SoundTouch.sln SoundTouch.vcxproj
-
-noinst_HEADERS=AAFilter.h cpu_detect.h cpu_detect_x86.cpp FIRFilter.h RateTransposer.h TDStretch.h PeakFinder.h \
-    InterpolateCubic.h InterpolateLinear.h InterpolateShannon.h
-
-lib_LTLIBRARIES=libSoundTouch.la
-#
-libSoundTouch_la_SOURCES=AAFilter.cpp FIRFilter.cpp FIFOSampleBuffer.cpp    \
-    RateTransposer.cpp SoundTouch.cpp TDStretch.cpp cpu_detect_x86.cpp      \
-    BPMDetect.cpp PeakFinder.cpp InterpolateLinear.cpp InterpolateCubic.cpp \
-    InterpolateShannon.cpp
-
-# Compiler flags
-#AM_CXXFLAGS+=
-
-# Compile the files that need MMX and SSE individually.
-libSoundTouch_la_LIBADD=libSoundTouchMMX.la libSoundTouchSSE.la
-noinst_LTLIBRARIES=libSoundTouchMMX.la libSoundTouchSSE.la
-libSoundTouchMMX_la_SOURCES=mmx_optimized.cpp
-libSoundTouchSSE_la_SOURCES=sse_optimized.cpp
-
-# We enable optimizations by default.
-# If MMX is supported compile with -mmmx.
-# Do not assume -msse is also supported.
-if HAVE_MMX
-libSoundTouchMMX_la_CXXFLAGS = -mmmx $(AM_CXXFLAGS)
-else
-libSoundTouchMMX_la_CXXFLAGS = $(AM_CXXFLAGS)
-endif
-
-# We enable optimizations by default.
-# If SSE is supported compile with -msse.
-if HAVE_SSE
-libSoundTouchSSE_la_CXXFLAGS = -msse $(AM_CXXFLAGS)
-else
-libSoundTouchSSE_la_CXXFLAGS = $(AM_CXXFLAGS)
-endif
-
-# Let the user disable optimizations if he wishes to.
-if !X86_OPTIMIZATIONS
-libSoundTouchMMX_la_CXXFLAGS = $(AM_CXXFLAGS)
-libSoundTouchSSE_la_CXXFLAGS = $(AM_CXXFLAGS)
-endif
-
-# Modify the default 0.0.0 to LIB_SONAME.0.0
-libSoundTouch_la_LDFLAGS=-version-info @LIB_SONAME@
-
-# other linking flags to add
-# noinst_LTLIBRARIES = libSoundTouchOpt.la
-# libSoundTouch_la_LIBADD = libSoundTouchOpt.la
-# libSoundTouchOpt_la_SOURCES = mmx_optimized.cpp sse_optimized.cpp 
-# libSoundTouchOpt_la_CXXFLAGS = -O3 -msse -fcheck-new -I../../include
+## Process this file with automake to create Makefile.in
+##
+## This file is part of SoundTouch, an audio processing library for pitch/time adjustments
+##
+## SoundTouch 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.
+##
+## SoundTouch is distributed in the hope that it will be useful, but WITHOUT ANY
+## WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+## A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+##
+## You should have received a copy of the GNU General Public License along with
+## this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+## Place - Suite 330, Boston, MA  02111-1307, USA
+
+
+include $(top_srcdir)/config/am_include.mk
+
+
+# set to something if you want other stuff to be included in the distribution tarball
+EXTRA_DIST=SoundTouch.sln SoundTouch.vcxproj
+
+noinst_HEADERS=AAFilter.h cpu_detect.h cpu_detect_x86.cpp FIRFilter.h RateTransposer.h TDStretch.h PeakFinder.h \
+    InterpolateCubic.h InterpolateLinear.h InterpolateShannon.h
+
+lib_LTLIBRARIES=libSoundTouch.la
+#
+libSoundTouch_la_SOURCES=AAFilter.cpp FIRFilter.cpp FIFOSampleBuffer.cpp    \
+    RateTransposer.cpp SoundTouch.cpp TDStretch.cpp cpu_detect_x86.cpp      \
+    BPMDetect.cpp PeakFinder.cpp InterpolateLinear.cpp InterpolateCubic.cpp \
+    InterpolateShannon.cpp
+
+# Compiler flags
+#AM_CXXFLAGS+=
+
+# Compile the files that need MMX and SSE individually.
+libSoundTouch_la_LIBADD=libSoundTouchMMX.la libSoundTouchSSE.la
+noinst_LTLIBRARIES=libSoundTouchMMX.la libSoundTouchSSE.la
+libSoundTouchMMX_la_SOURCES=mmx_optimized.cpp
+libSoundTouchSSE_la_SOURCES=sse_optimized.cpp
+
+# We enable optimizations by default.
+# If MMX is supported compile with -mmmx.
+# Do not assume -msse is also supported.
+if HAVE_MMX
+libSoundTouchMMX_la_CXXFLAGS = -mmmx $(AM_CXXFLAGS)
+else
+libSoundTouchMMX_la_CXXFLAGS = $(AM_CXXFLAGS)
+endif
+
+# We enable optimizations by default.
+# If SSE is supported compile with -msse.
+if HAVE_SSE
+libSoundTouchSSE_la_CXXFLAGS = -msse $(AM_CXXFLAGS)
+else
+libSoundTouchSSE_la_CXXFLAGS = $(AM_CXXFLAGS)
+endif
+
+# Let the user disable optimizations if he wishes to.
+if !X86_OPTIMIZATIONS
+libSoundTouchMMX_la_CXXFLAGS = $(AM_CXXFLAGS)
+libSoundTouchSSE_la_CXXFLAGS = $(AM_CXXFLAGS)
+endif
+
+# Modify the default 0.0.0 to LIB_SONAME.0.0
+libSoundTouch_la_LDFLAGS=-version-info @LIB_SONAME@
+
+# other linking flags to add
+# noinst_LTLIBRARIES = libSoundTouchOpt.la
+# libSoundTouch_la_LIBADD = libSoundTouchOpt.la
+# libSoundTouchOpt_la_SOURCES = mmx_optimized.cpp sse_optimized.cpp
+# libSoundTouchOpt_la_CXXFLAGS = -O3 -msse -fcheck-new -I../../include
diff --git a/source/SoundTouch/PeakFinder.cpp b/source/SoundTouch/PeakFinder.cpp
index 5423c85..ebb79ee 100644
--- a/source/SoundTouch/PeakFinder.cpp
+++ b/source/SoundTouch/PeakFinder.cpp
@@ -1,277 +1,277 @@
-////////////////////////////////////////////////////////////////////////////////
-///
-/// Peak detection routine. 
-///
-/// The routine detects highest value on an array of values and calculates the 
-/// precise peak location as a mass-center of the 'hump' around the peak value.
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include 
-#include 
-
-#include "PeakFinder.h"
-
-using namespace soundtouch;
-
-#define max(x, y) (((x) > (y)) ? (x) : (y))
-
-
-PeakFinder::PeakFinder()
-{
-    minPos = maxPos = 0;
-}
-
-
-// Finds real 'top' of a peak hump from neighnourhood of the given 'peakpos'.
-int PeakFinder::findTop(const float *data, int peakpos) const
-{
-    int i;
-    int start, end;
-    float refvalue;
-
-    refvalue = data[peakpos];
-
-    // seek within ±10 points
-    start = peakpos - 10;
-    if (start < minPos) start = minPos;
-    end = peakpos + 10;
-    if (end > maxPos) end = maxPos;
-
-    for (i = start; i <= end; i ++)
-    {
-        if (data[i] > refvalue)
-        {
-            peakpos = i;
-            refvalue = data[i];
-        }
-    }
-
-    // failure if max value is at edges of seek range => it's not peak, it's at slope.
-    if ((peakpos == start) || (peakpos == end)) return 0;
-
-    return peakpos;
-}
-
-
-// Finds 'ground level' of a peak hump by starting from 'peakpos' and proceeding
-// to direction defined by 'direction' until next 'hump' after minimum value will 
-// begin
-int PeakFinder::findGround(const float *data, int peakpos, int direction) const
-{
-    int lowpos;
-    int pos;
-    int climb_count;
-    float refvalue;
-    float delta;
-
-    climb_count = 0;
-    refvalue = data[peakpos];
-    lowpos = peakpos;
-
-    pos = peakpos;
-
-    while ((pos > minPos+1) && (pos < maxPos-1))
-    {
-        int prevpos;
-
-        prevpos = pos;
-        pos += direction;
-
-        // calculate derivate
-        delta = data[pos] - data[prevpos];
-        if (delta <= 0)
-        {
-            // going downhill, ok
-            if (climb_count)
-            {
-                climb_count --;  // decrease climb count
-            }
-
-            // check if new minimum found
-            if (data[pos] < refvalue)
-            {
-                // new minimum found
-                lowpos = pos;
-                refvalue = data[pos];
-            }
-        }
-        else
-        {
-            // going uphill, increase climbing counter
-            climb_count ++;
-            if (climb_count > 5) break;    // we've been climbing too long => it's next uphill => quit
-        }
-    }
-    return lowpos;
-}
-
-
-// Find offset where the value crosses the given level, when starting from 'peakpos' and
-// proceeds to direction defined in 'direction'
-int PeakFinder::findCrossingLevel(const float *data, float level, int peakpos, int direction) const
-{
-    float peaklevel;
-    int pos;
-
-    peaklevel = data[peakpos];
-    assert(peaklevel >= level);
-    pos = peakpos;
-    while ((pos >= minPos) && (pos + direction < maxPos))
-    {
-        if (data[pos + direction] < level) return pos;   // crossing found
-        pos += direction;
-    }
-    return -1;  // not found
-}
-
-
-// Calculates the center of mass location of 'data' array items between 'firstPos' and 'lastPos'
-double PeakFinder::calcMassCenter(const float *data, int firstPos, int lastPos) const
-{
-    int i;
-    float sum;
-    float wsum;
-
-    sum = 0;
-    wsum = 0;
-    for (i = firstPos; i <= lastPos; i ++)
-    {
-        sum += (float)i * data[i];
-        wsum += data[i];
-    }
-
-    if (wsum < 1e-6) return 0;
-    return sum / wsum;
-}
-
-
-/// get exact center of peak near given position by calculating local mass of center
-double PeakFinder::getPeakCenter(const float *data, int peakpos) const
-{
-    float peakLevel;            // peak level
-    int crosspos1, crosspos2;   // position where the peak 'hump' crosses cutting level
-    float cutLevel;             // cutting value
-    float groundLevel;          // ground level of the peak
-    int gp1, gp2;               // bottom positions of the peak 'hump'
-
-    // find ground positions.
-    gp1 = findGround(data, peakpos, -1);
-    gp2 = findGround(data, peakpos, 1);
-
-    peakLevel = data[peakpos];
-
-    if (gp1 == gp2) 
-    {
-        // avoid rounding errors when all are equal
-        assert(gp1 == peakpos);
-        cutLevel = groundLevel = peakLevel;
-    } else {
-        // get average of the ground levels
-        groundLevel = 0.5f * (data[gp1] + data[gp2]);
-
-        // calculate 70%-level of the peak
-        cutLevel = 0.70f * peakLevel + 0.30f * groundLevel;
-    }
-
-    // find mid-level crossings
-    crosspos1 = findCrossingLevel(data, cutLevel, peakpos, -1);
-    crosspos2 = findCrossingLevel(data, cutLevel, peakpos, 1);
-
-    if ((crosspos1 < 0) || (crosspos2 < 0)) return 0;   // no crossing, no peak..
-
-    // calculate mass center of the peak surroundings
-    return calcMassCenter(data, crosspos1, crosspos2);
-}
-
-
-double PeakFinder::detectPeak(const float *data, int aminPos, int amaxPos) 
-{
-
-    int i;
-    int peakpos;                // position of peak level
-    double highPeak, peak;
-
-    this->minPos = aminPos;
-    this->maxPos = amaxPos;
-
-    // find absolute peak
-    peakpos = minPos;
-    peak = data[minPos];
-    for (i = minPos + 1; i < maxPos; i ++)
-    {
-        if (data[i] > peak) 
-        {
-            peak = data[i];
-            peakpos = i;
-        }
-    }
-    
-    // Calculate exact location of the highest peak mass center
-    highPeak = getPeakCenter(data, peakpos);
-    peak = highPeak;
-
-    // Now check if the highest peak were in fact harmonic of the true base beat peak 
-    // - sometimes the highest peak can be Nth harmonic of the true base peak yet 
-    // just a slightly higher than the true base
-
-    for (i = 1; i < 3; i ++)
-    {
-        double peaktmp, harmonic;
-        int i1,i2;
-
-        harmonic = (double)pow(2.0, i);
-        peakpos = (int)(highPeak / harmonic + 0.5f);
-        if (peakpos < minPos) break;
-        peakpos = findTop(data, peakpos);   // seek true local maximum index
-        if (peakpos == 0) continue;         // no local max here
-
-        // calculate mass-center of possible harmonic peak
-        peaktmp = getPeakCenter(data, peakpos);
-
-        // accept harmonic peak if 
-        // (a) it is found
-        // (b) is within ±4% of the expected harmonic interval
-        // (c) has at least half x-corr value of the max. peak
-
-        double diff = harmonic * peaktmp / highPeak;
-        if ((diff < 0.96) || (diff > 1.04)) continue;   // peak too afar from expected
-
-        // now compare to highest detected peak
-        i1 = (int)(highPeak + 0.5);
-        i2 = (int)(peaktmp + 0.5);
-        if (data[i2] >= 0.4*data[i1])
-        {
-            // The harmonic is at least half as high primary peak,
-            // thus use the harmonic peak instead
-            peak = peaktmp;
-        }
-    }
-
-    return peak;
-}
+////////////////////////////////////////////////////////////////////////////////
+///
+/// Peak detection routine.
+///
+/// The routine detects highest value on an array of values and calculates the
+/// precise peak location as a mass-center of the 'hump' around the peak value.
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#include 
+#include 
+
+#include "PeakFinder.h"
+
+using namespace soundtouch;
+
+#define max(x, y) (((x) > (y)) ? (x) : (y))
+
+
+PeakFinder::PeakFinder()
+{
+    minPos = maxPos = 0;
+}
+
+
+// Finds real 'top' of a peak hump from neighnourhood of the given 'peakpos'.
+int PeakFinder::findTop(const float *data, int peakpos) const
+{
+    int i;
+    int start, end;
+    float refvalue;
+
+    refvalue = data[peakpos];
+
+    // seek within ±10 points
+    start = peakpos - 10;
+    if (start < minPos) start = minPos;
+    end = peakpos + 10;
+    if (end > maxPos) end = maxPos;
+
+    for (i = start; i <= end; i ++)
+    {
+        if (data[i] > refvalue)
+        {
+            peakpos = i;
+            refvalue = data[i];
+        }
+    }
+
+    // failure if max value is at edges of seek range => it's not peak, it's at slope.
+    if ((peakpos == start) || (peakpos == end)) return 0;
+
+    return peakpos;
+}
+
+
+// Finds 'ground level' of a peak hump by starting from 'peakpos' and proceeding
+// to direction defined by 'direction' until next 'hump' after minimum value will
+// begin
+int PeakFinder::findGround(const float *data, int peakpos, int direction) const
+{
+    int lowpos;
+    int pos;
+    int climb_count;
+    float refvalue;
+    float delta;
+
+    climb_count = 0;
+    refvalue = data[peakpos];
+    lowpos = peakpos;
+
+    pos = peakpos;
+
+    while ((pos > minPos+1) && (pos < maxPos-1))
+    {
+        int prevpos;
+
+        prevpos = pos;
+        pos += direction;
+
+        // calculate derivate
+        delta = data[pos] - data[prevpos];
+        if (delta <= 0)
+        {
+            // going downhill, ok
+            if (climb_count)
+            {
+                climb_count --;  // decrease climb count
+            }
+
+            // check if new minimum found
+            if (data[pos] < refvalue)
+            {
+                // new minimum found
+                lowpos = pos;
+                refvalue = data[pos];
+            }
+        }
+        else
+        {
+            // going uphill, increase climbing counter
+            climb_count ++;
+            if (climb_count > 5) break;    // we've been climbing too long => it's next uphill => quit
+        }
+    }
+    return lowpos;
+}
+
+
+// Find offset where the value crosses the given level, when starting from 'peakpos' and
+// proceeds to direction defined in 'direction'
+int PeakFinder::findCrossingLevel(const float *data, float level, int peakpos, int direction) const
+{
+    float peaklevel;
+    int pos;
+
+    peaklevel = data[peakpos];
+    assert(peaklevel >= level);
+    pos = peakpos;
+    while ((pos >= minPos) && (pos + direction < maxPos))
+    {
+        if (data[pos + direction] < level) return pos;   // crossing found
+        pos += direction;
+    }
+    return -1;  // not found
+}
+
+
+// Calculates the center of mass location of 'data' array items between 'firstPos' and 'lastPos'
+double PeakFinder::calcMassCenter(const float *data, int firstPos, int lastPos) const
+{
+    int i;
+    float sum;
+    float wsum;
+
+    sum = 0;
+    wsum = 0;
+    for (i = firstPos; i <= lastPos; i ++)
+    {
+        sum += (float)i * data[i];
+        wsum += data[i];
+    }
+
+    if (wsum < 1e-6) return 0;
+    return sum / wsum;
+}
+
+
+/// get exact center of peak near given position by calculating local mass of center
+double PeakFinder::getPeakCenter(const float *data, int peakpos) const
+{
+    float peakLevel;            // peak level
+    int crosspos1, crosspos2;   // position where the peak 'hump' crosses cutting level
+    float cutLevel;             // cutting value
+    float groundLevel;          // ground level of the peak
+    int gp1, gp2;               // bottom positions of the peak 'hump'
+
+    // find ground positions.
+    gp1 = findGround(data, peakpos, -1);
+    gp2 = findGround(data, peakpos, 1);
+
+    peakLevel = data[peakpos];
+
+    if (gp1 == gp2)
+    {
+        // avoid rounding errors when all are equal
+        assert(gp1 == peakpos);
+        cutLevel = groundLevel = peakLevel;
+    } else {
+        // get average of the ground levels
+        groundLevel = 0.5f * (data[gp1] + data[gp2]);
+
+        // calculate 70%-level of the peak
+        cutLevel = 0.70f * peakLevel + 0.30f * groundLevel;
+    }
+
+    // find mid-level crossings
+    crosspos1 = findCrossingLevel(data, cutLevel, peakpos, -1);
+    crosspos2 = findCrossingLevel(data, cutLevel, peakpos, 1);
+
+    if ((crosspos1 < 0) || (crosspos2 < 0)) return 0;   // no crossing, no peak..
+
+    // calculate mass center of the peak surroundings
+    return calcMassCenter(data, crosspos1, crosspos2);
+}
+
+
+double PeakFinder::detectPeak(const float *data, int aminPos, int amaxPos)
+{
+
+    int i;
+    int peakpos;                // position of peak level
+    double highPeak, peak;
+
+    this->minPos = aminPos;
+    this->maxPos = amaxPos;
+
+    // find absolute peak
+    peakpos = minPos;
+    peak = data[minPos];
+    for (i = minPos + 1; i < maxPos; i ++)
+    {
+        if (data[i] > peak)
+        {
+            peak = data[i];
+            peakpos = i;
+        }
+    }
+
+    // Calculate exact location of the highest peak mass center
+    highPeak = getPeakCenter(data, peakpos);
+    peak = highPeak;
+
+    // Now check if the highest peak were in fact harmonic of the true base beat peak
+    // - sometimes the highest peak can be Nth harmonic of the true base peak yet
+    // just a slightly higher than the true base
+
+    for (i = 1; i < 3; i ++)
+    {
+        double peaktmp, harmonic;
+        int i1,i2;
+
+        harmonic = (double)pow(2.0, i);
+        peakpos = (int)(highPeak / harmonic + 0.5f);
+        if (peakpos < minPos) break;
+        peakpos = findTop(data, peakpos);   // seek true local maximum index
+        if (peakpos == 0) continue;         // no local max here
+
+        // calculate mass-center of possible harmonic peak
+        peaktmp = getPeakCenter(data, peakpos);
+
+        // accept harmonic peak if
+        // (a) it is found
+        // (b) is within ±4% of the expected harmonic interval
+        // (c) has at least half x-corr value of the max. peak
+
+        double diff = harmonic * peaktmp / highPeak;
+        if ((diff < 0.96) || (diff > 1.04)) continue;   // peak too afar from expected
+
+        // now compare to highest detected peak
+        i1 = (int)(highPeak + 0.5);
+        i2 = (int)(peaktmp + 0.5);
+        if (data[i2] >= 0.4*data[i1])
+        {
+            // The harmonic is at least half as high primary peak,
+            // thus use the harmonic peak instead
+            peak = peaktmp;
+        }
+    }
+
+    return peak;
+}
diff --git a/source/SoundTouch/PeakFinder.h b/source/SoundTouch/PeakFinder.h
index 9fe66ad..106eac8 100644
--- a/source/SoundTouch/PeakFinder.h
+++ b/source/SoundTouch/PeakFinder.h
@@ -1,90 +1,90 @@
-////////////////////////////////////////////////////////////////////////////////
-///
-/// The routine detects highest value on an array of values and calculates the 
-/// precise peak location as a mass-center of the 'hump' around the peak value.
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef _PeakFinder_H_
-#define _PeakFinder_H_
-
-namespace soundtouch
-{
-
-class PeakFinder
-{
-protected:
-    /// Min, max allowed peak positions within the data vector
-    int minPos, maxPos;
-
-    /// Calculates the mass center between given vector items.
-    double calcMassCenter(const float *data, ///< Data vector.
-                         int firstPos,      ///< Index of first vector item belonging to the peak.
-                         int lastPos        ///< Index of last vector item belonging to the peak.
-                         ) const;
-
-    /// Finds the data vector index where the monotoniously decreasing signal crosses the
-    /// given level.
-    int   findCrossingLevel(const float *data,  ///< Data vector.
-                            float level,        ///< Goal crossing level.
-                            int peakpos,        ///< Peak position index within the data vector.
-                            int direction       /// Direction where to proceed from the peak: 1 = right, -1 = left.
-                            ) const;
-
-    // Finds real 'top' of a peak hump from neighnourhood of the given 'peakpos'.
-    int findTop(const float *data, int peakpos) const;
-
-
-    /// Finds the 'ground' level, i.e. smallest level between two neighbouring peaks, to right- 
-    /// or left-hand side of the given peak position.
-    int   findGround(const float *data,     /// Data vector.
-                     int peakpos,           /// Peak position index within the data vector.
-                     int direction          /// Direction where to proceed from the peak: 1 = right, -1 = left.
-                     ) const;
-
-    /// get exact center of peak near given position by calculating local mass of center
-    double getPeakCenter(const float *data, int peakpos) const;
-
-public:
-    /// Constructor. 
-    PeakFinder();
-
-    /// Detect exact peak position of the data vector by finding the largest peak 'hump'
-    /// and calculating the mass-center location of the peak hump.
-    ///
-    /// \return The location of the largest base harmonic peak hump.
-    double detectPeak(const float *data, /// Data vector to be analyzed. The data vector has
-                                        /// to be at least 'maxPos' items long.
-                     int minPos,        ///< Min allowed peak location within the vector data.
-                     int maxPos         ///< Max allowed peak location within the vector data.
-                     );
-};
-
-}
-
-#endif // _PeakFinder_H_
+////////////////////////////////////////////////////////////////////////////////
+///
+/// The routine detects highest value on an array of values and calculates the
+/// precise peak location as a mass-center of the 'hump' around the peak value.
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef _PeakFinder_H_
+#define _PeakFinder_H_
+
+namespace soundtouch
+{
+
+class PeakFinder
+{
+protected:
+    /// Min, max allowed peak positions within the data vector
+    int minPos, maxPos;
+
+    /// Calculates the mass center between given vector items.
+    double calcMassCenter(const float *data, ///< Data vector.
+                         int firstPos,      ///< Index of first vector item belonging to the peak.
+                         int lastPos        ///< Index of last vector item belonging to the peak.
+                         ) const;
+
+    /// Finds the data vector index where the monotoniously decreasing signal crosses the
+    /// given level.
+    int   findCrossingLevel(const float *data,  ///< Data vector.
+                            float level,        ///< Goal crossing level.
+                            int peakpos,        ///< Peak position index within the data vector.
+                            int direction       /// Direction where to proceed from the peak: 1 = right, -1 = left.
+                            ) const;
+
+    // Finds real 'top' of a peak hump from neighnourhood of the given 'peakpos'.
+    int findTop(const float *data, int peakpos) const;
+
+
+    /// Finds the 'ground' level, i.e. smallest level between two neighbouring peaks, to right-
+    /// or left-hand side of the given peak position.
+    int   findGround(const float *data,     /// Data vector.
+                     int peakpos,           /// Peak position index within the data vector.
+                     int direction          /// Direction where to proceed from the peak: 1 = right, -1 = left.
+                     ) const;
+
+    /// get exact center of peak near given position by calculating local mass of center
+    double getPeakCenter(const float *data, int peakpos) const;
+
+public:
+    /// Constructor.
+    PeakFinder();
+
+    /// Detect exact peak position of the data vector by finding the largest peak 'hump'
+    /// and calculating the mass-center location of the peak hump.
+    ///
+    /// \return The location of the largest base harmonic peak hump.
+    double detectPeak(const float *data, /// Data vector to be analyzed. The data vector has
+                                        /// to be at least 'maxPos' items long.
+                     int minPos,        ///< Min allowed peak location within the vector data.
+                     int maxPos         ///< Max allowed peak location within the vector data.
+                     );
+};
+
+}
+
+#endif // _PeakFinder_H_
diff --git a/source/SoundTouch/RateTransposer.cpp b/source/SoundTouch/RateTransposer.cpp
index a48ea86..2b92118 100644
--- a/source/SoundTouch/RateTransposer.cpp
+++ b/source/SoundTouch/RateTransposer.cpp
@@ -1,313 +1,313 @@
-////////////////////////////////////////////////////////////////////////////////
-/// 
-/// Sample rate transposer. Changes sample rate by using linear interpolation 
-/// together with anti-alias filtering (first order interpolation with anti-
-/// alias filtering should be quite adequate for this application)
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include 
-#include 
-#include 
-#include 
-#include "RateTransposer.h"
-#include "InterpolateLinear.h"
-#include "InterpolateCubic.h"
-#include "InterpolateShannon.h"
-#include "AAFilter.h"
-
-using namespace soundtouch;
-
-// Define default interpolation algorithm here
-TransposerBase::ALGORITHM TransposerBase::algorithm = TransposerBase::CUBIC;
-
-
-// Constructor
-RateTransposer::RateTransposer() : FIFOProcessor(&outputBuffer)
-{
-    bUseAAFilter = 
-#ifndef SOUNDTOUCH_PREVENT_CLICK_AT_RATE_CROSSOVER
-        true;
-#else
-        // Disable Anti-alias filter if desirable to avoid click at rate change zero value crossover
-        false;
-#endif
-
-    // Instantiates the anti-alias filter
-    pAAFilter = new AAFilter(64);
-    pTransposer = TransposerBase::newInstance();
-    clear();
-}
-
-
-RateTransposer::~RateTransposer()
-{
-    delete pAAFilter;
-    delete pTransposer;
-}
-
-
-/// Enables/disables the anti-alias filter. Zero to disable, nonzero to enable
-void RateTransposer::enableAAFilter(bool newMode)
-{
-#ifndef SOUNDTOUCH_PREVENT_CLICK_AT_RATE_CROSSOVER
-    // Disable Anti-alias filter if desirable to avoid click at rate change zero value crossover
-    bUseAAFilter = newMode;
-    clear();
-#endif
-}
-
-
-/// Returns nonzero if anti-alias filter is enabled.
-bool RateTransposer::isAAFilterEnabled() const
-{
-    return bUseAAFilter;
-}
-
-
-AAFilter *RateTransposer::getAAFilter()
-{
-    return pAAFilter;
-}
-
-
-// Sets new target iRate. Normal iRate = 1.0, smaller values represent slower 
-// iRate, larger faster iRates.
-void RateTransposer::setRate(double newRate)
-{
-    double fCutoff;
-
-    pTransposer->setRate(newRate);
-
-    // design a new anti-alias filter
-    if (newRate > 1.0) 
-    {
-        fCutoff = 0.5 / newRate;
-    } 
-    else 
-    {
-        fCutoff = 0.5 * newRate;
-    }
-    pAAFilter->setCutoffFreq(fCutoff);
-}
-
-
-// Adds 'nSamples' pcs of samples from the 'samples' memory position into
-// the input of the object.
-void RateTransposer::putSamples(const SAMPLETYPE *samples, uint nSamples)
-{
-    processSamples(samples, nSamples);
-}
-
-
-// Transposes sample rate by applying anti-alias filter to prevent folding. 
-// Returns amount of samples returned in the "dest" buffer.
-// The maximum amount of samples that can be returned at a time is set by
-// the 'set_returnBuffer_size' function.
-void RateTransposer::processSamples(const SAMPLETYPE *src, uint nSamples)
-{
-    if (nSamples == 0) return;
-
-    // Store samples to input buffer
-    inputBuffer.putSamples(src, nSamples);
-
-    // If anti-alias filter is turned off, simply transpose without applying
-    // the filter
-    if (bUseAAFilter == false) 
-    {
-        (void)pTransposer->transpose(outputBuffer, inputBuffer);
-        return;
-    }
-
-    assert(pAAFilter);
-
-    // Transpose with anti-alias filter
-    if (pTransposer->rate < 1.0f) 
-    {
-        // If the parameter 'Rate' value is smaller than 1, first transpose
-        // the samples and then apply the anti-alias filter to remove aliasing.
-
-        // Transpose the samples, store the result to end of "midBuffer"
-        pTransposer->transpose(midBuffer, inputBuffer);
-
-        // Apply the anti-alias filter for transposed samples in midBuffer
-        pAAFilter->evaluate(outputBuffer, midBuffer);
-    } 
-    else  
-    {
-        // If the parameter 'Rate' value is larger than 1, first apply the
-        // anti-alias filter to remove high frequencies (prevent them from folding
-        // over the lover frequencies), then transpose.
-
-        // Apply the anti-alias filter for samples in inputBuffer
-        pAAFilter->evaluate(midBuffer, inputBuffer);
-
-        // Transpose the AA-filtered samples in "midBuffer"
-        pTransposer->transpose(outputBuffer, midBuffer);
-    }
-}
-
-
-// Sets the number of channels, 1 = mono, 2 = stereo
-void RateTransposer::setChannels(int nChannels)
-{
-    if (!verifyNumberOfChannels(nChannels) ||
-        (pTransposer->numChannels == nChannels)) return;
-
-    pTransposer->setChannels(nChannels);
-    inputBuffer.setChannels(nChannels);
-    midBuffer.setChannels(nChannels);
-    outputBuffer.setChannels(nChannels);
-}
-
-
-// Clears all the samples in the object
-void RateTransposer::clear()
-{
-    outputBuffer.clear();
-    midBuffer.clear();
-    inputBuffer.clear();
-    pTransposer->resetRegisters();
-
-    // prefill buffer to avoid losing first samples at beginning of stream
-    int prefill = getLatency();
-    inputBuffer.addSilent(prefill);
-}
-
-
-// Returns nonzero if there aren't any samples available for outputting.
-int RateTransposer::isEmpty() const
-{
-    int res;
-
-    res = FIFOProcessor::isEmpty();
-    if (res == 0) return 0;
-    return inputBuffer.isEmpty();
-}
-
-
-/// Return approximate initial input-output latency
-int RateTransposer::getLatency() const
-{
-    return pTransposer->getLatency() +
-        ((bUseAAFilter) ? (pAAFilter->getLength() / 2) : 0);
-}
-
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// TransposerBase - Base class for interpolation
-// 
-
-// static function to set interpolation algorithm
-void TransposerBase::setAlgorithm(TransposerBase::ALGORITHM a)
-{
-    TransposerBase::algorithm = a;
-}
-
-
-// Transposes the sample rate of the given samples using linear interpolation. 
-// Returns the number of samples returned in the "dest" buffer
-int TransposerBase::transpose(FIFOSampleBuffer &dest, FIFOSampleBuffer &src)
-{
-    int numSrcSamples = src.numSamples();
-    int sizeDemand = (int)((double)numSrcSamples / rate) + 8;
-    int numOutput;
-    SAMPLETYPE *psrc = src.ptrBegin();
-    SAMPLETYPE *pdest = dest.ptrEnd(sizeDemand);
-
-#ifndef USE_MULTICH_ALWAYS
-    if (numChannels == 1)
-    {
-        numOutput = transposeMono(pdest, psrc, numSrcSamples);
-    }
-    else if (numChannels == 2) 
-    {
-        numOutput = transposeStereo(pdest, psrc, numSrcSamples);
-    } 
-    else 
-#endif // USE_MULTICH_ALWAYS
-    {
-        assert(numChannels > 0);
-        numOutput = transposeMulti(pdest, psrc, numSrcSamples);
-    }
-    dest.putSamples(numOutput);
-    src.receiveSamples(numSrcSamples);
-    return numOutput;
-}
-
-
-TransposerBase::TransposerBase()
-{
-    numChannels = 0;
-    rate = 1.0f;
-}
-
-
-TransposerBase::~TransposerBase()
-{
-}
-
-
-void TransposerBase::setChannels(int channels)
-{
-    numChannels = channels;
-    resetRegisters();
-}
-
-
-void TransposerBase::setRate(double newRate)
-{
-    rate = newRate;
-}
-
-
-// static factory function
-TransposerBase *TransposerBase::newInstance()
-{
-#ifdef SOUNDTOUCH_INTEGER_SAMPLES
-    // Notice: For integer arithmetic support only linear algorithm (due to simplest calculus)
-    return ::new InterpolateLinearInteger;
-#else
-    switch (algorithm)
-    {
-        case LINEAR:
-            return new InterpolateLinearFloat;
-
-        case CUBIC:
-            return new InterpolateCubic;
-
-        case SHANNON:
-            return new InterpolateShannon;
-
-        default:
-            assert(false);
-            return nullptr;
-    }
-#endif
-}
+////////////////////////////////////////////////////////////////////////////////
+///
+/// Sample rate transposer. Changes sample rate by using linear interpolation
+/// together with anti-alias filtering (first order interpolation with anti-
+/// alias filtering should be quite adequate for this application)
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#include 
+#include 
+#include 
+#include 
+#include "RateTransposer.h"
+#include "InterpolateLinear.h"
+#include "InterpolateCubic.h"
+#include "InterpolateShannon.h"
+#include "AAFilter.h"
+
+using namespace soundtouch;
+
+// Define default interpolation algorithm here
+TransposerBase::ALGORITHM TransposerBase::algorithm = TransposerBase::CUBIC;
+
+
+// Constructor
+RateTransposer::RateTransposer() : FIFOProcessor(&outputBuffer)
+{
+    bUseAAFilter =
+#ifndef SOUNDTOUCH_PREVENT_CLICK_AT_RATE_CROSSOVER
+        true;
+#else
+        // Disable Anti-alias filter if desirable to avoid click at rate change zero value crossover
+        false;
+#endif
+
+    // Instantiates the anti-alias filter
+    pAAFilter = new AAFilter(64);
+    pTransposer = TransposerBase::newInstance();
+    clear();
+}
+
+
+RateTransposer::~RateTransposer()
+{
+    delete pAAFilter;
+    delete pTransposer;
+}
+
+
+/// Enables/disables the anti-alias filter. Zero to disable, nonzero to enable
+void RateTransposer::enableAAFilter(bool newMode)
+{
+#ifndef SOUNDTOUCH_PREVENT_CLICK_AT_RATE_CROSSOVER
+    // Disable Anti-alias filter if desirable to avoid click at rate change zero value crossover
+    bUseAAFilter = newMode;
+    clear();
+#endif
+}
+
+
+/// Returns nonzero if anti-alias filter is enabled.
+bool RateTransposer::isAAFilterEnabled() const
+{
+    return bUseAAFilter;
+}
+
+
+AAFilter *RateTransposer::getAAFilter()
+{
+    return pAAFilter;
+}
+
+
+// Sets new target iRate. Normal iRate = 1.0, smaller values represent slower
+// iRate, larger faster iRates.
+void RateTransposer::setRate(double newRate)
+{
+    double fCutoff;
+
+    pTransposer->setRate(newRate);
+
+    // design a new anti-alias filter
+    if (newRate > 1.0)
+    {
+        fCutoff = 0.5 / newRate;
+    }
+    else
+    {
+        fCutoff = 0.5 * newRate;
+    }
+    pAAFilter->setCutoffFreq(fCutoff);
+}
+
+
+// Adds 'nSamples' pcs of samples from the 'samples' memory position into
+// the input of the object.
+void RateTransposer::putSamples(const SAMPLETYPE *samples, uint nSamples)
+{
+    processSamples(samples, nSamples);
+}
+
+
+// Transposes sample rate by applying anti-alias filter to prevent folding.
+// Returns amount of samples returned in the "dest" buffer.
+// The maximum amount of samples that can be returned at a time is set by
+// the 'set_returnBuffer_size' function.
+void RateTransposer::processSamples(const SAMPLETYPE *src, uint nSamples)
+{
+    if (nSamples == 0) return;
+
+    // Store samples to input buffer
+    inputBuffer.putSamples(src, nSamples);
+
+    // If anti-alias filter is turned off, simply transpose without applying
+    // the filter
+    if (bUseAAFilter == false)
+    {
+        (void)pTransposer->transpose(outputBuffer, inputBuffer);
+        return;
+    }
+
+    assert(pAAFilter);
+
+    // Transpose with anti-alias filter
+    if (pTransposer->rate < 1.0f)
+    {
+        // If the parameter 'Rate' value is smaller than 1, first transpose
+        // the samples and then apply the anti-alias filter to remove aliasing.
+
+        // Transpose the samples, store the result to end of "midBuffer"
+        pTransposer->transpose(midBuffer, inputBuffer);
+
+        // Apply the anti-alias filter for transposed samples in midBuffer
+        pAAFilter->evaluate(outputBuffer, midBuffer);
+    }
+    else
+    {
+        // If the parameter 'Rate' value is larger than 1, first apply the
+        // anti-alias filter to remove high frequencies (prevent them from folding
+        // over the lover frequencies), then transpose.
+
+        // Apply the anti-alias filter for samples in inputBuffer
+        pAAFilter->evaluate(midBuffer, inputBuffer);
+
+        // Transpose the AA-filtered samples in "midBuffer"
+        pTransposer->transpose(outputBuffer, midBuffer);
+    }
+}
+
+
+// Sets the number of channels, 1 = mono, 2 = stereo
+void RateTransposer::setChannels(int nChannels)
+{
+    if (!verifyNumberOfChannels(nChannels) ||
+        (pTransposer->numChannels == nChannels)) return;
+
+    pTransposer->setChannels(nChannels);
+    inputBuffer.setChannels(nChannels);
+    midBuffer.setChannels(nChannels);
+    outputBuffer.setChannels(nChannels);
+}
+
+
+// Clears all the samples in the object
+void RateTransposer::clear()
+{
+    outputBuffer.clear();
+    midBuffer.clear();
+    inputBuffer.clear();
+    pTransposer->resetRegisters();
+
+    // prefill buffer to avoid losing first samples at beginning of stream
+    int prefill = getLatency();
+    inputBuffer.addSilent(prefill);
+}
+
+
+// Returns nonzero if there aren't any samples available for outputting.
+int RateTransposer::isEmpty() const
+{
+    int res;
+
+    res = FIFOProcessor::isEmpty();
+    if (res == 0) return 0;
+    return inputBuffer.isEmpty();
+}
+
+
+/// Return approximate initial input-output latency
+int RateTransposer::getLatency() const
+{
+    return pTransposer->getLatency() +
+        ((bUseAAFilter) ? (pAAFilter->getLength() / 2) : 0);
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// TransposerBase - Base class for interpolation
+//
+
+// static function to set interpolation algorithm
+void TransposerBase::setAlgorithm(TransposerBase::ALGORITHM a)
+{
+    TransposerBase::algorithm = a;
+}
+
+
+// Transposes the sample rate of the given samples using linear interpolation.
+// Returns the number of samples returned in the "dest" buffer
+int TransposerBase::transpose(FIFOSampleBuffer &dest, FIFOSampleBuffer &src)
+{
+    int numSrcSamples = src.numSamples();
+    int sizeDemand = (int)((double)numSrcSamples / rate) + 8;
+    int numOutput;
+    SAMPLETYPE *psrc = src.ptrBegin();
+    SAMPLETYPE *pdest = dest.ptrEnd(sizeDemand);
+
+#ifndef USE_MULTICH_ALWAYS
+    if (numChannels == 1)
+    {
+        numOutput = transposeMono(pdest, psrc, numSrcSamples);
+    }
+    else if (numChannels == 2)
+    {
+        numOutput = transposeStereo(pdest, psrc, numSrcSamples);
+    }
+    else
+#endif // USE_MULTICH_ALWAYS
+    {
+        assert(numChannels > 0);
+        numOutput = transposeMulti(pdest, psrc, numSrcSamples);
+    }
+    dest.putSamples(numOutput);
+    src.receiveSamples(numSrcSamples);
+    return numOutput;
+}
+
+
+TransposerBase::TransposerBase()
+{
+    numChannels = 0;
+    rate = 1.0f;
+}
+
+
+TransposerBase::~TransposerBase()
+{
+}
+
+
+void TransposerBase::setChannels(int channels)
+{
+    numChannels = channels;
+    resetRegisters();
+}
+
+
+void TransposerBase::setRate(double newRate)
+{
+    rate = newRate;
+}
+
+
+// static factory function
+TransposerBase *TransposerBase::newInstance()
+{
+#ifdef SOUNDTOUCH_INTEGER_SAMPLES
+    // Notice: For integer arithmetic support only linear algorithm (due to simplest calculus)
+    return ::new InterpolateLinearInteger;
+#else
+    switch (algorithm)
+    {
+        case LINEAR:
+            return new InterpolateLinearFloat;
+
+        case CUBIC:
+            return new InterpolateCubic;
+
+        case SHANNON:
+            return new InterpolateShannon;
+
+        default:
+            assert(false);
+            return nullptr;
+    }
+#endif
+}
diff --git a/source/SoundTouch/RateTransposer.h b/source/SoundTouch/RateTransposer.h
index 411f4e8..32bbadc 100644
--- a/source/SoundTouch/RateTransposer.h
+++ b/source/SoundTouch/RateTransposer.h
@@ -1,164 +1,164 @@
-////////////////////////////////////////////////////////////////////////////////
-/// 
-/// Sample rate transposer. Changes sample rate by using linear interpolation 
-/// together with anti-alias filtering (first order interpolation with anti-
-/// alias filtering should be quite adequate for this application).
-///
-/// Use either of the derived classes of 'RateTransposerInteger' or 
-/// 'RateTransposerFloat' for corresponding integer/floating point tranposing
-/// algorithm implementation.
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef RateTransposer_H
-#define RateTransposer_H
-
-#include 
-#include "AAFilter.h"
-#include "FIFOSamplePipe.h"
-#include "FIFOSampleBuffer.h"
-
-#include "STTypes.h"
-
-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 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:
-    double rate;
-    int numChannels;
-
-    TransposerBase();
-    virtual ~TransposerBase();
-
-    virtual int transpose(FIFOSampleBuffer &dest, FIFOSampleBuffer &src);
-    virtual void setRate(double newRate);
-    virtual void setChannels(int channels);
-    virtual int getLatency() const = 0;
-
-    virtual void resetRegisters() = 0;
-
-    // static factory function
-    static TransposerBase *newInstance();
-
-    // static function to set interpolation algorithm
-    static void setAlgorithm(ALGORITHM a);
-};
-
-
-/// A common linear samplerate transposer class.
-///
-class RateTransposer : public FIFOProcessor
-{
-protected:
-    /// Anti-alias filter object
-    AAFilter *pAAFilter;
-    TransposerBase *pTransposer;
-
-    /// Buffer for collecting samples to feed the anti-alias filter between
-    /// two batches
-    FIFOSampleBuffer inputBuffer;
-
-    /// Buffer for keeping samples between transposing & anti-alias filter
-    FIFOSampleBuffer midBuffer;
-
-    /// Output sample buffer
-    FIFOSampleBuffer outputBuffer;
-
-    bool bUseAAFilter;
-
-
-    /// Transposes sample rate by applying anti-alias filter to prevent folding. 
-    /// Returns amount of samples returned in the "dest" buffer.
-    /// The maximum amount of samples that can be returned at a time is set by
-    /// the 'set_returnBuffer_size' function.
-    void processSamples(const SAMPLETYPE *src, 
-                        uint numSamples);
-
-public:
-    RateTransposer();
-    virtual ~RateTransposer() override;
-
-    /// Returns the output buffer object
-    FIFOSamplePipe *getOutput() { return &outputBuffer; };
-
-    /// Return anti-alias filter object
-    AAFilter *getAAFilter();
-
-    /// Enables/disables the anti-alias filter. Zero to disable, nonzero to enable
-    void enableAAFilter(bool newMode);
-
-    /// Returns nonzero if anti-alias filter is enabled.
-    bool isAAFilterEnabled() const;
-
-    /// Sets new target rate. Normal rate = 1.0, smaller values represent slower 
-    /// rate, larger faster rates.
-    virtual void setRate(double newRate);
-
-    /// Sets the number of channels, 1 = mono, 2 = stereo
-    void setChannels(int channels);
-
-    /// Adds 'numSamples' pcs of samples from the 'samples' memory position into
-    /// the input of the object.
-    void putSamples(const SAMPLETYPE *samples, uint numSamples) override;
-
-    /// Clears all the samples in the object
-    void clear() override;
-
-    /// Returns nonzero if there aren't any samples available for outputting.
-    int isEmpty() const override;
-
-    /// Return approximate initial input-output latency
-    int getLatency() const;
-};
-
-}
-
-#endif
+////////////////////////////////////////////////////////////////////////////////
+///
+/// Sample rate transposer. Changes sample rate by using linear interpolation
+/// together with anti-alias filtering (first order interpolation with anti-
+/// alias filtering should be quite adequate for this application).
+///
+/// Use either of the derived classes of 'RateTransposerInteger' or
+/// 'RateTransposerFloat' for corresponding integer/floating point tranposing
+/// algorithm implementation.
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef RateTransposer_H
+#define RateTransposer_H
+
+#include 
+#include "AAFilter.h"
+#include "FIFOSamplePipe.h"
+#include "FIFOSampleBuffer.h"
+
+#include "STTypes.h"
+
+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 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:
+    double rate;
+    int numChannels;
+
+    TransposerBase();
+    virtual ~TransposerBase();
+
+    virtual int transpose(FIFOSampleBuffer &dest, FIFOSampleBuffer &src);
+    virtual void setRate(double newRate);
+    virtual void setChannels(int channels);
+    virtual int getLatency() const = 0;
+
+    virtual void resetRegisters() = 0;
+
+    // static factory function
+    static TransposerBase *newInstance();
+
+    // static function to set interpolation algorithm
+    static void setAlgorithm(ALGORITHM a);
+};
+
+
+/// A common linear samplerate transposer class.
+///
+class RateTransposer : public FIFOProcessor
+{
+protected:
+    /// Anti-alias filter object
+    AAFilter *pAAFilter;
+    TransposerBase *pTransposer;
+
+    /// Buffer for collecting samples to feed the anti-alias filter between
+    /// two batches
+    FIFOSampleBuffer inputBuffer;
+
+    /// Buffer for keeping samples between transposing & anti-alias filter
+    FIFOSampleBuffer midBuffer;
+
+    /// Output sample buffer
+    FIFOSampleBuffer outputBuffer;
+
+    bool bUseAAFilter;
+
+
+    /// Transposes sample rate by applying anti-alias filter to prevent folding.
+    /// Returns amount of samples returned in the "dest" buffer.
+    /// The maximum amount of samples that can be returned at a time is set by
+    /// the 'set_returnBuffer_size' function.
+    void processSamples(const SAMPLETYPE *src,
+                        uint numSamples);
+
+public:
+    RateTransposer();
+    virtual ~RateTransposer() override;
+
+    /// Returns the output buffer object
+    FIFOSamplePipe *getOutput() { return &outputBuffer; };
+
+    /// Return anti-alias filter object
+    AAFilter *getAAFilter();
+
+    /// Enables/disables the anti-alias filter. Zero to disable, nonzero to enable
+    void enableAAFilter(bool newMode);
+
+    /// Returns nonzero if anti-alias filter is enabled.
+    bool isAAFilterEnabled() const;
+
+    /// Sets new target rate. Normal rate = 1.0, smaller values represent slower
+    /// rate, larger faster rates.
+    virtual void setRate(double newRate);
+
+    /// Sets the number of channels, 1 = mono, 2 = stereo
+    void setChannels(int channels);
+
+    /// Adds 'numSamples' pcs of samples from the 'samples' memory position into
+    /// the input of the object.
+    void putSamples(const SAMPLETYPE *samples, uint numSamples) override;
+
+    /// Clears all the samples in the object
+    void clear() override;
+
+    /// Returns nonzero if there aren't any samples available for outputting.
+    int isEmpty() const override;
+
+    /// Return approximate initial input-output latency
+    int getLatency() const;
+};
+
+}
+
+#endif
diff --git a/source/SoundTouch/SoundTouch.cpp b/source/SoundTouch/SoundTouch.cpp
index cb161f0..0eda80a 100644
--- a/source/SoundTouch/SoundTouch.cpp
+++ b/source/SoundTouch/SoundTouch.cpp
@@ -1,538 +1,538 @@
-//////////////////////////////////////////////////////////////////////////////
-///
-/// SoundTouch - main class for tempo/pitch/rate adjusting routines. 
-///
-/// Notes:
-/// - Initialize the SoundTouch object instance by setting up the sound stream 
-///   parameters with functions 'setSampleRate' and 'setChannels', then set 
-///   desired tempo/pitch/rate settings with the corresponding functions.
-///
-/// - The SoundTouch class behaves like a first-in-first-out pipeline: The 
-///   samples that are to be processed are fed into one of the pipe by calling
-///   function 'putSamples', while the ready processed samples can be read 
-///   from the other end of the pipeline with function 'receiveSamples'.
-/// 
-/// - The SoundTouch processing classes require certain sized 'batches' of 
-///   samples in order to process the sound. For this reason the classes buffer 
-///   incoming samples until there are enough of samples available for 
-///   processing, then they carry out the processing step and consequently
-///   make the processed samples available for outputting.
-/// 
-/// - For the above reason, the processing routines introduce a certain 
-///   'latency' between the input and output, so that the samples input to
-///   SoundTouch may not be immediately available in the output, and neither 
-///   the amount of outputtable samples may not immediately be in direct 
-///   relationship with the amount of previously input samples.
-///
-/// - The tempo/pitch/rate control parameters can be altered during processing.
-///   Please notice though that they aren't currently protected by semaphores,
-///   so in multi-thread application external semaphore protection may be
-///   required.
-///
-/// - This class utilizes classes 'TDStretch' for tempo change (without modifying
-///   pitch) and 'RateTransposer' for changing the playback rate (that is, both 
-///   tempo and pitch in the same ratio) of the sound. The third available control 
-///   'pitch' (change pitch but maintain tempo) is produced by a combination of
-///   combining the two other controls.
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include 
-#include 
-#include 
-#include 
-#include 
-
-#include "SoundTouch.h"
-#include "TDStretch.h"
-#include "RateTransposer.h"
-#include "cpu_detect.h"
-
-using namespace soundtouch;
-    
-/// test if two floating point numbers are equal
-#define TEST_FLOAT_EQUAL(a, b)  (fabs(a - b) < 1e-10)
-
-
-/// Print library version string for autoconf
-extern "C" void soundtouch_ac_test()
-{
-    printf("SoundTouch Version: %s\n",SOUNDTOUCH_VERSION);
-} 
-
-
-SoundTouch::SoundTouch()
-{
-    // Initialize rate transposer and tempo changer instances
-
-    pRateTransposer = new RateTransposer();
-    pTDStretch = TDStretch::newInstance();
-
-    setOutPipe(pTDStretch);
-
-    rate = tempo = 0;
-
-    virtualPitch = 
-    virtualRate = 
-    virtualTempo = 1.0;
-
-    calcEffectiveRateAndTempo();
-
-    samplesExpectedOut = 0;
-    samplesOutput = 0;
-
-    channels = 0;
-    bSrateSet = false;
-}
-
-
-SoundTouch::~SoundTouch()
-{
-    delete pRateTransposer;
-    delete pTDStretch;
-}
-
-
-/// Get SoundTouch library version string
-const char *SoundTouch::getVersionString()
-{
-    static const char *_version = SOUNDTOUCH_VERSION;
-
-    return _version;
-}
-
-
-/// Get SoundTouch library version Id
-uint SoundTouch::getVersionId()
-{
-    return SOUNDTOUCH_VERSION_ID;
-}
-
-
-// Sets the number of channels, 1 = mono, 2 = stereo
-void SoundTouch::setChannels(uint numChannels)
-{
-    if (!verifyNumberOfChannels(numChannels)) return;
-
-    channels = numChannels;
-    pRateTransposer->setChannels((int)numChannels);
-    pTDStretch->setChannels((int)numChannels);
-}
-
-
-// Sets new rate control value. Normal rate = 1.0, smaller values
-// represent slower rate, larger faster rates.
-void SoundTouch::setRate(double newRate)
-{
-    virtualRate = newRate;
-    calcEffectiveRateAndTempo();
-}
-
-
-// Sets new rate control value as a difference in percents compared
-// to the original rate (-50 .. +100 %)
-void SoundTouch::setRateChange(double newRate)
-{
-    virtualRate = 1.0 + 0.01 * newRate;
-    calcEffectiveRateAndTempo();
-}
-
-
-// Sets new tempo control value. Normal tempo = 1.0, smaller values
-// represent slower tempo, larger faster tempo.
-void SoundTouch::setTempo(double newTempo)
-{
-    virtualTempo = newTempo;
-    calcEffectiveRateAndTempo();
-}
-
-
-// Sets new tempo control value as a difference in percents compared
-// to the original tempo (-50 .. +100 %)
-void SoundTouch::setTempoChange(double newTempo)
-{
-    virtualTempo = 1.0 + 0.01 * newTempo;
-    calcEffectiveRateAndTempo();
-}
-
-
-// Sets new pitch control value. Original pitch = 1.0, smaller values
-// represent lower pitches, larger values higher pitch.
-void SoundTouch::setPitch(double newPitch)
-{
-    virtualPitch = newPitch;
-    calcEffectiveRateAndTempo();
-}
-
-
-// Sets pitch change in octaves compared to the original pitch
-// (-1.00 .. +1.00)
-void SoundTouch::setPitchOctaves(double newPitch)
-{
-    virtualPitch = exp(0.69314718056 * newPitch);
-    calcEffectiveRateAndTempo();
-}
-
-
-// Sets pitch change in semi-tones compared to the original pitch
-// (-12 .. +12)
-void SoundTouch::setPitchSemiTones(int newPitch)
-{
-    setPitchOctaves((double)newPitch / 12.0);
-}
-
-
-void SoundTouch::setPitchSemiTones(double newPitch)
-{
-    setPitchOctaves(newPitch / 12.0);
-}
-
-
-// Calculates 'effective' rate and tempo values from the
-// nominal control values.
-void SoundTouch::calcEffectiveRateAndTempo()
-{
-    double oldTempo = tempo;
-    double oldRate = rate;
-
-    tempo = virtualTempo / virtualPitch;
-    rate = virtualPitch * virtualRate;
-
-    if (!TEST_FLOAT_EQUAL(rate,oldRate)) pRateTransposer->setRate(rate);
-    if (!TEST_FLOAT_EQUAL(tempo, oldTempo)) pTDStretch->setTempo(tempo);
-
-#ifndef SOUNDTOUCH_PREVENT_CLICK_AT_RATE_CROSSOVER
-    if (rate <= 1.0f) 
-    {
-        if (output != pTDStretch) 
-        {
-            FIFOSamplePipe *tempoOut;
-
-            assert(output == pRateTransposer);
-            // move samples in the current output buffer to the output of pTDStretch
-            tempoOut = pTDStretch->getOutput();
-            tempoOut->moveSamples(*output);
-            // move samples in pitch transposer's store buffer to tempo changer's input
-            // deprecated : pTDStretch->moveSamples(*pRateTransposer->getStore());
-
-            output = pTDStretch;
-        }
-    }
-    else
-#endif
-    {
-        if (output != pRateTransposer) 
-        {
-            FIFOSamplePipe *transOut;
-
-            assert(output == pTDStretch);
-            // move samples in the current output buffer to the output of pRateTransposer
-            transOut = pRateTransposer->getOutput();
-            transOut->moveSamples(*output);
-            // move samples in tempo changer's input to pitch transposer's input
-            pRateTransposer->moveSamples(*pTDStretch->getInput());
-
-            output = pRateTransposer;
-        }
-    } 
-}
-
-
-// Sets sample rate.
-void SoundTouch::setSampleRate(uint srate)
-{
-    // set sample rate, leave other tempo changer parameters as they are.
-    pTDStretch->setParameters((int)srate);
-    bSrateSet = true;
-}
-
-
-// Adds 'numSamples' pcs of samples from the 'samples' memory position into
-// the input of the object.
-void SoundTouch::putSamples(const SAMPLETYPE *samples, uint nSamples)
-{
-    if (bSrateSet == false) 
-    {
-        ST_THROW_RT_ERROR("SoundTouch : Sample rate not defined");
-    } 
-    else if (channels == 0) 
-    {
-        ST_THROW_RT_ERROR("SoundTouch : Number of channels not defined");
-    }
-
-    // accumulate how many samples are expected out from processing, given the current 
-    // processing setting
-    samplesExpectedOut += (double)nSamples / ((double)rate * (double)tempo);
-
-#ifndef SOUNDTOUCH_PREVENT_CLICK_AT_RATE_CROSSOVER
-    if (rate <= 1.0f) 
-    {
-        // transpose the rate down, output the transposed sound to tempo changer buffer
-        assert(output == pTDStretch);
-        pRateTransposer->putSamples(samples, nSamples);
-        pTDStretch->moveSamples(*pRateTransposer);
-    } 
-    else 
-#endif
-    {
-        // evaluate the tempo changer, then transpose the rate up, 
-        assert(output == pRateTransposer);
-        pTDStretch->putSamples(samples, nSamples);
-        pRateTransposer->moveSamples(*pTDStretch);
-    }
-}
-
-
-// Flushes the last samples from the processing pipeline to the output.
-// Clears also the internal processing buffers.
-//
-// Note: This function is meant for extracting the last samples of a sound
-// stream. This function may introduce additional blank samples in the end
-// of the sound stream, and thus it's not recommended to call this function
-// in the middle of a sound stream.
-void SoundTouch::flush()
-{
-    int i;
-    int numStillExpected;
-    SAMPLETYPE *buff = new SAMPLETYPE[128 * channels];
-
-    // how many samples are still expected to output
-    numStillExpected = (int)((long)(samplesExpectedOut + 0.5) - samplesOutput);
-    if (numStillExpected < 0) numStillExpected = 0;
-
-    memset(buff, 0, 128 * channels * sizeof(SAMPLETYPE));
-    // "Push" the last active samples out from the processing pipeline by
-    // feeding blank samples into the processing pipeline until new, 
-    // processed samples appear in the output (not however, more than 
-    // 24ksamples in any case)
-    for (i = 0; (numStillExpected > (int)numSamples()) && (i < 200); i ++)
-    {
-        putSamples(buff, 128);
-    }
-
-    adjustAmountOfSamples(numStillExpected);
-
-    delete[] buff;
-
-    // Clear input buffers
-    pTDStretch->clearInput();
-    // yet leave the output intouched as that's where the
-    // flushed samples are!
-}
-
-
-// Changes a setting controlling the processing system behaviour. See the
-// 'SETTING_...' defines for available setting ID's.
-bool SoundTouch::setSetting(int settingId, int value)
-{
-    int sampleRate, sequenceMs, seekWindowMs, overlapMs;
-
-    // read current tdstretch routine parameters
-    pTDStretch->getParameters(&sampleRate, &sequenceMs, &seekWindowMs, &overlapMs);
-
-    switch (settingId) 
-    {
-        case SETTING_USE_AA_FILTER :
-            // enables / disabless anti-alias filter
-            pRateTransposer->enableAAFilter((value != 0) ? true : false);
-            return true;
-
-        case SETTING_AA_FILTER_LENGTH :
-            // sets anti-alias filter length
-            pRateTransposer->getAAFilter()->setLength(value);
-            return true;
-
-        case SETTING_USE_QUICKSEEK :
-            // enables / disables tempo routine quick seeking algorithm
-            pTDStretch->enableQuickSeek((value != 0) ? true : false);
-            return true;
-
-        case SETTING_SEQUENCE_MS:
-            // change time-stretch sequence duration parameter
-            pTDStretch->setParameters(sampleRate, value, seekWindowMs, overlapMs);
-            return true;
-
-        case SETTING_SEEKWINDOW_MS:
-            // change time-stretch seek window length parameter
-            pTDStretch->setParameters(sampleRate, sequenceMs, value, overlapMs);
-            return true;
-
-        case SETTING_OVERLAP_MS:
-            // change time-stretch overlap length parameter
-            pTDStretch->setParameters(sampleRate, sequenceMs, seekWindowMs, value);
-            return true;
-
-        default :
-            return false;
-    }
-}
-
-
-// Reads a setting controlling the processing system behaviour. See the
-// 'SETTING_...' defines for available setting ID's.
-//
-// Returns the setting value.
-int SoundTouch::getSetting(int settingId) const
-{
-    int temp;
-
-    switch (settingId) 
-    {
-        case SETTING_USE_AA_FILTER :
-            return (uint)pRateTransposer->isAAFilterEnabled();
-
-        case SETTING_AA_FILTER_LENGTH :
-            return pRateTransposer->getAAFilter()->getLength();
-
-        case SETTING_USE_QUICKSEEK :
-            return (uint)pTDStretch->isQuickSeekEnabled();
-
-        case SETTING_SEQUENCE_MS:
-            pTDStretch->getParameters(nullptr, &temp, nullptr, nullptr);
-            return temp;
-
-        case SETTING_SEEKWINDOW_MS:
-            pTDStretch->getParameters(nullptr, nullptr, &temp, nullptr);
-            return temp;
-
-        case SETTING_OVERLAP_MS:
-            pTDStretch->getParameters(nullptr, nullptr, nullptr, &temp);
-            return temp;
-
-        case SETTING_NOMINAL_INPUT_SEQUENCE :
-        {
-            int size = pTDStretch->getInputSampleReq();
-
-#ifndef SOUNDTOUCH_PREVENT_CLICK_AT_RATE_CROSSOVER
-            if (rate <= 1.0)
-            {
-                // transposing done before timestretch, which impacts latency
-                return (int)(size * rate + 0.5);
-            }
-#endif
-            return size;
-        }
-
-        case SETTING_NOMINAL_OUTPUT_SEQUENCE :
-        {
-            int size = pTDStretch->getOutputBatchSize();
-
-            if (rate > 1.0)
-            {
-                // transposing done after timestretch, which impacts latency
-                return (int)(size / rate + 0.5);
-            }
-            return size;
-        }
-
-        case SETTING_INITIAL_LATENCY:
-        {
-            double latency = pTDStretch->getLatency();
-            int latency_tr = pRateTransposer->getLatency();
-
-#ifndef SOUNDTOUCH_PREVENT_CLICK_AT_RATE_CROSSOVER
-            if (rate <= 1.0)
-            {
-                // transposing done before timestretch, which impacts latency
-                latency = (latency + latency_tr) * rate;
-            }
-            else
-#endif
-            {
-                latency += (double)latency_tr / rate;
-            }
-
-            return (int)(latency + 0.5);
-        }
-
-        default :
-            return 0;
-    }
-}
-
-
-// Clears all the samples in the object's output and internal processing
-// buffers.
-void SoundTouch::clear()
-{
-    samplesExpectedOut = 0;
-    samplesOutput = 0;
-    pRateTransposer->clear();
-    pTDStretch->clear();
-}
-
-
-/// Returns number of samples currently unprocessed.
-uint SoundTouch::numUnprocessedSamples() const
-{
-    FIFOSamplePipe * psp;
-    if (pTDStretch)
-    {
-        psp = pTDStretch->getInput();
-        if (psp)
-        {
-            return psp->numSamples();
-        }
-    }
-    return 0;
-}
-
-
-/// Output samples from beginning of the sample buffer. Copies requested samples to 
-/// output buffer and removes them from the sample buffer. If there are less than 
-/// 'numsample' samples in the buffer, returns all that available.
-///
-/// \return Number of samples returned.
-uint SoundTouch::receiveSamples(SAMPLETYPE *output, uint maxSamples)
-{
-    uint ret = FIFOProcessor::receiveSamples(output, maxSamples);
-    samplesOutput += (long)ret;
-    return ret;
-}
-
-
-/// Adjusts book-keeping so that given number of samples are removed from beginning of the 
-/// sample buffer without copying them anywhere. 
-///
-/// Used to reduce the number of samples in the buffer when accessing the sample buffer directly
-/// with 'ptrBegin' function.
-uint SoundTouch::receiveSamples(uint maxSamples)
-{
-    uint ret = FIFOProcessor::receiveSamples(maxSamples);
-    samplesOutput += (long)ret;
-    return ret;
-}
-
-
-/// Get ratio between input and output audio durations, useful for calculating
-/// processed output duration: if you'll process a stream of N samples, then 
-/// you can expect to get out N * getInputOutputSampleRatio() samples.
-double SoundTouch::getInputOutputSampleRatio()
-{
-    return 1.0 / (tempo * rate);
-}
+//////////////////////////////////////////////////////////////////////////////
+///
+/// SoundTouch - main class for tempo/pitch/rate adjusting routines.
+///
+/// Notes:
+/// - Initialize the SoundTouch object instance by setting up the sound stream
+///   parameters with functions 'setSampleRate' and 'setChannels', then set
+///   desired tempo/pitch/rate settings with the corresponding functions.
+///
+/// - The SoundTouch class behaves like a first-in-first-out pipeline: The
+///   samples that are to be processed are fed into one of the pipe by calling
+///   function 'putSamples', while the ready processed samples can be read
+///   from the other end of the pipeline with function 'receiveSamples'.
+///
+/// - The SoundTouch processing classes require certain sized 'batches' of
+///   samples in order to process the sound. For this reason the classes buffer
+///   incoming samples until there are enough of samples available for
+///   processing, then they carry out the processing step and consequently
+///   make the processed samples available for outputting.
+///
+/// - For the above reason, the processing routines introduce a certain
+///   'latency' between the input and output, so that the samples input to
+///   SoundTouch may not be immediately available in the output, and neither
+///   the amount of outputtable samples may not immediately be in direct
+///   relationship with the amount of previously input samples.
+///
+/// - The tempo/pitch/rate control parameters can be altered during processing.
+///   Please notice though that they aren't currently protected by semaphores,
+///   so in multi-thread application external semaphore protection may be
+///   required.
+///
+/// - This class utilizes classes 'TDStretch' for tempo change (without modifying
+///   pitch) and 'RateTransposer' for changing the playback rate (that is, both
+///   tempo and pitch in the same ratio) of the sound. The third available control
+///   'pitch' (change pitch but maintain tempo) is produced by a combination of
+///   combining the two other controls.
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#include 
+#include 
+#include 
+#include 
+#include 
+
+#include "SoundTouch.h"
+#include "TDStretch.h"
+#include "RateTransposer.h"
+#include "cpu_detect.h"
+
+using namespace soundtouch;
+
+/// test if two floating point numbers are equal
+#define TEST_FLOAT_EQUAL(a, b)  (fabs(a - b) < 1e-10)
+
+
+/// Print library version string for autoconf
+extern "C" void soundtouch_ac_test()
+{
+    printf("SoundTouch Version: %s\n",SOUNDTOUCH_VERSION);
+}
+
+
+SoundTouch::SoundTouch()
+{
+    // Initialize rate transposer and tempo changer instances
+
+    pRateTransposer = new RateTransposer();
+    pTDStretch = TDStretch::newInstance();
+
+    setOutPipe(pTDStretch);
+
+    rate = tempo = 0;
+
+    virtualPitch =
+    virtualRate =
+    virtualTempo = 1.0;
+
+    calcEffectiveRateAndTempo();
+
+    samplesExpectedOut = 0;
+    samplesOutput = 0;
+
+    channels = 0;
+    bSrateSet = false;
+}
+
+
+SoundTouch::~SoundTouch()
+{
+    delete pRateTransposer;
+    delete pTDStretch;
+}
+
+
+/// Get SoundTouch library version string
+const char *SoundTouch::getVersionString()
+{
+    static const char *_version = SOUNDTOUCH_VERSION;
+
+    return _version;
+}
+
+
+/// Get SoundTouch library version Id
+uint SoundTouch::getVersionId()
+{
+    return SOUNDTOUCH_VERSION_ID;
+}
+
+
+// Sets the number of channels, 1 = mono, 2 = stereo
+void SoundTouch::setChannels(uint numChannels)
+{
+    if (!verifyNumberOfChannels(numChannels)) return;
+
+    channels = numChannels;
+    pRateTransposer->setChannels((int)numChannels);
+    pTDStretch->setChannels((int)numChannels);
+}
+
+
+// Sets new rate control value. Normal rate = 1.0, smaller values
+// represent slower rate, larger faster rates.
+void SoundTouch::setRate(double newRate)
+{
+    virtualRate = newRate;
+    calcEffectiveRateAndTempo();
+}
+
+
+// Sets new rate control value as a difference in percents compared
+// to the original rate (-50 .. +100 %)
+void SoundTouch::setRateChange(double newRate)
+{
+    virtualRate = 1.0 + 0.01 * newRate;
+    calcEffectiveRateAndTempo();
+}
+
+
+// Sets new tempo control value. Normal tempo = 1.0, smaller values
+// represent slower tempo, larger faster tempo.
+void SoundTouch::setTempo(double newTempo)
+{
+    virtualTempo = newTempo;
+    calcEffectiveRateAndTempo();
+}
+
+
+// Sets new tempo control value as a difference in percents compared
+// to the original tempo (-50 .. +100 %)
+void SoundTouch::setTempoChange(double newTempo)
+{
+    virtualTempo = 1.0 + 0.01 * newTempo;
+    calcEffectiveRateAndTempo();
+}
+
+
+// Sets new pitch control value. Original pitch = 1.0, smaller values
+// represent lower pitches, larger values higher pitch.
+void SoundTouch::setPitch(double newPitch)
+{
+    virtualPitch = newPitch;
+    calcEffectiveRateAndTempo();
+}
+
+
+// Sets pitch change in octaves compared to the original pitch
+// (-1.00 .. +1.00)
+void SoundTouch::setPitchOctaves(double newPitch)
+{
+    virtualPitch = exp(0.69314718056 * newPitch);
+    calcEffectiveRateAndTempo();
+}
+
+
+// Sets pitch change in semi-tones compared to the original pitch
+// (-12 .. +12)
+void SoundTouch::setPitchSemiTones(int newPitch)
+{
+    setPitchOctaves((double)newPitch / 12.0);
+}
+
+
+void SoundTouch::setPitchSemiTones(double newPitch)
+{
+    setPitchOctaves(newPitch / 12.0);
+}
+
+
+// Calculates 'effective' rate and tempo values from the
+// nominal control values.
+void SoundTouch::calcEffectiveRateAndTempo()
+{
+    double oldTempo = tempo;
+    double oldRate = rate;
+
+    tempo = virtualTempo / virtualPitch;
+    rate = virtualPitch * virtualRate;
+
+    if (!TEST_FLOAT_EQUAL(rate,oldRate)) pRateTransposer->setRate(rate);
+    if (!TEST_FLOAT_EQUAL(tempo, oldTempo)) pTDStretch->setTempo(tempo);
+
+#ifndef SOUNDTOUCH_PREVENT_CLICK_AT_RATE_CROSSOVER
+    if (rate <= 1.0f)
+    {
+        if (output != pTDStretch)
+        {
+            FIFOSamplePipe *tempoOut;
+
+            assert(output == pRateTransposer);
+            // move samples in the current output buffer to the output of pTDStretch
+            tempoOut = pTDStretch->getOutput();
+            tempoOut->moveSamples(*output);
+            // move samples in pitch transposer's store buffer to tempo changer's input
+            // deprecated : pTDStretch->moveSamples(*pRateTransposer->getStore());
+
+            output = pTDStretch;
+        }
+    }
+    else
+#endif
+    {
+        if (output != pRateTransposer)
+        {
+            FIFOSamplePipe *transOut;
+
+            assert(output == pTDStretch);
+            // move samples in the current output buffer to the output of pRateTransposer
+            transOut = pRateTransposer->getOutput();
+            transOut->moveSamples(*output);
+            // move samples in tempo changer's input to pitch transposer's input
+            pRateTransposer->moveSamples(*pTDStretch->getInput());
+
+            output = pRateTransposer;
+        }
+    }
+}
+
+
+// Sets sample rate.
+void SoundTouch::setSampleRate(uint srate)
+{
+    // set sample rate, leave other tempo changer parameters as they are.
+    pTDStretch->setParameters((int)srate);
+    bSrateSet = true;
+}
+
+
+// Adds 'numSamples' pcs of samples from the 'samples' memory position into
+// the input of the object.
+void SoundTouch::putSamples(const SAMPLETYPE *samples, uint nSamples)
+{
+    if (bSrateSet == false)
+    {
+        ST_THROW_RT_ERROR("SoundTouch : Sample rate not defined");
+    }
+    else if (channels == 0)
+    {
+        ST_THROW_RT_ERROR("SoundTouch : Number of channels not defined");
+    }
+
+    // accumulate how many samples are expected out from processing, given the current
+    // processing setting
+    samplesExpectedOut += (double)nSamples / ((double)rate * (double)tempo);
+
+#ifndef SOUNDTOUCH_PREVENT_CLICK_AT_RATE_CROSSOVER
+    if (rate <= 1.0f)
+    {
+        // transpose the rate down, output the transposed sound to tempo changer buffer
+        assert(output == pTDStretch);
+        pRateTransposer->putSamples(samples, nSamples);
+        pTDStretch->moveSamples(*pRateTransposer);
+    }
+    else
+#endif
+    {
+        // evaluate the tempo changer, then transpose the rate up,
+        assert(output == pRateTransposer);
+        pTDStretch->putSamples(samples, nSamples);
+        pRateTransposer->moveSamples(*pTDStretch);
+    }
+}
+
+
+// Flushes the last samples from the processing pipeline to the output.
+// Clears also the internal processing buffers.
+//
+// Note: This function is meant for extracting the last samples of a sound
+// stream. This function may introduce additional blank samples in the end
+// of the sound stream, and thus it's not recommended to call this function
+// in the middle of a sound stream.
+void SoundTouch::flush()
+{
+    int i;
+    int numStillExpected;
+    SAMPLETYPE *buff = new SAMPLETYPE[128 * channels];
+
+    // how many samples are still expected to output
+    numStillExpected = (int)((long)(samplesExpectedOut + 0.5) - samplesOutput);
+    if (numStillExpected < 0) numStillExpected = 0;
+
+    memset(buff, 0, 128 * channels * sizeof(SAMPLETYPE));
+    // "Push" the last active samples out from the processing pipeline by
+    // feeding blank samples into the processing pipeline until new,
+    // processed samples appear in the output (not however, more than
+    // 24ksamples in any case)
+    for (i = 0; (numStillExpected > (int)numSamples()) && (i < 200); i ++)
+    {
+        putSamples(buff, 128);
+    }
+
+    adjustAmountOfSamples(numStillExpected);
+
+    delete[] buff;
+
+    // Clear input buffers
+    pTDStretch->clearInput();
+    // yet leave the output intouched as that's where the
+    // flushed samples are!
+}
+
+
+// Changes a setting controlling the processing system behaviour. See the
+// 'SETTING_...' defines for available setting ID's.
+bool SoundTouch::setSetting(int settingId, int value)
+{
+    int sampleRate, sequenceMs, seekWindowMs, overlapMs;
+
+    // read current tdstretch routine parameters
+    pTDStretch->getParameters(&sampleRate, &sequenceMs, &seekWindowMs, &overlapMs);
+
+    switch (settingId)
+    {
+        case SETTING_USE_AA_FILTER :
+            // enables / disabless anti-alias filter
+            pRateTransposer->enableAAFilter((value != 0) ? true : false);
+            return true;
+
+        case SETTING_AA_FILTER_LENGTH :
+            // sets anti-alias filter length
+            pRateTransposer->getAAFilter()->setLength(value);
+            return true;
+
+        case SETTING_USE_QUICKSEEK :
+            // enables / disables tempo routine quick seeking algorithm
+            pTDStretch->enableQuickSeek((value != 0) ? true : false);
+            return true;
+
+        case SETTING_SEQUENCE_MS:
+            // change time-stretch sequence duration parameter
+            pTDStretch->setParameters(sampleRate, value, seekWindowMs, overlapMs);
+            return true;
+
+        case SETTING_SEEKWINDOW_MS:
+            // change time-stretch seek window length parameter
+            pTDStretch->setParameters(sampleRate, sequenceMs, value, overlapMs);
+            return true;
+
+        case SETTING_OVERLAP_MS:
+            // change time-stretch overlap length parameter
+            pTDStretch->setParameters(sampleRate, sequenceMs, seekWindowMs, value);
+            return true;
+
+        default :
+            return false;
+    }
+}
+
+
+// Reads a setting controlling the processing system behaviour. See the
+// 'SETTING_...' defines for available setting ID's.
+//
+// Returns the setting value.
+int SoundTouch::getSetting(int settingId) const
+{
+    int temp;
+
+    switch (settingId)
+    {
+        case SETTING_USE_AA_FILTER :
+            return (uint)pRateTransposer->isAAFilterEnabled();
+
+        case SETTING_AA_FILTER_LENGTH :
+            return pRateTransposer->getAAFilter()->getLength();
+
+        case SETTING_USE_QUICKSEEK :
+            return (uint)pTDStretch->isQuickSeekEnabled();
+
+        case SETTING_SEQUENCE_MS:
+            pTDStretch->getParameters(nullptr, &temp, nullptr, nullptr);
+            return temp;
+
+        case SETTING_SEEKWINDOW_MS:
+            pTDStretch->getParameters(nullptr, nullptr, &temp, nullptr);
+            return temp;
+
+        case SETTING_OVERLAP_MS:
+            pTDStretch->getParameters(nullptr, nullptr, nullptr, &temp);
+            return temp;
+
+        case SETTING_NOMINAL_INPUT_SEQUENCE :
+        {
+            int size = pTDStretch->getInputSampleReq();
+
+#ifndef SOUNDTOUCH_PREVENT_CLICK_AT_RATE_CROSSOVER
+            if (rate <= 1.0)
+            {
+                // transposing done before timestretch, which impacts latency
+                return (int)(size * rate + 0.5);
+            }
+#endif
+            return size;
+        }
+
+        case SETTING_NOMINAL_OUTPUT_SEQUENCE :
+        {
+            int size = pTDStretch->getOutputBatchSize();
+
+            if (rate > 1.0)
+            {
+                // transposing done after timestretch, which impacts latency
+                return (int)(size / rate + 0.5);
+            }
+            return size;
+        }
+
+        case SETTING_INITIAL_LATENCY:
+        {
+            double latency = pTDStretch->getLatency();
+            int latency_tr = pRateTransposer->getLatency();
+
+#ifndef SOUNDTOUCH_PREVENT_CLICK_AT_RATE_CROSSOVER
+            if (rate <= 1.0)
+            {
+                // transposing done before timestretch, which impacts latency
+                latency = (latency + latency_tr) * rate;
+            }
+            else
+#endif
+            {
+                latency += (double)latency_tr / rate;
+            }
+
+            return (int)(latency + 0.5);
+        }
+
+        default :
+            return 0;
+    }
+}
+
+
+// Clears all the samples in the object's output and internal processing
+// buffers.
+void SoundTouch::clear()
+{
+    samplesExpectedOut = 0;
+    samplesOutput = 0;
+    pRateTransposer->clear();
+    pTDStretch->clear();
+}
+
+
+/// Returns number of samples currently unprocessed.
+uint SoundTouch::numUnprocessedSamples() const
+{
+    FIFOSamplePipe * psp;
+    if (pTDStretch)
+    {
+        psp = pTDStretch->getInput();
+        if (psp)
+        {
+            return psp->numSamples();
+        }
+    }
+    return 0;
+}
+
+
+/// Output samples from beginning of the sample buffer. Copies requested samples to
+/// output buffer and removes them from the sample buffer. If there are less than
+/// 'numsample' samples in the buffer, returns all that available.
+///
+/// \return Number of samples returned.
+uint SoundTouch::receiveSamples(SAMPLETYPE *output, uint maxSamples)
+{
+    uint ret = FIFOProcessor::receiveSamples(output, maxSamples);
+    samplesOutput += (long)ret;
+    return ret;
+}
+
+
+/// Adjusts book-keeping so that given number of samples are removed from beginning of the
+/// sample buffer without copying them anywhere.
+///
+/// Used to reduce the number of samples in the buffer when accessing the sample buffer directly
+/// with 'ptrBegin' function.
+uint SoundTouch::receiveSamples(uint maxSamples)
+{
+    uint ret = FIFOProcessor::receiveSamples(maxSamples);
+    samplesOutput += (long)ret;
+    return ret;
+}
+
+
+/// Get ratio between input and output audio durations, useful for calculating
+/// processed output duration: if you'll process a stream of N samples, then
+/// you can expect to get out N * getInputOutputSampleRatio() samples.
+double SoundTouch::getInputOutputSampleRatio()
+{
+    return 1.0 / (tempo * rate);
+}
diff --git a/source/SoundTouch/TDStretch.cpp b/source/SoundTouch/TDStretch.cpp
index f04dde0..93ac181 100644
--- a/source/SoundTouch/TDStretch.cpp
+++ b/source/SoundTouch/TDStretch.cpp
@@ -1,1088 +1,1088 @@
-///////////////////////////////////////////////////////////////////////////////
-/// 
-/// Sampled sound tempo changer/time stretch algorithm. Changes the sound tempo 
-/// while maintaining the original pitch by using a time domain WSOLA-like 
-/// method with several performance-increasing tweaks.
-///
-/// Notes : MMX optimized functions reside in a separate, platform-specific 
-/// file, e.g. 'mmx_win.cpp' or 'mmx_gcc.cpp'.
-///
-/// This source file contains OpenMP optimizations that allow speeding up the
-/// corss-correlation algorithm by executing it in several threads / CPU cores 
-/// in parallel. See the following article link for more detailed discussion 
-/// about SoundTouch OpenMP optimizations:
-/// http://www.softwarecoven.com/parallel-computing-in-embedded-mobile-devices
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include 
-#include 
-#include 
-#include 
-#include 
-
-#include "STTypes.h"
-#include "cpu_detect.h"
-#include "TDStretch.h"
-
-using namespace soundtouch;
-
-#define max(x, y) (((x) > (y)) ? (x) : (y))
-
-/*****************************************************************************
- *
- * Implementation of the class 'TDStretch'
- *
- *****************************************************************************/
-
-
-TDStretch::TDStretch() : FIFOProcessor(&outputBuffer)
-{
-    bQuickSeek = false;
-    channels = 2;
-
-    pMidBuffer = nullptr;
-    pMidBufferUnaligned = nullptr;
-    overlapLength = 0;
-
-    bAutoSeqSetting = true;
-    bAutoSeekSetting = true;
-
-    tempo = 1.0f;
-    setParameters(44100, DEFAULT_SEQUENCE_MS, DEFAULT_SEEKWINDOW_MS, DEFAULT_OVERLAP_MS);
-    setTempo(1.0f);
-
-    clear();
-}
-
-
-
-TDStretch::~TDStretch()
-{
-    delete[] pMidBufferUnaligned;
-}
-
-
-
-// Sets routine control parameters. These control are certain time constants
-// defining how the sound is stretched to the desired duration.
-//
-// 'sampleRate' = sample rate of the sound
-// 'sequenceMS' = one processing sequence length in milliseconds (default = 82 ms)
-// 'seekwindowMS' = seeking window length for scanning the best overlapping 
-//      position (default = 28 ms)
-// 'overlapMS' = overlapping length (default = 12 ms)
-
-void TDStretch::setParameters(int aSampleRate, int aSequenceMS, 
-                              int aSeekWindowMS, int aOverlapMS)
-{
-    // accept only positive parameter values - if zero or negative, use old values instead
-    if (aSampleRate > 0)
-    {
-        if (aSampleRate > 192000) ST_THROW_RT_ERROR("Error: Excessive samplerate");
-        this->sampleRate = aSampleRate;
-    }
-
-    if (aOverlapMS > 0) this->overlapMs = aOverlapMS;
-
-    if (aSequenceMS > 0)
-    {
-        this->sequenceMs = aSequenceMS;
-        bAutoSeqSetting = false;
-    } 
-    else if (aSequenceMS == 0)
-    {
-        // if zero, use automatic setting
-        bAutoSeqSetting = true;
-    }
-
-    if (aSeekWindowMS > 0) 
-    {
-        this->seekWindowMs = aSeekWindowMS;
-        bAutoSeekSetting = false;
-    } 
-    else if (aSeekWindowMS == 0) 
-    {
-        // if zero, use automatic setting
-        bAutoSeekSetting = true;
-    }
-
-    calcSeqParameters();
-
-    calculateOverlapLength(overlapMs);
-
-    // set tempo to recalculate 'sampleReq'
-    setTempo(tempo);
-}
-
-
-
-/// Get routine control parameters, see setParameters() function.
-/// Any of the parameters to this function can be nullptr, in such case corresponding parameter
-/// value isn't returned.
-void TDStretch::getParameters(int *pSampleRate, int *pSequenceMs, int *pSeekWindowMs, int *pOverlapMs) const
-{
-    if (pSampleRate)
-    {
-        *pSampleRate = sampleRate;
-    }
-
-    if (pSequenceMs)
-    {
-        *pSequenceMs = (bAutoSeqSetting) ? (USE_AUTO_SEQUENCE_LEN) : sequenceMs;
-    }
-
-    if (pSeekWindowMs)
-    {
-        *pSeekWindowMs = (bAutoSeekSetting) ? (USE_AUTO_SEEKWINDOW_LEN) : seekWindowMs;
-    }
-
-    if (pOverlapMs)
-    {
-        *pOverlapMs = overlapMs;
-    }
-}
-
-
-// Overlaps samples in 'midBuffer' with the samples in 'pInput'
-void TDStretch::overlapMono(SAMPLETYPE *pOutput, const SAMPLETYPE *pInput) const
-{
-    int i;
-    SAMPLETYPE m1, m2;
-
-    m1 = (SAMPLETYPE)0;
-    m2 = (SAMPLETYPE)overlapLength;
-
-    for (i = 0; i < overlapLength ; i ++)
-    {
-        pOutput[i] = (pInput[i] * m1 + pMidBuffer[i] * m2 ) / overlapLength;
-        m1 += 1;
-        m2 -= 1;
-    }
-}
-
-
-
-void TDStretch::clearMidBuffer()
-{
-    memset(pMidBuffer, 0, channels * sizeof(SAMPLETYPE) * overlapLength);
-}
-
-
-void TDStretch::clearInput()
-{
-    inputBuffer.clear();
-    clearMidBuffer();
-    isBeginning = true;
-    maxnorm = 0;
-    maxnormf = 1e8;
-    skipFract = 0;
-}
-
-
-// Clears the sample buffers
-void TDStretch::clear()
-{
-    outputBuffer.clear();
-    clearInput();
-}
-
-
-
-// Enables/disables the quick position seeking algorithm. Zero to disable, nonzero
-// to enable
-void TDStretch::enableQuickSeek(bool enable)
-{
-    bQuickSeek = enable;
-}
-
-
-// Returns nonzero if the quick seeking algorithm is enabled.
-bool TDStretch::isQuickSeekEnabled() const
-{
-    return bQuickSeek;
-}
-
-
-// Seeks for the optimal overlap-mixing position.
-int TDStretch::seekBestOverlapPosition(const SAMPLETYPE *refPos)
-{
-    if (bQuickSeek) 
-    {
-        return seekBestOverlapPositionQuick(refPos);
-    }
-    else 
-    {
-        return seekBestOverlapPositionFull(refPos);
-    }
-}
-
-
-// Overlaps samples in 'midBuffer' with the samples in 'pInputBuffer' at position
-// of 'ovlPos'.
-inline void TDStretch::overlap(SAMPLETYPE *pOutput, const SAMPLETYPE *pInput, uint ovlPos) const
-{
-#ifndef USE_MULTICH_ALWAYS
-    if (channels == 1)
-    {
-        // mono sound.
-        overlapMono(pOutput, pInput + ovlPos);
-    }
-    else if (channels == 2)
-    {
-        // stereo sound
-        overlapStereo(pOutput, pInput + 2 * ovlPos);
-    } 
-    else 
-#endif // USE_MULTICH_ALWAYS
-    {
-        assert(channels > 0);
-        overlapMulti(pOutput, pInput + channels * ovlPos);
-    }
-}
-
-
-// Seeks for the optimal overlap-mixing position. The 'stereo' version of the
-// routine
-//
-// The best position is determined as the position where the two overlapped
-// sample sequences are 'most alike', in terms of the highest cross-correlation
-// value over the overlapping period
-int TDStretch::seekBestOverlapPositionFull(const SAMPLETYPE *refPos) 
-{
-    int bestOffs;
-    double bestCorr;
-    int i;
-    double norm;
-
-    bestCorr = -FLT_MAX;
-    bestOffs = 0;
-
-    // Scans for the best correlation value by testing each possible position
-    // over the permitted range.
-    bestCorr = calcCrossCorr(refPos, pMidBuffer, norm);
-    bestCorr = (bestCorr + 0.1) * 0.75;
-
-    #pragma omp parallel for
-    for (i = 1; i < seekLength; i ++)
-    {
-        double corr;
-        // Calculates correlation value for the mixing position corresponding to 'i'
-#if defined(_OPENMP) || defined(ST_SIMD_AVOID_UNALIGNED)
-        // in parallel OpenMP mode, can't use norm accumulator version as parallel executor won't
-        // iterate the loop in sequential order
-        // in SIMD mode, avoid accumulator version to allow avoiding unaligned positions
-        corr = calcCrossCorr(refPos + channels * i, pMidBuffer, norm);
-#else
-        // In non-parallel version call "calcCrossCorrAccumulate" that is otherwise same
-        // as "calcCrossCorr", but saves time by reusing & updating previously stored 
-        // "norm" value
-        corr = calcCrossCorrAccumulate(refPos + channels * i, pMidBuffer, norm);
-#endif
-        // heuristic rule to slightly favour values close to mid of the range
-        double tmp = (double)(2 * i - seekLength) / (double)seekLength;
-        corr = ((corr + 0.1) * (1.0 - 0.25 * tmp * tmp));
-
-        // Checks for the highest correlation value
-        if (corr > bestCorr) 
-        {
-            // For optimal performance, enter critical section only in case that best value found.
-            // in such case repeat 'if' condition as it's possible that parallel execution may have
-            // updated the bestCorr value in the mean time
-            #pragma omp critical
-            if (corr > bestCorr)
-            {
-                bestCorr = corr;
-                bestOffs = i;
-            }
-        }
-    }
-
-#ifdef SOUNDTOUCH_INTEGER_SAMPLES
-    adaptNormalizer();
-#endif
-
-    // clear cross correlation routine state if necessary (is so e.g. in MMX routines).
-    clearCrossCorrState();
-
-    return bestOffs;
-}
-
-
-// Quick seek algorithm for improved runtime-performance: First roughly scans through the 
-// correlation area, and then scan surroundings of two best preliminary correlation candidates
-// with improved precision
-//
-// Based on testing:
-// - This algorithm gives on average 99% as good match as the full algorithm
-// - this quick seek algorithm finds the best match on ~90% of cases
-// - on those 10% of cases when this algorithm doesn't find best match, 
-//   it still finds on average ~90% match vs. the best possible match
-int TDStretch::seekBestOverlapPositionQuick(const SAMPLETYPE *refPos)
-{
-#define _MIN(a, b)   (((a) < (b)) ? (a) : (b))
-#define SCANSTEP    16
-#define SCANWIND    8
-
-    int bestOffs;
-    int i;
-    int bestOffs2;
-    float bestCorr, corr;
-    float bestCorr2;
-    double norm;
-
-    // note: 'float' types used in this function in case that the platform would need to use software-fp
-
-    bestCorr =
-    bestCorr2 = -FLT_MAX;
-    bestOffs = 
-    bestOffs2 = SCANWIND;
-
-    // Scans for the best correlation value by testing each possible position
-    // over the permitted range. Look for two best matches on the first pass to
-    // increase possibility of ideal match.
-    //
-    // Begin from "SCANSTEP" instead of SCANWIND to make the calculation
-    // catch the 'middlepoint' of seekLength vector as that's the a-priori 
-    // expected best match position
-    //
-    // Roughly:
-    // - 15% of cases find best result directly on the first round,
-    // - 75% cases find better match on 2nd round around the best match from 1st round
-    // - 10% cases find better match on 2nd round around the 2nd-best-match from 1st round
-    for (i = SCANSTEP; i < seekLength - SCANWIND - 1; i += SCANSTEP)
-    {
-        // Calculates correlation value for the mixing position corresponding
-        // to 'i'
-        corr = (float)calcCrossCorr(refPos + channels*i, pMidBuffer, norm);
-        // heuristic rule to slightly favour values close to mid of the seek range
-        float tmp = (float)(2 * i - seekLength - 1) / (float)seekLength;
-        corr = ((corr + 0.1f) * (1.0f - 0.25f * tmp * tmp));
-
-        // Checks for the highest correlation value
-        if (corr > bestCorr)
-        {
-            // found new best match. keep the previous best as 2nd best match
-            bestCorr2 = bestCorr;
-            bestOffs2 = bestOffs;
-            bestCorr = corr;
-            bestOffs = i;
-        }
-        else if (corr > bestCorr2)
-        {
-            // not new best, but still new 2nd best match
-            bestCorr2 = corr;
-            bestOffs2 = i;
-        }
-    }
-
-    // Scans surroundings of the found best match with small stepping
-    int end = _MIN(bestOffs + SCANWIND + 1, seekLength);
-    for (i = bestOffs - SCANWIND; i < end; i++)
-    {
-        if (i == bestOffs) continue;    // this offset already calculated, thus skip
-
-        // Calculates correlation value for the mixing position corresponding
-        // to 'i'
-        corr = (float)calcCrossCorr(refPos + channels*i, pMidBuffer, norm);
-        // heuristic rule to slightly favour values close to mid of the range
-        float tmp = (float)(2 * i - seekLength - 1) / (float)seekLength;
-        corr = ((corr + 0.1f) * (1.0f - 0.25f * tmp * tmp));
-
-        // Checks for the highest correlation value
-        if (corr > bestCorr)
-        {
-            bestCorr = corr;
-            bestOffs = i;
-        }
-    }
-
-    // Scans surroundings of the 2nd best match with small stepping
-    end = _MIN(bestOffs2 + SCANWIND + 1, seekLength);
-    for (i = bestOffs2 - SCANWIND; i < end; i++)
-    {
-        if (i == bestOffs2) continue;    // this offset already calculated, thus skip
-
-        // Calculates correlation value for the mixing position corresponding
-        // to 'i'
-        corr = (float)calcCrossCorr(refPos + channels*i, pMidBuffer, norm);
-        // heuristic rule to slightly favour values close to mid of the range
-        float tmp = (float)(2 * i - seekLength - 1) / (float)seekLength;
-        corr = ((corr + 0.1f) * (1.0f - 0.25f * tmp * tmp));
-
-        // Checks for the highest correlation value
-        if (corr > bestCorr)
-        {
-            bestCorr = corr;
-            bestOffs = i;
-        }
-    }
-
-    // clear cross correlation routine state if necessary (is so e.g. in MMX routines).
-    clearCrossCorrState();
-
-#ifdef SOUNDTOUCH_INTEGER_SAMPLES
-    adaptNormalizer();
-#endif
-
-    return bestOffs;
-}
-
-
-
-
-/// For integer algorithm: adapt normalization factor divider with music so that 
-/// it'll not be pessimistically restrictive that can degrade quality on quieter sections
-/// yet won't cause integer overflows either
-void TDStretch::adaptNormalizer()
-{
-    // Do not adapt normalizer over too silent sequences to avoid averaging filter depleting to
-    // too low values during pauses in music
-    if ((maxnorm > 1000) || (maxnormf > 40000000))
-    { 
-        //norm averaging filter
-        maxnormf = 0.9f * maxnormf + 0.1f * (float)maxnorm;
-
-        if ((maxnorm > 800000000) && (overlapDividerBitsNorm < 16))
-        {
-            // large values, so increase divider
-            overlapDividerBitsNorm++;
-            if (maxnorm > 1600000000) overlapDividerBitsNorm++; // extra large value => extra increase
-        }
-        else if ((maxnormf < 1000000) && (overlapDividerBitsNorm > 0))
-        {
-            // extra small values, decrease divider
-            overlapDividerBitsNorm--;
-        }
-    }
-
-    maxnorm = 0;
-}
-
-
-/// clear cross correlation routine state if necessary 
-void TDStretch::clearCrossCorrState()
-{
-    // default implementation is empty.
-}
-
-
-/// Calculates processing sequence length according to tempo setting
-void TDStretch::calcSeqParameters()
-{
-    // Adjust tempo param according to tempo, so that variating processing sequence length is used
-    // at various tempo settings, between the given low...top limits
-    #define AUTOSEQ_TEMPO_LOW   0.5     // auto setting low tempo range (-50%)
-    #define AUTOSEQ_TEMPO_TOP   2.0     // auto setting top tempo range (+100%)
-
-    // sequence-ms setting values at above low & top tempo
-    #define AUTOSEQ_AT_MIN      90.0
-    #define AUTOSEQ_AT_MAX      40.0
-    #define AUTOSEQ_K           ((AUTOSEQ_AT_MAX - AUTOSEQ_AT_MIN) / (AUTOSEQ_TEMPO_TOP - AUTOSEQ_TEMPO_LOW))
-    #define AUTOSEQ_C           (AUTOSEQ_AT_MIN - (AUTOSEQ_K) * (AUTOSEQ_TEMPO_LOW))
-
-    // seek-window-ms setting values at above low & top tempoq
-    #define AUTOSEEK_AT_MIN     20.0
-    #define AUTOSEEK_AT_MAX     15.0
-    #define AUTOSEEK_K          ((AUTOSEEK_AT_MAX - AUTOSEEK_AT_MIN) / (AUTOSEQ_TEMPO_TOP - AUTOSEQ_TEMPO_LOW))
-    #define AUTOSEEK_C          (AUTOSEEK_AT_MIN - (AUTOSEEK_K) * (AUTOSEQ_TEMPO_LOW))
-
-    #define CHECK_LIMITS(x, mi, ma) (((x) < (mi)) ? (mi) : (((x) > (ma)) ? (ma) : (x)))
-
-    double seq, seek;
-    
-    if (bAutoSeqSetting)
-    {
-        seq = AUTOSEQ_C + AUTOSEQ_K * tempo;
-        seq = CHECK_LIMITS(seq, AUTOSEQ_AT_MAX, AUTOSEQ_AT_MIN);
-        sequenceMs = (int)(seq + 0.5);
-    }
-
-    if (bAutoSeekSetting)
-    {
-        seek = AUTOSEEK_C + AUTOSEEK_K * tempo;
-        seek = CHECK_LIMITS(seek, AUTOSEEK_AT_MAX, AUTOSEEK_AT_MIN);
-        seekWindowMs = (int)(seek + 0.5);
-    }
-
-    // Update seek window lengths
-    seekWindowLength = (sampleRate * sequenceMs) / 1000;
-    if (seekWindowLength < 2 * overlapLength) 
-    {
-        seekWindowLength = 2 * overlapLength;
-    }
-    seekLength = (sampleRate * seekWindowMs) / 1000;
-}
-
-
-
-// Sets new target tempo. Normal tempo = 'SCALE', smaller values represent slower 
-// tempo, larger faster tempo.
-void TDStretch::setTempo(double newTempo)
-{
-    int intskip;
-
-    tempo = newTempo;
-
-    // Calculate new sequence duration
-    calcSeqParameters();
-
-    // Calculate ideal skip length (according to tempo value) 
-    nominalSkip = tempo * (seekWindowLength - overlapLength);
-    intskip = (int)(nominalSkip + 0.5);
-
-    // Calculate how many samples are needed in the 'inputBuffer' to 
-    // process another batch of samples
-    //sampleReq = max(intskip + overlapLength, seekWindowLength) + seekLength / 2;
-    sampleReq = max(intskip + overlapLength, seekWindowLength) + seekLength;
-}
-
-
-
-// Sets the number of channels, 1 = mono, 2 = stereo
-void TDStretch::setChannels(int numChannels)
-{
-    if (!verifyNumberOfChannels(numChannels) ||
-        (channels == numChannels)) return;
-
-    channels = numChannels;
-    inputBuffer.setChannels(channels);
-    outputBuffer.setChannels(channels);
-
-    // re-init overlap/buffer
-    overlapLength=0;
-    setParameters(sampleRate);
-}
-
-
-// nominal tempo, no need for processing, just pass the samples through
-// to outputBuffer
-/*
-void TDStretch::processNominalTempo()
-{
-    assert(tempo == 1.0f);
-
-    if (bMidBufferDirty) 
-    {
-        // If there are samples in pMidBuffer waiting for overlapping,
-        // do a single sliding overlapping with them in order to prevent a 
-        // clicking distortion in the output sound
-        if (inputBuffer.numSamples() < overlapLength) 
-        {
-            // wait until we've got overlapLength input samples
-            return;
-        }
-        // Mix the samples in the beginning of 'inputBuffer' with the 
-        // samples in 'midBuffer' using sliding overlapping 
-        overlap(outputBuffer.ptrEnd(overlapLength), inputBuffer.ptrBegin(), 0);
-        outputBuffer.putSamples(overlapLength);
-        inputBuffer.receiveSamples(overlapLength);
-        clearMidBuffer();
-        // now we've caught the nominal sample flow and may switch to
-        // bypass mode
-    }
-
-    // Simply bypass samples from input to output
-    outputBuffer.moveSamples(inputBuffer);
-}
-*/
-
-
-// Processes as many processing frames of the samples 'inputBuffer', store
-// the result into 'outputBuffer'
-void TDStretch::processSamples()
-{
-    int ovlSkip;
-    int offset = 0;
-    int temp;
-
-    /* Removed this small optimization - can introduce a click to sound when tempo setting
-       crosses the nominal value
-    if (tempo == 1.0f) 
-    {
-        // tempo not changed from the original, so bypass the processing
-        processNominalTempo();
-        return;
-    }
-    */
-
-    // Process samples as long as there are enough samples in 'inputBuffer'
-    // to form a processing frame.
-    while ((int)inputBuffer.numSamples() >= sampleReq) 
-    {
-        if (isBeginning == false)
-        {
-            // apart from the very beginning of the track, 
-            // scan for the best overlapping position & do overlap-add
-            offset = seekBestOverlapPosition(inputBuffer.ptrBegin());
-
-            // Mix the samples in the 'inputBuffer' at position of 'offset' with the 
-            // samples in 'midBuffer' using sliding overlapping
-            // ... first partially overlap with the end of the previous sequence
-            // (that's in 'midBuffer')
-            overlap(outputBuffer.ptrEnd((uint)overlapLength), inputBuffer.ptrBegin(), (uint)offset);
-            outputBuffer.putSamples((uint)overlapLength);
-            offset += overlapLength;
-        }
-        else
-        {
-            // Adjust processing offset at beginning of track by not perform initial overlapping
-            // and compensating that in the 'input buffer skip' calculation
-            isBeginning = false;
-            int skip = (int)(tempo * overlapLength + 0.5 * seekLength + 0.5);
-
-            #ifdef ST_SIMD_AVOID_UNALIGNED
-            // in SIMD mode, round the skip amount to value corresponding to aligned memory address
-            if (channels == 1)
-            {
-                skip &= -4;
-            }
-            else if (channels == 2)
-            {
-                skip &= -2;
-            }
-            #endif
-            skipFract -= skip;
-            if (skipFract <= -nominalSkip)
-            {
-                skipFract = -nominalSkip;
-            }
-        }
-
-        // ... then copy sequence samples from 'inputBuffer' to output:
-
-        // crosscheck that we don't have buffer overflow...
-        if ((int)inputBuffer.numSamples() < (offset + seekWindowLength - overlapLength))
-        {
-            continue;    // just in case, shouldn't really happen
-        }
-
-        // length of sequence
-        temp = (seekWindowLength - 2 * overlapLength);
-        outputBuffer.putSamples(inputBuffer.ptrBegin() + channels * offset, (uint)temp);
-
-        // Copies the end of the current sequence from 'inputBuffer' to 
-        // 'midBuffer' for being mixed with the beginning of the next 
-        // processing sequence and so on
-        assert((offset + temp + overlapLength) <= (int)inputBuffer.numSamples());
-        memcpy(pMidBuffer, inputBuffer.ptrBegin() + channels * (offset + temp), 
-            channels * sizeof(SAMPLETYPE) * overlapLength);
-
-        // Remove the processed samples from the input buffer. Update
-        // the difference between integer & nominal skip step to 'skipFract'
-        // in order to prevent the error from accumulating over time.
-        skipFract += nominalSkip;   // real skip size
-        ovlSkip = (int)skipFract;   // rounded to integer skip
-        skipFract -= ovlSkip;       // maintain the fraction part, i.e. real vs. integer skip
-        inputBuffer.receiveSamples((uint)ovlSkip);
-    }
-}
-
-
-// Adds 'numsamples' pcs of samples from the 'samples' memory position into
-// the input of the object.
-void TDStretch::putSamples(const SAMPLETYPE *samples, uint nSamples)
-{
-    // Add the samples into the input buffer
-    inputBuffer.putSamples(samples, nSamples);
-    // Process the samples in input buffer
-    processSamples();
-}
-
-
-
-/// Set new overlap length parameter & reallocate RefMidBuffer if necessary.
-void TDStretch::acceptNewOverlapLength(int newOverlapLength)
-{
-    int prevOvl;
-
-    assert(newOverlapLength >= 0);
-    prevOvl = overlapLength;
-    overlapLength = newOverlapLength;
-
-    if (overlapLength > prevOvl)
-    {
-        delete[] pMidBufferUnaligned;
-
-        pMidBufferUnaligned = new SAMPLETYPE[overlapLength * channels + 16 / sizeof(SAMPLETYPE)];
-        // ensure that 'pMidBuffer' is aligned to 16 byte boundary for efficiency
-        pMidBuffer = (SAMPLETYPE *)SOUNDTOUCH_ALIGN_POINTER_16(pMidBufferUnaligned);
-
-        clearMidBuffer();
-    }
-}
-
-
-// Operator 'new' is overloaded so that it automatically creates a suitable instance 
-// depending on if we've a MMX/SSE/etc-capable CPU available or not.
-void * TDStretch::operator new(size_t)
-{
-    // Notice! don't use "new TDStretch" directly, use "newInstance" to create a new instance instead!
-    ST_THROW_RT_ERROR("Error in TDStretch::new: Don't use 'new TDStretch' directly, use 'newInstance' member instead!");
-    return newInstance();
-}
-
-
-TDStretch * TDStretch::newInstance()
-{
-    uint uExtensions;
-
-    uExtensions = detectCPUextensions();
-    (void)uExtensions;
-
-    // Check if MMX/SSE instruction set extensions supported by CPU
-
-#ifdef SOUNDTOUCH_ALLOW_MMX
-    // MMX routines available only with integer sample types
-    if (uExtensions & SUPPORT_MMX)
-    {
-        return ::new TDStretchMMX;
-    }
-    else
-#endif // SOUNDTOUCH_ALLOW_MMX
-
-
-#ifdef SOUNDTOUCH_ALLOW_SSE
-    if (uExtensions & SUPPORT_SSE)
-    {
-        // SSE support
-        return ::new TDStretchSSE;
-    }
-    else
-#endif // SOUNDTOUCH_ALLOW_SSE
-
-    {
-        // ISA optimizations not supported, use plain C version
-        return ::new TDStretch;
-    }
-}
-
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// Integer arithmetic specific algorithm implementations.
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#ifdef SOUNDTOUCH_INTEGER_SAMPLES
-
-// Overlaps samples in 'midBuffer' with the samples in 'input'. The 'Stereo' 
-// version of the routine.
-void TDStretch::overlapStereo(short *poutput, const short *input) const
-{
-    int i;
-    short temp;
-    int cnt2;
-
-    for (i = 0; i < overlapLength ; i ++)
-    {
-        temp = (short)(overlapLength - i);
-        cnt2 = 2 * i;
-        poutput[cnt2] = (input[cnt2] * i + pMidBuffer[cnt2] * temp )  / overlapLength;
-        poutput[cnt2 + 1] = (input[cnt2 + 1] * i + pMidBuffer[cnt2 + 1] * temp ) / overlapLength;
-    }
-}
-
-
-// Overlaps samples in 'midBuffer' with the samples in 'input'. The 'Multi'
-// version of the routine.
-void TDStretch::overlapMulti(short *poutput, const short *input) const
-{
-    short m1;
-    int i = 0;
-
-    for (m1 = 0; m1 < overlapLength; m1 ++)
-    {
-        short m2 = (short)(overlapLength - m1);
-        for (int c = 0; c < channels; c ++)
-        {
-            poutput[i] = (input[i] * m1 + pMidBuffer[i] * m2)  / overlapLength;
-            i++;
-        }
-    }
-}
-
-// Calculates the x having the closest 2^x value for the given value
-static int _getClosest2Power(double value)
-{
-    return (int)(log(value) / log(2.0) + 0.5);
-}
-
-
-/// Calculates overlap period length in samples.
-/// Integer version rounds overlap length to closest power of 2
-/// for a divide scaling operation.
-void TDStretch::calculateOverlapLength(int aoverlapMs)
-{
-    int newOvl;
-
-    assert(aoverlapMs >= 0);
-
-    // calculate overlap length so that it's power of 2 - thus it's easy to do
-    // integer division by right-shifting. Term "-1" at end is to account for 
-    // the extra most significatnt bit left unused in result by signed multiplication 
-    overlapDividerBitsPure = _getClosest2Power((sampleRate * aoverlapMs) / 1000.0) - 1;
-    if (overlapDividerBitsPure > 9) overlapDividerBitsPure = 9;
-    if (overlapDividerBitsPure < 3) overlapDividerBitsPure = 3;
-    newOvl = (int)pow(2.0, (int)overlapDividerBitsPure + 1);    // +1 => account for -1 above
-
-    acceptNewOverlapLength(newOvl);
-
-    overlapDividerBitsNorm = overlapDividerBitsPure;
-
-    // calculate sloping divider so that crosscorrelation operation won't 
-    // overflow 32-bit register. Max. sum of the crosscorrelation sum without 
-    // divider would be 2^30*(N^3-N)/3, where N = overlap length
-    slopingDivider = (newOvl * newOvl - 1) / 3;
-}
-
-
-double TDStretch::calcCrossCorr(const short *mixingPos, const short *compare, double &norm)
-{
-    long corr;
-    unsigned long lnorm;
-    int i;
-
-    #ifdef ST_SIMD_AVOID_UNALIGNED
-        // in SIMD mode skip 'mixingPos' positions that aren't aligned to 16-byte boundary
-        if (((ulongptr)mixingPos) & 15) return -1e50;
-    #endif
-
-    // hint compiler autovectorization that loop length is divisible by 8
-    int ilength = (channels * overlapLength) & -8;
-
-    corr = lnorm = 0;
-    // Same routine for stereo and mono
-    for (i = 0; i < ilength; i += 2)
-    {
-        corr += (mixingPos[i] * compare[i] + 
-                 mixingPos[i + 1] * compare[i + 1]) >> overlapDividerBitsNorm;
-        lnorm += (mixingPos[i] * mixingPos[i] + 
-                  mixingPos[i + 1] * mixingPos[i + 1]) >> overlapDividerBitsNorm;
-        // do intermediate scalings to avoid integer overflow
-    }
-
-    if (lnorm > maxnorm)
-    {
-        // modify 'maxnorm' inside critical section to avoid multi-access conflict if in OpenMP mode
-        #pragma omp critical
-        if (lnorm > maxnorm)
-        {
-            maxnorm = lnorm;
-        }
-    }
-    // Normalize result by dividing by sqrt(norm) - this step is easiest 
-    // done using floating point operation
-    norm = (double)lnorm;
-    return (double)corr / sqrt((norm < 1e-9) ? 1.0 : norm);
-}
-
-
-/// Update cross-correlation by accumulating "norm" coefficient by previously calculated value
-double TDStretch::calcCrossCorrAccumulate(const short *mixingPos, const short *compare, double &norm)
-{
-    long corr;
-    long lnorm;
-    int i;
-
-    // hint compiler autovectorization that loop length is divisible by 8
-    int ilength = (channels * overlapLength) & -8;
-
-    // cancel first normalizer tap from previous round
-    lnorm = 0;
-    for (i = 1; i <= channels; i ++)
-    {
-        lnorm -= (mixingPos[-i] * mixingPos[-i]) >> overlapDividerBitsNorm;
-    }
-
-    corr = 0;
-    // Same routine for stereo and mono.
-    for (i = 0; i < ilength; i += 2) 
-    {
-        corr += (mixingPos[i] * compare[i] + 
-                 mixingPos[i + 1] * compare[i + 1]) >> overlapDividerBitsNorm;
-    }
-
-    // update normalizer with last samples of this round
-    for (int j = 0; j < channels; j ++)
-    {
-        i --;
-        lnorm += (mixingPos[i] * mixingPos[i]) >> overlapDividerBitsNorm;
-    }
-
-    norm += (double)lnorm;
-    if (norm > maxnorm)
-    {
-        maxnorm = (unsigned long)norm;
-    }
-
-    // Normalize result by dividing by sqrt(norm) - this step is easiest 
-    // done using floating point operation
-    return (double)corr / sqrt((norm < 1e-9) ? 1.0 : norm);
-}
-
-#endif // SOUNDTOUCH_INTEGER_SAMPLES
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// Floating point arithmetic specific algorithm implementations.
-//
-
-#ifdef SOUNDTOUCH_FLOAT_SAMPLES
-
-// Overlaps samples in 'midBuffer' with the samples in 'pInput'
-void TDStretch::overlapStereo(float *pOutput, const float *pInput) const
-{
-    int i;
-    float fScale;
-    float f1;
-    float f2;
-
-    fScale = 1.0f / (float)overlapLength;
-
-    f1 = 0;
-    f2 = 1.0f;
-
-    for (i = 0; i < 2 * (int)overlapLength ; i += 2) 
-    {
-        pOutput[i + 0] = pInput[i + 0] * f1 + pMidBuffer[i + 0] * f2;
-        pOutput[i + 1] = pInput[i + 1] * f1 + pMidBuffer[i + 1] * f2;
-
-        f1 += fScale;
-        f2 -= fScale;
-    }
-}
-
-
-// Overlaps samples in 'midBuffer' with the samples in 'input'. 
-void TDStretch::overlapMulti(float *pOutput, const float *pInput) const
-{
-    int i;
-    float fScale;
-    float f1;
-    float f2;
-
-    fScale = 1.0f / (float)overlapLength;
-
-    f1 = 0;
-    f2 = 1.0f;
-
-    i=0;
-    for (int i2 = 0; i2 < overlapLength; i2 ++)
-    {
-        // note: Could optimize this slightly by taking into account that always channels > 2
-        for (int c = 0; c < channels; c ++)
-        {
-            pOutput[i] = pInput[i] * f1 + pMidBuffer[i] * f2;
-            i++;
-        }
-        f1 += fScale;
-        f2 -= fScale;
-    }
-}
-
-
-/// Calculates overlapInMsec period length in samples.
-void TDStretch::calculateOverlapLength(int overlapInMsec)
-{
-    int newOvl;
-
-    assert(overlapInMsec >= 0);
-    newOvl = (sampleRate * overlapInMsec) / 1000;
-    if (newOvl < 16) newOvl = 16;
-
-    // must be divisible by 8
-    newOvl -= newOvl % 8;
-
-    acceptNewOverlapLength(newOvl);
-}
-
-
-/// Calculate cross-correlation
-double TDStretch::calcCrossCorr(const float *mixingPos, const float *compare, double &anorm)
-{
-    float corr;
-    float norm;
-    int i;
-
-    #ifdef ST_SIMD_AVOID_UNALIGNED
-        // in SIMD mode skip 'mixingPos' positions that aren't aligned to 16-byte boundary
-        if (((ulongptr)mixingPos) & 15) return -1e50;
-    #endif
-
-    // hint compiler autovectorization that loop length is divisible by 8
-    int ilength = (channels * overlapLength) & -8;
-
-    corr = norm = 0;
-    // Same routine for stereo and mono
-    for (i = 0; i < ilength; i ++)
-    {
-        corr += mixingPos[i] * compare[i];
-        norm += mixingPos[i] * mixingPos[i];
-    }
-
-    anorm = norm;
-    return corr / sqrt((norm < 1e-9 ? 1.0 : norm));
-}
-
-
-/// Update cross-correlation by accumulating "norm" coefficient by previously calculated value
-double TDStretch::calcCrossCorrAccumulate(const float *mixingPos, const float *compare, double &norm)
-{
-    float corr;
-    int i;
-
-    corr = 0;
-
-    // cancel first normalizer tap from previous round
-    for (i = 1; i <= channels; i ++)
-    {
-        norm -= mixingPos[-i] * mixingPos[-i];
-    }
-
-    // hint compiler autovectorization that loop length is divisible by 8
-    int ilength = (channels * overlapLength) & -8;
-
-    // Same routine for stereo and mono
-    for (i = 0; i < ilength; i ++)
-    {
-        corr += mixingPos[i] * compare[i];
-    }
-
-    // update normalizer with last samples of this round
-    for (int j = 0; j < channels; j ++)
-    {
-        i --;
-        norm += mixingPos[i] * mixingPos[i];
-    }
-
-    return corr / sqrt((norm < 1e-9 ? 1.0 : norm));
-}
-
-
-#endif // SOUNDTOUCH_FLOAT_SAMPLES
+///////////////////////////////////////////////////////////////////////////////
+///
+/// Sampled sound tempo changer/time stretch algorithm. Changes the sound tempo
+/// while maintaining the original pitch by using a time domain WSOLA-like
+/// method with several performance-increasing tweaks.
+///
+/// Notes : MMX optimized functions reside in a separate, platform-specific
+/// file, e.g. 'mmx_win.cpp' or 'mmx_gcc.cpp'.
+///
+/// This source file contains OpenMP optimizations that allow speeding up the
+/// corss-correlation algorithm by executing it in several threads / CPU cores
+/// in parallel. See the following article link for more detailed discussion
+/// about SoundTouch OpenMP optimizations:
+/// http://www.softwarecoven.com/parallel-computing-in-embedded-mobile-devices
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#include 
+#include 
+#include 
+#include 
+#include 
+
+#include "STTypes.h"
+#include "cpu_detect.h"
+#include "TDStretch.h"
+
+using namespace soundtouch;
+
+#define max(x, y) (((x) > (y)) ? (x) : (y))
+
+/*****************************************************************************
+ *
+ * Implementation of the class 'TDStretch'
+ *
+ *****************************************************************************/
+
+
+TDStretch::TDStretch() : FIFOProcessor(&outputBuffer)
+{
+    bQuickSeek = false;
+    channels = 2;
+
+    pMidBuffer = nullptr;
+    pMidBufferUnaligned = nullptr;
+    overlapLength = 0;
+
+    bAutoSeqSetting = true;
+    bAutoSeekSetting = true;
+
+    tempo = 1.0f;
+    setParameters(44100, DEFAULT_SEQUENCE_MS, DEFAULT_SEEKWINDOW_MS, DEFAULT_OVERLAP_MS);
+    setTempo(1.0f);
+
+    clear();
+}
+
+
+
+TDStretch::~TDStretch()
+{
+    delete[] pMidBufferUnaligned;
+}
+
+
+
+// Sets routine control parameters. These control are certain time constants
+// defining how the sound is stretched to the desired duration.
+//
+// 'sampleRate' = sample rate of the sound
+// 'sequenceMS' = one processing sequence length in milliseconds (default = 82 ms)
+// 'seekwindowMS' = seeking window length for scanning the best overlapping
+//      position (default = 28 ms)
+// 'overlapMS' = overlapping length (default = 12 ms)
+
+void TDStretch::setParameters(int aSampleRate, int aSequenceMS,
+                              int aSeekWindowMS, int aOverlapMS)
+{
+    // accept only positive parameter values - if zero or negative, use old values instead
+    if (aSampleRate > 0)
+    {
+        if (aSampleRate > 192000) ST_THROW_RT_ERROR("Error: Excessive samplerate");
+        this->sampleRate = aSampleRate;
+    }
+
+    if (aOverlapMS > 0) this->overlapMs = aOverlapMS;
+
+    if (aSequenceMS > 0)
+    {
+        this->sequenceMs = aSequenceMS;
+        bAutoSeqSetting = false;
+    }
+    else if (aSequenceMS == 0)
+    {
+        // if zero, use automatic setting
+        bAutoSeqSetting = true;
+    }
+
+    if (aSeekWindowMS > 0)
+    {
+        this->seekWindowMs = aSeekWindowMS;
+        bAutoSeekSetting = false;
+    }
+    else if (aSeekWindowMS == 0)
+    {
+        // if zero, use automatic setting
+        bAutoSeekSetting = true;
+    }
+
+    calcSeqParameters();
+
+    calculateOverlapLength(overlapMs);
+
+    // set tempo to recalculate 'sampleReq'
+    setTempo(tempo);
+}
+
+
+
+/// Get routine control parameters, see setParameters() function.
+/// Any of the parameters to this function can be nullptr, in such case corresponding parameter
+/// value isn't returned.
+void TDStretch::getParameters(int *pSampleRate, int *pSequenceMs, int *pSeekWindowMs, int *pOverlapMs) const
+{
+    if (pSampleRate)
+    {
+        *pSampleRate = sampleRate;
+    }
+
+    if (pSequenceMs)
+    {
+        *pSequenceMs = (bAutoSeqSetting) ? (USE_AUTO_SEQUENCE_LEN) : sequenceMs;
+    }
+
+    if (pSeekWindowMs)
+    {
+        *pSeekWindowMs = (bAutoSeekSetting) ? (USE_AUTO_SEEKWINDOW_LEN) : seekWindowMs;
+    }
+
+    if (pOverlapMs)
+    {
+        *pOverlapMs = overlapMs;
+    }
+}
+
+
+// Overlaps samples in 'midBuffer' with the samples in 'pInput'
+void TDStretch::overlapMono(SAMPLETYPE *pOutput, const SAMPLETYPE *pInput) const
+{
+    int i;
+    SAMPLETYPE m1, m2;
+
+    m1 = (SAMPLETYPE)0;
+    m2 = (SAMPLETYPE)overlapLength;
+
+    for (i = 0; i < overlapLength ; i ++)
+    {
+        pOutput[i] = (pInput[i] * m1 + pMidBuffer[i] * m2 ) / overlapLength;
+        m1 += 1;
+        m2 -= 1;
+    }
+}
+
+
+
+void TDStretch::clearMidBuffer()
+{
+    memset(pMidBuffer, 0, channels * sizeof(SAMPLETYPE) * overlapLength);
+}
+
+
+void TDStretch::clearInput()
+{
+    inputBuffer.clear();
+    clearMidBuffer();
+    isBeginning = true;
+    maxnorm = 0;
+    maxnormf = 1e8;
+    skipFract = 0;
+}
+
+
+// Clears the sample buffers
+void TDStretch::clear()
+{
+    outputBuffer.clear();
+    clearInput();
+}
+
+
+
+// Enables/disables the quick position seeking algorithm. Zero to disable, nonzero
+// to enable
+void TDStretch::enableQuickSeek(bool enable)
+{
+    bQuickSeek = enable;
+}
+
+
+// Returns nonzero if the quick seeking algorithm is enabled.
+bool TDStretch::isQuickSeekEnabled() const
+{
+    return bQuickSeek;
+}
+
+
+// Seeks for the optimal overlap-mixing position.
+int TDStretch::seekBestOverlapPosition(const SAMPLETYPE *refPos)
+{
+    if (bQuickSeek)
+    {
+        return seekBestOverlapPositionQuick(refPos);
+    }
+    else
+    {
+        return seekBestOverlapPositionFull(refPos);
+    }
+}
+
+
+// Overlaps samples in 'midBuffer' with the samples in 'pInputBuffer' at position
+// of 'ovlPos'.
+inline void TDStretch::overlap(SAMPLETYPE *pOutput, const SAMPLETYPE *pInput, uint ovlPos) const
+{
+#ifndef USE_MULTICH_ALWAYS
+    if (channels == 1)
+    {
+        // mono sound.
+        overlapMono(pOutput, pInput + ovlPos);
+    }
+    else if (channels == 2)
+    {
+        // stereo sound
+        overlapStereo(pOutput, pInput + 2 * ovlPos);
+    }
+    else
+#endif // USE_MULTICH_ALWAYS
+    {
+        assert(channels > 0);
+        overlapMulti(pOutput, pInput + channels * ovlPos);
+    }
+}
+
+
+// Seeks for the optimal overlap-mixing position. The 'stereo' version of the
+// routine
+//
+// The best position is determined as the position where the two overlapped
+// sample sequences are 'most alike', in terms of the highest cross-correlation
+// value over the overlapping period
+int TDStretch::seekBestOverlapPositionFull(const SAMPLETYPE *refPos)
+{
+    int bestOffs;
+    double bestCorr;
+    int i;
+    double norm;
+
+    bestCorr = -FLT_MAX;
+    bestOffs = 0;
+
+    // Scans for the best correlation value by testing each possible position
+    // over the permitted range.
+    bestCorr = calcCrossCorr(refPos, pMidBuffer, norm);
+    bestCorr = (bestCorr + 0.1) * 0.75;
+
+    #pragma omp parallel for
+    for (i = 1; i < seekLength; i ++)
+    {
+        double corr;
+        // Calculates correlation value for the mixing position corresponding to 'i'
+#if defined(_OPENMP) || defined(ST_SIMD_AVOID_UNALIGNED)
+        // in parallel OpenMP mode, can't use norm accumulator version as parallel executor won't
+        // iterate the loop in sequential order
+        // in SIMD mode, avoid accumulator version to allow avoiding unaligned positions
+        corr = calcCrossCorr(refPos + channels * i, pMidBuffer, norm);
+#else
+        // In non-parallel version call "calcCrossCorrAccumulate" that is otherwise same
+        // as "calcCrossCorr", but saves time by reusing & updating previously stored
+        // "norm" value
+        corr = calcCrossCorrAccumulate(refPos + channels * i, pMidBuffer, norm);
+#endif
+        // heuristic rule to slightly favour values close to mid of the range
+        double tmp = (double)(2 * i - seekLength) / (double)seekLength;
+        corr = ((corr + 0.1) * (1.0 - 0.25 * tmp * tmp));
+
+        // Checks for the highest correlation value
+        if (corr > bestCorr)
+        {
+            // For optimal performance, enter critical section only in case that best value found.
+            // in such case repeat 'if' condition as it's possible that parallel execution may have
+            // updated the bestCorr value in the mean time
+            #pragma omp critical
+            if (corr > bestCorr)
+            {
+                bestCorr = corr;
+                bestOffs = i;
+            }
+        }
+    }
+
+#ifdef SOUNDTOUCH_INTEGER_SAMPLES
+    adaptNormalizer();
+#endif
+
+    // clear cross correlation routine state if necessary (is so e.g. in MMX routines).
+    clearCrossCorrState();
+
+    return bestOffs;
+}
+
+
+// Quick seek algorithm for improved runtime-performance: First roughly scans through the
+// correlation area, and then scan surroundings of two best preliminary correlation candidates
+// with improved precision
+//
+// Based on testing:
+// - This algorithm gives on average 99% as good match as the full algorithm
+// - this quick seek algorithm finds the best match on ~90% of cases
+// - on those 10% of cases when this algorithm doesn't find best match,
+//   it still finds on average ~90% match vs. the best possible match
+int TDStretch::seekBestOverlapPositionQuick(const SAMPLETYPE *refPos)
+{
+#define _MIN(a, b)   (((a) < (b)) ? (a) : (b))
+#define SCANSTEP    16
+#define SCANWIND    8
+
+    int bestOffs;
+    int i;
+    int bestOffs2;
+    float bestCorr, corr;
+    float bestCorr2;
+    double norm;
+
+    // note: 'float' types used in this function in case that the platform would need to use software-fp
+
+    bestCorr =
+    bestCorr2 = -FLT_MAX;
+    bestOffs =
+    bestOffs2 = SCANWIND;
+
+    // Scans for the best correlation value by testing each possible position
+    // over the permitted range. Look for two best matches on the first pass to
+    // increase possibility of ideal match.
+    //
+    // Begin from "SCANSTEP" instead of SCANWIND to make the calculation
+    // catch the 'middlepoint' of seekLength vector as that's the a-priori
+    // expected best match position
+    //
+    // Roughly:
+    // - 15% of cases find best result directly on the first round,
+    // - 75% cases find better match on 2nd round around the best match from 1st round
+    // - 10% cases find better match on 2nd round around the 2nd-best-match from 1st round
+    for (i = SCANSTEP; i < seekLength - SCANWIND - 1; i += SCANSTEP)
+    {
+        // Calculates correlation value for the mixing position corresponding
+        // to 'i'
+        corr = (float)calcCrossCorr(refPos + channels*i, pMidBuffer, norm);
+        // heuristic rule to slightly favour values close to mid of the seek range
+        float tmp = (float)(2 * i - seekLength - 1) / (float)seekLength;
+        corr = ((corr + 0.1f) * (1.0f - 0.25f * tmp * tmp));
+
+        // Checks for the highest correlation value
+        if (corr > bestCorr)
+        {
+            // found new best match. keep the previous best as 2nd best match
+            bestCorr2 = bestCorr;
+            bestOffs2 = bestOffs;
+            bestCorr = corr;
+            bestOffs = i;
+        }
+        else if (corr > bestCorr2)
+        {
+            // not new best, but still new 2nd best match
+            bestCorr2 = corr;
+            bestOffs2 = i;
+        }
+    }
+
+    // Scans surroundings of the found best match with small stepping
+    int end = _MIN(bestOffs + SCANWIND + 1, seekLength);
+    for (i = bestOffs - SCANWIND; i < end; i++)
+    {
+        if (i == bestOffs) continue;    // this offset already calculated, thus skip
+
+        // Calculates correlation value for the mixing position corresponding
+        // to 'i'
+        corr = (float)calcCrossCorr(refPos + channels*i, pMidBuffer, norm);
+        // heuristic rule to slightly favour values close to mid of the range
+        float tmp = (float)(2 * i - seekLength - 1) / (float)seekLength;
+        corr = ((corr + 0.1f) * (1.0f - 0.25f * tmp * tmp));
+
+        // Checks for the highest correlation value
+        if (corr > bestCorr)
+        {
+            bestCorr = corr;
+            bestOffs = i;
+        }
+    }
+
+    // Scans surroundings of the 2nd best match with small stepping
+    end = _MIN(bestOffs2 + SCANWIND + 1, seekLength);
+    for (i = bestOffs2 - SCANWIND; i < end; i++)
+    {
+        if (i == bestOffs2) continue;    // this offset already calculated, thus skip
+
+        // Calculates correlation value for the mixing position corresponding
+        // to 'i'
+        corr = (float)calcCrossCorr(refPos + channels*i, pMidBuffer, norm);
+        // heuristic rule to slightly favour values close to mid of the range
+        float tmp = (float)(2 * i - seekLength - 1) / (float)seekLength;
+        corr = ((corr + 0.1f) * (1.0f - 0.25f * tmp * tmp));
+
+        // Checks for the highest correlation value
+        if (corr > bestCorr)
+        {
+            bestCorr = corr;
+            bestOffs = i;
+        }
+    }
+
+    // clear cross correlation routine state if necessary (is so e.g. in MMX routines).
+    clearCrossCorrState();
+
+#ifdef SOUNDTOUCH_INTEGER_SAMPLES
+    adaptNormalizer();
+#endif
+
+    return bestOffs;
+}
+
+
+
+
+/// For integer algorithm: adapt normalization factor divider with music so that
+/// it'll not be pessimistically restrictive that can degrade quality on quieter sections
+/// yet won't cause integer overflows either
+void TDStretch::adaptNormalizer()
+{
+    // Do not adapt normalizer over too silent sequences to avoid averaging filter depleting to
+    // too low values during pauses in music
+    if ((maxnorm > 1000) || (maxnormf > 40000000))
+    {
+        //norm averaging filter
+        maxnormf = 0.9f * maxnormf + 0.1f * (float)maxnorm;
+
+        if ((maxnorm > 800000000) && (overlapDividerBitsNorm < 16))
+        {
+            // large values, so increase divider
+            overlapDividerBitsNorm++;
+            if (maxnorm > 1600000000) overlapDividerBitsNorm++; // extra large value => extra increase
+        }
+        else if ((maxnormf < 1000000) && (overlapDividerBitsNorm > 0))
+        {
+            // extra small values, decrease divider
+            overlapDividerBitsNorm--;
+        }
+    }
+
+    maxnorm = 0;
+}
+
+
+/// clear cross correlation routine state if necessary
+void TDStretch::clearCrossCorrState()
+{
+    // default implementation is empty.
+}
+
+
+/// Calculates processing sequence length according to tempo setting
+void TDStretch::calcSeqParameters()
+{
+    // Adjust tempo param according to tempo, so that variating processing sequence length is used
+    // at various tempo settings, between the given low...top limits
+    #define AUTOSEQ_TEMPO_LOW   0.5     // auto setting low tempo range (-50%)
+    #define AUTOSEQ_TEMPO_TOP   2.0     // auto setting top tempo range (+100%)
+
+    // sequence-ms setting values at above low & top tempo
+    #define AUTOSEQ_AT_MIN      90.0
+    #define AUTOSEQ_AT_MAX      40.0
+    #define AUTOSEQ_K           ((AUTOSEQ_AT_MAX - AUTOSEQ_AT_MIN) / (AUTOSEQ_TEMPO_TOP - AUTOSEQ_TEMPO_LOW))
+    #define AUTOSEQ_C           (AUTOSEQ_AT_MIN - (AUTOSEQ_K) * (AUTOSEQ_TEMPO_LOW))
+
+    // seek-window-ms setting values at above low & top tempoq
+    #define AUTOSEEK_AT_MIN     20.0
+    #define AUTOSEEK_AT_MAX     15.0
+    #define AUTOSEEK_K          ((AUTOSEEK_AT_MAX - AUTOSEEK_AT_MIN) / (AUTOSEQ_TEMPO_TOP - AUTOSEQ_TEMPO_LOW))
+    #define AUTOSEEK_C          (AUTOSEEK_AT_MIN - (AUTOSEEK_K) * (AUTOSEQ_TEMPO_LOW))
+
+    #define CHECK_LIMITS(x, mi, ma) (((x) < (mi)) ? (mi) : (((x) > (ma)) ? (ma) : (x)))
+
+    double seq, seek;
+
+    if (bAutoSeqSetting)
+    {
+        seq = AUTOSEQ_C + AUTOSEQ_K * tempo;
+        seq = CHECK_LIMITS(seq, AUTOSEQ_AT_MAX, AUTOSEQ_AT_MIN);
+        sequenceMs = (int)(seq + 0.5);
+    }
+
+    if (bAutoSeekSetting)
+    {
+        seek = AUTOSEEK_C + AUTOSEEK_K * tempo;
+        seek = CHECK_LIMITS(seek, AUTOSEEK_AT_MAX, AUTOSEEK_AT_MIN);
+        seekWindowMs = (int)(seek + 0.5);
+    }
+
+    // Update seek window lengths
+    seekWindowLength = (sampleRate * sequenceMs) / 1000;
+    if (seekWindowLength < 2 * overlapLength)
+    {
+        seekWindowLength = 2 * overlapLength;
+    }
+    seekLength = (sampleRate * seekWindowMs) / 1000;
+}
+
+
+
+// Sets new target tempo. Normal tempo = 'SCALE', smaller values represent slower
+// tempo, larger faster tempo.
+void TDStretch::setTempo(double newTempo)
+{
+    int intskip;
+
+    tempo = newTempo;
+
+    // Calculate new sequence duration
+    calcSeqParameters();
+
+    // Calculate ideal skip length (according to tempo value)
+    nominalSkip = tempo * (seekWindowLength - overlapLength);
+    intskip = (int)(nominalSkip + 0.5);
+
+    // Calculate how many samples are needed in the 'inputBuffer' to
+    // process another batch of samples
+    //sampleReq = max(intskip + overlapLength, seekWindowLength) + seekLength / 2;
+    sampleReq = max(intskip + overlapLength, seekWindowLength) + seekLength;
+}
+
+
+
+// Sets the number of channels, 1 = mono, 2 = stereo
+void TDStretch::setChannels(int numChannels)
+{
+    if (!verifyNumberOfChannels(numChannels) ||
+        (channels == numChannels)) return;
+
+    channels = numChannels;
+    inputBuffer.setChannels(channels);
+    outputBuffer.setChannels(channels);
+
+    // re-init overlap/buffer
+    overlapLength=0;
+    setParameters(sampleRate);
+}
+
+
+// nominal tempo, no need for processing, just pass the samples through
+// to outputBuffer
+/*
+void TDStretch::processNominalTempo()
+{
+    assert(tempo == 1.0f);
+
+    if (bMidBufferDirty)
+    {
+        // If there are samples in pMidBuffer waiting for overlapping,
+        // do a single sliding overlapping with them in order to prevent a
+        // clicking distortion in the output sound
+        if (inputBuffer.numSamples() < overlapLength)
+        {
+            // wait until we've got overlapLength input samples
+            return;
+        }
+        // Mix the samples in the beginning of 'inputBuffer' with the
+        // samples in 'midBuffer' using sliding overlapping
+        overlap(outputBuffer.ptrEnd(overlapLength), inputBuffer.ptrBegin(), 0);
+        outputBuffer.putSamples(overlapLength);
+        inputBuffer.receiveSamples(overlapLength);
+        clearMidBuffer();
+        // now we've caught the nominal sample flow and may switch to
+        // bypass mode
+    }
+
+    // Simply bypass samples from input to output
+    outputBuffer.moveSamples(inputBuffer);
+}
+*/
+
+
+// Processes as many processing frames of the samples 'inputBuffer', store
+// the result into 'outputBuffer'
+void TDStretch::processSamples()
+{
+    int ovlSkip;
+    int offset = 0;
+    int temp;
+
+    /* Removed this small optimization - can introduce a click to sound when tempo setting
+       crosses the nominal value
+    if (tempo == 1.0f)
+    {
+        // tempo not changed from the original, so bypass the processing
+        processNominalTempo();
+        return;
+    }
+    */
+
+    // Process samples as long as there are enough samples in 'inputBuffer'
+    // to form a processing frame.
+    while ((int)inputBuffer.numSamples() >= sampleReq)
+    {
+        if (isBeginning == false)
+        {
+            // apart from the very beginning of the track,
+            // scan for the best overlapping position & do overlap-add
+            offset = seekBestOverlapPosition(inputBuffer.ptrBegin());
+
+            // Mix the samples in the 'inputBuffer' at position of 'offset' with the
+            // samples in 'midBuffer' using sliding overlapping
+            // ... first partially overlap with the end of the previous sequence
+            // (that's in 'midBuffer')
+            overlap(outputBuffer.ptrEnd((uint)overlapLength), inputBuffer.ptrBegin(), (uint)offset);
+            outputBuffer.putSamples((uint)overlapLength);
+            offset += overlapLength;
+        }
+        else
+        {
+            // Adjust processing offset at beginning of track by not perform initial overlapping
+            // and compensating that in the 'input buffer skip' calculation
+            isBeginning = false;
+            int skip = (int)(tempo * overlapLength + 0.5 * seekLength + 0.5);
+
+            #ifdef ST_SIMD_AVOID_UNALIGNED
+            // in SIMD mode, round the skip amount to value corresponding to aligned memory address
+            if (channels == 1)
+            {
+                skip &= -4;
+            }
+            else if (channels == 2)
+            {
+                skip &= -2;
+            }
+            #endif
+            skipFract -= skip;
+            if (skipFract <= -nominalSkip)
+            {
+                skipFract = -nominalSkip;
+            }
+        }
+
+        // ... then copy sequence samples from 'inputBuffer' to output:
+
+        // crosscheck that we don't have buffer overflow...
+        if ((int)inputBuffer.numSamples() < (offset + seekWindowLength - overlapLength))
+        {
+            continue;    // just in case, shouldn't really happen
+        }
+
+        // length of sequence
+        temp = (seekWindowLength - 2 * overlapLength);
+        outputBuffer.putSamples(inputBuffer.ptrBegin() + channels * offset, (uint)temp);
+
+        // Copies the end of the current sequence from 'inputBuffer' to
+        // 'midBuffer' for being mixed with the beginning of the next
+        // processing sequence and so on
+        assert((offset + temp + overlapLength) <= (int)inputBuffer.numSamples());
+        memcpy(pMidBuffer, inputBuffer.ptrBegin() + channels * (offset + temp),
+            channels * sizeof(SAMPLETYPE) * overlapLength);
+
+        // Remove the processed samples from the input buffer. Update
+        // the difference between integer & nominal skip step to 'skipFract'
+        // in order to prevent the error from accumulating over time.
+        skipFract += nominalSkip;   // real skip size
+        ovlSkip = (int)skipFract;   // rounded to integer skip
+        skipFract -= ovlSkip;       // maintain the fraction part, i.e. real vs. integer skip
+        inputBuffer.receiveSamples((uint)ovlSkip);
+    }
+}
+
+
+// Adds 'numsamples' pcs of samples from the 'samples' memory position into
+// the input of the object.
+void TDStretch::putSamples(const SAMPLETYPE *samples, uint nSamples)
+{
+    // Add the samples into the input buffer
+    inputBuffer.putSamples(samples, nSamples);
+    // Process the samples in input buffer
+    processSamples();
+}
+
+
+
+/// Set new overlap length parameter & reallocate RefMidBuffer if necessary.
+void TDStretch::acceptNewOverlapLength(int newOverlapLength)
+{
+    int prevOvl;
+
+    assert(newOverlapLength >= 0);
+    prevOvl = overlapLength;
+    overlapLength = newOverlapLength;
+
+    if (overlapLength > prevOvl)
+    {
+        delete[] pMidBufferUnaligned;
+
+        pMidBufferUnaligned = new SAMPLETYPE[overlapLength * channels + 16 / sizeof(SAMPLETYPE)];
+        // ensure that 'pMidBuffer' is aligned to 16 byte boundary for efficiency
+        pMidBuffer = (SAMPLETYPE *)SOUNDTOUCH_ALIGN_POINTER_16(pMidBufferUnaligned);
+
+        clearMidBuffer();
+    }
+}
+
+
+// Operator 'new' is overloaded so that it automatically creates a suitable instance
+// depending on if we've a MMX/SSE/etc-capable CPU available or not.
+void * TDStretch::operator new(size_t)
+{
+    // Notice! don't use "new TDStretch" directly, use "newInstance" to create a new instance instead!
+    ST_THROW_RT_ERROR("Error in TDStretch::new: Don't use 'new TDStretch' directly, use 'newInstance' member instead!");
+    return newInstance();
+}
+
+
+TDStretch * TDStretch::newInstance()
+{
+    uint uExtensions;
+
+    uExtensions = detectCPUextensions();
+    (void)uExtensions;
+
+    // Check if MMX/SSE instruction set extensions supported by CPU
+
+#ifdef SOUNDTOUCH_ALLOW_MMX
+    // MMX routines available only with integer sample types
+    if (uExtensions & SUPPORT_MMX)
+    {
+        return ::new TDStretchMMX;
+    }
+    else
+#endif // SOUNDTOUCH_ALLOW_MMX
+
+
+#ifdef SOUNDTOUCH_ALLOW_SSE
+    if (uExtensions & SUPPORT_SSE)
+    {
+        // SSE support
+        return ::new TDStretchSSE;
+    }
+    else
+#endif // SOUNDTOUCH_ALLOW_SSE
+
+    {
+        // ISA optimizations not supported, use plain C version
+        return ::new TDStretch;
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Integer arithmetic specific algorithm implementations.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifdef SOUNDTOUCH_INTEGER_SAMPLES
+
+// Overlaps samples in 'midBuffer' with the samples in 'input'. The 'Stereo'
+// version of the routine.
+void TDStretch::overlapStereo(short *poutput, const short *input) const
+{
+    int i;
+    short temp;
+    int cnt2;
+
+    for (i = 0; i < overlapLength ; i ++)
+    {
+        temp = (short)(overlapLength - i);
+        cnt2 = 2 * i;
+        poutput[cnt2] = (input[cnt2] * i + pMidBuffer[cnt2] * temp )  / overlapLength;
+        poutput[cnt2 + 1] = (input[cnt2 + 1] * i + pMidBuffer[cnt2 + 1] * temp ) / overlapLength;
+    }
+}
+
+
+// Overlaps samples in 'midBuffer' with the samples in 'input'. The 'Multi'
+// version of the routine.
+void TDStretch::overlapMulti(short *poutput, const short *input) const
+{
+    short m1;
+    int i = 0;
+
+    for (m1 = 0; m1 < overlapLength; m1 ++)
+    {
+        short m2 = (short)(overlapLength - m1);
+        for (int c = 0; c < channels; c ++)
+        {
+            poutput[i] = (input[i] * m1 + pMidBuffer[i] * m2)  / overlapLength;
+            i++;
+        }
+    }
+}
+
+// Calculates the x having the closest 2^x value for the given value
+static int _getClosest2Power(double value)
+{
+    return (int)(log(value) / log(2.0) + 0.5);
+}
+
+
+/// Calculates overlap period length in samples.
+/// Integer version rounds overlap length to closest power of 2
+/// for a divide scaling operation.
+void TDStretch::calculateOverlapLength(int aoverlapMs)
+{
+    int newOvl;
+
+    assert(aoverlapMs >= 0);
+
+    // calculate overlap length so that it's power of 2 - thus it's easy to do
+    // integer division by right-shifting. Term "-1" at end is to account for
+    // the extra most significatnt bit left unused in result by signed multiplication
+    overlapDividerBitsPure = _getClosest2Power((sampleRate * aoverlapMs) / 1000.0) - 1;
+    if (overlapDividerBitsPure > 9) overlapDividerBitsPure = 9;
+    if (overlapDividerBitsPure < 3) overlapDividerBitsPure = 3;
+    newOvl = (int)pow(2.0, (int)overlapDividerBitsPure + 1);    // +1 => account for -1 above
+
+    acceptNewOverlapLength(newOvl);
+
+    overlapDividerBitsNorm = overlapDividerBitsPure;
+
+    // calculate sloping divider so that crosscorrelation operation won't
+    // overflow 32-bit register. Max. sum of the crosscorrelation sum without
+    // divider would be 2^30*(N^3-N)/3, where N = overlap length
+    slopingDivider = (newOvl * newOvl - 1) / 3;
+}
+
+
+double TDStretch::calcCrossCorr(const short *mixingPos, const short *compare, double &norm)
+{
+    long corr;
+    unsigned long lnorm;
+    int i;
+
+    #ifdef ST_SIMD_AVOID_UNALIGNED
+        // in SIMD mode skip 'mixingPos' positions that aren't aligned to 16-byte boundary
+        if (((ulongptr)mixingPos) & 15) return -1e50;
+    #endif
+
+    // hint compiler autovectorization that loop length is divisible by 8
+    int ilength = (channels * overlapLength) & -8;
+
+    corr = lnorm = 0;
+    // Same routine for stereo and mono
+    for (i = 0; i < ilength; i += 2)
+    {
+        corr += (mixingPos[i] * compare[i] +
+                 mixingPos[i + 1] * compare[i + 1]) >> overlapDividerBitsNorm;
+        lnorm += (mixingPos[i] * mixingPos[i] +
+                  mixingPos[i + 1] * mixingPos[i + 1]) >> overlapDividerBitsNorm;
+        // do intermediate scalings to avoid integer overflow
+    }
+
+    if (lnorm > maxnorm)
+    {
+        // modify 'maxnorm' inside critical section to avoid multi-access conflict if in OpenMP mode
+        #pragma omp critical
+        if (lnorm > maxnorm)
+        {
+            maxnorm = lnorm;
+        }
+    }
+    // Normalize result by dividing by sqrt(norm) - this step is easiest
+    // done using floating point operation
+    norm = (double)lnorm;
+    return (double)corr / sqrt((norm < 1e-9) ? 1.0 : norm);
+}
+
+
+/// Update cross-correlation by accumulating "norm" coefficient by previously calculated value
+double TDStretch::calcCrossCorrAccumulate(const short *mixingPos, const short *compare, double &norm)
+{
+    long corr;
+    long lnorm;
+    int i;
+
+    // hint compiler autovectorization that loop length is divisible by 8
+    int ilength = (channels * overlapLength) & -8;
+
+    // cancel first normalizer tap from previous round
+    lnorm = 0;
+    for (i = 1; i <= channels; i ++)
+    {
+        lnorm -= (mixingPos[-i] * mixingPos[-i]) >> overlapDividerBitsNorm;
+    }
+
+    corr = 0;
+    // Same routine for stereo and mono.
+    for (i = 0; i < ilength; i += 2)
+    {
+        corr += (mixingPos[i] * compare[i] +
+                 mixingPos[i + 1] * compare[i + 1]) >> overlapDividerBitsNorm;
+    }
+
+    // update normalizer with last samples of this round
+    for (int j = 0; j < channels; j ++)
+    {
+        i --;
+        lnorm += (mixingPos[i] * mixingPos[i]) >> overlapDividerBitsNorm;
+    }
+
+    norm += (double)lnorm;
+    if (norm > maxnorm)
+    {
+        maxnorm = (unsigned long)norm;
+    }
+
+    // Normalize result by dividing by sqrt(norm) - this step is easiest
+    // done using floating point operation
+    return (double)corr / sqrt((norm < 1e-9) ? 1.0 : norm);
+}
+
+#endif // SOUNDTOUCH_INTEGER_SAMPLES
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Floating point arithmetic specific algorithm implementations.
+//
+
+#ifdef SOUNDTOUCH_FLOAT_SAMPLES
+
+// Overlaps samples in 'midBuffer' with the samples in 'pInput'
+void TDStretch::overlapStereo(float *pOutput, const float *pInput) const
+{
+    int i;
+    float fScale;
+    float f1;
+    float f2;
+
+    fScale = 1.0f / (float)overlapLength;
+
+    f1 = 0;
+    f2 = 1.0f;
+
+    for (i = 0; i < 2 * (int)overlapLength ; i += 2)
+    {
+        pOutput[i + 0] = pInput[i + 0] * f1 + pMidBuffer[i + 0] * f2;
+        pOutput[i + 1] = pInput[i + 1] * f1 + pMidBuffer[i + 1] * f2;
+
+        f1 += fScale;
+        f2 -= fScale;
+    }
+}
+
+
+// Overlaps samples in 'midBuffer' with the samples in 'input'.
+void TDStretch::overlapMulti(float *pOutput, const float *pInput) const
+{
+    int i;
+    float fScale;
+    float f1;
+    float f2;
+
+    fScale = 1.0f / (float)overlapLength;
+
+    f1 = 0;
+    f2 = 1.0f;
+
+    i=0;
+    for (int i2 = 0; i2 < overlapLength; i2 ++)
+    {
+        // note: Could optimize this slightly by taking into account that always channels > 2
+        for (int c = 0; c < channels; c ++)
+        {
+            pOutput[i] = pInput[i] * f1 + pMidBuffer[i] * f2;
+            i++;
+        }
+        f1 += fScale;
+        f2 -= fScale;
+    }
+}
+
+
+/// Calculates overlapInMsec period length in samples.
+void TDStretch::calculateOverlapLength(int overlapInMsec)
+{
+    int newOvl;
+
+    assert(overlapInMsec >= 0);
+    newOvl = (sampleRate * overlapInMsec) / 1000;
+    if (newOvl < 16) newOvl = 16;
+
+    // must be divisible by 8
+    newOvl -= newOvl % 8;
+
+    acceptNewOverlapLength(newOvl);
+}
+
+
+/// Calculate cross-correlation
+double TDStretch::calcCrossCorr(const float *mixingPos, const float *compare, double &anorm)
+{
+    float corr;
+    float norm;
+    int i;
+
+    #ifdef ST_SIMD_AVOID_UNALIGNED
+        // in SIMD mode skip 'mixingPos' positions that aren't aligned to 16-byte boundary
+        if (((ulongptr)mixingPos) & 15) return -1e50;
+    #endif
+
+    // hint compiler autovectorization that loop length is divisible by 8
+    int ilength = (channels * overlapLength) & -8;
+
+    corr = norm = 0;
+    // Same routine for stereo and mono
+    for (i = 0; i < ilength; i ++)
+    {
+        corr += mixingPos[i] * compare[i];
+        norm += mixingPos[i] * mixingPos[i];
+    }
+
+    anorm = norm;
+    return corr / sqrt((norm < 1e-9 ? 1.0 : norm));
+}
+
+
+/// Update cross-correlation by accumulating "norm" coefficient by previously calculated value
+double TDStretch::calcCrossCorrAccumulate(const float *mixingPos, const float *compare, double &norm)
+{
+    float corr;
+    int i;
+
+    corr = 0;
+
+    // cancel first normalizer tap from previous round
+    for (i = 1; i <= channels; i ++)
+    {
+        norm -= mixingPos[-i] * mixingPos[-i];
+    }
+
+    // hint compiler autovectorization that loop length is divisible by 8
+    int ilength = (channels * overlapLength) & -8;
+
+    // Same routine for stereo and mono
+    for (i = 0; i < ilength; i ++)
+    {
+        corr += mixingPos[i] * compare[i];
+    }
+
+    // update normalizer with last samples of this round
+    for (int j = 0; j < channels; j ++)
+    {
+        i --;
+        norm += mixingPos[i] * mixingPos[i];
+    }
+
+    return corr / sqrt((norm < 1e-9 ? 1.0 : norm));
+}
+
+
+#endif // SOUNDTOUCH_FLOAT_SAMPLES
diff --git a/source/SoundTouch/TDStretch.h b/source/SoundTouch/TDStretch.h
index 6fddc23..483dd53 100644
--- a/source/SoundTouch/TDStretch.h
+++ b/source/SoundTouch/TDStretch.h
@@ -1,279 +1,279 @@
-////////////////////////////////////////////////////////////////////////////////
-/// 
-/// Sampled sound tempo changer/time stretch algorithm. Changes the sound tempo 
-/// while maintaining the original pitch by using a time domain WSOLA-like method 
-/// with several performance-increasing tweaks.
-///
-/// Note : MMX/SSE optimized functions reside in separate, platform-specific files 
-/// 'mmx_optimized.cpp' and 'sse_optimized.cpp'
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef TDStretch_H
-#define TDStretch_H
-
-#include 
-#include "STTypes.h"
-#include "RateTransposer.h"
-#include "FIFOSamplePipe.h"
-
-namespace soundtouch
-{
-
-/// Default values for sound processing parameters:
-/// Notice that the default parameters are tuned for contemporary popular music 
-/// processing. For speech processing applications these parameters suit better:
-///     #define DEFAULT_SEQUENCE_MS     40
-///     #define DEFAULT_SEEKWINDOW_MS   15
-///     #define DEFAULT_OVERLAP_MS      8
-///
-
-/// Default length of a single processing sequence, in milliseconds. This determines to how 
-/// long sequences the original sound is chopped in the time-stretch algorithm.
-///
-/// The larger this value is, the lesser sequences are used in processing. In principle
-/// a bigger value sounds better when slowing down tempo, but worse when increasing tempo
-/// and vice versa.
-///
-/// Increasing this value reduces computational burden & vice versa.
-//#define DEFAULT_SEQUENCE_MS         40
-#define DEFAULT_SEQUENCE_MS         USE_AUTO_SEQUENCE_LEN
-
-/// Giving this value for the sequence length sets automatic parameter value
-/// according to tempo setting (recommended)
-#define USE_AUTO_SEQUENCE_LEN       0
-
-/// Seeking window default length in milliseconds for algorithm that finds the best possible 
-/// overlapping location. This determines from how wide window the algorithm may look for an 
-/// optimal joining location when mixing the sound sequences back together. 
-///
-/// The bigger this window setting is, the higher the possibility to find a better mixing
-/// position will become, but at the same time large values may cause a "drifting" artifact
-/// because consequent sequences will be taken at more uneven intervals.
-///
-/// If there's a disturbing artifact that sounds as if a constant frequency was drifting 
-/// around, try reducing this setting.
-///
-/// Increasing this value increases computational burden & vice versa.
-//#define DEFAULT_SEEKWINDOW_MS       15
-#define DEFAULT_SEEKWINDOW_MS       USE_AUTO_SEEKWINDOW_LEN
-
-/// Giving this value for the seek window length sets automatic parameter value
-/// according to tempo setting (recommended)
-#define USE_AUTO_SEEKWINDOW_LEN     0
-
-/// Overlap length in milliseconds. When the chopped sound sequences are mixed back together, 
-/// to form a continuous sound stream, this parameter defines over how long period the two 
-/// consecutive sequences are let to overlap each other. 
-///
-/// This shouldn't be that critical parameter. If you reduce the DEFAULT_SEQUENCE_MS setting 
-/// by a large amount, you might wish to try a smaller value on this.
-///
-/// Increasing this value increases computational burden & vice versa.
-#define DEFAULT_OVERLAP_MS      8
-
-
-/// Class that does the time-stretch (tempo change) effect for the processed
-/// sound.
-class TDStretch : public FIFOProcessor
-{
-protected:
-    int channels;
-    int sampleReq;
-
-    int overlapLength;
-    int seekLength;
-    int seekWindowLength;
-    int overlapDividerBitsNorm;
-    int overlapDividerBitsPure;
-    int slopingDivider;
-    int sampleRate;
-    int sequenceMs;
-    int seekWindowMs;
-    int overlapMs;
-
-    unsigned long maxnorm;
-    float maxnormf;
-
-    double tempo;
-    double nominalSkip;
-    double skipFract;
-
-    bool bQuickSeek;
-    bool bAutoSeqSetting;
-    bool bAutoSeekSetting;
-    bool isBeginning;
-
-    SAMPLETYPE *pMidBuffer;
-    SAMPLETYPE *pMidBufferUnaligned;
-
-    FIFOSampleBuffer outputBuffer;
-    FIFOSampleBuffer inputBuffer;
-
-    void acceptNewOverlapLength(int newOverlapLength);
-
-    virtual void clearCrossCorrState();
-    void calculateOverlapLength(int overlapMs);
-
-    virtual double calcCrossCorr(const SAMPLETYPE *mixingPos, const SAMPLETYPE *compare, double &norm);
-    virtual double calcCrossCorrAccumulate(const SAMPLETYPE *mixingPos, const SAMPLETYPE *compare, double &norm);
-
-    virtual int seekBestOverlapPositionFull(const SAMPLETYPE *refPos);
-    virtual int seekBestOverlapPositionQuick(const SAMPLETYPE *refPos);
-    virtual int seekBestOverlapPosition(const SAMPLETYPE *refPos);
-
-    virtual void overlapStereo(SAMPLETYPE *output, const SAMPLETYPE *input) const;
-    virtual void overlapMono(SAMPLETYPE *output, const SAMPLETYPE *input) const;
-    virtual void overlapMulti(SAMPLETYPE *output, const SAMPLETYPE *input) const;
-
-    void clearMidBuffer();
-    void overlap(SAMPLETYPE *output, const SAMPLETYPE *input, uint ovlPos) const;
-
-    void calcSeqParameters();
-    void adaptNormalizer();
-
-    /// Changes the tempo of the given sound samples.
-    /// Returns amount of samples returned in the "output" buffer.
-    /// The maximum amount of samples that can be returned at a time is set by
-    /// the 'set_returnBuffer_size' function.
-    void processSamples();
-    
-public:
-    TDStretch();
-    virtual ~TDStretch() override;
-
-    /// Operator 'new' is overloaded so that it automatically creates a suitable instance 
-    /// depending on if we've a MMX/SSE/etc-capable CPU available or not.
-    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 feature set depending on if the CPU
-    /// supports MMX/SSE/etc extensions.
-    static TDStretch *newInstance();
-    
-    /// Returns the output buffer object
-    FIFOSamplePipe *getOutput() { return &outputBuffer; };
-
-    /// Returns the input buffer object
-    FIFOSamplePipe *getInput() { return &inputBuffer; };
-
-    /// Sets new target tempo. Normal tempo = 'SCALE', smaller values represent slower 
-    /// tempo, larger faster tempo.
-    void setTempo(double newTempo);
-
-    /// Returns nonzero if there aren't any samples available for outputting.
-    virtual void clear() override;
-
-    /// Clears the input buffer
-    void clearInput();
-
-    /// Sets the number of channels, 1 = mono, 2 = stereo
-    void setChannels(int numChannels);
-
-    /// Enables/disables the quick position seeking algorithm. Zero to disable, 
-    /// nonzero to enable
-    void enableQuickSeek(bool enable);
-
-    /// Returns nonzero if the quick seeking algorithm is enabled.
-    bool isQuickSeekEnabled() const;
-
-    /// Sets routine control parameters. These control are certain time constants
-    /// defining how the sound is stretched to the desired duration.
-    //
-    /// 'sampleRate' = sample rate of the sound
-    /// 'sequenceMS' = one processing sequence length in milliseconds
-    /// 'seekwindowMS' = seeking window length for scanning the best overlapping 
-    ///      position
-    /// 'overlapMS' = overlapping length
-    void setParameters(int sampleRate,          ///< Samplerate of sound being processed (Hz)
-                       int sequenceMS = -1,     ///< Single processing sequence length (ms)
-                       int seekwindowMS = -1,   ///< Offset seeking window length (ms)
-                       int overlapMS = -1       ///< Sequence overlapping length (ms)
-                       );
-
-    /// Get routine control parameters, see setParameters() function.
-    /// Any of the parameters to this function can be nullptr, in such case corresponding parameter
-    /// value isn't returned.
-    void getParameters(int *pSampleRate, int *pSequenceMs, int *pSeekWindowMs, int *pOverlapMs) const;
-
-    /// Adds 'numsamples' pcs of samples from the 'samples' memory position into
-    /// the input of the object.
-    virtual void putSamples(
-            const SAMPLETYPE *samples,  ///< Input sample data
-            uint numSamples                         ///< Number of samples in 'samples' so that one sample
-                                                    ///< contains both channels if stereo
-            ) override;
-
-    /// return nominal input sample requirement for triggering a processing batch
-    int getInputSampleReq() const
-    {
-        return (int)(nominalSkip + 0.5);
-    }
-
-    /// return nominal output sample amount when running a processing batch
-    int getOutputBatchSize() const
-    {
-        return seekWindowLength - overlapLength;
-    }
-
-	/// return approximate initial input-output latency
-	int getLatency() const
-	{
-		return sampleReq;
-	}
-};
-
-
-// Implementation-specific class declarations:
-
-#ifdef SOUNDTOUCH_ALLOW_MMX
-    /// Class that implements MMX optimized routines for 16bit integer samples type.
-    class TDStretchMMX : public TDStretch
-    {
-    protected:
-        double calcCrossCorr(const short *mixingPos, const short *compare, double &norm) override;
-        double calcCrossCorrAccumulate(const short *mixingPos, const short *compare, double &norm) override;
-        virtual void overlapStereo(short *output, const short *input) const override;
-        virtual void clearCrossCorrState() override;
-    };
-#endif /// SOUNDTOUCH_ALLOW_MMX
-
-
-#ifdef SOUNDTOUCH_ALLOW_SSE
-    /// Class that implements SSE optimized routines for floating point samples type.
-    class TDStretchSSE : public TDStretch
-    {
-    protected:
-        double calcCrossCorr(const float *mixingPos, const float *compare, double &norm) override;
-        double calcCrossCorrAccumulate(const float *mixingPos, const float *compare, double &norm) override;
-    };
-
-#endif /// SOUNDTOUCH_ALLOW_SSE
-
-}
-#endif  /// TDStretch_H
+////////////////////////////////////////////////////////////////////////////////
+///
+/// Sampled sound tempo changer/time stretch algorithm. Changes the sound tempo
+/// while maintaining the original pitch by using a time domain WSOLA-like method
+/// with several performance-increasing tweaks.
+///
+/// Note : MMX/SSE optimized functions reside in separate, platform-specific files
+/// 'mmx_optimized.cpp' and 'sse_optimized.cpp'
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef TDStretch_H
+#define TDStretch_H
+
+#include 
+#include "STTypes.h"
+#include "RateTransposer.h"
+#include "FIFOSamplePipe.h"
+
+namespace soundtouch
+{
+
+/// Default values for sound processing parameters:
+/// Notice that the default parameters are tuned for contemporary popular music
+/// processing. For speech processing applications these parameters suit better:
+///     #define DEFAULT_SEQUENCE_MS     40
+///     #define DEFAULT_SEEKWINDOW_MS   15
+///     #define DEFAULT_OVERLAP_MS      8
+///
+
+/// Default length of a single processing sequence, in milliseconds. This determines to how
+/// long sequences the original sound is chopped in the time-stretch algorithm.
+///
+/// The larger this value is, the lesser sequences are used in processing. In principle
+/// a bigger value sounds better when slowing down tempo, but worse when increasing tempo
+/// and vice versa.
+///
+/// Increasing this value reduces computational burden & vice versa.
+//#define DEFAULT_SEQUENCE_MS         40
+#define DEFAULT_SEQUENCE_MS         USE_AUTO_SEQUENCE_LEN
+
+/// Giving this value for the sequence length sets automatic parameter value
+/// according to tempo setting (recommended)
+#define USE_AUTO_SEQUENCE_LEN       0
+
+/// Seeking window default length in milliseconds for algorithm that finds the best possible
+/// overlapping location. This determines from how wide window the algorithm may look for an
+/// optimal joining location when mixing the sound sequences back together.
+///
+/// The bigger this window setting is, the higher the possibility to find a better mixing
+/// position will become, but at the same time large values may cause a "drifting" artifact
+/// because consequent sequences will be taken at more uneven intervals.
+///
+/// If there's a disturbing artifact that sounds as if a constant frequency was drifting
+/// around, try reducing this setting.
+///
+/// Increasing this value increases computational burden & vice versa.
+//#define DEFAULT_SEEKWINDOW_MS       15
+#define DEFAULT_SEEKWINDOW_MS       USE_AUTO_SEEKWINDOW_LEN
+
+/// Giving this value for the seek window length sets automatic parameter value
+/// according to tempo setting (recommended)
+#define USE_AUTO_SEEKWINDOW_LEN     0
+
+/// Overlap length in milliseconds. When the chopped sound sequences are mixed back together,
+/// to form a continuous sound stream, this parameter defines over how long period the two
+/// consecutive sequences are let to overlap each other.
+///
+/// This shouldn't be that critical parameter. If you reduce the DEFAULT_SEQUENCE_MS setting
+/// by a large amount, you might wish to try a smaller value on this.
+///
+/// Increasing this value increases computational burden & vice versa.
+#define DEFAULT_OVERLAP_MS      8
+
+
+/// Class that does the time-stretch (tempo change) effect for the processed
+/// sound.
+class TDStretch : public FIFOProcessor
+{
+protected:
+    int channels;
+    int sampleReq;
+
+    int overlapLength;
+    int seekLength;
+    int seekWindowLength;
+    int overlapDividerBitsNorm;
+    int overlapDividerBitsPure;
+    int slopingDivider;
+    int sampleRate;
+    int sequenceMs;
+    int seekWindowMs;
+    int overlapMs;
+
+    unsigned long maxnorm;
+    float maxnormf;
+
+    double tempo;
+    double nominalSkip;
+    double skipFract;
+
+    bool bQuickSeek;
+    bool bAutoSeqSetting;
+    bool bAutoSeekSetting;
+    bool isBeginning;
+
+    SAMPLETYPE *pMidBuffer;
+    SAMPLETYPE *pMidBufferUnaligned;
+
+    FIFOSampleBuffer outputBuffer;
+    FIFOSampleBuffer inputBuffer;
+
+    void acceptNewOverlapLength(int newOverlapLength);
+
+    virtual void clearCrossCorrState();
+    void calculateOverlapLength(int overlapMs);
+
+    virtual double calcCrossCorr(const SAMPLETYPE *mixingPos, const SAMPLETYPE *compare, double &norm);
+    virtual double calcCrossCorrAccumulate(const SAMPLETYPE *mixingPos, const SAMPLETYPE *compare, double &norm);
+
+    virtual int seekBestOverlapPositionFull(const SAMPLETYPE *refPos);
+    virtual int seekBestOverlapPositionQuick(const SAMPLETYPE *refPos);
+    virtual int seekBestOverlapPosition(const SAMPLETYPE *refPos);
+
+    virtual void overlapStereo(SAMPLETYPE *output, const SAMPLETYPE *input) const;
+    virtual void overlapMono(SAMPLETYPE *output, const SAMPLETYPE *input) const;
+    virtual void overlapMulti(SAMPLETYPE *output, const SAMPLETYPE *input) const;
+
+    void clearMidBuffer();
+    void overlap(SAMPLETYPE *output, const SAMPLETYPE *input, uint ovlPos) const;
+
+    void calcSeqParameters();
+    void adaptNormalizer();
+
+    /// Changes the tempo of the given sound samples.
+    /// Returns amount of samples returned in the "output" buffer.
+    /// The maximum amount of samples that can be returned at a time is set by
+    /// the 'set_returnBuffer_size' function.
+    void processSamples();
+
+public:
+    TDStretch();
+    virtual ~TDStretch() override;
+
+    /// Operator 'new' is overloaded so that it automatically creates a suitable instance
+    /// depending on if we've a MMX/SSE/etc-capable CPU available or not.
+    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 feature set depending on if the CPU
+    /// supports MMX/SSE/etc extensions.
+    static TDStretch *newInstance();
+
+    /// Returns the output buffer object
+    FIFOSamplePipe *getOutput() { return &outputBuffer; };
+
+    /// Returns the input buffer object
+    FIFOSamplePipe *getInput() { return &inputBuffer; };
+
+    /// Sets new target tempo. Normal tempo = 'SCALE', smaller values represent slower
+    /// tempo, larger faster tempo.
+    void setTempo(double newTempo);
+
+    /// Returns nonzero if there aren't any samples available for outputting.
+    virtual void clear() override;
+
+    /// Clears the input buffer
+    void clearInput();
+
+    /// Sets the number of channels, 1 = mono, 2 = stereo
+    void setChannels(int numChannels);
+
+    /// Enables/disables the quick position seeking algorithm. Zero to disable,
+    /// nonzero to enable
+    void enableQuickSeek(bool enable);
+
+    /// Returns nonzero if the quick seeking algorithm is enabled.
+    bool isQuickSeekEnabled() const;
+
+    /// Sets routine control parameters. These control are certain time constants
+    /// defining how the sound is stretched to the desired duration.
+    //
+    /// 'sampleRate' = sample rate of the sound
+    /// 'sequenceMS' = one processing sequence length in milliseconds
+    /// 'seekwindowMS' = seeking window length for scanning the best overlapping
+    ///      position
+    /// 'overlapMS' = overlapping length
+    void setParameters(int sampleRate,          ///< Samplerate of sound being processed (Hz)
+                       int sequenceMS = -1,     ///< Single processing sequence length (ms)
+                       int seekwindowMS = -1,   ///< Offset seeking window length (ms)
+                       int overlapMS = -1       ///< Sequence overlapping length (ms)
+                       );
+
+    /// Get routine control parameters, see setParameters() function.
+    /// Any of the parameters to this function can be nullptr, in such case corresponding parameter
+    /// value isn't returned.
+    void getParameters(int *pSampleRate, int *pSequenceMs, int *pSeekWindowMs, int *pOverlapMs) const;
+
+    /// Adds 'numsamples' pcs of samples from the 'samples' memory position into
+    /// the input of the object.
+    virtual void putSamples(
+            const SAMPLETYPE *samples,  ///< Input sample data
+            uint numSamples                         ///< Number of samples in 'samples' so that one sample
+                                                    ///< contains both channels if stereo
+            ) override;
+
+    /// return nominal input sample requirement for triggering a processing batch
+    int getInputSampleReq() const
+    {
+        return (int)(nominalSkip + 0.5);
+    }
+
+    /// return nominal output sample amount when running a processing batch
+    int getOutputBatchSize() const
+    {
+        return seekWindowLength - overlapLength;
+    }
+
+	/// return approximate initial input-output latency
+	int getLatency() const
+	{
+		return sampleReq;
+	}
+};
+
+
+// Implementation-specific class declarations:
+
+#ifdef SOUNDTOUCH_ALLOW_MMX
+    /// Class that implements MMX optimized routines for 16bit integer samples type.
+    class TDStretchMMX : public TDStretch
+    {
+    protected:
+        double calcCrossCorr(const short *mixingPos, const short *compare, double &norm) override;
+        double calcCrossCorrAccumulate(const short *mixingPos, const short *compare, double &norm) override;
+        virtual void overlapStereo(short *output, const short *input) const override;
+        virtual void clearCrossCorrState() override;
+    };
+#endif /// SOUNDTOUCH_ALLOW_MMX
+
+
+#ifdef SOUNDTOUCH_ALLOW_SSE
+    /// Class that implements SSE optimized routines for floating point samples type.
+    class TDStretchSSE : public TDStretch
+    {
+    protected:
+        double calcCrossCorr(const float *mixingPos, const float *compare, double &norm) override;
+        double calcCrossCorrAccumulate(const float *mixingPos, const float *compare, double &norm) override;
+    };
+
+#endif /// SOUNDTOUCH_ALLOW_SSE
+
+}
+#endif  /// TDStretch_H
diff --git a/source/SoundTouch/cpu_detect.h b/source/SoundTouch/cpu_detect.h
index 0cdc223..0794c44 100644
--- a/source/SoundTouch/cpu_detect.h
+++ b/source/SoundTouch/cpu_detect.h
@@ -1,55 +1,55 @@
-////////////////////////////////////////////////////////////////////////////////
-///
-/// A header file for detecting the Intel MMX instructions set extension.
-///
-/// Please see 'mmx_win.cpp', 'mmx_cpp.cpp' and 'mmx_non_x86.cpp' for the 
-/// routine implementations for x86 Windows, x86 gnu version and non-x86 
-/// platforms, respectively.
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef _CPU_DETECT_H_
-#define _CPU_DETECT_H_
-
-#include "STTypes.h"
-
-#define SUPPORT_MMX         0x0001
-#define SUPPORT_3DNOW       0x0002
-#define SUPPORT_ALTIVEC     0x0004
-#define SUPPORT_SSE         0x0008
-#define SUPPORT_SSE2        0x0010
-
-/// Checks which instruction set extensions are supported by the CPU.
-///
-/// \return A bitmask of supported extensions, see SUPPORT_... defines.
-uint detectCPUextensions(void);
-
-/// Disables given set of instruction extensions. See SUPPORT_... defines.
-void disableExtensions(uint wDisableMask);
-
-#endif  // _CPU_DETECT_H_
+////////////////////////////////////////////////////////////////////////////////
+///
+/// A header file for detecting the Intel MMX instructions set extension.
+///
+/// Please see 'mmx_win.cpp', 'mmx_cpp.cpp' and 'mmx_non_x86.cpp' for the
+/// routine implementations for x86 Windows, x86 gnu version and non-x86
+/// platforms, respectively.
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef _CPU_DETECT_H_
+#define _CPU_DETECT_H_
+
+#include "STTypes.h"
+
+#define SUPPORT_MMX         0x0001
+#define SUPPORT_3DNOW       0x0002
+#define SUPPORT_ALTIVEC     0x0004
+#define SUPPORT_SSE         0x0008
+#define SUPPORT_SSE2        0x0010
+
+/// Checks which instruction set extensions are supported by the CPU.
+///
+/// \return A bitmask of supported extensions, see SUPPORT_... defines.
+uint detectCPUextensions(void);
+
+/// Disables given set of instruction extensions. See SUPPORT_... defines.
+void disableExtensions(uint wDisableMask);
+
+#endif  // _CPU_DETECT_H_
diff --git a/source/SoundTouch/cpu_detect_x86.cpp b/source/SoundTouch/cpu_detect_x86.cpp
index b128610..18d88e9 100644
--- a/source/SoundTouch/cpu_detect_x86.cpp
+++ b/source/SoundTouch/cpu_detect_x86.cpp
@@ -1,130 +1,130 @@
-////////////////////////////////////////////////////////////////////////////////
-///
-/// Generic version of the x86 CPU extension detection routine.
-///
-/// This file is for GNU & other non-Windows compilers, see 'cpu_detect_x86_win.cpp' 
-/// for the Microsoft compiler version.
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include "cpu_detect.h"
-#include "STTypes.h"
-
-
-#if defined(SOUNDTOUCH_ALLOW_X86_OPTIMIZATIONS)
-
-   #if defined(__GNUC__) && defined(__i386__)
-       // gcc
-       #include "cpuid.h"
-   #elif defined(_M_IX86)
-       // windows non-gcc
-       #include 
-   #endif
-
-   #define bit_MMX     (1 << 23)
-   #define bit_SSE     (1 << 25)
-   #define bit_SSE2    (1 << 26)
-#endif
-
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// processor instructions extension detection routines
-//
-//////////////////////////////////////////////////////////////////////////////
-
-// Flag variable indicating whick ISA extensions are disabled (for debugging)
-static uint _dwDisabledISA = 0x00;      // 0xffffffff; //<- use this to disable all extensions
-
-// Disables given set of instruction extensions. See SUPPORT_... defines.
-void disableExtensions(uint dwDisableMask)
-{
-    _dwDisabledISA = dwDisableMask;
-}
-
-
-/// Checks which instruction set extensions are supported by the CPU.
-uint detectCPUextensions(void)
-{
-/// If building for a 64bit system (no Itanium) and the user wants optimizations.
-/// Return the OR of SUPPORT_{MMX,SSE,SSE2}. 11001 or 0x19.
-/// Keep the _dwDisabledISA test (2 more operations, could be eliminated).
-#if ((defined(__GNUC__) && defined(__x86_64__)) \
-    || defined(_M_X64))  \
-    && defined(SOUNDTOUCH_ALLOW_X86_OPTIMIZATIONS)
-    return 0x19 & ~_dwDisabledISA;
-
-/// If building for a 32bit system and the user wants optimizations.
-/// Keep the _dwDisabledISA test (2 more operations, could be eliminated).
-#elif ((defined(__GNUC__) && defined(__i386__)) \
-    || defined(_M_IX86))  \
-    && defined(SOUNDTOUCH_ALLOW_X86_OPTIMIZATIONS)
-
-    if (_dwDisabledISA == 0xffffffff) return 0;
- 
-    uint res = 0;
- 
-#if defined(__GNUC__)
-    // GCC version of cpuid. Requires GCC 4.3.0 or later for __cpuid intrinsic support.
-    uint eax, ebx, ecx, edx;  // unsigned int is the standard type. uint is defined by the compiler and not guaranteed to be portable.
-
-    // Check if no cpuid support.
-    if (!__get_cpuid (1, &eax, &ebx, &ecx, &edx)) return 0; // always disable extensions.
-
-    if (edx & bit_MMX)  res = res | SUPPORT_MMX;
-    if (edx & bit_SSE)  res = res | SUPPORT_SSE;
-    if (edx & bit_SSE2) res = res | SUPPORT_SSE2;
-
-#else
-    // Window / VS version of cpuid. Notice that Visual Studio 2005 or later required 
-    // for __cpuid intrinsic support.
-    int reg[4] = {-1};
-
-    // Check if no cpuid support.
-    __cpuid(reg,0);
-    if ((unsigned int)reg[0] == 0) return 0; // always disable extensions.
-
-    __cpuid(reg,1);
-    if ((unsigned int)reg[3] & bit_MMX)  res = res | SUPPORT_MMX;
-    if ((unsigned int)reg[3] & bit_SSE)  res = res | SUPPORT_SSE;
-    if ((unsigned int)reg[3] & bit_SSE2) res = res | SUPPORT_SSE2;
-
-#endif
-
-    return res & ~_dwDisabledISA;
-
-#else
-
-/// One of these is true:
-/// 1) We don't want optimizations.
-/// 2) Using an unsupported compiler.
-/// 3) Running on a non-x86 platform.
-    return 0;
-
-#endif
-}
+////////////////////////////////////////////////////////////////////////////////
+///
+/// Generic version of the x86 CPU extension detection routine.
+///
+/// This file is for GNU & other non-Windows compilers, see 'cpu_detect_x86_win.cpp'
+/// for the Microsoft compiler version.
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#include "cpu_detect.h"
+#include "STTypes.h"
+
+
+#if defined(SOUNDTOUCH_ALLOW_X86_OPTIMIZATIONS)
+
+   #if defined(__GNUC__) && defined(__i386__)
+       // gcc
+       #include "cpuid.h"
+   #elif defined(_M_IX86)
+       // windows non-gcc
+       #include 
+   #endif
+
+   #define bit_MMX     (1 << 23)
+   #define bit_SSE     (1 << 25)
+   #define bit_SSE2    (1 << 26)
+#endif
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// processor instructions extension detection routines
+//
+//////////////////////////////////////////////////////////////////////////////
+
+// Flag variable indicating whick ISA extensions are disabled (for debugging)
+static uint _dwDisabledISA = 0x00;      // 0xffffffff; //<- use this to disable all extensions
+
+// Disables given set of instruction extensions. See SUPPORT_... defines.
+void disableExtensions(uint dwDisableMask)
+{
+    _dwDisabledISA = dwDisableMask;
+}
+
+
+/// Checks which instruction set extensions are supported by the CPU.
+uint detectCPUextensions(void)
+{
+/// If building for a 64bit system (no Itanium) and the user wants optimizations.
+/// Return the OR of SUPPORT_{MMX,SSE,SSE2}. 11001 or 0x19.
+/// Keep the _dwDisabledISA test (2 more operations, could be eliminated).
+#if ((defined(__GNUC__) && defined(__x86_64__)) \
+    || defined(_M_X64))  \
+    && defined(SOUNDTOUCH_ALLOW_X86_OPTIMIZATIONS)
+    return 0x19 & ~_dwDisabledISA;
+
+/// If building for a 32bit system and the user wants optimizations.
+/// Keep the _dwDisabledISA test (2 more operations, could be eliminated).
+#elif ((defined(__GNUC__) && defined(__i386__)) \
+    || defined(_M_IX86))  \
+    && defined(SOUNDTOUCH_ALLOW_X86_OPTIMIZATIONS)
+
+    if (_dwDisabledISA == 0xffffffff) return 0;
+
+    uint res = 0;
+
+#if defined(__GNUC__)
+    // GCC version of cpuid. Requires GCC 4.3.0 or later for __cpuid intrinsic support.
+    uint eax, ebx, ecx, edx;  // unsigned int is the standard type. uint is defined by the compiler and not guaranteed to be portable.
+
+    // Check if no cpuid support.
+    if (!__get_cpuid (1, &eax, &ebx, &ecx, &edx)) return 0; // always disable extensions.
+
+    if (edx & bit_MMX)  res = res | SUPPORT_MMX;
+    if (edx & bit_SSE)  res = res | SUPPORT_SSE;
+    if (edx & bit_SSE2) res = res | SUPPORT_SSE2;
+
+#else
+    // Window / VS version of cpuid. Notice that Visual Studio 2005 or later required
+    // for __cpuid intrinsic support.
+    int reg[4] = {-1};
+
+    // Check if no cpuid support.
+    __cpuid(reg,0);
+    if ((unsigned int)reg[0] == 0) return 0; // always disable extensions.
+
+    __cpuid(reg,1);
+    if ((unsigned int)reg[3] & bit_MMX)  res = res | SUPPORT_MMX;
+    if ((unsigned int)reg[3] & bit_SSE)  res = res | SUPPORT_SSE;
+    if ((unsigned int)reg[3] & bit_SSE2) res = res | SUPPORT_SSE2;
+
+#endif
+
+    return res & ~_dwDisabledISA;
+
+#else
+
+/// One of these is true:
+/// 1) We don't want optimizations.
+/// 2) Using an unsupported compiler.
+/// 3) Running on a non-x86 platform.
+    return 0;
+
+#endif
+}
diff --git a/source/SoundTouch/mmx_optimized.cpp b/source/SoundTouch/mmx_optimized.cpp
index 0a2949c..2fdeeac 100644
--- a/source/SoundTouch/mmx_optimized.cpp
+++ b/source/SoundTouch/mmx_optimized.cpp
@@ -1,396 +1,396 @@
-////////////////////////////////////////////////////////////////////////////////
-///
-/// MMX optimized routines. All MMX optimized functions have been gathered into 
-/// this single source code file, regardless to their class or original source 
-/// code file, in order to ease porting the library to other compiler and 
-/// processor platforms.
-///
-/// The MMX-optimizations are programmed using MMX compiler intrinsics that
-/// are supported both by Microsoft Visual C++ and GCC compilers, so this file
-/// should compile with both toolsets.
-///
-/// NOTICE: If using Visual Studio 6.0, you'll need to install the "Visual C++ 
-/// 6.0 processor pack" update to support compiler intrinsic syntax. The update
-/// is available for download at Microsoft Developers Network, see here:
-/// http://msdn.microsoft.com/en-us/vstudio/aa718349.aspx
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include "STTypes.h"
-
-#ifdef SOUNDTOUCH_ALLOW_MMX
-// MMX routines available only with integer sample type
-
-using namespace soundtouch;
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// implementation of MMX optimized functions of class 'TDStretchMMX'
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#include "TDStretch.h"
-#include 
-#include 
-#include 
-
-
-// Calculates cross correlation of two buffers
-double TDStretchMMX::calcCrossCorr(const short *pV1, const short *pV2, double &dnorm)
-{
-    const __m64 *pVec1, *pVec2;
-    __m64 shifter;
-    __m64 accu, normaccu;
-    long corr, norm;
-    int i;
-   
-    pVec1 = (__m64*)pV1;
-    pVec2 = (__m64*)pV2;
-
-    shifter = _m_from_int(overlapDividerBitsNorm);
-    normaccu = accu = _mm_setzero_si64();
-
-    // Process 4 parallel sets of 2 * stereo samples or 4 * mono samples 
-    // during each round for improved CPU-level parallellization.
-    for (i = 0; i < channels * overlapLength / 16; i ++)
-    {
-        __m64 temp, temp2;
-
-        // dictionary of instructions:
-        // _m_pmaddwd   : 4*16bit multiply-add, resulting two 32bits = [a0*b0+a1*b1 ; a2*b2+a3*b3]
-        // _mm_add_pi32 : 2*32bit add
-        // _m_psrad     : 32bit right-shift
-
-        temp = _mm_add_pi32(_mm_sra_pi32(_mm_madd_pi16(pVec1[0], pVec2[0]), shifter),
-                            _mm_sra_pi32(_mm_madd_pi16(pVec1[1], pVec2[1]), shifter));
-        temp2 = _mm_add_pi32(_mm_sra_pi32(_mm_madd_pi16(pVec1[0], pVec1[0]), shifter),
-                            _mm_sra_pi32(_mm_madd_pi16(pVec1[1], pVec1[1]), shifter));
-        accu = _mm_add_pi32(accu, temp);
-        normaccu = _mm_add_pi32(normaccu, temp2);
-
-        temp = _mm_add_pi32(_mm_sra_pi32(_mm_madd_pi16(pVec1[2], pVec2[2]), shifter),
-                            _mm_sra_pi32(_mm_madd_pi16(pVec1[3], pVec2[3]), shifter));
-        temp2 = _mm_add_pi32(_mm_sra_pi32(_mm_madd_pi16(pVec1[2], pVec1[2]), shifter),
-                            _mm_sra_pi32(_mm_madd_pi16(pVec1[3], pVec1[3]), shifter));
-        accu = _mm_add_pi32(accu, temp);
-        normaccu = _mm_add_pi32(normaccu, temp2);
-
-        pVec1 += 4;
-        pVec2 += 4;
-    }
-
-    // copy hi-dword of mm0 to lo-dword of mm1, then sum mmo+mm1
-    // and finally store the result into the variable "corr"
-
-    accu = _mm_add_pi32(accu, _mm_srli_si64(accu, 32));
-    corr = _m_to_int(accu);
-
-    normaccu = _mm_add_pi32(normaccu, _mm_srli_si64(normaccu, 32));
-    norm = _m_to_int(normaccu);
-
-    // Clear MMS state
-    _m_empty();
-
-    if (norm > (long)maxnorm)
-    {
-        // modify 'maxnorm' inside critical section to avoid multi-access conflict if in OpenMP mode
-        #pragma omp critical
-        if (norm > (long)maxnorm)
-        {
-            maxnorm = norm;
-        }
-    }
-
-    // Normalize result by dividing by sqrt(norm) - this step is easiest 
-    // done using floating point operation
-    dnorm = (double)norm;
-
-    return (double)corr / sqrt(dnorm < 1e-9 ? 1.0 : dnorm);
-    // Note: Warning about the missing EMMS instruction is harmless
-    // as it'll be called elsewhere.
-}
-
-
-/// Update cross-correlation by accumulating "norm" coefficient by previously calculated value
-double TDStretchMMX::calcCrossCorrAccumulate(const short *pV1, const short *pV2, double &dnorm)
-{
-    const __m64 *pVec1, *pVec2;
-    __m64 shifter;
-    __m64 accu;
-    long corr, lnorm;
-    int i;
-   
-    // cancel first normalizer tap from previous round
-    lnorm = 0;
-    for (i = 1; i <= channels; i ++)
-    {
-        lnorm -= (pV1[-i] * pV1[-i]) >> overlapDividerBitsNorm;
-    }
-
-    pVec1 = (__m64*)pV1;
-    pVec2 = (__m64*)pV2;
-
-    shifter = _m_from_int(overlapDividerBitsNorm);
-    accu = _mm_setzero_si64();
-
-    // Process 4 parallel sets of 2 * stereo samples or 4 * mono samples 
-    // during each round for improved CPU-level parallellization.
-    for (i = 0; i < channels * overlapLength / 16; i ++)
-    {
-        __m64 temp;
-
-        // dictionary of instructions:
-        // _m_pmaddwd   : 4*16bit multiply-add, resulting two 32bits = [a0*b0+a1*b1 ; a2*b2+a3*b3]
-        // _mm_add_pi32 : 2*32bit add
-        // _m_psrad     : 32bit right-shift
-
-        temp = _mm_add_pi32(_mm_sra_pi32(_mm_madd_pi16(pVec1[0], pVec2[0]), shifter),
-                            _mm_sra_pi32(_mm_madd_pi16(pVec1[1], pVec2[1]), shifter));
-        accu = _mm_add_pi32(accu, temp);
-
-        temp = _mm_add_pi32(_mm_sra_pi32(_mm_madd_pi16(pVec1[2], pVec2[2]), shifter),
-                            _mm_sra_pi32(_mm_madd_pi16(pVec1[3], pVec2[3]), shifter));
-        accu = _mm_add_pi32(accu, temp);
-
-        pVec1 += 4;
-        pVec2 += 4;
-    }
-
-    // copy hi-dword of mm0 to lo-dword of mm1, then sum mmo+mm1
-    // and finally store the result into the variable "corr"
-
-    accu = _mm_add_pi32(accu, _mm_srli_si64(accu, 32));
-    corr = _m_to_int(accu);
-
-    // Clear MMS state
-    _m_empty();
-
-    // update normalizer with last samples of this round
-    pV1 = (short *)pVec1;
-    for (int j = 1; j <= channels; j ++)
-    {
-        lnorm += (pV1[-j] * pV1[-j]) >> overlapDividerBitsNorm;
-    }
-    dnorm += (double)lnorm;
-
-    if (lnorm > (long)maxnorm)
-    {
-        maxnorm = lnorm;
-    }
-
-    // Normalize result by dividing by sqrt(norm) - this step is easiest 
-    // done using floating point operation
-    return (double)corr / sqrt((dnorm < 1e-9) ? 1.0 : dnorm);
-}
-
-
-void TDStretchMMX::clearCrossCorrState()
-{
-    // Clear MMS state
-    _m_empty();
-    //_asm EMMS;
-}
-
-
-// MMX-optimized version of the function overlapStereo
-void TDStretchMMX::overlapStereo(short *output, const short *input) const
-{
-    const __m64 *pVinput, *pVMidBuf;
-    __m64 *pVdest;
-    __m64 mix1, mix2, adder, shifter;
-    int i;
-
-    pVinput  = (const __m64*)input;
-    pVMidBuf = (const __m64*)pMidBuffer;
-    pVdest   = (__m64*)output;
-
-    // mix1  = mixer values for 1st stereo sample
-    // mix1  = mixer values for 2nd stereo sample
-    // adder = adder for updating mixer values after each round
-    
-    mix1  = _mm_set_pi16(0, overlapLength,   0, overlapLength);
-    adder = _mm_set_pi16(1, -1, 1, -1);
-    mix2  = _mm_add_pi16(mix1, adder);
-    adder = _mm_add_pi16(adder, adder);
-
-    // Overlaplength-division by shifter. "+1" is to account for "-1" deduced in
-    // overlapDividerBits calculation earlier.
-    shifter = _m_from_int(overlapDividerBitsPure + 1);
-
-    for (i = 0; i < overlapLength / 4; i ++)
-    {
-        __m64 temp1, temp2;
-                
-        // load & shuffle data so that input & mixbuffer data samples are paired
-        temp1 = _mm_unpacklo_pi16(pVMidBuf[0], pVinput[0]);     // = i0l m0l i0r m0r
-        temp2 = _mm_unpackhi_pi16(pVMidBuf[0], pVinput[0]);     // = i1l m1l i1r m1r
-
-        // temp = (temp .* mix) >> shifter
-        temp1 = _mm_sra_pi32(_mm_madd_pi16(temp1, mix1), shifter);
-        temp2 = _mm_sra_pi32(_mm_madd_pi16(temp2, mix2), shifter);
-        pVdest[0] = _mm_packs_pi32(temp1, temp2); // pack 2*2*32bit => 4*16bit
-
-        // update mix += adder
-        mix1 = _mm_add_pi16(mix1, adder);
-        mix2 = _mm_add_pi16(mix2, adder);
-
-        // --- second round begins here ---
-
-        // load & shuffle data so that input & mixbuffer data samples are paired
-        temp1 = _mm_unpacklo_pi16(pVMidBuf[1], pVinput[1]);       // = i2l m2l i2r m2r
-        temp2 = _mm_unpackhi_pi16(pVMidBuf[1], pVinput[1]);       // = i3l m3l i3r m3r
-
-        // temp = (temp .* mix) >> shifter
-        temp1 = _mm_sra_pi32(_mm_madd_pi16(temp1, mix1), shifter);
-        temp2 = _mm_sra_pi32(_mm_madd_pi16(temp2, mix2), shifter);
-        pVdest[1] = _mm_packs_pi32(temp1, temp2); // pack 2*2*32bit => 4*16bit
-
-        // update mix += adder
-        mix1 = _mm_add_pi16(mix1, adder);
-        mix2 = _mm_add_pi16(mix2, adder);
-
-        pVinput  += 2;
-        pVMidBuf += 2;
-        pVdest   += 2;
-    }
-
-    _m_empty(); // clear MMS state
-}
-
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// implementation of MMX optimized functions of class 'FIRFilter'
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#include "FIRFilter.h"
-
-
-FIRFilterMMX::FIRFilterMMX() : FIRFilter()
-{
-    filterCoeffsAlign = nullptr;
-    filterCoeffsUnalign = nullptr;
-}
-
-
-FIRFilterMMX::~FIRFilterMMX()
-{
-    delete[] filterCoeffsUnalign;
-}
-
-
-// (overloaded) Calculates filter coefficients for MMX routine
-void FIRFilterMMX::setCoefficients(const short *coeffs, uint newLength, uint uResultDivFactor)
-{
-    uint i;
-    FIRFilter::setCoefficients(coeffs, newLength, uResultDivFactor);
-
-    // Ensure that filter coeffs array is aligned to 16-byte boundary
-    delete[] filterCoeffsUnalign;
-    filterCoeffsUnalign = new short[2 * newLength + 8];
-    filterCoeffsAlign = (short *)SOUNDTOUCH_ALIGN_POINTER_16(filterCoeffsUnalign);
-
-    // rearrange the filter coefficients for mmx routines 
-    for (i = 0;i < length; i += 4) 
-    {
-        filterCoeffsAlign[2 * i + 0] = coeffs[i + 0];
-        filterCoeffsAlign[2 * i + 1] = coeffs[i + 2];
-        filterCoeffsAlign[2 * i + 2] = coeffs[i + 0];
-        filterCoeffsAlign[2 * i + 3] = coeffs[i + 2];
-
-        filterCoeffsAlign[2 * i + 4] = coeffs[i + 1];
-        filterCoeffsAlign[2 * i + 5] = coeffs[i + 3];
-        filterCoeffsAlign[2 * i + 6] = coeffs[i + 1];
-        filterCoeffsAlign[2 * i + 7] = coeffs[i + 3];
-    }
-}
-
-
-// mmx-optimized version of the filter routine for stereo sound
-uint FIRFilterMMX::evaluateFilterStereo(short *dest, const short *src, uint numSamples) const
-{
-    // Create stack copies of the needed member variables for asm routines :
-    uint i, j;
-    __m64 *pVdest = (__m64*)dest;
-
-    if (length < 2) return 0;
-
-    for (i = 0; i < (numSamples - length) / 2; i ++)
-    {
-        __m64 accu1;
-        __m64 accu2;
-        const __m64 *pVsrc = (const __m64*)src;
-        const __m64 *pVfilter = (const __m64*)filterCoeffsAlign;
-
-        accu1 = accu2 = _mm_setzero_si64();
-        for (j = 0; j < lengthDiv8 * 2; j ++)
-        {
-            __m64 temp1, temp2;
-
-            temp1 = _mm_unpacklo_pi16(pVsrc[0], pVsrc[1]);  // = l2 l0 r2 r0
-            temp2 = _mm_unpackhi_pi16(pVsrc[0], pVsrc[1]);  // = l3 l1 r3 r1
-
-            accu1 = _mm_add_pi32(accu1, _mm_madd_pi16(temp1, pVfilter[0]));  // += l2*f2+l0*f0 r2*f2+r0*f0
-            accu1 = _mm_add_pi32(accu1, _mm_madd_pi16(temp2, pVfilter[1]));  // += l3*f3+l1*f1 r3*f3+r1*f1
-
-            temp1 = _mm_unpacklo_pi16(pVsrc[1], pVsrc[2]);  // = l4 l2 r4 r2
-
-            accu2 = _mm_add_pi32(accu2, _mm_madd_pi16(temp2, pVfilter[0]));  // += l3*f2+l1*f0 r3*f2+r1*f0
-            accu2 = _mm_add_pi32(accu2, _mm_madd_pi16(temp1, pVfilter[1]));  // += l4*f3+l2*f1 r4*f3+r2*f1
-
-            // accu1 += l2*f2+l0*f0 r2*f2+r0*f0
-            //       += l3*f3+l1*f1 r3*f3+r1*f1
-
-            // accu2 += l3*f2+l1*f0 r3*f2+r1*f0
-            //          l4*f3+l2*f1 r4*f3+r2*f1
-
-            pVfilter += 2;
-            pVsrc += 2;
-        }
-        // accu >>= resultDivFactor
-        accu1 = _mm_srai_pi32(accu1, resultDivFactor);
-        accu2 = _mm_srai_pi32(accu2, resultDivFactor);
-
-        // pack 2*2*32bits => 4*16 bits
-        pVdest[0] = _mm_packs_pi32(accu1, accu2);
-        src += 4;
-        pVdest ++;
-    }
-
-   _m_empty();  // clear emms state
-
-    return (numSamples & 0xfffffffe) - length;
-}
-
-#else
-
-// workaround to not complain about empty module
-bool _dontcomplain_mmx_empty;
-
-#endif  // SOUNDTOUCH_ALLOW_MMX
+////////////////////////////////////////////////////////////////////////////////
+///
+/// MMX optimized routines. All MMX optimized functions have been gathered into
+/// this single source code file, regardless to their class or original source
+/// code file, in order to ease porting the library to other compiler and
+/// processor platforms.
+///
+/// The MMX-optimizations are programmed using MMX compiler intrinsics that
+/// are supported both by Microsoft Visual C++ and GCC compilers, so this file
+/// should compile with both toolsets.
+///
+/// NOTICE: If using Visual Studio 6.0, you'll need to install the "Visual C++
+/// 6.0 processor pack" update to support compiler intrinsic syntax. The update
+/// is available for download at Microsoft Developers Network, see here:
+/// http://msdn.microsoft.com/en-us/vstudio/aa718349.aspx
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#include "STTypes.h"
+
+#ifdef SOUNDTOUCH_ALLOW_MMX
+// MMX routines available only with integer sample type
+
+using namespace soundtouch;
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// implementation of MMX optimized functions of class 'TDStretchMMX'
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include "TDStretch.h"
+#include 
+#include 
+#include 
+
+
+// Calculates cross correlation of two buffers
+double TDStretchMMX::calcCrossCorr(const short *pV1, const short *pV2, double &dnorm)
+{
+    const __m64 *pVec1, *pVec2;
+    __m64 shifter;
+    __m64 accu, normaccu;
+    long corr, norm;
+    int i;
+
+    pVec1 = (__m64*)pV1;
+    pVec2 = (__m64*)pV2;
+
+    shifter = _m_from_int(overlapDividerBitsNorm);
+    normaccu = accu = _mm_setzero_si64();
+
+    // Process 4 parallel sets of 2 * stereo samples or 4 * mono samples
+    // during each round for improved CPU-level parallellization.
+    for (i = 0; i < channels * overlapLength / 16; i ++)
+    {
+        __m64 temp, temp2;
+
+        // dictionary of instructions:
+        // _m_pmaddwd   : 4*16bit multiply-add, resulting two 32bits = [a0*b0+a1*b1 ; a2*b2+a3*b3]
+        // _mm_add_pi32 : 2*32bit add
+        // _m_psrad     : 32bit right-shift
+
+        temp = _mm_add_pi32(_mm_sra_pi32(_mm_madd_pi16(pVec1[0], pVec2[0]), shifter),
+                            _mm_sra_pi32(_mm_madd_pi16(pVec1[1], pVec2[1]), shifter));
+        temp2 = _mm_add_pi32(_mm_sra_pi32(_mm_madd_pi16(pVec1[0], pVec1[0]), shifter),
+                            _mm_sra_pi32(_mm_madd_pi16(pVec1[1], pVec1[1]), shifter));
+        accu = _mm_add_pi32(accu, temp);
+        normaccu = _mm_add_pi32(normaccu, temp2);
+
+        temp = _mm_add_pi32(_mm_sra_pi32(_mm_madd_pi16(pVec1[2], pVec2[2]), shifter),
+                            _mm_sra_pi32(_mm_madd_pi16(pVec1[3], pVec2[3]), shifter));
+        temp2 = _mm_add_pi32(_mm_sra_pi32(_mm_madd_pi16(pVec1[2], pVec1[2]), shifter),
+                            _mm_sra_pi32(_mm_madd_pi16(pVec1[3], pVec1[3]), shifter));
+        accu = _mm_add_pi32(accu, temp);
+        normaccu = _mm_add_pi32(normaccu, temp2);
+
+        pVec1 += 4;
+        pVec2 += 4;
+    }
+
+    // copy hi-dword of mm0 to lo-dword of mm1, then sum mmo+mm1
+    // and finally store the result into the variable "corr"
+
+    accu = _mm_add_pi32(accu, _mm_srli_si64(accu, 32));
+    corr = _m_to_int(accu);
+
+    normaccu = _mm_add_pi32(normaccu, _mm_srli_si64(normaccu, 32));
+    norm = _m_to_int(normaccu);
+
+    // Clear MMS state
+    _m_empty();
+
+    if (norm > (long)maxnorm)
+    {
+        // modify 'maxnorm' inside critical section to avoid multi-access conflict if in OpenMP mode
+        #pragma omp critical
+        if (norm > (long)maxnorm)
+        {
+            maxnorm = norm;
+        }
+    }
+
+    // Normalize result by dividing by sqrt(norm) - this step is easiest
+    // done using floating point operation
+    dnorm = (double)norm;
+
+    return (double)corr / sqrt(dnorm < 1e-9 ? 1.0 : dnorm);
+    // Note: Warning about the missing EMMS instruction is harmless
+    // as it'll be called elsewhere.
+}
+
+
+/// Update cross-correlation by accumulating "norm" coefficient by previously calculated value
+double TDStretchMMX::calcCrossCorrAccumulate(const short *pV1, const short *pV2, double &dnorm)
+{
+    const __m64 *pVec1, *pVec2;
+    __m64 shifter;
+    __m64 accu;
+    long corr, lnorm;
+    int i;
+
+    // cancel first normalizer tap from previous round
+    lnorm = 0;
+    for (i = 1; i <= channels; i ++)
+    {
+        lnorm -= (pV1[-i] * pV1[-i]) >> overlapDividerBitsNorm;
+    }
+
+    pVec1 = (__m64*)pV1;
+    pVec2 = (__m64*)pV2;
+
+    shifter = _m_from_int(overlapDividerBitsNorm);
+    accu = _mm_setzero_si64();
+
+    // Process 4 parallel sets of 2 * stereo samples or 4 * mono samples
+    // during each round for improved CPU-level parallellization.
+    for (i = 0; i < channels * overlapLength / 16; i ++)
+    {
+        __m64 temp;
+
+        // dictionary of instructions:
+        // _m_pmaddwd   : 4*16bit multiply-add, resulting two 32bits = [a0*b0+a1*b1 ; a2*b2+a3*b3]
+        // _mm_add_pi32 : 2*32bit add
+        // _m_psrad     : 32bit right-shift
+
+        temp = _mm_add_pi32(_mm_sra_pi32(_mm_madd_pi16(pVec1[0], pVec2[0]), shifter),
+                            _mm_sra_pi32(_mm_madd_pi16(pVec1[1], pVec2[1]), shifter));
+        accu = _mm_add_pi32(accu, temp);
+
+        temp = _mm_add_pi32(_mm_sra_pi32(_mm_madd_pi16(pVec1[2], pVec2[2]), shifter),
+                            _mm_sra_pi32(_mm_madd_pi16(pVec1[3], pVec2[3]), shifter));
+        accu = _mm_add_pi32(accu, temp);
+
+        pVec1 += 4;
+        pVec2 += 4;
+    }
+
+    // copy hi-dword of mm0 to lo-dword of mm1, then sum mmo+mm1
+    // and finally store the result into the variable "corr"
+
+    accu = _mm_add_pi32(accu, _mm_srli_si64(accu, 32));
+    corr = _m_to_int(accu);
+
+    // Clear MMS state
+    _m_empty();
+
+    // update normalizer with last samples of this round
+    pV1 = (short *)pVec1;
+    for (int j = 1; j <= channels; j ++)
+    {
+        lnorm += (pV1[-j] * pV1[-j]) >> overlapDividerBitsNorm;
+    }
+    dnorm += (double)lnorm;
+
+    if (lnorm > (long)maxnorm)
+    {
+        maxnorm = lnorm;
+    }
+
+    // Normalize result by dividing by sqrt(norm) - this step is easiest
+    // done using floating point operation
+    return (double)corr / sqrt((dnorm < 1e-9) ? 1.0 : dnorm);
+}
+
+
+void TDStretchMMX::clearCrossCorrState()
+{
+    // Clear MMS state
+    _m_empty();
+    //_asm EMMS;
+}
+
+
+// MMX-optimized version of the function overlapStereo
+void TDStretchMMX::overlapStereo(short *output, const short *input) const
+{
+    const __m64 *pVinput, *pVMidBuf;
+    __m64 *pVdest;
+    __m64 mix1, mix2, adder, shifter;
+    int i;
+
+    pVinput  = (const __m64*)input;
+    pVMidBuf = (const __m64*)pMidBuffer;
+    pVdest   = (__m64*)output;
+
+    // mix1  = mixer values for 1st stereo sample
+    // mix1  = mixer values for 2nd stereo sample
+    // adder = adder for updating mixer values after each round
+
+    mix1  = _mm_set_pi16(0, overlapLength,   0, overlapLength);
+    adder = _mm_set_pi16(1, -1, 1, -1);
+    mix2  = _mm_add_pi16(mix1, adder);
+    adder = _mm_add_pi16(adder, adder);
+
+    // Overlaplength-division by shifter. "+1" is to account for "-1" deduced in
+    // overlapDividerBits calculation earlier.
+    shifter = _m_from_int(overlapDividerBitsPure + 1);
+
+    for (i = 0; i < overlapLength / 4; i ++)
+    {
+        __m64 temp1, temp2;
+
+        // load & shuffle data so that input & mixbuffer data samples are paired
+        temp1 = _mm_unpacklo_pi16(pVMidBuf[0], pVinput[0]);     // = i0l m0l i0r m0r
+        temp2 = _mm_unpackhi_pi16(pVMidBuf[0], pVinput[0]);     // = i1l m1l i1r m1r
+
+        // temp = (temp .* mix) >> shifter
+        temp1 = _mm_sra_pi32(_mm_madd_pi16(temp1, mix1), shifter);
+        temp2 = _mm_sra_pi32(_mm_madd_pi16(temp2, mix2), shifter);
+        pVdest[0] = _mm_packs_pi32(temp1, temp2); // pack 2*2*32bit => 4*16bit
+
+        // update mix += adder
+        mix1 = _mm_add_pi16(mix1, adder);
+        mix2 = _mm_add_pi16(mix2, adder);
+
+        // --- second round begins here ---
+
+        // load & shuffle data so that input & mixbuffer data samples are paired
+        temp1 = _mm_unpacklo_pi16(pVMidBuf[1], pVinput[1]);       // = i2l m2l i2r m2r
+        temp2 = _mm_unpackhi_pi16(pVMidBuf[1], pVinput[1]);       // = i3l m3l i3r m3r
+
+        // temp = (temp .* mix) >> shifter
+        temp1 = _mm_sra_pi32(_mm_madd_pi16(temp1, mix1), shifter);
+        temp2 = _mm_sra_pi32(_mm_madd_pi16(temp2, mix2), shifter);
+        pVdest[1] = _mm_packs_pi32(temp1, temp2); // pack 2*2*32bit => 4*16bit
+
+        // update mix += adder
+        mix1 = _mm_add_pi16(mix1, adder);
+        mix2 = _mm_add_pi16(mix2, adder);
+
+        pVinput  += 2;
+        pVMidBuf += 2;
+        pVdest   += 2;
+    }
+
+    _m_empty(); // clear MMS state
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// implementation of MMX optimized functions of class 'FIRFilter'
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include "FIRFilter.h"
+
+
+FIRFilterMMX::FIRFilterMMX() : FIRFilter()
+{
+    filterCoeffsAlign = nullptr;
+    filterCoeffsUnalign = nullptr;
+}
+
+
+FIRFilterMMX::~FIRFilterMMX()
+{
+    delete[] filterCoeffsUnalign;
+}
+
+
+// (overloaded) Calculates filter coefficients for MMX routine
+void FIRFilterMMX::setCoefficients(const short *coeffs, uint newLength, uint uResultDivFactor)
+{
+    uint i;
+    FIRFilter::setCoefficients(coeffs, newLength, uResultDivFactor);
+
+    // Ensure that filter coeffs array is aligned to 16-byte boundary
+    delete[] filterCoeffsUnalign;
+    filterCoeffsUnalign = new short[2 * newLength + 8];
+    filterCoeffsAlign = (short *)SOUNDTOUCH_ALIGN_POINTER_16(filterCoeffsUnalign);
+
+    // rearrange the filter coefficients for mmx routines
+    for (i = 0;i < length; i += 4)
+    {
+        filterCoeffsAlign[2 * i + 0] = coeffs[i + 0];
+        filterCoeffsAlign[2 * i + 1] = coeffs[i + 2];
+        filterCoeffsAlign[2 * i + 2] = coeffs[i + 0];
+        filterCoeffsAlign[2 * i + 3] = coeffs[i + 2];
+
+        filterCoeffsAlign[2 * i + 4] = coeffs[i + 1];
+        filterCoeffsAlign[2 * i + 5] = coeffs[i + 3];
+        filterCoeffsAlign[2 * i + 6] = coeffs[i + 1];
+        filterCoeffsAlign[2 * i + 7] = coeffs[i + 3];
+    }
+}
+
+
+// mmx-optimized version of the filter routine for stereo sound
+uint FIRFilterMMX::evaluateFilterStereo(short *dest, const short *src, uint numSamples) const
+{
+    // Create stack copies of the needed member variables for asm routines :
+    uint i, j;
+    __m64 *pVdest = (__m64*)dest;
+
+    if (length < 2) return 0;
+
+    for (i = 0; i < (numSamples - length) / 2; i ++)
+    {
+        __m64 accu1;
+        __m64 accu2;
+        const __m64 *pVsrc = (const __m64*)src;
+        const __m64 *pVfilter = (const __m64*)filterCoeffsAlign;
+
+        accu1 = accu2 = _mm_setzero_si64();
+        for (j = 0; j < lengthDiv8 * 2; j ++)
+        {
+            __m64 temp1, temp2;
+
+            temp1 = _mm_unpacklo_pi16(pVsrc[0], pVsrc[1]);  // = l2 l0 r2 r0
+            temp2 = _mm_unpackhi_pi16(pVsrc[0], pVsrc[1]);  // = l3 l1 r3 r1
+
+            accu1 = _mm_add_pi32(accu1, _mm_madd_pi16(temp1, pVfilter[0]));  // += l2*f2+l0*f0 r2*f2+r0*f0
+            accu1 = _mm_add_pi32(accu1, _mm_madd_pi16(temp2, pVfilter[1]));  // += l3*f3+l1*f1 r3*f3+r1*f1
+
+            temp1 = _mm_unpacklo_pi16(pVsrc[1], pVsrc[2]);  // = l4 l2 r4 r2
+
+            accu2 = _mm_add_pi32(accu2, _mm_madd_pi16(temp2, pVfilter[0]));  // += l3*f2+l1*f0 r3*f2+r1*f0
+            accu2 = _mm_add_pi32(accu2, _mm_madd_pi16(temp1, pVfilter[1]));  // += l4*f3+l2*f1 r4*f3+r2*f1
+
+            // accu1 += l2*f2+l0*f0 r2*f2+r0*f0
+            //       += l3*f3+l1*f1 r3*f3+r1*f1
+
+            // accu2 += l3*f2+l1*f0 r3*f2+r1*f0
+            //          l4*f3+l2*f1 r4*f3+r2*f1
+
+            pVfilter += 2;
+            pVsrc += 2;
+        }
+        // accu >>= resultDivFactor
+        accu1 = _mm_srai_pi32(accu1, resultDivFactor);
+        accu2 = _mm_srai_pi32(accu2, resultDivFactor);
+
+        // pack 2*2*32bits => 4*16 bits
+        pVdest[0] = _mm_packs_pi32(accu1, accu2);
+        src += 4;
+        pVdest ++;
+    }
+
+   _m_empty();  // clear emms state
+
+    return (numSamples & 0xfffffffe) - length;
+}
+
+#else
+
+// workaround to not complain about empty module
+bool _dontcomplain_mmx_empty;
+
+#endif  // SOUNDTOUCH_ALLOW_MMX
diff --git a/source/SoundTouch/sse_optimized.cpp b/source/SoundTouch/sse_optimized.cpp
index ebcc441..73658a5 100644
--- a/source/SoundTouch/sse_optimized.cpp
+++ b/source/SoundTouch/sse_optimized.cpp
@@ -1,365 +1,365 @@
-////////////////////////////////////////////////////////////////////////////////
-///
-/// SSE optimized routines for Pentium-III, Athlon-XP and later CPUs. All SSE 
-/// optimized functions have been gathered into this single source 
-/// code file, regardless to their class or original source code file, in order 
-/// to ease porting the library to other compiler and processor platforms.
-///
-/// The SSE-optimizations are programmed using SSE compiler intrinsics that
-/// are supported both by Microsoft Visual C++ and GCC compilers, so this file
-/// should compile with both toolsets.
-///
-/// NOTICE: If using Visual Studio 6.0, you'll need to install the "Visual C++ 
-/// 6.0 processor pack" update to support SSE instruction set. The update is 
-/// available for download at Microsoft Developers Network, see here:
-/// http://msdn.microsoft.com/en-us/vstudio/aa718349.aspx
-///
-/// If the above URL is expired or removed, go to "http://msdn.microsoft.com" and 
-/// perform a search with keywords "processor pack".
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#include "cpu_detect.h"
-#include "STTypes.h"
-
-using namespace soundtouch;
-
-#ifdef SOUNDTOUCH_ALLOW_SSE
-
-// SSE routines available only with float sample type    
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// implementation of SSE optimized functions of class 'TDStretchSSE'
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#include "TDStretch.h"
-#include 
-#include 
-
-// Calculates cross correlation of two buffers
-double TDStretchSSE::calcCrossCorr(const float *pV1, const float *pV2, double &anorm)
-{
-    int i;
-    const float *pVec1;
-    const __m128 *pVec2;
-    __m128 vSum, vNorm;
-
-    // Note. It means a major slow-down if the routine needs to tolerate 
-    // unaligned __m128 memory accesses. It's way faster if we can skip 
-    // unaligned slots and use _mm_load_ps instruction instead of _mm_loadu_ps.
-    // This can mean up to ~ 10-fold difference (incl. part of which is
-    // due to skipping every second round for stereo sound though).
-    //
-    // Compile-time define SOUNDTOUCH_ALLOW_NONEXACT_SIMD_OPTIMIZATION is provided
-    // for choosing if this little cheating is allowed.
-
-#ifdef ST_SIMD_AVOID_UNALIGNED
-    // Little cheating allowed, return valid correlation only for 
-    // aligned locations, meaning every second round for stereo sound.
-
-    #define _MM_LOAD    _mm_load_ps
-
-    if (((ulongptr)pV1) & 15) return -1e50;    // skip unaligned locations
-
-#else
-    // No cheating allowed, use unaligned load & take the resulting
-    // performance hit.
-    #define _MM_LOAD    _mm_loadu_ps
-#endif 
-
-    // ensure overlapLength is divisible by 8
-    assert((overlapLength % 8) == 0);
-
-    // Calculates the cross-correlation value between 'pV1' and 'pV2' vectors
-    // Note: pV2 _must_ be aligned to 16-bit boundary, pV1 need not.
-    pVec1 = (const float*)pV1;
-    pVec2 = (const __m128*)pV2;
-    vSum = vNorm = _mm_setzero_ps();
-
-    // Unroll the loop by factor of 4 * 4 operations. Use same routine for
-    // stereo & mono, for mono it just means twice the amount of unrolling.
-    for (i = 0; i < channels * overlapLength / 16; i ++) 
-    {
-        __m128 vTemp;
-        // vSum += pV1[0..3] * pV2[0..3]
-        vTemp = _MM_LOAD(pVec1);
-        vSum  = _mm_add_ps(vSum,  _mm_mul_ps(vTemp ,pVec2[0]));
-        vNorm = _mm_add_ps(vNorm, _mm_mul_ps(vTemp ,vTemp));
-
-        // vSum += pV1[4..7] * pV2[4..7]
-        vTemp = _MM_LOAD(pVec1 + 4);
-        vSum  = _mm_add_ps(vSum, _mm_mul_ps(vTemp, pVec2[1]));
-        vNorm = _mm_add_ps(vNorm, _mm_mul_ps(vTemp ,vTemp));
-
-        // vSum += pV1[8..11] * pV2[8..11]
-        vTemp = _MM_LOAD(pVec1 + 8);
-        vSum  = _mm_add_ps(vSum, _mm_mul_ps(vTemp, pVec2[2]));
-        vNorm = _mm_add_ps(vNorm, _mm_mul_ps(vTemp ,vTemp));
-
-        // vSum += pV1[12..15] * pV2[12..15]
-        vTemp = _MM_LOAD(pVec1 + 12);
-        vSum  = _mm_add_ps(vSum, _mm_mul_ps(vTemp, pVec2[3]));
-        vNorm = _mm_add_ps(vNorm, _mm_mul_ps(vTemp ,vTemp));
-
-        pVec1 += 16;
-        pVec2 += 4;
-    }
-
-    // return value = vSum[0] + vSum[1] + vSum[2] + vSum[3]
-    float *pvNorm = (float*)&vNorm;
-    float norm = (pvNorm[0] + pvNorm[1] + pvNorm[2] + pvNorm[3]);
-    anorm = norm;
-
-    float *pvSum = (float*)&vSum;
-    return (double)(pvSum[0] + pvSum[1] + pvSum[2] + pvSum[3]) / sqrt(norm < 1e-9 ? 1.0 : norm);
-
-    /* This is approximately corresponding routine in C-language yet without normalization:
-    double corr, norm;
-    uint i;
-
-    // Calculates the cross-correlation value between 'pV1' and 'pV2' vectors
-    corr = norm = 0.0;
-    for (i = 0; i < channels * overlapLength / 16; i ++) 
-    {
-        corr += pV1[0] * pV2[0] +
-                pV1[1] * pV2[1] +
-                pV1[2] * pV2[2] +
-                pV1[3] * pV2[3] +
-                pV1[4] * pV2[4] +
-                pV1[5] * pV2[5] +
-                pV1[6] * pV2[6] +
-                pV1[7] * pV2[7] +
-                pV1[8] * pV2[8] +
-                pV1[9] * pV2[9] +
-                pV1[10] * pV2[10] +
-                pV1[11] * pV2[11] +
-                pV1[12] * pV2[12] +
-                pV1[13] * pV2[13] +
-                pV1[14] * pV2[14] +
-                pV1[15] * pV2[15];
-
-    for (j = 0; j < 15; j ++) norm += pV1[j] * pV1[j];
-
-        pV1 += 16;
-        pV2 += 16;
-    }
-    return corr / sqrt(norm);
-    */
-}
-
-
-
-double TDStretchSSE::calcCrossCorrAccumulate(const float *pV1, const float *pV2, double &norm)
-{
-    // call usual calcCrossCorr function because SSE does not show big benefit of 
-    // accumulating "norm" value, and also the "norm" rolling algorithm would get 
-    // complicated due to SSE-specific alignment-vs-nonexact correlation rules.
-    return calcCrossCorr(pV1, pV2, norm);
-}
-
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// implementation of SSE optimized functions of class 'FIRFilter'
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#include "FIRFilter.h"
-
-FIRFilterSSE::FIRFilterSSE() : FIRFilter()
-{
-    filterCoeffsAlign = nullptr;
-    filterCoeffsUnalign = nullptr;
-}
-
-
-FIRFilterSSE::~FIRFilterSSE()
-{
-    delete[] filterCoeffsUnalign;
-    filterCoeffsAlign = nullptr;
-    filterCoeffsUnalign = nullptr;
-}
-
-
-// (overloaded) Calculates filter coefficients for SSE routine
-void FIRFilterSSE::setCoefficients(const float *coeffs, uint newLength, uint uResultDivFactor)
-{
-    uint i;
-    float fDivider;
-
-    FIRFilter::setCoefficients(coeffs, newLength, uResultDivFactor);
-
-    // Scale the filter coefficients so that it won't be necessary to scale the filtering result
-    // also rearrange coefficients suitably for SSE
-    // Ensure that filter coeffs array is aligned to 16-byte boundary
-    delete[] filterCoeffsUnalign;
-    filterCoeffsUnalign = new float[2 * newLength + 4];
-    filterCoeffsAlign = (float *)SOUNDTOUCH_ALIGN_POINTER_16(filterCoeffsUnalign);
-
-    fDivider = (float)resultDivider;
-
-    // rearrange the filter coefficients for mmx routines 
-    for (i = 0; i < newLength; i ++)
-    {
-        filterCoeffsAlign[2 * i + 0] =
-        filterCoeffsAlign[2 * i + 1] = coeffs[i + 0] / fDivider;
-    }
-}
-
-
-
-// SSE-optimized version of the filter routine for stereo sound
-uint FIRFilterSSE::evaluateFilterStereo(float *dest, const float *source, uint numSamples) const
-{
-    int count = (int)((numSamples - length) & (uint)-2);
-    int j;
-
-    assert(count % 2 == 0);
-
-    if (count < 2) return 0;
-
-    assert(source != nullptr);
-    assert(dest != nullptr);
-    assert((length % 8) == 0);
-    assert(filterCoeffsAlign != nullptr);
-    assert(((ulongptr)filterCoeffsAlign) % 16 == 0);
-
-    // filter is evaluated for two stereo samples with each iteration, thus use of 'j += 2'
-    #pragma omp parallel for
-    for (j = 0; j < count; j += 2)
-    {
-        const float *pSrc;
-        float *pDest;
-        const __m128 *pFil;
-        __m128 sum1, sum2;
-        uint i;
-
-        pSrc = (const float*)source + j * 2;      // source audio data
-        pDest = dest + j * 2;                     // destination audio data
-        pFil = (const __m128*)filterCoeffsAlign;  // filter coefficients. NOTE: Assumes coefficients 
-                                                  // are aligned to 16-byte boundary
-        sum1 = sum2 = _mm_setzero_ps();
-
-        for (i = 0; i < length / 8; i ++) 
-        {
-            // Unroll loop for efficiency & calculate filter for 2*2 stereo samples 
-            // at each pass
-
-            // sum1 is accu for 2*2 filtered stereo sound data at the primary sound data offset
-            // sum2 is accu for 2*2 filtered stereo sound data for the next sound sample offset.
-
-            sum1 = _mm_add_ps(sum1, _mm_mul_ps(_mm_loadu_ps(pSrc)    , pFil[0]));
-            sum2 = _mm_add_ps(sum2, _mm_mul_ps(_mm_loadu_ps(pSrc + 2), pFil[0]));
-
-            sum1 = _mm_add_ps(sum1, _mm_mul_ps(_mm_loadu_ps(pSrc + 4), pFil[1]));
-            sum2 = _mm_add_ps(sum2, _mm_mul_ps(_mm_loadu_ps(pSrc + 6), pFil[1]));
-
-            sum1 = _mm_add_ps(sum1, _mm_mul_ps(_mm_loadu_ps(pSrc + 8) ,  pFil[2]));
-            sum2 = _mm_add_ps(sum2, _mm_mul_ps(_mm_loadu_ps(pSrc + 10), pFil[2]));
-
-            sum1 = _mm_add_ps(sum1, _mm_mul_ps(_mm_loadu_ps(pSrc + 12), pFil[3]));
-            sum2 = _mm_add_ps(sum2, _mm_mul_ps(_mm_loadu_ps(pSrc + 14), pFil[3]));
-
-            pSrc += 16;
-            pFil += 4;
-        }
-
-        // Now sum1 and sum2 both have a filtered 2-channel sample each, but we still need
-        // to sum the two hi- and lo-floats of these registers together.
-
-        // post-shuffle & add the filtered values and store to dest.
-        _mm_storeu_ps(pDest, _mm_add_ps(
-                    _mm_shuffle_ps(sum1, sum2, _MM_SHUFFLE(1,0,3,2)),   // s2_1 s2_0 s1_3 s1_2
-                    _mm_shuffle_ps(sum1, sum2, _MM_SHUFFLE(3,2,1,0))    // s2_3 s2_2 s1_1 s1_0
-                    ));
-    }
-
-    // Ideas for further improvement:
-    // 1. If it could be guaranteed that 'source' were always aligned to 16-byte 
-    //    boundary, a faster aligned '_mm_load_ps' instruction could be used.
-    // 2. If it could be guaranteed that 'dest' were always aligned to 16-byte 
-    //    boundary, a faster '_mm_store_ps' instruction could be used.
-
-    return (uint)count;
-
-    /* original routine in C-language. please notice the C-version has differently 
-       organized coefficients though.
-    double suml1, suml2;
-    double sumr1, sumr2;
-    uint i, j;
-
-    for (j = 0; j < count; j += 2)
-    {
-        const float *ptr;
-        const float *pFil;
-
-        suml1 = sumr1 = 0.0;
-        suml2 = sumr2 = 0.0;
-        ptr = src;
-        pFil = filterCoeffs;
-        for (i = 0; i < lengthLocal; i ++) 
-        {
-            // unroll loop for efficiency.
-
-            suml1 += ptr[0] * pFil[0] + 
-                     ptr[2] * pFil[2] +
-                     ptr[4] * pFil[4] +
-                     ptr[6] * pFil[6];
-
-            sumr1 += ptr[1] * pFil[1] + 
-                     ptr[3] * pFil[3] +
-                     ptr[5] * pFil[5] +
-                     ptr[7] * pFil[7];
-
-            suml2 += ptr[8] * pFil[0] + 
-                     ptr[10] * pFil[2] +
-                     ptr[12] * pFil[4] +
-                     ptr[14] * pFil[6];
-
-            sumr2 += ptr[9] * pFil[1] + 
-                     ptr[11] * pFil[3] +
-                     ptr[13] * pFil[5] +
-                     ptr[15] * pFil[7];
-
-            ptr += 16;
-            pFil += 8;
-        }
-        dest[0] = (float)suml1;
-        dest[1] = (float)sumr1;
-        dest[2] = (float)suml2;
-        dest[3] = (float)sumr2;
-
-        src += 4;
-        dest += 4;
-    }
-    */
-}
-
-#endif  // SOUNDTOUCH_ALLOW_SSE
+////////////////////////////////////////////////////////////////////////////////
+///
+/// SSE optimized routines for Pentium-III, Athlon-XP and later CPUs. All SSE
+/// optimized functions have been gathered into this single source
+/// code file, regardless to their class or original source code file, in order
+/// to ease porting the library to other compiler and processor platforms.
+///
+/// The SSE-optimizations are programmed using SSE compiler intrinsics that
+/// are supported both by Microsoft Visual C++ and GCC compilers, so this file
+/// should compile with both toolsets.
+///
+/// NOTICE: If using Visual Studio 6.0, you'll need to install the "Visual C++
+/// 6.0 processor pack" update to support SSE instruction set. The update is
+/// available for download at Microsoft Developers Network, see here:
+/// http://msdn.microsoft.com/en-us/vstudio/aa718349.aspx
+///
+/// If the above URL is expired or removed, go to "http://msdn.microsoft.com" and
+/// perform a search with keywords "processor pack".
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#include "cpu_detect.h"
+#include "STTypes.h"
+
+using namespace soundtouch;
+
+#ifdef SOUNDTOUCH_ALLOW_SSE
+
+// SSE routines available only with float sample type
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// implementation of SSE optimized functions of class 'TDStretchSSE'
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include "TDStretch.h"
+#include 
+#include 
+
+// Calculates cross correlation of two buffers
+double TDStretchSSE::calcCrossCorr(const float *pV1, const float *pV2, double &anorm)
+{
+    int i;
+    const float *pVec1;
+    const __m128 *pVec2;
+    __m128 vSum, vNorm;
+
+    // Note. It means a major slow-down if the routine needs to tolerate
+    // unaligned __m128 memory accesses. It's way faster if we can skip
+    // unaligned slots and use _mm_load_ps instruction instead of _mm_loadu_ps.
+    // This can mean up to ~ 10-fold difference (incl. part of which is
+    // due to skipping every second round for stereo sound though).
+    //
+    // Compile-time define SOUNDTOUCH_ALLOW_NONEXACT_SIMD_OPTIMIZATION is provided
+    // for choosing if this little cheating is allowed.
+
+#ifdef ST_SIMD_AVOID_UNALIGNED
+    // Little cheating allowed, return valid correlation only for
+    // aligned locations, meaning every second round for stereo sound.
+
+    #define _MM_LOAD    _mm_load_ps
+
+    if (((ulongptr)pV1) & 15) return -1e50;    // skip unaligned locations
+
+#else
+    // No cheating allowed, use unaligned load & take the resulting
+    // performance hit.
+    #define _MM_LOAD    _mm_loadu_ps
+#endif
+
+    // ensure overlapLength is divisible by 8
+    assert((overlapLength % 8) == 0);
+
+    // Calculates the cross-correlation value between 'pV1' and 'pV2' vectors
+    // Note: pV2 _must_ be aligned to 16-bit boundary, pV1 need not.
+    pVec1 = (const float*)pV1;
+    pVec2 = (const __m128*)pV2;
+    vSum = vNorm = _mm_setzero_ps();
+
+    // Unroll the loop by factor of 4 * 4 operations. Use same routine for
+    // stereo & mono, for mono it just means twice the amount of unrolling.
+    for (i = 0; i < channels * overlapLength / 16; i ++)
+    {
+        __m128 vTemp;
+        // vSum += pV1[0..3] * pV2[0..3]
+        vTemp = _MM_LOAD(pVec1);
+        vSum  = _mm_add_ps(vSum,  _mm_mul_ps(vTemp ,pVec2[0]));
+        vNorm = _mm_add_ps(vNorm, _mm_mul_ps(vTemp ,vTemp));
+
+        // vSum += pV1[4..7] * pV2[4..7]
+        vTemp = _MM_LOAD(pVec1 + 4);
+        vSum  = _mm_add_ps(vSum, _mm_mul_ps(vTemp, pVec2[1]));
+        vNorm = _mm_add_ps(vNorm, _mm_mul_ps(vTemp ,vTemp));
+
+        // vSum += pV1[8..11] * pV2[8..11]
+        vTemp = _MM_LOAD(pVec1 + 8);
+        vSum  = _mm_add_ps(vSum, _mm_mul_ps(vTemp, pVec2[2]));
+        vNorm = _mm_add_ps(vNorm, _mm_mul_ps(vTemp ,vTemp));
+
+        // vSum += pV1[12..15] * pV2[12..15]
+        vTemp = _MM_LOAD(pVec1 + 12);
+        vSum  = _mm_add_ps(vSum, _mm_mul_ps(vTemp, pVec2[3]));
+        vNorm = _mm_add_ps(vNorm, _mm_mul_ps(vTemp ,vTemp));
+
+        pVec1 += 16;
+        pVec2 += 4;
+    }
+
+    // return value = vSum[0] + vSum[1] + vSum[2] + vSum[3]
+    float *pvNorm = (float*)&vNorm;
+    float norm = (pvNorm[0] + pvNorm[1] + pvNorm[2] + pvNorm[3]);
+    anorm = norm;
+
+    float *pvSum = (float*)&vSum;
+    return (double)(pvSum[0] + pvSum[1] + pvSum[2] + pvSum[3]) / sqrt(norm < 1e-9 ? 1.0 : norm);
+
+    /* This is approximately corresponding routine in C-language yet without normalization:
+    double corr, norm;
+    uint i;
+
+    // Calculates the cross-correlation value between 'pV1' and 'pV2' vectors
+    corr = norm = 0.0;
+    for (i = 0; i < channels * overlapLength / 16; i ++)
+    {
+        corr += pV1[0] * pV2[0] +
+                pV1[1] * pV2[1] +
+                pV1[2] * pV2[2] +
+                pV1[3] * pV2[3] +
+                pV1[4] * pV2[4] +
+                pV1[5] * pV2[5] +
+                pV1[6] * pV2[6] +
+                pV1[7] * pV2[7] +
+                pV1[8] * pV2[8] +
+                pV1[9] * pV2[9] +
+                pV1[10] * pV2[10] +
+                pV1[11] * pV2[11] +
+                pV1[12] * pV2[12] +
+                pV1[13] * pV2[13] +
+                pV1[14] * pV2[14] +
+                pV1[15] * pV2[15];
+
+    for (j = 0; j < 15; j ++) norm += pV1[j] * pV1[j];
+
+        pV1 += 16;
+        pV2 += 16;
+    }
+    return corr / sqrt(norm);
+    */
+}
+
+
+
+double TDStretchSSE::calcCrossCorrAccumulate(const float *pV1, const float *pV2, double &norm)
+{
+    // call usual calcCrossCorr function because SSE does not show big benefit of
+    // accumulating "norm" value, and also the "norm" rolling algorithm would get
+    // complicated due to SSE-specific alignment-vs-nonexact correlation rules.
+    return calcCrossCorr(pV1, pV2, norm);
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// implementation of SSE optimized functions of class 'FIRFilter'
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include "FIRFilter.h"
+
+FIRFilterSSE::FIRFilterSSE() : FIRFilter()
+{
+    filterCoeffsAlign = nullptr;
+    filterCoeffsUnalign = nullptr;
+}
+
+
+FIRFilterSSE::~FIRFilterSSE()
+{
+    delete[] filterCoeffsUnalign;
+    filterCoeffsAlign = nullptr;
+    filterCoeffsUnalign = nullptr;
+}
+
+
+// (overloaded) Calculates filter coefficients for SSE routine
+void FIRFilterSSE::setCoefficients(const float *coeffs, uint newLength, uint uResultDivFactor)
+{
+    uint i;
+    float fDivider;
+
+    FIRFilter::setCoefficients(coeffs, newLength, uResultDivFactor);
+
+    // Scale the filter coefficients so that it won't be necessary to scale the filtering result
+    // also rearrange coefficients suitably for SSE
+    // Ensure that filter coeffs array is aligned to 16-byte boundary
+    delete[] filterCoeffsUnalign;
+    filterCoeffsUnalign = new float[2 * newLength + 4];
+    filterCoeffsAlign = (float *)SOUNDTOUCH_ALIGN_POINTER_16(filterCoeffsUnalign);
+
+    fDivider = (float)resultDivider;
+
+    // rearrange the filter coefficients for mmx routines
+    for (i = 0; i < newLength; i ++)
+    {
+        filterCoeffsAlign[2 * i + 0] =
+        filterCoeffsAlign[2 * i + 1] = coeffs[i + 0] / fDivider;
+    }
+}
+
+
+
+// SSE-optimized version of the filter routine for stereo sound
+uint FIRFilterSSE::evaluateFilterStereo(float *dest, const float *source, uint numSamples) const
+{
+    int count = (int)((numSamples - length) & (uint)-2);
+    int j;
+
+    assert(count % 2 == 0);
+
+    if (count < 2) return 0;
+
+    assert(source != nullptr);
+    assert(dest != nullptr);
+    assert((length % 8) == 0);
+    assert(filterCoeffsAlign != nullptr);
+    assert(((ulongptr)filterCoeffsAlign) % 16 == 0);
+
+    // filter is evaluated for two stereo samples with each iteration, thus use of 'j += 2'
+    #pragma omp parallel for
+    for (j = 0; j < count; j += 2)
+    {
+        const float *pSrc;
+        float *pDest;
+        const __m128 *pFil;
+        __m128 sum1, sum2;
+        uint i;
+
+        pSrc = (const float*)source + j * 2;      // source audio data
+        pDest = dest + j * 2;                     // destination audio data
+        pFil = (const __m128*)filterCoeffsAlign;  // filter coefficients. NOTE: Assumes coefficients
+                                                  // are aligned to 16-byte boundary
+        sum1 = sum2 = _mm_setzero_ps();
+
+        for (i = 0; i < length / 8; i ++)
+        {
+            // Unroll loop for efficiency & calculate filter for 2*2 stereo samples
+            // at each pass
+
+            // sum1 is accu for 2*2 filtered stereo sound data at the primary sound data offset
+            // sum2 is accu for 2*2 filtered stereo sound data for the next sound sample offset.
+
+            sum1 = _mm_add_ps(sum1, _mm_mul_ps(_mm_loadu_ps(pSrc)    , pFil[0]));
+            sum2 = _mm_add_ps(sum2, _mm_mul_ps(_mm_loadu_ps(pSrc + 2), pFil[0]));
+
+            sum1 = _mm_add_ps(sum1, _mm_mul_ps(_mm_loadu_ps(pSrc + 4), pFil[1]));
+            sum2 = _mm_add_ps(sum2, _mm_mul_ps(_mm_loadu_ps(pSrc + 6), pFil[1]));
+
+            sum1 = _mm_add_ps(sum1, _mm_mul_ps(_mm_loadu_ps(pSrc + 8) ,  pFil[2]));
+            sum2 = _mm_add_ps(sum2, _mm_mul_ps(_mm_loadu_ps(pSrc + 10), pFil[2]));
+
+            sum1 = _mm_add_ps(sum1, _mm_mul_ps(_mm_loadu_ps(pSrc + 12), pFil[3]));
+            sum2 = _mm_add_ps(sum2, _mm_mul_ps(_mm_loadu_ps(pSrc + 14), pFil[3]));
+
+            pSrc += 16;
+            pFil += 4;
+        }
+
+        // Now sum1 and sum2 both have a filtered 2-channel sample each, but we still need
+        // to sum the two hi- and lo-floats of these registers together.
+
+        // post-shuffle & add the filtered values and store to dest.
+        _mm_storeu_ps(pDest, _mm_add_ps(
+                    _mm_shuffle_ps(sum1, sum2, _MM_SHUFFLE(1,0,3,2)),   // s2_1 s2_0 s1_3 s1_2
+                    _mm_shuffle_ps(sum1, sum2, _MM_SHUFFLE(3,2,1,0))    // s2_3 s2_2 s1_1 s1_0
+                    ));
+    }
+
+    // Ideas for further improvement:
+    // 1. If it could be guaranteed that 'source' were always aligned to 16-byte
+    //    boundary, a faster aligned '_mm_load_ps' instruction could be used.
+    // 2. If it could be guaranteed that 'dest' were always aligned to 16-byte
+    //    boundary, a faster '_mm_store_ps' instruction could be used.
+
+    return (uint)count;
+
+    /* original routine in C-language. please notice the C-version has differently
+       organized coefficients though.
+    double suml1, suml2;
+    double sumr1, sumr2;
+    uint i, j;
+
+    for (j = 0; j < count; j += 2)
+    {
+        const float *ptr;
+        const float *pFil;
+
+        suml1 = sumr1 = 0.0;
+        suml2 = sumr2 = 0.0;
+        ptr = src;
+        pFil = filterCoeffs;
+        for (i = 0; i < lengthLocal; i ++)
+        {
+            // unroll loop for efficiency.
+
+            suml1 += ptr[0] * pFil[0] +
+                     ptr[2] * pFil[2] +
+                     ptr[4] * pFil[4] +
+                     ptr[6] * pFil[6];
+
+            sumr1 += ptr[1] * pFil[1] +
+                     ptr[3] * pFil[3] +
+                     ptr[5] * pFil[5] +
+                     ptr[7] * pFil[7];
+
+            suml2 += ptr[8] * pFil[0] +
+                     ptr[10] * pFil[2] +
+                     ptr[12] * pFil[4] +
+                     ptr[14] * pFil[6];
+
+            sumr2 += ptr[9] * pFil[1] +
+                     ptr[11] * pFil[3] +
+                     ptr[13] * pFil[5] +
+                     ptr[15] * pFil[7];
+
+            ptr += 16;
+            pFil += 8;
+        }
+        dest[0] = (float)suml1;
+        dest[1] = (float)sumr1;
+        dest[2] = (float)suml2;
+        dest[3] = (float)sumr2;
+
+        src += 4;
+        dest += 4;
+    }
+    */
+}
+
+#endif  // SOUNDTOUCH_ALLOW_SSE
diff --git a/source/SoundTouchDLL/DllTest/DllTest.cpp b/source/SoundTouchDLL/DllTest/DllTest.cpp
index 8fb7d09..0105592 100644
--- a/source/SoundTouchDLL/DllTest/DllTest.cpp
+++ b/source/SoundTouchDLL/DllTest/DllTest.cpp
@@ -1,115 +1,115 @@
-////////////////////////////////////////////////////////////////////////////////
-///
-/// DllTest.cpp : This is small app main routine used for testing sound processing
-/// with SoundTouch.dll API
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-
-#include 
-#include 
-#include 
-#include "../SoundTouchDLL.h"
-#include "../../SoundStretch/WavFile.h"
-
-using namespace std;
-using namespace soundstretch;
-
-// DllTest main
-int wmain(int argc, const wchar_t *argv[])
-{
-    // Check program arguments
-    if (argc < 4)
-    {
-        cout << "Too few arguments. Usage: DllTest [infile.wav] [outfile.wav] [sampletype]" << endl;
-        return -1;
-    }
-
-    wstring inFileName = argv[1];
-    wstring outFileName = argv[2];
-    wstring str_sampleType = argv[3];
-
-    bool floatSample;
-    if (str_sampleType == L"float")
-    {
-        floatSample = true;
-    }
-    else if (str_sampleType == L"short")
-    {
-        floatSample = false;
-    }
-    else
-    { 
-        cerr << "Missing or invalid sampletype. Expected either short or float" << endl;
-        return -1;
-    }
-
-    try
-    {
-        // Open input & output WAV files
-        WavInFile inFile(inFileName);
-        int numChannels = inFile.getNumChannels();
-        int sampleRate = inFile.getSampleRate();
-        WavOutFile outFile(outFileName, sampleRate, inFile.getNumBits(), numChannels);
-
-        // Create SoundTouch DLL instance
-        HANDLE st = soundtouch_createInstance();
-        soundtouch_setChannels(st, numChannels);
-        soundtouch_setSampleRate(st, sampleRate);
-        soundtouch_setPitchSemiTones(st, 2);
-
-        cout << "processing with soundtouch.dll routines";
-
-        if (floatSample)
-        {
-            // Process file with SoundTouch.DLL float sample (default) API
-            float fbuffer[2048];
-            int nmax = 2048 / numChannels;
-
-            cout << " using float api ..." << endl;
-            while (inFile.eof() == false)
-            {
-                int n = inFile.read(fbuffer, nmax * numChannels) / numChannels;
-                soundtouch_putSamples(st, fbuffer, n);
-                do
-                {
-                    n = soundtouch_receiveSamples(st, fbuffer, nmax);
-                    outFile.write(fbuffer, n * numChannels);
-                } while (n > 0);
-            }
-        }
-        else
-        {
-            // Process file with SoundTouch.DLL int16 (short) sample API.
-            // Notice that SoundTouch.dll does internally processing using floating
-            // point routines so the int16 API is not any faster, but provided for 
-            // convenience.
-            short i16buffer[2048];
-            int nmax = 2048 / numChannels;
-
-            cout << " using i16 api ..." << endl;
-            while (inFile.eof() == false)
-            {
-                int n = inFile.read(i16buffer, nmax * numChannels) / numChannels;
-                soundtouch_putSamples_i16(st, i16buffer, n);
-                do
-                {
-                    n = soundtouch_receiveSamples_i16(st, i16buffer, nmax);
-                    outFile.write(i16buffer, n * numChannels);
-                } while (n > 0);
-            }
-        }
-
-        soundtouch_destroyInstance(st);
-        cout << "done." << endl;
-    }
-    catch (const runtime_error &e)
-    {
-        cerr << e.what() << endl;
-    }
-
-    return 0;
-}
+////////////////////////////////////////////////////////////////////////////////
+///
+/// DllTest.cpp : This is small app main routine used for testing sound processing
+/// with SoundTouch.dll API
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+
+#include 
+#include 
+#include 
+#include "../SoundTouchDLL.h"
+#include "../../SoundStretch/WavFile.h"
+
+using namespace std;
+using namespace soundstretch;
+
+// DllTest main
+int wmain(int argc, const wchar_t *argv[])
+{
+    // Check program arguments
+    if (argc < 4)
+    {
+        cout << "Too few arguments. Usage: DllTest [infile.wav] [outfile.wav] [sampletype]" << endl;
+        return -1;
+    }
+
+    wstring inFileName = argv[1];
+    wstring outFileName = argv[2];
+    wstring str_sampleType = argv[3];
+
+    bool floatSample;
+    if (str_sampleType == L"float")
+    {
+        floatSample = true;
+    }
+    else if (str_sampleType == L"short")
+    {
+        floatSample = false;
+    }
+    else
+    { 
+        cerr << "Missing or invalid sampletype. Expected either short or float" << endl;
+        return -1;
+    }
+
+    try
+    {
+        // Open input & output WAV files
+        WavInFile inFile(inFileName);
+        int numChannels = inFile.getNumChannels();
+        int sampleRate = inFile.getSampleRate();
+        WavOutFile outFile(outFileName, sampleRate, inFile.getNumBits(), numChannels);
+
+        // Create SoundTouch DLL instance
+        HANDLE st = soundtouch_createInstance();
+        soundtouch_setChannels(st, numChannels);
+        soundtouch_setSampleRate(st, sampleRate);
+        soundtouch_setPitchSemiTones(st, 2);
+
+        cout << "processing with soundtouch.dll routines";
+
+        if (floatSample)
+        {
+            // Process file with SoundTouch.DLL float sample (default) API
+            float fbuffer[2048];
+            int nmax = 2048 / numChannels;
+
+            cout << " using float api ..." << endl;
+            while (inFile.eof() == false)
+            {
+                int n = inFile.read(fbuffer, nmax * numChannels) / numChannels;
+                soundtouch_putSamples(st, fbuffer, n);
+                do
+                {
+                    n = soundtouch_receiveSamples(st, fbuffer, nmax);
+                    outFile.write(fbuffer, n * numChannels);
+                } while (n > 0);
+            }
+        }
+        else
+        {
+            // Process file with SoundTouch.DLL int16 (short) sample API.
+            // Notice that SoundTouch.dll does internally processing using floating
+            // point routines so the int16 API is not any faster, but provided for 
+            // convenience.
+            short i16buffer[2048];
+            int nmax = 2048 / numChannels;
+
+            cout << " using i16 api ..." << endl;
+            while (inFile.eof() == false)
+            {
+                int n = inFile.read(i16buffer, nmax * numChannels) / numChannels;
+                soundtouch_putSamples_i16(st, i16buffer, n);
+                do
+                {
+                    n = soundtouch_receiveSamples_i16(st, i16buffer, nmax);
+                    outFile.write(i16buffer, n * numChannels);
+                } while (n > 0);
+            }
+        }
+
+        soundtouch_destroyInstance(st);
+        cout << "done." << endl;
+    }
+    catch (const runtime_error &e)
+    {
+        cerr << e.what() << endl;
+    }
+
+    return 0;
+}
diff --git a/source/SoundTouchDLL/Makefile.am b/source/SoundTouchDLL/Makefile.am
index 4909763..38b82bc 100644
--- a/source/SoundTouchDLL/Makefile.am
+++ b/source/SoundTouchDLL/Makefile.am
@@ -1,47 +1,47 @@
-## Process this file with automake to create Makefile.in
-##
-## This file is part of SoundTouch, an audio processing library for pitch/time adjustments
-##
-## SoundTouch 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.
-##
-## SoundTouch is distributed in the hope that it will be useful, but WITHOUT ANY
-## WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-## A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-##
-## You should have received a copy of the GNU General Public License along with
-## this program; if not, write to the Free Software Foundation, Inc., 59 Temple
-## Place - Suite 330, Boston, MA  02111-1307, USA
-
-include $(top_srcdir)/config/am_include.mk
-
-noinst_HEADERS=../SoundTouch/AAFilter.h ../SoundTouch/cpu_detect.h ../SoundTouch/cpu_detect_x86.cpp ../SoundTouch/FIRFilter.h \
-    ../SoundTouch/RateTransposer.h ../SoundTouch/TDStretch.h ../SoundTouch/PeakFinder.h ../SoundTouch/InterpolateCubic.h \
-    ../SoundTouch/InterpolateLinear.h ../SoundTouch/InterpolateShannon.h
-
-include_HEADERS=SoundTouchDLL.h
-
-lib_LTLIBRARIES=libSoundTouchDll.la
-#
-libSoundTouchDll_la_SOURCES=../SoundTouch/AAFilter.cpp ../SoundTouch/FIRFilter.cpp \
-    ../SoundTouch/FIFOSampleBuffer.cpp ../SoundTouch/RateTransposer.cpp ../SoundTouch/SoundTouch.cpp \
-    ../SoundTouch/TDStretch.cpp ../SoundTouch/sse_optimized.cpp ../SoundTouch/cpu_detect_x86.cpp \
-    ../SoundTouch/BPMDetect.cpp ../SoundTouch/PeakFinder.cpp ../SoundTouch/InterpolateLinear.cpp \
-    ../SoundTouch/InterpolateCubic.cpp ../SoundTouch/InterpolateShannon.cpp SoundTouchDLL.cpp
-
-# Compiler flags
-
-# Modify the default 0.0.0 to LIB_SONAME.0.0
-AM_LDFLAGS=$(LDFLAGS) -version-info @LIB_SONAME@
-
-if X86
-CXXFLAGS1=-mstackrealign -msse
-endif
-
-if X86_64
-CXXFLAGS2=-fPIC
-endif
-
-AM_CXXFLAGS=$(CXXFLAGS) $(CXXFLAGS1) $(CXXFLAGS2) -shared -DDLL_EXPORTS -fvisibility=hidden
+## Process this file with automake to create Makefile.in
+##
+## This file is part of SoundTouch, an audio processing library for pitch/time adjustments
+##
+## SoundTouch 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.
+##
+## SoundTouch is distributed in the hope that it will be useful, but WITHOUT ANY
+## WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+## A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+##
+## You should have received a copy of the GNU General Public License along with
+## this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+## Place - Suite 330, Boston, MA  02111-1307, USA
+
+include $(top_srcdir)/config/am_include.mk
+
+noinst_HEADERS=../SoundTouch/AAFilter.h ../SoundTouch/cpu_detect.h ../SoundTouch/cpu_detect_x86.cpp ../SoundTouch/FIRFilter.h \
+    ../SoundTouch/RateTransposer.h ../SoundTouch/TDStretch.h ../SoundTouch/PeakFinder.h ../SoundTouch/InterpolateCubic.h \
+    ../SoundTouch/InterpolateLinear.h ../SoundTouch/InterpolateShannon.h
+
+include_HEADERS=SoundTouchDLL.h
+
+lib_LTLIBRARIES=libSoundTouchDll.la
+#
+libSoundTouchDll_la_SOURCES=../SoundTouch/AAFilter.cpp ../SoundTouch/FIRFilter.cpp \
+    ../SoundTouch/FIFOSampleBuffer.cpp ../SoundTouch/RateTransposer.cpp ../SoundTouch/SoundTouch.cpp \
+    ../SoundTouch/TDStretch.cpp ../SoundTouch/sse_optimized.cpp ../SoundTouch/cpu_detect_x86.cpp \
+    ../SoundTouch/BPMDetect.cpp ../SoundTouch/PeakFinder.cpp ../SoundTouch/InterpolateLinear.cpp \
+    ../SoundTouch/InterpolateCubic.cpp ../SoundTouch/InterpolateShannon.cpp SoundTouchDLL.cpp
+
+# Compiler flags
+
+# Modify the default 0.0.0 to LIB_SONAME.0.0
+AM_LDFLAGS=$(LDFLAGS) -version-info @LIB_SONAME@
+
+if X86
+CXXFLAGS1=-mstackrealign -msse
+endif
+
+if X86_64
+CXXFLAGS2=-fPIC
+endif
+
+AM_CXXFLAGS=$(CXXFLAGS) $(CXXFLAGS1) $(CXXFLAGS2) -shared -DDLL_EXPORTS -fvisibility=hidden
diff --git a/source/SoundTouchDLL/SoundTouchDLL.cpp b/source/SoundTouchDLL/SoundTouchDLL.cpp
index 6021061..0829758 100644
--- a/source/SoundTouchDLL/SoundTouchDLL.cpp
+++ b/source/SoundTouchDLL/SoundTouchDLL.cpp
@@ -1,582 +1,582 @@
-//////////////////////////////////////////////////////////////////////////////
-///
-/// SoundTouch DLL wrapper - wraps SoundTouch routines into a Dynamic Load
-/// Library interface.
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-
-#if defined(_WIN32) || defined(WIN32)
-    #include 
-
-    // DLL main in Windows compilation
-    BOOL APIENTRY DllMain( HANDLE hModule,
-                           DWORD  ul_reason_for_call,
-                           LPVOID lpReserved
-                         )
-    {
-        switch (ul_reason_for_call)
-        {
-        case DLL_PROCESS_ATTACH:
-        case DLL_THREAD_ATTACH:
-        case DLL_THREAD_DETACH:
-        case DLL_PROCESS_DETACH:
-            break;
-        }
-        return TRUE;
-    }
-#endif
-
-#include 
-#include 
-#include "SoundTouchDLL.h"
-#include "SoundTouch.h"
-#include "BPMDetect.h"
-
-using namespace soundtouch;
-
-#ifdef SOUNDTOUCH_INTEGER_SAMPLES
-    #error "error - compile the dll version with float samples"
-#endif // SOUNDTOUCH_INTEGER_SAMPLES
-
-//////////////
-
-typedef struct
-{
-    DWORD dwMagic;
-    SoundTouch *pst;
-} STHANDLE;
-
-typedef struct
-{
-    DWORD dwMagic;
-    BPMDetect *pbpm;
-    uint numChannels;
-} BPMHANDLE;
-
-#define STMAGIC  0x1770C001
-#define BPMMAGIC 0x1771C10a
-
-SOUNDTOUCHDLL_API HANDLE __cdecl soundtouch_createInstance()
-{
-    STHANDLE *tmp = new STHANDLE;
-
-    if (tmp)
-    {
-        tmp->dwMagic = STMAGIC;
-        tmp->pst = new SoundTouch();
-        if (tmp->pst == nullptr)
-        {
-            delete tmp;
-            tmp = nullptr;
-        }
-    }
-    return (HANDLE)tmp;
-}
-
-
-SOUNDTOUCHDLL_API void __cdecl soundtouch_destroyInstance(HANDLE h)
-{
-    STHANDLE *sth = (STHANDLE*)h;
-    if (sth->dwMagic != STMAGIC) return;
-
-    sth->dwMagic = 0;
-    if (sth->pst) delete sth->pst;
-    sth->pst = nullptr;
-    delete sth;
-}
-
-
-/// Get SoundTouch library version string
-SOUNDTOUCHDLL_API const char *__cdecl soundtouch_getVersionString()
-{
-    return SoundTouch::getVersionString();
-}
-
-
-/// Get SoundTouch library version string - alternative function for
-/// environments that can't properly handle character string as return value
-SOUNDTOUCHDLL_API void __cdecl soundtouch_getVersionString2(char* versionString, int bufferSize)
-{
-    strncpy(versionString, SoundTouch::getVersionString(), bufferSize - 1);
-    versionString[bufferSize - 1] = 0;
-}
-
-
-/// Get SoundTouch library version Id
-SOUNDTOUCHDLL_API uint __cdecl soundtouch_getVersionId()
-{
-    return SoundTouch::getVersionId();
-}
-
-/// Sets new rate control value. Normal rate = 1.0, smaller values
-/// represent slower rate, larger faster rates.
-SOUNDTOUCHDLL_API void __cdecl soundtouch_setRate(HANDLE h, float newRate)
-{
-    STHANDLE *sth = (STHANDLE*)h;
-    if (sth->dwMagic != STMAGIC) return;
-
-    sth->pst->setRate(newRate);
-}
-
-
-/// Sets new tempo control value. Normal tempo = 1.0, smaller values
-/// represent slower tempo, larger faster tempo.
-SOUNDTOUCHDLL_API void __cdecl soundtouch_setTempo(HANDLE h, float newTempo)
-{
-    STHANDLE *sth = (STHANDLE*)h;
-    if (sth->dwMagic != STMAGIC) return;
-
-    sth->pst->setTempo(newTempo);
-}
-
-/// Sets new rate control value as a difference in percents compared
-/// to the original rate (-50 .. +100 %)
-SOUNDTOUCHDLL_API void __cdecl soundtouch_setRateChange(HANDLE h, float newRate)
-{
-    STHANDLE *sth = (STHANDLE*)h;
-    if (sth->dwMagic != STMAGIC) return;
-
-    sth->pst->setRateChange(newRate);
-}
-
-/// Sets new tempo control value as a difference in percents compared
-/// to the original tempo (-50 .. +100 %)
-SOUNDTOUCHDLL_API void __cdecl soundtouch_setTempoChange(HANDLE h, float newTempo)
-{
-    STHANDLE *sth = (STHANDLE*)h;
-    if (sth->dwMagic != STMAGIC) return;
-
-    sth->pst->setTempoChange(newTempo);
-}
-
-/// Sets new pitch control value. Original pitch = 1.0, smaller values
-/// represent lower pitches, larger values higher pitch.
-SOUNDTOUCHDLL_API void __cdecl soundtouch_setPitch(HANDLE h, float newPitch)
-{
-    STHANDLE *sth = (STHANDLE*)h;
-    if (sth->dwMagic != STMAGIC) return;
-
-    sth->pst->setPitch(newPitch);
-}
-
-/// Sets pitch change in octaves compared to the original pitch
-/// (-1.00 .. +1.00)
-SOUNDTOUCHDLL_API void __cdecl soundtouch_setPitchOctaves(HANDLE h, float newPitch)
-{
-    STHANDLE *sth = (STHANDLE*)h;
-    if (sth->dwMagic != STMAGIC) return;
-
-    sth->pst->setPitchOctaves(newPitch);
-}
-
-/// Sets pitch change in semi-tones compared to the original pitch
-/// (-12 .. +12)
-SOUNDTOUCHDLL_API void __cdecl soundtouch_setPitchSemiTones(HANDLE h, float newPitch)
-{
-    STHANDLE *sth = (STHANDLE*)h;
-    if (sth->dwMagic != STMAGIC) return;
-
-    sth->pst->setPitchSemiTones(newPitch);
-}
-
-
-/// Sets the number of channels, 1 = mono, 2 = stereo
-SOUNDTOUCHDLL_API int __cdecl soundtouch_setChannels(HANDLE h, uint numChannels)
-{
-    STHANDLE *sth = (STHANDLE*)h;
-    if (sth->dwMagic != STMAGIC) return 0;
-
-    try
-    {
-        sth->pst->setChannels(numChannels);
-    }
-    catch (const std::exception&)
-    {
-        return 0;
-    }
-    return 1;
-}
-
-/// Sets sample rate.
-SOUNDTOUCHDLL_API int __cdecl soundtouch_setSampleRate(HANDLE h, uint srate)
-{
-    STHANDLE *sth = (STHANDLE*)h;
-    if (sth->dwMagic != STMAGIC) return 0;
-
-    try
-    {
-        sth->pst->setSampleRate(srate);
-    }
-    catch (const std::exception&)
-    {
-        return 0;
-    }
-    return 1;
-}
-
-/// Flushes the last samples from the processing pipeline to the output.
-/// Clears also the internal processing buffers.
-//
-/// Note: This function is meant for extracting the last samples of a sound
-/// stream. This function may introduce additional blank samples in the end
-/// of the sound stream, and thus it's not recommended to call this function
-/// in the middle of a sound stream.
-SOUNDTOUCHDLL_API int __cdecl soundtouch_flush(HANDLE h)
-{
-    STHANDLE *sth = (STHANDLE*)h;
-    if (sth->dwMagic != STMAGIC) return 0;
-
-    try
-    {
-        sth->pst->flush();
-    }
-    catch (const std::exception&)
-    {
-        return 0;
-    }
-    return 1;
-}
-
-/// Adds 'numSamples' pcs of samples from the 'samples' memory position into
-/// the input of the object. Notice that sample rate _has_to_ be set before
-/// calling this function, otherwise throws a runtime_error exception.
-SOUNDTOUCHDLL_API int __cdecl soundtouch_putSamples(HANDLE h,
-        const SAMPLETYPE *samples,      ///< Pointer to sample buffer.
-        unsigned int numSamples         ///< Number of samples in buffer. Notice
-                                        ///< that in case of stereo-sound a single sample
-                                        ///< contains data for both channels.
-        )
-{
-    STHANDLE *sth = (STHANDLE*)h;
-    if (sth->dwMagic != STMAGIC) return 0;
-
-    try
-    {
-        sth->pst->putSamples(samples, numSamples);
-    }
-    catch (const std::exception&)
-    {
-        return 0;
-    }
-    return 1;
-}
-
-/// int16 version of soundtouch_putSamples(): This accept int16 (short) sample data
-/// and internally converts it to float format before processing
-SOUNDTOUCHDLL_API void __cdecl soundtouch_putSamples_i16(HANDLE h,
-        const short *samples,       ///< Pointer to sample buffer.
-        unsigned int numSamples     ///< Number of sample frames in buffer. Notice
-                                    ///< that in case of multi-channel sound a single sample
-                                    ///< contains data for all channels.
-        )
-{
-    STHANDLE *sth = (STHANDLE*)h;
-    if (sth->dwMagic != STMAGIC) return;
-
-    uint numChannels = sth->pst->numChannels();
-
-    // iterate until all samples converted & put to SoundTouch object
-    while (numSamples > 0)
-    {
-        float convert[8192];    // allocate temporary conversion buffer from stack
-
-        // how many multichannel samples fit into 'convert' buffer:
-        uint convSamples = 8192 / numChannels;
-
-        // convert max 'nround' values at a time to guarantee that these fit in the 'convert' buffer
-        uint n = (numSamples > convSamples) ? convSamples : numSamples;
-        for (uint i = 0; i < n * numChannels; i++)
-        {
-            convert[i] = samples[i];
-        }
-        // put the converted samples into SoundTouch
-        sth->pst->putSamples(convert, n);
-
-        numSamples -= n;
-        samples += n * numChannels;
-    }
-}
-
-/// Clears all the samples in the object's output and internal processing
-/// buffers.
-SOUNDTOUCHDLL_API void __cdecl soundtouch_clear(HANDLE h)
-{
-    STHANDLE *sth = (STHANDLE*)h;
-    if (sth->dwMagic != STMAGIC) return;
-
-    sth->pst->clear();
-}
-
-/// Changes a setting controlling the processing system behaviour. See the
-/// 'SETTING_...' defines for available setting ID's.
-///
-/// \return 'nonzero' if the setting was successfully changed
-SOUNDTOUCHDLL_API int __cdecl soundtouch_setSetting(HANDLE h,
-        int settingId,   ///< Setting ID number. see SETTING_... defines.
-        int value        ///< New setting value.
-        )
-{
-    STHANDLE *sth = (STHANDLE*)h;
-    if (sth->dwMagic != STMAGIC) return FALSE;
-
-    return sth->pst->setSetting(settingId, value);
-}
-
-/// Reads a setting controlling the processing system behaviour. See the
-/// 'SETTING_...' defines for available setting ID's.
-///
-/// \return the setting value.
-SOUNDTOUCHDLL_API int __cdecl soundtouch_getSetting(HANDLE h,
-        int settingId    ///< Setting ID number, see SETTING_... defines.
-        )
-{
-    STHANDLE *sth = (STHANDLE*)h;
-    if (sth->dwMagic != STMAGIC) return -1;
-
-    return sth->pst->getSetting(settingId);
-}
-
-
-/// Returns number of samples currently unprocessed.
-SOUNDTOUCHDLL_API uint __cdecl soundtouch_numUnprocessedSamples(HANDLE h)
-{
-    STHANDLE *sth = (STHANDLE*)h;
-    if (sth->dwMagic != STMAGIC) return 0;
-
-    return sth->pst->numUnprocessedSamples();
-}
-
-
-/// Receive ready samples from the processing pipeline.
-///
-/// if called with outBuffer=nullptr, just reduces amount of ready samples within the pipeline.
-SOUNDTOUCHDLL_API uint __cdecl soundtouch_receiveSamples(HANDLE h,
-        SAMPLETYPE *outBuffer,      ///< Buffer where to copy output samples.
-        unsigned int maxSamples     ///< How many samples to receive at max.
-        )
-{
-    STHANDLE *sth = (STHANDLE*)h;
-    if (sth->dwMagic != STMAGIC) return 0;
-
-    if (outBuffer)
-    {
-        return sth->pst->receiveSamples(outBuffer, maxSamples);
-    }
-    else
-    {
-        return sth->pst->receiveSamples(maxSamples);
-    }
-}
-
-
-/// int16 version of soundtouch_receiveSamples(): This converts internal float samples
-/// into int16 (short) return data type
-SOUNDTOUCHDLL_API uint __cdecl soundtouch_receiveSamples_i16(HANDLE h,
-        short *outBuffer,           ///< Buffer where to copy output samples.
-        unsigned int maxSamples     ///< How many samples to receive at max.
-        )
-{
-    STHANDLE *sth = (STHANDLE*)h;
-    if (sth->dwMagic != STMAGIC) return 0;
-    uint outTotal = 0;
-
-    if (outBuffer == nullptr)
-    {
-        // only reduce sample count, not receive samples
-        return sth->pst->receiveSamples(maxSamples);
-    }
-
-    uint numChannels = sth->pst->numChannels();
-
-    // iterate until all samples converted & put to SoundTouch object
-    while (maxSamples > 0)
-    {
-        float convert[8192];    // allocate temporary conversion buffer from stack
-
-        // how many multichannel samples fit into 'convert' buffer:
-        uint convSamples = 8192 / numChannels;
-
-        // request max 'nround' values at a time to guarantee that these fit in the 'convert' buffer
-        uint n = (maxSamples > convSamples) ? convSamples : maxSamples;
-
-        uint out = sth->pst->receiveSamples(convert, n);
-
-        // convert & saturate received samples to int16
-        for (uint i = 0; i < out * numChannels; i++)
-        {
-            // first convert value to int32, then saturate to int16 min/max limits
-            int value = (int)convert[i];
-            value = (value < SHRT_MIN) ? SHRT_MIN : (value > SHRT_MAX) ? SHRT_MAX : value;
-            outBuffer[i] = (short)value;
-        }
-        outTotal += out;
-        if (out < n) break;  // didn't get as many as asked => no more samples available => break here
-
-        maxSamples -= n;
-        outBuffer += out * numChannels;
-    }
-
-    // return number of processed samples
-    return outTotal;
-}
-
-
-/// Returns number of samples currently available.
-SOUNDTOUCHDLL_API uint __cdecl soundtouch_numSamples(HANDLE h)
-{
-    STHANDLE *sth = (STHANDLE*)h;
-    if (sth->dwMagic != STMAGIC) return 0;
-
-    return sth->pst->numSamples();
-}
-
-
-/// Returns nonzero if there aren't any samples available for outputting.
-SOUNDTOUCHDLL_API int __cdecl soundtouch_isEmpty(HANDLE h)
-{
-    STHANDLE *sth = (STHANDLE*)h;
-    if (sth->dwMagic != STMAGIC) return -1;
-
-    return sth->pst->isEmpty();
-}
-
-
-SOUNDTOUCHDLL_API HANDLE __cdecl bpm_createInstance(int numChannels, int sampleRate)
-{
-    BPMHANDLE *tmp = new BPMHANDLE;
-
-    if (tmp)
-    {
-        tmp->dwMagic = BPMMAGIC;
-        try
-        {
-            tmp->pbpm = new BPMDetect(numChannels, sampleRate);
-        }
-        catch (const std::exception&)
-        {
-            tmp->pbpm = nullptr;
-        }
-        if (tmp->pbpm == nullptr)
-        {
-            delete tmp;
-            tmp = nullptr;
-        }
-    }
-    return (HANDLE)tmp;
-}
-
-
-SOUNDTOUCHDLL_API void __cdecl bpm_destroyInstance(HANDLE h)
-{
-    BPMHANDLE *sth = (BPMHANDLE*)h;
-    if (sth->dwMagic != BPMMAGIC) return;
-
-    sth->dwMagic = 0;
-    if (sth->pbpm) delete sth->pbpm;
-    sth->pbpm = nullptr;
-    delete sth;
-}
-
-
-/// Feed 'numSamples' sample frames from 'samples' into the BPM detection handler
-SOUNDTOUCHDLL_API void __cdecl bpm_putSamples(HANDLE h,
-        const float *samples,
-        unsigned int numSamples)
-{
-    BPMHANDLE *bpmh = (BPMHANDLE*)h;
-    if (bpmh->dwMagic != BPMMAGIC) return;
-
-    bpmh->pbpm->inputSamples(samples, numSamples);
-}
-
-
-/// Feed 'numSamples' sample frames from 'samples' into the BPM detection handler.
-/// 16bit int sample format version.
-SOUNDTOUCHDLL_API void __cdecl bpm_putSamples_i16(HANDLE h,
-        const short *samples,
-        unsigned int numSamples)
-{
-    BPMHANDLE *bpmh = (BPMHANDLE*)h;
-    if (bpmh->dwMagic != BPMMAGIC) return;
-
-    uint numChannels = bpmh->numChannels;
-
-    // iterate until all samples converted & put to SoundTouch object
-    while (numSamples > 0)
-    {
-        float convert[8192];    // allocate temporary conversion buffer from stack
-
-        // how many multichannel samples fit into 'convert' buffer:
-        uint convSamples = 8192 / numChannels;
-
-        // convert max 'nround' values at a time to guarantee that these fit in the 'convert' buffer
-        uint n = (numSamples > convSamples) ? convSamples : numSamples;
-        for (uint i = 0; i < n * numChannels; i++)
-        {
-            convert[i] = samples[i];
-        }
-        // put the converted samples into SoundTouch
-        bpmh->pbpm->inputSamples(convert, n);
-
-        numSamples -= n;
-        samples += n * numChannels;
-    }
-}
-
-
-/// Analyzes the results and returns the BPM rate. Use this function to read result
-/// after whole song data has been input to the class by consecutive calls of
-/// 'inputSamples' function.
-///
-/// \return Beats-per-minute rate, or zero if detection failed.
-SOUNDTOUCHDLL_API float __cdecl bpm_getBpm(HANDLE h)
-{
-    BPMHANDLE *bpmh = (BPMHANDLE*)h;
-    if (bpmh->dwMagic != BPMMAGIC) return 0;
-
-    return bpmh->pbpm->getBpm();
-}
-
-
-/// Get beat position arrays. Note: The array includes also really low beat detection values 
-/// in absence of clear strong beats. Consumer may wish to filter low values away.
-/// - "pos" receive array of beat positions
-/// - "values" receive array of beat detection strengths
-/// - max_num indicates max.size of "pos" and "values" array.  
-///
-/// You can query a suitable array sized by calling this with nullptr in "pos" & "values".
-///
-/// \return number of beats in the arrays.
-SOUNDTOUCHDLL_API int __cdecl bpm_getBeats(HANDLE h, float* pos, float* strength, int count)
-{
-	BPMHANDLE *bpmh = (BPMHANDLE *)h;
-	if (bpmh->dwMagic != BPMMAGIC) return 0;
-
-	return bpmh->pbpm->getBeats(pos, strength, count);
-}
+//////////////////////////////////////////////////////////////////////////////
+///
+/// SoundTouch DLL wrapper - wraps SoundTouch routines into a Dynamic Load
+/// Library interface.
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+
+#if defined(_WIN32) || defined(WIN32)
+    #include 
+
+    // DLL main in Windows compilation
+    BOOL APIENTRY DllMain( HANDLE hModule,
+                           DWORD  ul_reason_for_call,
+                           LPVOID lpReserved
+                         )
+    {
+        switch (ul_reason_for_call)
+        {
+        case DLL_PROCESS_ATTACH:
+        case DLL_THREAD_ATTACH:
+        case DLL_THREAD_DETACH:
+        case DLL_PROCESS_DETACH:
+            break;
+        }
+        return TRUE;
+    }
+#endif
+
+#include 
+#include 
+#include "SoundTouchDLL.h"
+#include "SoundTouch.h"
+#include "BPMDetect.h"
+
+using namespace soundtouch;
+
+#ifdef SOUNDTOUCH_INTEGER_SAMPLES
+    #error "error - compile the dll version with float samples"
+#endif // SOUNDTOUCH_INTEGER_SAMPLES
+
+//////////////
+
+typedef struct
+{
+    DWORD dwMagic;
+    SoundTouch *pst;
+} STHANDLE;
+
+typedef struct
+{
+    DWORD dwMagic;
+    BPMDetect *pbpm;
+    uint numChannels;
+} BPMHANDLE;
+
+#define STMAGIC  0x1770C001
+#define BPMMAGIC 0x1771C10a
+
+SOUNDTOUCHDLL_API HANDLE __cdecl soundtouch_createInstance()
+{
+    STHANDLE *tmp = new STHANDLE;
+
+    if (tmp)
+    {
+        tmp->dwMagic = STMAGIC;
+        tmp->pst = new SoundTouch();
+        if (tmp->pst == nullptr)
+        {
+            delete tmp;
+            tmp = nullptr;
+        }
+    }
+    return (HANDLE)tmp;
+}
+
+
+SOUNDTOUCHDLL_API void __cdecl soundtouch_destroyInstance(HANDLE h)
+{
+    STHANDLE *sth = (STHANDLE*)h;
+    if (sth->dwMagic != STMAGIC) return;
+
+    sth->dwMagic = 0;
+    if (sth->pst) delete sth->pst;
+    sth->pst = nullptr;
+    delete sth;
+}
+
+
+/// Get SoundTouch library version string
+SOUNDTOUCHDLL_API const char *__cdecl soundtouch_getVersionString()
+{
+    return SoundTouch::getVersionString();
+}
+
+
+/// Get SoundTouch library version string - alternative function for
+/// environments that can't properly handle character string as return value
+SOUNDTOUCHDLL_API void __cdecl soundtouch_getVersionString2(char* versionString, int bufferSize)
+{
+    strncpy(versionString, SoundTouch::getVersionString(), bufferSize - 1);
+    versionString[bufferSize - 1] = 0;
+}
+
+
+/// Get SoundTouch library version Id
+SOUNDTOUCHDLL_API uint __cdecl soundtouch_getVersionId()
+{
+    return SoundTouch::getVersionId();
+}
+
+/// Sets new rate control value. Normal rate = 1.0, smaller values
+/// represent slower rate, larger faster rates.
+SOUNDTOUCHDLL_API void __cdecl soundtouch_setRate(HANDLE h, float newRate)
+{
+    STHANDLE *sth = (STHANDLE*)h;
+    if (sth->dwMagic != STMAGIC) return;
+
+    sth->pst->setRate(newRate);
+}
+
+
+/// Sets new tempo control value. Normal tempo = 1.0, smaller values
+/// represent slower tempo, larger faster tempo.
+SOUNDTOUCHDLL_API void __cdecl soundtouch_setTempo(HANDLE h, float newTempo)
+{
+    STHANDLE *sth = (STHANDLE*)h;
+    if (sth->dwMagic != STMAGIC) return;
+
+    sth->pst->setTempo(newTempo);
+}
+
+/// Sets new rate control value as a difference in percents compared
+/// to the original rate (-50 .. +100 %)
+SOUNDTOUCHDLL_API void __cdecl soundtouch_setRateChange(HANDLE h, float newRate)
+{
+    STHANDLE *sth = (STHANDLE*)h;
+    if (sth->dwMagic != STMAGIC) return;
+
+    sth->pst->setRateChange(newRate);
+}
+
+/// Sets new tempo control value as a difference in percents compared
+/// to the original tempo (-50 .. +100 %)
+SOUNDTOUCHDLL_API void __cdecl soundtouch_setTempoChange(HANDLE h, float newTempo)
+{
+    STHANDLE *sth = (STHANDLE*)h;
+    if (sth->dwMagic != STMAGIC) return;
+
+    sth->pst->setTempoChange(newTempo);
+}
+
+/// Sets new pitch control value. Original pitch = 1.0, smaller values
+/// represent lower pitches, larger values higher pitch.
+SOUNDTOUCHDLL_API void __cdecl soundtouch_setPitch(HANDLE h, float newPitch)
+{
+    STHANDLE *sth = (STHANDLE*)h;
+    if (sth->dwMagic != STMAGIC) return;
+
+    sth->pst->setPitch(newPitch);
+}
+
+/// Sets pitch change in octaves compared to the original pitch
+/// (-1.00 .. +1.00)
+SOUNDTOUCHDLL_API void __cdecl soundtouch_setPitchOctaves(HANDLE h, float newPitch)
+{
+    STHANDLE *sth = (STHANDLE*)h;
+    if (sth->dwMagic != STMAGIC) return;
+
+    sth->pst->setPitchOctaves(newPitch);
+}
+
+/// Sets pitch change in semi-tones compared to the original pitch
+/// (-12 .. +12)
+SOUNDTOUCHDLL_API void __cdecl soundtouch_setPitchSemiTones(HANDLE h, float newPitch)
+{
+    STHANDLE *sth = (STHANDLE*)h;
+    if (sth->dwMagic != STMAGIC) return;
+
+    sth->pst->setPitchSemiTones(newPitch);
+}
+
+
+/// Sets the number of channels, 1 = mono, 2 = stereo
+SOUNDTOUCHDLL_API int __cdecl soundtouch_setChannels(HANDLE h, uint numChannels)
+{
+    STHANDLE *sth = (STHANDLE*)h;
+    if (sth->dwMagic != STMAGIC) return 0;
+
+    try
+    {
+        sth->pst->setChannels(numChannels);
+    }
+    catch (const std::exception&)
+    {
+        return 0;
+    }
+    return 1;
+}
+
+/// Sets sample rate.
+SOUNDTOUCHDLL_API int __cdecl soundtouch_setSampleRate(HANDLE h, uint srate)
+{
+    STHANDLE *sth = (STHANDLE*)h;
+    if (sth->dwMagic != STMAGIC) return 0;
+
+    try
+    {
+        sth->pst->setSampleRate(srate);
+    }
+    catch (const std::exception&)
+    {
+        return 0;
+    }
+    return 1;
+}
+
+/// Flushes the last samples from the processing pipeline to the output.
+/// Clears also the internal processing buffers.
+//
+/// Note: This function is meant for extracting the last samples of a sound
+/// stream. This function may introduce additional blank samples in the end
+/// of the sound stream, and thus it's not recommended to call this function
+/// in the middle of a sound stream.
+SOUNDTOUCHDLL_API int __cdecl soundtouch_flush(HANDLE h)
+{
+    STHANDLE *sth = (STHANDLE*)h;
+    if (sth->dwMagic != STMAGIC) return 0;
+
+    try
+    {
+        sth->pst->flush();
+    }
+    catch (const std::exception&)
+    {
+        return 0;
+    }
+    return 1;
+}
+
+/// Adds 'numSamples' pcs of samples from the 'samples' memory position into
+/// the input of the object. Notice that sample rate _has_to_ be set before
+/// calling this function, otherwise throws a runtime_error exception.
+SOUNDTOUCHDLL_API int __cdecl soundtouch_putSamples(HANDLE h,
+        const SAMPLETYPE *samples,      ///< Pointer to sample buffer.
+        unsigned int numSamples         ///< Number of samples in buffer. Notice
+                                        ///< that in case of stereo-sound a single sample
+                                        ///< contains data for both channels.
+        )
+{
+    STHANDLE *sth = (STHANDLE*)h;
+    if (sth->dwMagic != STMAGIC) return 0;
+
+    try
+    {
+        sth->pst->putSamples(samples, numSamples);
+    }
+    catch (const std::exception&)
+    {
+        return 0;
+    }
+    return 1;
+}
+
+/// int16 version of soundtouch_putSamples(): This accept int16 (short) sample data
+/// and internally converts it to float format before processing
+SOUNDTOUCHDLL_API void __cdecl soundtouch_putSamples_i16(HANDLE h,
+        const short *samples,       ///< Pointer to sample buffer.
+        unsigned int numSamples     ///< Number of sample frames in buffer. Notice
+                                    ///< that in case of multi-channel sound a single sample
+                                    ///< contains data for all channels.
+        )
+{
+    STHANDLE *sth = (STHANDLE*)h;
+    if (sth->dwMagic != STMAGIC) return;
+
+    uint numChannels = sth->pst->numChannels();
+
+    // iterate until all samples converted & put to SoundTouch object
+    while (numSamples > 0)
+    {
+        float convert[8192];    // allocate temporary conversion buffer from stack
+
+        // how many multichannel samples fit into 'convert' buffer:
+        uint convSamples = 8192 / numChannels;
+
+        // convert max 'nround' values at a time to guarantee that these fit in the 'convert' buffer
+        uint n = (numSamples > convSamples) ? convSamples : numSamples;
+        for (uint i = 0; i < n * numChannels; i++)
+        {
+            convert[i] = samples[i];
+        }
+        // put the converted samples into SoundTouch
+        sth->pst->putSamples(convert, n);
+
+        numSamples -= n;
+        samples += n * numChannels;
+    }
+}
+
+/// Clears all the samples in the object's output and internal processing
+/// buffers.
+SOUNDTOUCHDLL_API void __cdecl soundtouch_clear(HANDLE h)
+{
+    STHANDLE *sth = (STHANDLE*)h;
+    if (sth->dwMagic != STMAGIC) return;
+
+    sth->pst->clear();
+}
+
+/// Changes a setting controlling the processing system behaviour. See the
+/// 'SETTING_...' defines for available setting ID's.
+///
+/// \return 'nonzero' if the setting was successfully changed
+SOUNDTOUCHDLL_API int __cdecl soundtouch_setSetting(HANDLE h,
+        int settingId,   ///< Setting ID number. see SETTING_... defines.
+        int value        ///< New setting value.
+        )
+{
+    STHANDLE *sth = (STHANDLE*)h;
+    if (sth->dwMagic != STMAGIC) return FALSE;
+
+    return sth->pst->setSetting(settingId, value);
+}
+
+/// Reads a setting controlling the processing system behaviour. See the
+/// 'SETTING_...' defines for available setting ID's.
+///
+/// \return the setting value.
+SOUNDTOUCHDLL_API int __cdecl soundtouch_getSetting(HANDLE h,
+        int settingId    ///< Setting ID number, see SETTING_... defines.
+        )
+{
+    STHANDLE *sth = (STHANDLE*)h;
+    if (sth->dwMagic != STMAGIC) return -1;
+
+    return sth->pst->getSetting(settingId);
+}
+
+
+/// Returns number of samples currently unprocessed.
+SOUNDTOUCHDLL_API uint __cdecl soundtouch_numUnprocessedSamples(HANDLE h)
+{
+    STHANDLE *sth = (STHANDLE*)h;
+    if (sth->dwMagic != STMAGIC) return 0;
+
+    return sth->pst->numUnprocessedSamples();
+}
+
+
+/// Receive ready samples from the processing pipeline.
+///
+/// if called with outBuffer=nullptr, just reduces amount of ready samples within the pipeline.
+SOUNDTOUCHDLL_API uint __cdecl soundtouch_receiveSamples(HANDLE h,
+        SAMPLETYPE *outBuffer,      ///< Buffer where to copy output samples.
+        unsigned int maxSamples     ///< How many samples to receive at max.
+        )
+{
+    STHANDLE *sth = (STHANDLE*)h;
+    if (sth->dwMagic != STMAGIC) return 0;
+
+    if (outBuffer)
+    {
+        return sth->pst->receiveSamples(outBuffer, maxSamples);
+    }
+    else
+    {
+        return sth->pst->receiveSamples(maxSamples);
+    }
+}
+
+
+/// int16 version of soundtouch_receiveSamples(): This converts internal float samples
+/// into int16 (short) return data type
+SOUNDTOUCHDLL_API uint __cdecl soundtouch_receiveSamples_i16(HANDLE h,
+        short *outBuffer,           ///< Buffer where to copy output samples.
+        unsigned int maxSamples     ///< How many samples to receive at max.
+        )
+{
+    STHANDLE *sth = (STHANDLE*)h;
+    if (sth->dwMagic != STMAGIC) return 0;
+    uint outTotal = 0;
+
+    if (outBuffer == nullptr)
+    {
+        // only reduce sample count, not receive samples
+        return sth->pst->receiveSamples(maxSamples);
+    }
+
+    uint numChannels = sth->pst->numChannels();
+
+    // iterate until all samples converted & put to SoundTouch object
+    while (maxSamples > 0)
+    {
+        float convert[8192];    // allocate temporary conversion buffer from stack
+
+        // how many multichannel samples fit into 'convert' buffer:
+        uint convSamples = 8192 / numChannels;
+
+        // request max 'nround' values at a time to guarantee that these fit in the 'convert' buffer
+        uint n = (maxSamples > convSamples) ? convSamples : maxSamples;
+
+        uint out = sth->pst->receiveSamples(convert, n);
+
+        // convert & saturate received samples to int16
+        for (uint i = 0; i < out * numChannels; i++)
+        {
+            // first convert value to int32, then saturate to int16 min/max limits
+            int value = (int)convert[i];
+            value = (value < SHRT_MIN) ? SHRT_MIN : (value > SHRT_MAX) ? SHRT_MAX : value;
+            outBuffer[i] = (short)value;
+        }
+        outTotal += out;
+        if (out < n) break;  // didn't get as many as asked => no more samples available => break here
+
+        maxSamples -= n;
+        outBuffer += out * numChannels;
+    }
+
+    // return number of processed samples
+    return outTotal;
+}
+
+
+/// Returns number of samples currently available.
+SOUNDTOUCHDLL_API uint __cdecl soundtouch_numSamples(HANDLE h)
+{
+    STHANDLE *sth = (STHANDLE*)h;
+    if (sth->dwMagic != STMAGIC) return 0;
+
+    return sth->pst->numSamples();
+}
+
+
+/// Returns nonzero if there aren't any samples available for outputting.
+SOUNDTOUCHDLL_API int __cdecl soundtouch_isEmpty(HANDLE h)
+{
+    STHANDLE *sth = (STHANDLE*)h;
+    if (sth->dwMagic != STMAGIC) return -1;
+
+    return sth->pst->isEmpty();
+}
+
+
+SOUNDTOUCHDLL_API HANDLE __cdecl bpm_createInstance(int numChannels, int sampleRate)
+{
+    BPMHANDLE *tmp = new BPMHANDLE;
+
+    if (tmp)
+    {
+        tmp->dwMagic = BPMMAGIC;
+        try
+        {
+            tmp->pbpm = new BPMDetect(numChannels, sampleRate);
+        }
+        catch (const std::exception&)
+        {
+            tmp->pbpm = nullptr;
+        }
+        if (tmp->pbpm == nullptr)
+        {
+            delete tmp;
+            tmp = nullptr;
+        }
+    }
+    return (HANDLE)tmp;
+}
+
+
+SOUNDTOUCHDLL_API void __cdecl bpm_destroyInstance(HANDLE h)
+{
+    BPMHANDLE *sth = (BPMHANDLE*)h;
+    if (sth->dwMagic != BPMMAGIC) return;
+
+    sth->dwMagic = 0;
+    if (sth->pbpm) delete sth->pbpm;
+    sth->pbpm = nullptr;
+    delete sth;
+}
+
+
+/// Feed 'numSamples' sample frames from 'samples' into the BPM detection handler
+SOUNDTOUCHDLL_API void __cdecl bpm_putSamples(HANDLE h,
+        const float *samples,
+        unsigned int numSamples)
+{
+    BPMHANDLE *bpmh = (BPMHANDLE*)h;
+    if (bpmh->dwMagic != BPMMAGIC) return;
+
+    bpmh->pbpm->inputSamples(samples, numSamples);
+}
+
+
+/// Feed 'numSamples' sample frames from 'samples' into the BPM detection handler.
+/// 16bit int sample format version.
+SOUNDTOUCHDLL_API void __cdecl bpm_putSamples_i16(HANDLE h,
+        const short *samples,
+        unsigned int numSamples)
+{
+    BPMHANDLE *bpmh = (BPMHANDLE*)h;
+    if (bpmh->dwMagic != BPMMAGIC) return;
+
+    uint numChannels = bpmh->numChannels;
+
+    // iterate until all samples converted & put to SoundTouch object
+    while (numSamples > 0)
+    {
+        float convert[8192];    // allocate temporary conversion buffer from stack
+
+        // how many multichannel samples fit into 'convert' buffer:
+        uint convSamples = 8192 / numChannels;
+
+        // convert max 'nround' values at a time to guarantee that these fit in the 'convert' buffer
+        uint n = (numSamples > convSamples) ? convSamples : numSamples;
+        for (uint i = 0; i < n * numChannels; i++)
+        {
+            convert[i] = samples[i];
+        }
+        // put the converted samples into SoundTouch
+        bpmh->pbpm->inputSamples(convert, n);
+
+        numSamples -= n;
+        samples += n * numChannels;
+    }
+}
+
+
+/// Analyzes the results and returns the BPM rate. Use this function to read result
+/// after whole song data has been input to the class by consecutive calls of
+/// 'inputSamples' function.
+///
+/// \return Beats-per-minute rate, or zero if detection failed.
+SOUNDTOUCHDLL_API float __cdecl bpm_getBpm(HANDLE h)
+{
+    BPMHANDLE *bpmh = (BPMHANDLE*)h;
+    if (bpmh->dwMagic != BPMMAGIC) return 0;
+
+    return bpmh->pbpm->getBpm();
+}
+
+
+/// Get beat position arrays. Note: The array includes also really low beat detection values
+/// in absence of clear strong beats. Consumer may wish to filter low values away.
+/// - "pos" receive array of beat positions
+/// - "values" receive array of beat detection strengths
+/// - max_num indicates max.size of "pos" and "values" array.
+///
+/// You can query a suitable array sized by calling this with nullptr in "pos" & "values".
+///
+/// \return number of beats in the arrays.
+SOUNDTOUCHDLL_API int __cdecl bpm_getBeats(HANDLE h, float* pos, float* strength, int count)
+{
+	BPMHANDLE *bpmh = (BPMHANDLE *)h;
+	if (bpmh->dwMagic != BPMMAGIC) return 0;
+
+	return bpmh->pbpm->getBeats(pos, strength, count);
+}
diff --git a/source/SoundTouchDLL/SoundTouchDLL.h b/source/SoundTouchDLL/SoundTouchDLL.h
index 47cc132..1dde9b0 100644
--- a/source/SoundTouchDLL/SoundTouchDLL.h
+++ b/source/SoundTouchDLL/SoundTouchDLL.h
@@ -1,240 +1,240 @@
-//////////////////////////////////////////////////////////////////////////////
-///
-/// SoundTouch DLL wrapper - wraps SoundTouch routines into a Dynamic Load 
-/// Library interface.
-///
-/// Author        : Copyright (c) Olli Parviainen
-/// Author e-mail : oparviai 'at' iki.fi
-/// SoundTouch WWW: http://www.surina.net/soundtouch
-///
-////////////////////////////////////////////////////////////////////////////////
-//
-// License :
-//
-//  SoundTouch audio processing library
-//  Copyright (c) Olli Parviainen
-//
-//  This library is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU Lesser General Public
-//  License as published by the Free Software Foundation; either
-//  version 2.1 of the License, or (at your option) any later version.
-//
-//  This library is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-//  Lesser General Public License for more details.
-//
-//  You should have received a copy of the GNU Lesser General Public
-//  License along with this library; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef _SoundTouchDLL_h_
-#define _SoundTouchDLL_h_
-
-#if defined(_WIN32) || defined(WIN32)
-    // Windows
-    #ifndef __cplusplus
-        #error "Expected g++"
-    #endif
-
-    #ifdef DLL_EXPORTS
-        #define SOUNDTOUCHDLL_API extern "C" __declspec(dllexport)
-    #else
-        #define SOUNDTOUCHDLL_API extern "C" __declspec(dllimport)
-    #endif
-
-#else
-    // GNU version
-
-    #if defined(DLL_EXPORTS) || defined(SoundTouchDLL_EXPORTS)
-        // GCC declaration for exporting functions
-        #define SOUNDTOUCHDLL_API extern "C" __attribute__((__visibility__("default")))
-    #else
-        // import function
-        #define SOUNDTOUCHDLL_API extern "C"
-    #endif
-
-    // Linux-replacements for Windows declarations:
-    #define __cdecl
-    typedef unsigned int DWORD;
-    #define FALSE    0
-    #define TRUE    1
-
-#endif
-
-typedef void * HANDLE;
-
-/// Create a new instance of SoundTouch processor.
-SOUNDTOUCHDLL_API HANDLE __cdecl soundtouch_createInstance();
-
-/// Destroys a SoundTouch processor instance.
-SOUNDTOUCHDLL_API void __cdecl soundtouch_destroyInstance(HANDLE h);
-
-/// Get SoundTouch library version string
-SOUNDTOUCHDLL_API const char *__cdecl soundtouch_getVersionString();
-
-/// Get SoundTouch library version string - alternative function for 
-/// environments that can't properly handle character string as return value
-SOUNDTOUCHDLL_API void __cdecl soundtouch_getVersionString2(char* versionString, int bufferSize);
-
-/// Get SoundTouch library version Id
-SOUNDTOUCHDLL_API unsigned int __cdecl soundtouch_getVersionId();
-
-/// Sets new rate control value. Normal rate = 1.0, smaller values
-/// represent slower rate, larger faster rates.
-SOUNDTOUCHDLL_API void __cdecl soundtouch_setRate(HANDLE h, float newRate);
-
-/// Sets new tempo control value. Normal tempo = 1.0, smaller values
-/// represent slower tempo, larger faster tempo.
-SOUNDTOUCHDLL_API void __cdecl soundtouch_setTempo(HANDLE h, float newTempo);
-
-/// Sets new rate control value as a difference in percents compared
-/// to the original rate (-50 .. +100 %);
-SOUNDTOUCHDLL_API void __cdecl soundtouch_setRateChange(HANDLE h, float newRate);
-
-/// Sets new tempo control value as a difference in percents compared
-/// to the original tempo (-50 .. +100 %);
-SOUNDTOUCHDLL_API void __cdecl soundtouch_setTempoChange(HANDLE h, float newTempo);
-
-/// Sets new pitch control value. Original pitch = 1.0, smaller values
-/// represent lower pitches, larger values higher pitch.
-SOUNDTOUCHDLL_API void __cdecl soundtouch_setPitch(HANDLE h, float newPitch);
-
-/// Sets pitch change in octaves compared to the original pitch  
-/// (-1.00 .. +1.00);
-SOUNDTOUCHDLL_API void __cdecl soundtouch_setPitchOctaves(HANDLE h, float newPitch);
-
-/// Sets pitch change in semi-tones compared to the original pitch
-/// (-12 .. +12);
-SOUNDTOUCHDLL_API void __cdecl soundtouch_setPitchSemiTones(HANDLE h, float newPitch);
-
-
-/// Sets the number of channels, 1 = mono, 2 = stereo, n = multichannel
-SOUNDTOUCHDLL_API int __cdecl soundtouch_setChannels(HANDLE h, unsigned int numChannels);
-
-/// Sets sample rate.
-SOUNDTOUCHDLL_API int __cdecl soundtouch_setSampleRate(HANDLE h, unsigned int srate);
-
-/// Flushes the last samples from the processing pipeline to the output.
-/// Clears also the internal processing buffers.
-//
-/// Note: This function is meant for extracting the last samples of a sound
-/// stream. This function may introduce additional blank samples in the end
-/// of the sound stream, and thus it's not recommended to call this function
-/// in the middle of a sound stream.
-SOUNDTOUCHDLL_API int __cdecl soundtouch_flush(HANDLE h);
-
-/// Adds 'numSamples' pcs of samples from the 'samples' memory position into
-/// the input of the object. Notice that sample rate _has_to_ be set before
-/// calling this function, otherwise throws a runtime_error exception.
-SOUNDTOUCHDLL_API int __cdecl soundtouch_putSamples(HANDLE h,
-        const float *samples,       ///< Pointer to sample buffer.
-        unsigned int numSamples     ///< Number of sample frames in buffer. Notice
-                                    ///< that in case of multi-channel sound a single 
-                                    ///< sample frame contains data for all channels.
-);
-
-/// int16 version of soundtouch_putSamples(): This accept int16 (short) sample data
-/// and internally converts it to float format before processing
-SOUNDTOUCHDLL_API void __cdecl soundtouch_putSamples_i16(HANDLE h,
-        const short *samples,       ///< Pointer to sample buffer.
-        unsigned int numSamples     ///< Number of sample frames in buffer. Notice
-                                    ///< that in case of multi-channel sound a single 
-                                    ///< sample frame contains data for all channels.
-);
-
-
-/// Clears all the samples in the object's output and internal processing
-/// buffers.
-SOUNDTOUCHDLL_API void __cdecl soundtouch_clear(HANDLE h);
-
-/// Changes a setting controlling the processing system behaviour. See the
-/// 'SETTING_...' defines for available setting ID's.
-/// 
-/// \return 'nonzero' if the setting was successfully changed, otherwise zero
-SOUNDTOUCHDLL_API int __cdecl soundtouch_setSetting(HANDLE h, 
-        int settingId,   ///< Setting ID number. see SETTING_... defines.
-        int value        ///< New setting value.
-);
-
-/// Reads a setting controlling the processing system behaviour. See the
-/// 'SETTING_...' defines for available setting ID's.
-///
-/// \return the setting value.
-SOUNDTOUCHDLL_API int __cdecl soundtouch_getSetting(HANDLE h, 
-        int settingId    ///< Setting ID number, see SETTING_... defines.
-);
-
-
-/// Returns number of samples currently unprocessed.
-SOUNDTOUCHDLL_API unsigned int __cdecl soundtouch_numUnprocessedSamples(HANDLE h);
-
-/// Adjusts book-keeping so that given number of samples are removed from beginning of the 
-/// sample buffer without copying them anywhere. 
-///
-/// Used to reduce the number of samples in the buffer when accessing the sample buffer directly
-/// with 'ptrBegin' function.
-SOUNDTOUCHDLL_API unsigned int __cdecl soundtouch_receiveSamples(HANDLE h, 
-        float *outBuffer,           ///< Buffer where to copy output samples.
-        unsigned int maxSamples     ///< How many samples to receive at max.
-);
-
-
-/// int16 version of soundtouch_receiveSamples(): This converts internal float samples
-/// into int16 (short) return data type
-SOUNDTOUCHDLL_API unsigned int __cdecl soundtouch_receiveSamples_i16(HANDLE h,
-        short *outBuffer,           ///< Buffer where to copy output samples.
-        unsigned int maxSamples     ///< How many samples to receive at max.
-);
-
-/// Returns number of samples currently available.
-SOUNDTOUCHDLL_API unsigned int __cdecl soundtouch_numSamples(HANDLE h);
-
-/// Returns nonzero if there aren't any samples available for outputting.
-SOUNDTOUCHDLL_API int __cdecl soundtouch_isEmpty(HANDLE h);
-
-/// Create a new instance of BPM detector
-SOUNDTOUCHDLL_API HANDLE __cdecl bpm_createInstance(int numChannels, int sampleRate);
-
-/// Destroys a BPM detector instance.
-SOUNDTOUCHDLL_API void __cdecl bpm_destroyInstance(HANDLE h);
-
-/// Feed 'numSamples' sample frames from 'samples' into the BPM detector.
-SOUNDTOUCHDLL_API void __cdecl bpm_putSamples(HANDLE h, 
-        const float *samples,           ///< Pointer to sample buffer.
-        unsigned int numSamples         ///< Number of samples in buffer. Notice
-                                        ///< that in case of stereo-sound a single sample
-                                        ///< contains data for both channels.
-        );
-
-/// Feed 'numSamples' sample frames from 'samples' into the BPM detector.
-/// 16bit int sample format version.
-SOUNDTOUCHDLL_API void __cdecl bpm_putSamples_i16(HANDLE h, 
-        const short *samples,           ///< Pointer to sample buffer.
-        unsigned int numSamples         ///< Number of samples in buffer. Notice
-                                        ///< that in case of stereo-sound a single sample
-                                        ///< contains data for both channels.
-        );
-
-/// Analyzes the results and returns the BPM rate. Use this function to read result
-/// after whole song data has been input to the class by consecutive calls of
-/// 'inputSamples' function.
-///
-/// \return Beats-per-minute rate, or zero if detection failed.
-SOUNDTOUCHDLL_API float __cdecl bpm_getBpm(HANDLE h);
-
-/// Get beat position arrays. Note: The array includes also really low beat detection values 
-/// in absence of clear strong beats. Consumer may wish to filter low values away.
-/// - "pos" receive array of beat positions
-/// - "values" receive array of beat detection strengths
-/// - max_num indicates max.size of "pos" and "values" array.  
-///
-/// You can query a suitable array sized by calling this with nullptr in "pos" & "values".
-///
-/// \return number of beats in the arrays.
-SOUNDTOUCHDLL_API int __cdecl bpm_getBeats(HANDLE h, float *pos, float *strength, int count);
-
-#endif  // _SoundTouchDLL_h_
-
+//////////////////////////////////////////////////////////////////////////////
+///
+/// SoundTouch DLL wrapper - wraps SoundTouch routines into a Dynamic Load
+/// Library interface.
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef _SoundTouchDLL_h_
+#define _SoundTouchDLL_h_
+
+#if defined(_WIN32) || defined(WIN32)
+    // Windows
+    #ifndef __cplusplus
+        #error "Expected g++"
+    #endif
+
+    #ifdef DLL_EXPORTS
+        #define SOUNDTOUCHDLL_API extern "C" __declspec(dllexport)
+    #else
+        #define SOUNDTOUCHDLL_API extern "C" __declspec(dllimport)
+    #endif
+
+#else
+    // GNU version
+
+    #if defined(DLL_EXPORTS) || defined(SoundTouchDLL_EXPORTS)
+        // GCC declaration for exporting functions
+        #define SOUNDTOUCHDLL_API extern "C" __attribute__((__visibility__("default")))
+    #else
+        // import function
+        #define SOUNDTOUCHDLL_API extern "C"
+    #endif
+
+    // Linux-replacements for Windows declarations:
+    #define __cdecl
+    typedef unsigned int DWORD;
+    #define FALSE    0
+    #define TRUE    1
+
+#endif
+
+typedef void * HANDLE;
+
+/// Create a new instance of SoundTouch processor.
+SOUNDTOUCHDLL_API HANDLE __cdecl soundtouch_createInstance();
+
+/// Destroys a SoundTouch processor instance.
+SOUNDTOUCHDLL_API void __cdecl soundtouch_destroyInstance(HANDLE h);
+
+/// Get SoundTouch library version string
+SOUNDTOUCHDLL_API const char *__cdecl soundtouch_getVersionString();
+
+/// Get SoundTouch library version string - alternative function for
+/// environments that can't properly handle character string as return value
+SOUNDTOUCHDLL_API void __cdecl soundtouch_getVersionString2(char* versionString, int bufferSize);
+
+/// Get SoundTouch library version Id
+SOUNDTOUCHDLL_API unsigned int __cdecl soundtouch_getVersionId();
+
+/// Sets new rate control value. Normal rate = 1.0, smaller values
+/// represent slower rate, larger faster rates.
+SOUNDTOUCHDLL_API void __cdecl soundtouch_setRate(HANDLE h, float newRate);
+
+/// Sets new tempo control value. Normal tempo = 1.0, smaller values
+/// represent slower tempo, larger faster tempo.
+SOUNDTOUCHDLL_API void __cdecl soundtouch_setTempo(HANDLE h, float newTempo);
+
+/// Sets new rate control value as a difference in percents compared
+/// to the original rate (-50 .. +100 %);
+SOUNDTOUCHDLL_API void __cdecl soundtouch_setRateChange(HANDLE h, float newRate);
+
+/// Sets new tempo control value as a difference in percents compared
+/// to the original tempo (-50 .. +100 %);
+SOUNDTOUCHDLL_API void __cdecl soundtouch_setTempoChange(HANDLE h, float newTempo);
+
+/// Sets new pitch control value. Original pitch = 1.0, smaller values
+/// represent lower pitches, larger values higher pitch.
+SOUNDTOUCHDLL_API void __cdecl soundtouch_setPitch(HANDLE h, float newPitch);
+
+/// Sets pitch change in octaves compared to the original pitch
+/// (-1.00 .. +1.00);
+SOUNDTOUCHDLL_API void __cdecl soundtouch_setPitchOctaves(HANDLE h, float newPitch);
+
+/// Sets pitch change in semi-tones compared to the original pitch
+/// (-12 .. +12);
+SOUNDTOUCHDLL_API void __cdecl soundtouch_setPitchSemiTones(HANDLE h, float newPitch);
+
+
+/// Sets the number of channels, 1 = mono, 2 = stereo, n = multichannel
+SOUNDTOUCHDLL_API int __cdecl soundtouch_setChannels(HANDLE h, unsigned int numChannels);
+
+/// Sets sample rate.
+SOUNDTOUCHDLL_API int __cdecl soundtouch_setSampleRate(HANDLE h, unsigned int srate);
+
+/// Flushes the last samples from the processing pipeline to the output.
+/// Clears also the internal processing buffers.
+//
+/// Note: This function is meant for extracting the last samples of a sound
+/// stream. This function may introduce additional blank samples in the end
+/// of the sound stream, and thus it's not recommended to call this function
+/// in the middle of a sound stream.
+SOUNDTOUCHDLL_API int __cdecl soundtouch_flush(HANDLE h);
+
+/// Adds 'numSamples' pcs of samples from the 'samples' memory position into
+/// the input of the object. Notice that sample rate _has_to_ be set before
+/// calling this function, otherwise throws a runtime_error exception.
+SOUNDTOUCHDLL_API int __cdecl soundtouch_putSamples(HANDLE h,
+        const float *samples,       ///< Pointer to sample buffer.
+        unsigned int numSamples     ///< Number of sample frames in buffer. Notice
+                                    ///< that in case of multi-channel sound a single
+                                    ///< sample frame contains data for all channels.
+);
+
+/// int16 version of soundtouch_putSamples(): This accept int16 (short) sample data
+/// and internally converts it to float format before processing
+SOUNDTOUCHDLL_API void __cdecl soundtouch_putSamples_i16(HANDLE h,
+        const short *samples,       ///< Pointer to sample buffer.
+        unsigned int numSamples     ///< Number of sample frames in buffer. Notice
+                                    ///< that in case of multi-channel sound a single
+                                    ///< sample frame contains data for all channels.
+);
+
+
+/// Clears all the samples in the object's output and internal processing
+/// buffers.
+SOUNDTOUCHDLL_API void __cdecl soundtouch_clear(HANDLE h);
+
+/// Changes a setting controlling the processing system behaviour. See the
+/// 'SETTING_...' defines for available setting ID's.
+///
+/// \return 'nonzero' if the setting was successfully changed, otherwise zero
+SOUNDTOUCHDLL_API int __cdecl soundtouch_setSetting(HANDLE h,
+        int settingId,   ///< Setting ID number. see SETTING_... defines.
+        int value        ///< New setting value.
+);
+
+/// Reads a setting controlling the processing system behaviour. See the
+/// 'SETTING_...' defines for available setting ID's.
+///
+/// \return the setting value.
+SOUNDTOUCHDLL_API int __cdecl soundtouch_getSetting(HANDLE h,
+        int settingId    ///< Setting ID number, see SETTING_... defines.
+);
+
+
+/// Returns number of samples currently unprocessed.
+SOUNDTOUCHDLL_API unsigned int __cdecl soundtouch_numUnprocessedSamples(HANDLE h);
+
+/// Adjusts book-keeping so that given number of samples are removed from beginning of the
+/// sample buffer without copying them anywhere.
+///
+/// Used to reduce the number of samples in the buffer when accessing the sample buffer directly
+/// with 'ptrBegin' function.
+SOUNDTOUCHDLL_API unsigned int __cdecl soundtouch_receiveSamples(HANDLE h,
+        float *outBuffer,           ///< Buffer where to copy output samples.
+        unsigned int maxSamples     ///< How many samples to receive at max.
+);
+
+
+/// int16 version of soundtouch_receiveSamples(): This converts internal float samples
+/// into int16 (short) return data type
+SOUNDTOUCHDLL_API unsigned int __cdecl soundtouch_receiveSamples_i16(HANDLE h,
+        short *outBuffer,           ///< Buffer where to copy output samples.
+        unsigned int maxSamples     ///< How many samples to receive at max.
+);
+
+/// Returns number of samples currently available.
+SOUNDTOUCHDLL_API unsigned int __cdecl soundtouch_numSamples(HANDLE h);
+
+/// Returns nonzero if there aren't any samples available for outputting.
+SOUNDTOUCHDLL_API int __cdecl soundtouch_isEmpty(HANDLE h);
+
+/// Create a new instance of BPM detector
+SOUNDTOUCHDLL_API HANDLE __cdecl bpm_createInstance(int numChannels, int sampleRate);
+
+/// Destroys a BPM detector instance.
+SOUNDTOUCHDLL_API void __cdecl bpm_destroyInstance(HANDLE h);
+
+/// Feed 'numSamples' sample frames from 'samples' into the BPM detector.
+SOUNDTOUCHDLL_API void __cdecl bpm_putSamples(HANDLE h,
+        const float *samples,           ///< Pointer to sample buffer.
+        unsigned int numSamples         ///< Number of samples in buffer. Notice
+                                        ///< that in case of stereo-sound a single sample
+                                        ///< contains data for both channels.
+        );
+
+/// Feed 'numSamples' sample frames from 'samples' into the BPM detector.
+/// 16bit int sample format version.
+SOUNDTOUCHDLL_API void __cdecl bpm_putSamples_i16(HANDLE h,
+        const short *samples,           ///< Pointer to sample buffer.
+        unsigned int numSamples         ///< Number of samples in buffer. Notice
+                                        ///< that in case of stereo-sound a single sample
+                                        ///< contains data for both channels.
+        );
+
+/// Analyzes the results and returns the BPM rate. Use this function to read result
+/// after whole song data has been input to the class by consecutive calls of
+/// 'inputSamples' function.
+///
+/// \return Beats-per-minute rate, or zero if detection failed.
+SOUNDTOUCHDLL_API float __cdecl bpm_getBpm(HANDLE h);
+
+/// Get beat position arrays. Note: The array includes also really low beat detection values
+/// in absence of clear strong beats. Consumer may wish to filter low values away.
+/// - "pos" receive array of beat positions
+/// - "values" receive array of beat detection strengths
+/// - max_num indicates max.size of "pos" and "values" array.
+///
+/// You can query a suitable array sized by calling this with nullptr in "pos" & "values".
+///
+/// \return number of beats in the arrays.
+SOUNDTOUCHDLL_API int __cdecl bpm_getBeats(HANDLE h, float *pos, float *strength, int count);
+
+#endif  // _SoundTouchDLL_h_
+
diff --git a/source/SoundTouchDLL/SoundTouchDLL.rc b/source/SoundTouchDLL/SoundTouchDLL.rc
index 3db03c6..70a666f 100644
--- a/source/SoundTouchDLL/SoundTouchDLL.rc
+++ b/source/SoundTouchDLL/SoundTouchDLL.rc
@@ -25,18 +25,18 @@ LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
 // TEXTINCLUDE
 //
 
-1 TEXTINCLUDE 
+1 TEXTINCLUDE
 BEGIN
     "resource.h\0"
 END
 
-2 TEXTINCLUDE 
+2 TEXTINCLUDE
 BEGIN
     "#include ""afxres.h""\r\n"
     "\0"
 END
 
-3 TEXTINCLUDE 
+3 TEXTINCLUDE
 BEGIN
     "\r\n"
     "\0"
diff --git a/source/SoundTouchDLL/resource.h b/source/SoundTouchDLL/resource.h
index a061ba4..0ef1170 100644
--- a/source/SoundTouchDLL/resource.h
+++ b/source/SoundTouchDLL/resource.h
@@ -1,15 +1,15 @@
-//{{NO_DEPENDENCIES}}
-// Microsoft Visual C++ generated include file.
-// Used by SoundTouchDLL.rc
-//
-
-// Next default values for new objects
-// 
-#ifdef APSTUDIO_INVOKED
-#ifndef APSTUDIO_READONLY_SYMBOLS
-#define _APS_NEXT_RESOURCE_VALUE        101
-#define _APS_NEXT_COMMAND_VALUE         40001
-#define _APS_NEXT_CONTROL_VALUE         1000
-#define _APS_NEXT_SYMED_VALUE           101
-#endif
-#endif
+//{{NO_DEPENDENCIES}}
+// Microsoft Visual C++ generated include file.
+// Used by SoundTouchDLL.rc
+//
+
+// Next default values for new objects
+//
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        101
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1000
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif