From ebc3923b35083dac0565cf2bf072d9d15e3e611a Mon Sep 17 00:00:00 2001
From: JordanTheToaster <jordanh48@ymail.com>
Date: Tue, 6 Aug 2024 03:23:12 +0100
Subject: [PATCH] 3rdparty/soundtouch: Bump to v2.3.3

---
 3rdparty/soundtouch/README.html               |  41 +-
 3rdparty/soundtouch/soundtouch/BPMDetect.h    |  22 +-
 .../soundtouch/soundtouch/FIFOSampleBuffer.h  |  48 +-
 .../soundtouch/soundtouch/FIFOSamplePipe.h    |  48 +-
 3rdparty/soundtouch/soundtouch/STTypes.h      |  34 +-
 3rdparty/soundtouch/soundtouch/SoundTouch.h   | 118 ++--
 .../source/SoundStretch/SS_CharTypes.h        |  52 ++
 .../source/SoundStretch/WavFile.cpp           | 576 +++++++++---------
 .../soundtouch/source/SoundStretch/WavFile.h  |  50 +-
 .../soundtouch/source/SoundTouch/AAFilter.cpp |  28 +-
 .../soundtouch/source/SoundTouch/AAFilter.h   |  26 +-
 .../source/SoundTouch/BPMDetect.cpp           |  50 +-
 .../source/SoundTouch/FIFOSampleBuffer.cpp    |  54 +-
 .../source/SoundTouch/FIRFilter.cpp           |  58 +-
 .../soundtouch/source/SoundTouch/FIRFilter.h  |  32 +-
 .../source/SoundTouch/InterpolateCubic.cpp    |  22 +-
 .../source/SoundTouch/InterpolateCubic.h      |  18 +-
 .../source/SoundTouch/InterpolateLinear.cpp   |  36 +-
 .../source/SoundTouch/InterpolateLinear.h     |  36 +-
 .../source/SoundTouch/InterpolateShannon.cpp  |  26 +-
 .../source/SoundTouch/InterpolateShannon.h    |  20 +-
 .../source/SoundTouch/PeakFinder.cpp          |  20 +-
 .../soundtouch/source/SoundTouch/PeakFinder.h |   6 +-
 .../source/SoundTouch/RateTransposer.cpp      |  40 +-
 .../source/SoundTouch/RateTransposer.h        |  24 +-
 .../source/SoundTouch/SoundTouch.cpp          |  86 +--
 .../source/SoundTouch/TDStretch.cpp           | 142 ++---
 .../soundtouch/source/SoundTouch/TDStretch.h  |  44 +-
 .../soundtouch/source/SoundTouch/cpu_detect.h |   4 +-
 .../source/SoundTouch/cpu_detect_x86.cpp      |   8 +-
 .../source/SoundTouch/mmx_optimized.cpp       |  32 +-
 .../source/SoundTouch/sse_optimized.cpp       |  68 +--
 32 files changed, 954 insertions(+), 915 deletions(-)
 create mode 100644 3rdparty/soundtouch/source/SoundStretch/SS_CharTypes.h
diff --git a/3rdparty/soundtouch/README.html b/3rdparty/soundtouch/README.html
index 1efe7a6ec2..3ce778e437 100644
--- a/3rdparty/soundtouch/README.html
+++ b/3rdparty/soundtouch/README.html
@@ -15,8 +15,8 @@
 
 <body class="normal">
   <hr>
-  <h1>SoundTouch audio processing library v2.3.1</h1>
-  <p class="normal">SoundTouch library Copyright &copy; Olli Parviainen 2001-2021</p>
+  <h1>SoundTouch audio processing library v2.3.3</h1>
+  <p class="normal">SoundTouch library Copyright &copy; Olli Parviainen 2001-2024</p>
   <hr>
   <h2>1. Introduction </h2>
   <p>SoundTouch is an open-source audio processing library that allows
@@ -35,7 +35,7 @@
   <p>Author email: oparviai 'at' iki.fi </p>
   <p>SoundTouch WWW page: <a href="http://soundtouch.surina.net">http://soundtouch.surina.net</a></p>
   <p>SoundTouch git repository: <a
-      href="https://gitlab.com/soundtouch/soundtouch.git">https://gitlab.com/soundtouch/soundtouch.git</a></p>
+      href="https://codeberg.org/soundtouch/soundtouch.git">https://codeberg.org/soundtouch/soundtouch.git</a></p>
   <hr>
   <h2>2. Compiling SoundTouch</h2>
   <p>Before compiling, notice that you can choose the sample data format if it's
@@ -131,10 +131,12 @@
   </table>
 
   <b>Compiling portable Shared Library / DLL version</b>
-  <p> The GNU autotools compilation does not automatically create a shared-library version of
-    SoundTouch (.so or .dll) that features position-independent code and C-language
-    api that are more suitable for cross-language development than C++ libraries.</p>
-  <p> Use script "make-gnu-dll-sh" to build a portable dynamic library version if such is desired.</p>
+  <p> The GNU autotools compilation automatically builds an additional dynamic-link version
+    of SoundTouch library that features position-independent code and "C"-style API that is
+    more suitable for calling the SoundTouch routines from other programming languages.</p>
+    <p>This dynamic-link library is built under source/SoundTouchDLL directory, whose
+    subdirectories also comtain simple example apps that use the dynamic-link library.
+  </p>
 
   <h4><b>2.2.2 Compiling with cmake</b></h4>
   <p>'cmake' build scripts are provided as an alternative to the autotools toolchain.</p>
@@ -145,6 +147,9 @@
     cmake .
     make -j
     make install</pre>
+  <p>To list available build options:</p>
+  <pre>
+    cmake -LH</pre>
   <p>To compile the additional portable Shared Library / DLL version with the native C-language API:</p>
   <pre>
     cmake . -DSOUNDTOUCH_DLL=ON
@@ -448,7 +453,7 @@
     <h2><a name="SoundStretch"></a>4. SoundStretch audio processing utility
     </h2>
     <p>SoundStretch audio processing utility<br>
-      Copyright (c) Olli Parviainen 2002-2015</p>
+      Copyright (c) Olli Parviainen 2002-2024</p>
     <p>SoundStretch is a simple command-line application that can change
       tempo, pitch and playback rates of WAV sound files. This program is
       intended primarily to demonstrate how the "SoundTouch" library can be
@@ -603,6 +608,18 @@
     <hr>
     <h2>5. Change History</h2>
     <h3>5.1. SoundTouch library Change History </h3>
+    <p><b>2.3.3:</b></p>
+    <ul class="current">
+        <li>Fixing compiler warnings, maintenance fixes to make/build files for various systems
+        </li>
+    </ul>
+    <p><b>2.3.2:</b></p>
+    <ul>
+        <li>Improve autotools makefiles to build the `SoundTouchDLL` dynamic-link link library with
+          C-style API. This library variation is easier to import and use from other programming
+          languages than the default C++ library.
+      </li>
+    </ul>
     <p><b>2.3.1:</b></p>
     <ul>
       <li>Adjusted cmake build settings and header files that cmake installs</li>
@@ -622,7 +639,7 @@
         window. This ensures that with zero tempo change the output will be same as input.
       </li>
       <li>Bugfix: Fix a bug in TDstrectch with too small initial skipFract value that occurred
-        with certain processing parameter settings: Replace assert with assignment that 
+        with certain processing parameter settings: Replace assert with assignment that
         corrects the situation.
       </li>
       <li>Remove OpenMP "_init_threading" workaround from Android build as it's not needed with concurrent
@@ -865,11 +882,14 @@
       <li> Initial release</li>
     </ul>
     <h3>5.2. SoundStretch application Change History </h3>
+    <p><b>2.3.3:</b></p>
+    <ul class="current_soundstretch">
+      <li>Added support for Asian / non-latin filenames in Windows. Gnu platform has supported them already earlier.</li>
+    </ul>
     <p><b>1.9:</b></p>
     <ul>
       <li>Added support for WAV file 'fact' information chunk.</li>
     </ul>
-
     <p><b>1.7.0:</b></p>
     <ul>
       <li>Bugfixes in Wavfile: exception string formatting, avoid getLengthMs() integer
@@ -966,6 +986,7 @@
       <li> Michael Pruett</li>
       <li> Rajeev Puran</li>
       <li> RJ Ryan</li>
+      <li> Serge Sans Paille</li>
       <li> John Sheehy</li>
       <li> Tim Shuttleworth</li>
       <li> Albert Sirvent</li>
diff --git a/3rdparty/soundtouch/soundtouch/BPMDetect.h b/3rdparty/soundtouch/soundtouch/BPMDetect.h
index f025fbd1c5..bf596a1bc8 100644
--- a/3rdparty/soundtouch/soundtouch/BPMDetect.h
+++ b/3rdparty/soundtouch/soundtouch/BPMDetect.h
@@ -14,10 +14,10 @@
 ///   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 
+/// - 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 
+/// - 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
@@ -137,8 +137,8 @@ namespace soundtouch
         // 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 
+        /// 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.
         );
@@ -175,9 +175,9 @@ namespace soundtouch
 
         /// 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. 
-        /// 
+        /// 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
@@ -190,13 +190,13 @@ namespace soundtouch
         /// \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 
+        /// 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.  
+        /// - max_num indicates max.size of "pos" and "values" array.
         ///
-        /// You can query a suitable array sized by calling this with NULL in "pos" & "values".
+        /// 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);
diff --git a/3rdparty/soundtouch/soundtouch/FIFOSampleBuffer.h b/3rdparty/soundtouch/soundtouch/FIFOSampleBuffer.h
index 890570a99a..e7cdbed9e6 100644
--- a/3rdparty/soundtouch/soundtouch/FIFOSampleBuffer.h
+++ b/3rdparty/soundtouch/soundtouch/FIFOSampleBuffer.h
@@ -1,12 +1,12 @@
 ////////////////////////////////////////////////////////////////////////////////
 ///
-/// A buffer class for temporarily storaging sound samples, operates as a 
+/// 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' 
+/// 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 
+/// 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
@@ -47,7 +47,7 @@ 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 
+/// Notice that in case of stereo audio, one sample is considered to consist of
 /// both channel data.
 class FIFOSampleBuffer : public FIFOSamplePipe
 {
@@ -68,12 +68,12 @@ private:
     /// Channels, 1=mono, 2=stereo.
     uint channels;
 
-    /// Current position pointer to the buffer. This pointer is increased when samples are 
+    /// 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 
+    /// Rewind the buffer by moving data from position pointed by 'bufferPos' to real
     /// beginning of the buffer.
     void rewind();
 
@@ -93,27 +93,27 @@ public:
     /// destructor
     ~FIFOSampleBuffer() override;
 
-    /// Returns a pointer to the beginning of the output samples. 
-    /// This function is provided for accessing the output samples directly. 
+    /// 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 
+    /// 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 
+    /// 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 
+    /// 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 
+                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.
                 );
 
@@ -123,17 +123,17 @@ public:
                             uint numSamples                         ///< Number of samples to insert.
                             ) override;
 
-    /// Adjusts the book-keeping to increase number of samples in the buffer without 
+    /// 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 
+    /// 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 
+    /// 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.
@@ -141,8 +141,8 @@ public:
                                 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. 
+    /// 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.
@@ -156,7 +156,7 @@ public:
     void setChannels(int numChannels);
 
     /// Get number of channels
-    int getChannels() 
+    int getChannels()
     {
         return channels;
     }
diff --git a/3rdparty/soundtouch/soundtouch/FIFOSamplePipe.h b/3rdparty/soundtouch/soundtouch/FIFOSamplePipe.h
index 8d415a00a7..93b6bf47ab 100644
--- a/3rdparty/soundtouch/soundtouch/FIFOSamplePipe.h
+++ b/3rdparty/soundtouch/soundtouch/FIFOSamplePipe.h
@@ -5,7 +5,7 @@
 /// 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 
+/// '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
@@ -68,12 +68,12 @@ public:
     virtual ~FIFOSamplePipe() {}
 
 
-    /// Returns a pointer to the beginning of the output samples. 
-    /// This function is provided for accessing the output samples directly. 
+    /// 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 
+    /// output samples from the buffer by calling the
     /// 'receiveSamples(numSamples)' function
     virtual SAMPLETYPE *ptrBegin() = 0;
 
@@ -88,14 +88,14 @@ public:
     void moveSamples(FIFOSamplePipe &other  ///< Other pipe instance where from the receive the data.
          )
     {
-        int oNumSamples = other.numSamples();
+        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 
+    /// 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.
@@ -103,8 +103,8 @@ public:
                                 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. 
+    /// 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.
@@ -127,12 +127,12 @@ public:
 };
 
 
-/// Base-class for sound processing routines working in FIFO principle. With this base 
+/// 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 
+/// 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 
+/// 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
@@ -144,16 +144,16 @@ protected:
     /// Sets output pipe.
     void setOutPipe(FIFOSamplePipe *pOutput)
     {
-        assert(output == NULL);
-        assert(pOutput != NULL);
+        assert(output == nullptr);
+        assert(pOutput != nullptr);
         output = pOutput;
     }
 
-    /// Constructor. Doesn't define output pipe; it has to be set be 
+    /// Constructor. Doesn't define output pipe; it has to be set be
     /// 'setOutPipe' function.
     FIFOProcessor()
     {
-        output = NULL;
+        output = nullptr;
     }
 
     /// Constructor. Configures output pipe.
@@ -168,12 +168,12 @@ protected:
     {
     }
 
-    /// Returns a pointer to the beginning of the output samples. 
-    /// This function is provided for accessing the output samples directly. 
+    /// 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 
+    /// output samples from the buffer by calling the
     /// 'receiveSamples(numSamples)' function
     virtual SAMPLETYPE *ptrBegin() override
     {
@@ -182,8 +182,8 @@ protected:
 
 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 
+    /// 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.
@@ -194,8 +194,8 @@ public:
         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. 
+    /// 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.
diff --git a/3rdparty/soundtouch/soundtouch/STTypes.h b/3rdparty/soundtouch/soundtouch/STTypes.h
index dc964b0222..03dea9e43d 100644
--- a/3rdparty/soundtouch/soundtouch/STTypes.h
+++ b/3rdparty/soundtouch/soundtouch/STTypes.h
@@ -59,15 +59,15 @@ namespace soundtouch
     /// Max allowed number of channels
     #define SOUNDTOUCH_MAX_CHANNELS     16
 
-    /// Activate these undef's to overrule the possible sampletype 
+    /// 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 
+    /// 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
 
@@ -79,31 +79,31 @@ namespace soundtouch
     #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 
+        /// 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 
+        /// - 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 
+        ///   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. 
+        /// 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 
+        /// 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
@@ -181,9 +181,9 @@ namespace soundtouch
     #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 
+// 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
 
diff --git a/3rdparty/soundtouch/soundtouch/SoundTouch.h b/3rdparty/soundtouch/soundtouch/SoundTouch.h
index 850b9c7591..704520964d 100644
--- a/3rdparty/soundtouch/soundtouch/SoundTouch.h
+++ b/3rdparty/soundtouch/soundtouch/SoundTouch.h
@@ -1,27 +1,27 @@
 //////////////////////////////////////////////////////////////////////////////
 ///
-/// SoundTouch - main class for tempo/pitch/rate adjusting routines. 
+/// 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 
+/// - 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 
+/// - 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 
+///   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 
+///
+/// - 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 
+///
+/// - 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 
+///   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.
@@ -30,8 +30,8 @@
 ///   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) 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.
 ///
@@ -72,10 +72,10 @@ namespace soundtouch
 {
 
 /// Soundtouch library version string
-#define SOUNDTOUCH_VERSION          "2.3.1"
+#define SOUNDTOUCH_VERSION          "2.3.3"
 
 /// SoundTouch library version id
-#define SOUNDTOUCH_VERSION_ID       (20301)
+#define SOUNDTOUCH_VERSION_ID       (20303)
 
 //
 // Available setting IDs for the 'setSetting' & 'get_setting' functions:
@@ -91,55 +91,55 @@ namespace soundtouch
 ///  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. 
+/// 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. 
+/// 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. 
+/// 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 
+/// 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. 
+/// output samples.
 ///
-/// This value does not include initial buffering at beginning of a new processing 
+/// 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: 
+/// Notices:
 /// - This is read-only parameter, i.e. setSetting ignores this parameter
-/// - This parameter value is not constant but change depending on 
+/// - 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 
+/// 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: 
+/// Notices:
 /// - This is read-only parameter, i.e. setSetting ignores this parameter
-/// - This parameter value is not constant but change depending on 
+/// - 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. 
+/// 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. 
+/// 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.
 ///
@@ -149,18 +149,18 @@ namespace soundtouch
 ///        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. 
+/// 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 
+/// 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: 
+///
+/// Notices:
 /// - This is read-only parameter, i.e. setSetting ignores this parameter
-/// - This parameter value is not constant but change depending on 
+/// - This parameter value is not constant but change depending on
 ///   tempo/pitch/rate/samplerate settings.
 #define SETTING_INITIAL_LATENCY             8
 
@@ -193,7 +193,7 @@ private:
     /// 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 
+    /// Calculates effective rate & tempo valuescfrom 'virtualRate', 'virtualTempo' and
     /// 'virtualPitch' parameters.
     void calcEffectiveRateAndTempo();
 
@@ -237,7 +237,7 @@ public:
     /// represent lower pitches, larger values higher pitch.
     void setPitch(double newPitch);
 
-    /// Sets pitch change in octaves compared to the original pitch  
+    /// Sets pitch change in octaves compared to the original pitch
     /// (-1.00 .. +1.00)
     void setPitchOctaves(double newPitch);
 
@@ -253,20 +253,20 @@ public:
     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 
+    /// 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, 
+    /// 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 
+    /// 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 
+    /// is exactly one million audio samples, then you can expect the processed
     /// output duration  be 0.869565 * 1000000 = 869565 samples.
     double getInputOutputSampleRatio();
 
@@ -289,8 +289,8 @@ public:
                                                     ///< 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 
+    /// 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.
@@ -298,8 +298,8 @@ public:
         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. 
+    /// 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.
@@ -312,7 +312,7 @@ public:
 
     /// 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.
@@ -338,7 +338,7 @@ public:
     /// 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 
+    /// - 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.
diff --git a/3rdparty/soundtouch/source/SoundStretch/SS_CharTypes.h b/3rdparty/soundtouch/source/SoundStretch/SS_CharTypes.h
new file mode 100644
index 0000000000..e720819aec
--- /dev/null
+++ b/3rdparty/soundtouch/source/SoundStretch/SS_CharTypes.h
@@ -0,0 +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 <string>
+
+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/3rdparty/soundtouch/source/SoundStretch/WavFile.cpp b/3rdparty/soundtouch/source/SoundStretch/WavFile.cpp
index 619fa370b0..3ed20770f5 100644
--- a/3rdparty/soundtouch/source/SoundStretch/WavFile.cpp
+++ b/3rdparty/soundtouch/source/SoundStretch/WavFile.cpp
@@ -1,12 +1,12 @@
  ////////////////////////////////////////////////////////////////////////////////
 ///
-/// Classes for easy reading & writing of WAV sound files. 
+/// 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 
+/// 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...
@@ -42,91 +42,100 @@
 #include <string>
 #include <sstream>
 #include <cstring>
-#include <assert.h>
-#include <limits.h>
+#include <cassert>
+#include <climits>
 
 #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 fmtStr[] = "fmt ";
 static const char factStr[] = "fact";
 static const char dataStr[] = "data";
 
 //////////////////////////////////////////////////////////////////////////////
 //
-// Helper functions for swapping byte order to correctly read/write WAV files 
+// 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. 
+// 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
+// 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
+// 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 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)
+// 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++)
     {
-        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]);
-        }
+        pData[i] = _swap16(pData[i]);
     }
+}
 
 #else   // BIG_ENDIAN
-    // little-endian CPU, WAV file is ok as such
+// 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 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 short _swap16(short& wData)
+{
+    // do nothing
+    return wData;
+}
 
-    // dummy helper-function
-    static inline void _swap16Buffer(short *pData, int numBytes)
-    {
-        // do nothing
-    }
+// dummy helper-function
+static inline void _swap16Buffer(short*, int)
+{
+    // do nothing
+}
 
 #endif  // BIG_ENDIAN
 
@@ -138,7 +147,7 @@ static const char dataStr[] = "data";
 
 WavFileBase::WavFileBase()
 {
-    convBuff = NULL;
+    convBuff = nullptr;
     convBuffSize = 0;
 }
 
@@ -151,7 +160,7 @@ WavFileBase::~WavFileBase()
 
 
 /// Get pointer to conversion buffer of at min. given size
-void *WavFileBase::getConvBuffer(int sizeBytes)
+void* WavFileBase::getConvBuffer(int sizeBytes)
 {
     if (convBuffSize < sizeBytes)
     {
@@ -169,32 +178,26 @@ void *WavFileBase::getConvBuffer(int sizeBytes)
 // Class WavInFile
 //
 
-WavInFile::WavInFile(const char *fileName)
+WavInFile::WavInFile(const STRING& fileName)
 {
     // Try to open the file for reading
-    fptr = fopen(fileName, "rb");
-    if (fptr == NULL) 
+    fptr = FOPEN(fileName.c_str(), "rb");
+    if (fptr == nullptr)
     {
-        // didn't succeed
-        string msg = "Error : Unable to open file \"";
-        msg += fileName;
-        msg += "\" for reading.";
-        ST_THROW_RT_ERROR(msg.c_str());
+        ST_THROW_RT_ERROR("Error : Unable to open file for reading.");
     }
 
     init();
 }
 
 
-WavInFile::WavInFile(FILE *file)
+WavInFile::WavInFile(FILE* file)
 {
     // Try to open the file for reading
     fptr = file;
-    if (!file) 
+    if (!file)
     {
-        // didn't succeed
-        string msg = "Error : Unable to access input stream for reading";
-        ST_THROW_RT_ERROR(msg.c_str());
+        ST_THROW_RT_ERROR("Error : Unable to access input stream for reading");
     }
 
     init();
@@ -211,19 +214,17 @@ void WavInFile::init()
 
     // Read the file headers
     hdrsOk = readWavHeaders();
-    if (hdrsOk != 0) 
+    if (hdrsOk != 0)
     {
-        // Something didn't match in the wav file headers 
         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) ||
+    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))
     {
-        // Something didn't match in the wav file headers 
         ST_THROW_RT_ERROR("Error: Illegal wav file header format parameters.");
     }
 
@@ -234,7 +235,7 @@ void WavInFile::init()
 WavInFile::~WavInFile()
 {
     if (fptr) fclose(fptr);
-    fptr = NULL;
+    fptr = nullptr;
 }
 
 
@@ -260,7 +261,7 @@ int WavInFile::checkCharTags() const
 }
 
 
-int WavInFile::read(unsigned char *buffer, int maxElems)
+int WavInFile::read(unsigned char* buffer, int maxElems)
 {
     int numBytes;
     uint afterDataRead;
@@ -274,7 +275,7 @@ int WavInFile::read(unsigned char *buffer, int maxElems)
 
     numBytes = maxElems;
     afterDataRead = dataRead + numBytes;
-    if (afterDataRead > header.data.data_len) 
+    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;
@@ -289,7 +290,7 @@ int WavInFile::read(unsigned char *buffer, int maxElems)
 }
 
 
-int WavInFile::read(short *buffer, int maxElems)
+int WavInFile::read(short* buffer, int maxElems)
 {
     unsigned int afterDataRead;
     int numBytes;
@@ -298,62 +299,62 @@ int WavInFile::read(short *buffer, int maxElems)
     assert(buffer);
     switch (header.format.bits_per_sample)
     {
-        case 8:
-        {
-            // 8 bit format
-            unsigned char *temp = (unsigned char*)getConvBuffer(maxElems);
-            int i;
+    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;
+        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);
         }
 
-        case 16:
-        {
-            // 16 bit format
+        numBytes = (int)fread(buffer, 1, numBytes, fptr);
+        dataRead += numBytes;
+        numElems = numBytes / 2;
 
-            assert(sizeof(short) == 2);
+        // 16bit samples, swap byte order if necessary
+        _swap16Buffer((short*)buffer, numElems);
+        break;
+    }
 
-            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());
-        }
+    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 
+/// 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)
+int WavInFile::read(float* buffer, int maxElems)
 {
     unsigned int afterDataRead;
     int numBytes;
@@ -374,7 +375,7 @@ int WavInFile::read(float *buffer, int maxElems)
 
     numBytes = maxElems * bytesPerSample;
     afterDataRead = dataRead + numBytes;
-    if (afterDataRead > header.data.data_len) 
+    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;
@@ -382,7 +383,7 @@ int WavInFile::read(float *buffer, int maxElems)
     }
 
     // read raw data into temporary buffer
-    char *temp = (char*)getConvBuffer(numBytes);
+    char* temp = (char*)getConvBuffer(numBytes);
     numBytes = (int)fread(temp, 1, numBytes, fptr);
     dataRead += numBytes;
 
@@ -391,56 +392,56 @@ int WavInFile::read(float *buffer, int maxElems)
     // swap byte ordert & convert to float, depending on sample format
     switch (bytesPerSample)
     {
-        case 1:
+    case 1:
+    {
+        unsigned char* temp2 = (unsigned char*)temp;
+        double conv = 1.0 / 128.0;
+        for (int i = 0; i < numElems; i++)
         {
-            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;
+            buffer[i] = (float)(temp2[i] * conv - 1.0);
         }
+        break;
+    }
 
-        case 2:
+    case 2:
+    {
+        short* temp2 = (short*)temp;
+        double conv = 1.0 / 32768.0;
+        for (int i = 0; i < numElems; i++)
         {
-            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;
+            short value = temp2[i];
+            buffer[i] = (float)(_swap16(value) * conv);
         }
+        break;
+    }
 
-        case 3:
+    case 3:
+    {
+        char* temp2 = (char*)temp;
+        double conv = 1.0 / 8388608.0;
+        for (int i = 0; i < numElems; i++)
         {
-            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;
+            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:
+    case 4:
+    {
+        int* temp2 = (int*)temp;
+        double conv = 1.0 / 2147483648.0;
+        assert(sizeof(int) == 4);
+        for (int i = 0; i < numElems; i++)
         {
-            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;
+            int value = temp2[i];
+            buffer[i] = (float)(_swap32(value) * conv);
         }
+        break;
+    }
     }
 
     return numElems;
@@ -450,7 +451,7 @@ int WavInFile::read(float *buffer, int maxElems)
 int WavInFile::eof() const
 {
     // return true if all data has been read or file eof has reached
-    return (dataRead == header.data.data_len || feof(fptr));
+    return ((uint)dataRead == header.data.data_len || feof(fptr));
 }
 
 
@@ -462,15 +463,15 @@ static int isAlpha(char c)
 
 
 // test if all characters are between a white space ' ' and little 'z'
-static int isAlphaStr(const char *str)
+static int isAlphaStr(const char* str)
 {
     char c;
 
     c = str[0];
-    while (c) 
+    while (c)
     {
         if (isAlpha(c) == 0) return 0;
-        str ++;
+        str++;
         c = str[0];
     }
 
@@ -483,7 +484,7 @@ 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);
+    _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;
@@ -500,7 +501,7 @@ int WavInFile::readHeaderBlock()
     string sLabel;
 
     // lead label string
-    if (fread(label, 1, 4, fptr) !=4) return -1;
+    if (fread(label, 1, 4, fptr) != 4) return -1;
     label[4] = 0;
 
     if (isAlphaStr(label) == 0) return -1;    // not a valid label
@@ -510,7 +511,7 @@ int WavInFile::readHeaderBlock()
     {
         int nLen, nDump;
 
-        // 'fmt ' block 
+        // 'fmt ' block
         memcpy(header.format.fmt, fmtStr, 4);
 
         // read length of the format field
@@ -518,7 +519,7 @@ int WavInFile::readHeaderBlock()
         // swap byte order if necessary
         _swap32(nLen);
 
-        // calculate how much length differs from expected 
+        // calculate how much length differs from expected
         nDump = nLen - ((int)sizeof(header.format) - 8);
 
         // verify that header length isn't smaller than expected structure
@@ -536,12 +537,12 @@ int WavInFile::readHeaderBlock()
         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;
+        _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)
@@ -555,7 +556,7 @@ int WavInFile::readHeaderBlock()
     {
         int nLen, nDump;
 
-        // 'fact' block 
+        // 'fact' block
         memcpy(header.fact.fact_field, factStr, 4);
 
         // read length of the fact field
@@ -581,7 +582,7 @@ int WavInFile::readHeaderBlock()
         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;
+        _swap32((int&)header.fact.fact_sample_len);    // int sample_length;
 
         // if fact_len is larger than expected, skip the extra data
         if (nDump > 0)
@@ -598,7 +599,7 @@ int WavInFile::readHeaderBlock()
         if (fread(&(header.data.data_len), sizeof(uint), 1, fptr) != 1) return -1;
 
         // swap byte order if necessary
-        _swap32((int &)header.data.data_len);
+        _swap32((int&)header.data.data_len);
 
         return 1;
     }
@@ -611,7 +612,7 @@ int WavInFile::readHeaderBlock()
         // read length
         if (fread(&len, sizeof(len), 1, fptr) != 1) return -1;
         // scan through the block
-        for (i = 0; i < len; i ++)
+        for (i = 0; i < len; i++)
         {
             if (fread(&temp, 1, 1, fptr) != 1) return -1;
             if (feof(fptr)) return -1;   // unexpected eof
@@ -703,17 +704,13 @@ uint WavInFile::getElapsedMS() const
 // Class WavOutFile
 //
 
-WavOutFile::WavOutFile(const char *fileName, int sampleRate, int bits, int channels)
+WavOutFile::WavOutFile(const STRING& fileName, int sampleRate, int bits, int channels)
 {
     bytesWritten = 0;
-    fptr = fopen(fileName, "wb");
-    if (fptr == NULL) 
+    fptr = FOPEN(fileName.c_str(), "wb");
+    if (fptr == nullptr)
     {
-        string msg = "Error : Unable to open file \"";
-        msg += fileName;
-        msg += "\" for writing.";
-        //pmsg = msg.c_str;
-        ST_THROW_RT_ERROR(msg.c_str());
+        ST_THROW_RT_ERROR("Error : Unable to open file for writing.");
     }
 
     fillInHeader(sampleRate, bits, channels);
@@ -721,14 +718,13 @@ WavOutFile::WavOutFile(const char *fileName, int sampleRate, int bits, int chann
 }
 
 
-WavOutFile::WavOutFile(FILE *file, int sampleRate, int bits, int channels)
+WavOutFile::WavOutFile(FILE* file, int sampleRate, int bits, int channels)
 {
     bytesWritten = 0;
     fptr = file;
-    if (fptr == NULL) 
+    if (fptr == nullptr)
     {
-        string msg = "Error : Unable to access output file stream.";
-        ST_THROW_RT_ERROR(msg.c_str());
+        ST_THROW_RT_ERROR("Error : Unable to access output file stream.");
     }
 
     fillInHeader(sampleRate, bits, channels);
@@ -740,7 +736,7 @@ WavOutFile::~WavOutFile()
 {
     finishHeader();
     if (fptr) fclose(fptr);
-    fptr = NULL;
+    fptr = nullptr;
 }
 
 
@@ -788,8 +784,8 @@ 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; 
-    
+    header.fact.fact_sample_len = bytesWritten / header.format.byte_per_sample;
+
     writeHeader();
 }
 
@@ -801,18 +797,18 @@ void WavOutFile::writeHeader()
 
     // 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);
-    
+    _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);
@@ -826,7 +822,7 @@ void WavOutFile::writeHeader()
 }
 
 
-void WavOutFile::write(const unsigned char *buffer, int numElems)
+void WavOutFile::write(const unsigned char* buffer, int numElems)
 {
     int res;
 
@@ -837,7 +833,7 @@ void WavOutFile::write(const unsigned char *buffer, int numElems)
     assert(sizeof(char) == 1);
 
     res = (int)fwrite(buffer, 1, numElems, fptr);
-    if (res != numElems) 
+    if (res != numElems)
     {
         ST_THROW_RT_ERROR("Error while writing to a wav file.");
     }
@@ -846,7 +842,7 @@ void WavOutFile::write(const unsigned char *buffer, int numElems)
 }
 
 
-void WavOutFile::write(const short *buffer, int numElems)
+void WavOutFile::write(const short* buffer, int numElems)
 {
     int res;
 
@@ -855,47 +851,47 @@ void WavOutFile::write(const short *buffer, int numElems)
 
     switch (header.format.bits_per_sample)
     {
-        case 8:
+    case 8:
+    {
+        int i;
+        unsigned char* temp = (unsigned char*)getConvBuffer(numElems);
+        // convert from 16bit format to 8bit format
+        for (i = 0; i < numElems; i++)
         {
-            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;
+            temp[i] = (unsigned char)(buffer[i] / 256 + 128);
         }
+        // write in 8bit format
+        write(temp, numElems);
+        break;
+    }
 
-        case 16:
+    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)
         {
-            // 16bit format
-
-            // use temp buffer to swap byte order if necessary
-            short *pTemp = (short *)getConvBuffer(numElems * sizeof(short));
-            memcpy(pTemp, buffer, numElems * 2);
-            _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;
+            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());
-        }
+    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());
+    }
     }
 }
 
@@ -903,10 +899,10 @@ void WavOutFile::write(const short *buffer, int numElems)
 /// Convert from float to integer and saturate
 inline int saturate(float fvalue, float minval, float maxval)
 {
-    if (fvalue > maxval) 
+    if (fvalue > maxval)
     {
         fvalue = maxval;
-    } 
+    }
     else if (fvalue < minval)
     {
         fvalue = minval;
@@ -915,7 +911,7 @@ inline int saturate(float fvalue, float minval, float maxval)
 }
 
 
-void WavOutFile::write(const float *buffer, int numElems)
+void WavOutFile::write(const float* buffer, int numElems)
 {
     int numBytes;
     int bytesPerSample;
@@ -924,63 +920,65 @@ void WavOutFile::write(const float *buffer, int numElems)
 
     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
+    void* temp = getConvBuffer(numBytes + 7);   // round bit up to avoid buffer overrun with 24bit-value assignment
 
     switch (bytesPerSample)
     {
-        case 1:
+    case 1:
+    {
+        unsigned char* temp2 = (unsigned char*)temp;
+        for (int i = 0; i < numElems; i++)
         {
-            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;
+            temp2[i] = (unsigned char)saturate(buffer[i] * 128.0f + 128.0f, 0.0f, 255.0f);
         }
+        break;
+    }
 
-        case 2:
+    case 2:
+    {
+        short* temp2 = (short*)temp;
+        for (int i = 0; i < numElems; i++)
         {
-            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;
+            short value = (short)saturate(buffer[i] * 32768.0f, -32768.0f, 32767.0f);
+            temp2[i] = _swap16(value);
         }
+        break;
+    }
 
-        case 3:
+    case 3:
+    {
+        char* temp2 = (char*)temp;
+        for (int i = 0; i < numElems; i++)
         {
-            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;
+            int value = saturate(buffer[i] * 8388608.0f, -8388608.0f, 8388607.0f);
+            *((int*)temp2) = _swap32(value);
+            temp2 += 3;
         }
+        break;
+    }
 
-        case 4:
+    case 4:
+    {
+        int* temp2 = (int*)temp;
+        for (int i = 0; i < numElems; i++)
         {
-            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;
+            int value = saturate(buffer[i] * 2147483648.0f, -2147483648.0f, 2147483647.0f);
+            temp2[i] = _swap32(value);
         }
+        break;
+    }
 
-        default:
-            assert(false);
+    default:
+        assert(false);
     }
 
     int res = (int)fwrite(temp, 1, numBytes, fptr);
 
-    if (res != numBytes) 
+    if (res != numBytes)
     {
         ST_THROW_RT_ERROR("Error while writing to a wav file.");
     }
     bytesWritten += numBytes;
 }
+
+}
diff --git a/3rdparty/soundtouch/source/SoundStretch/WavFile.h b/3rdparty/soundtouch/source/SoundStretch/WavFile.h
index 21e7890385..812b034f1c 100644
--- a/3rdparty/soundtouch/source/SoundStretch/WavFile.h
+++ b/3rdparty/soundtouch/source/SoundStretch/WavFile.h
@@ -4,10 +4,10 @@
 ///
 /// 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 
+///
+/// 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. 
+/// 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
@@ -40,15 +40,20 @@
 #ifndef WAVFILE_H
 #define WAVFILE_H
 
-#include <stdio.h>
+#include <cstdio>
+#include <string>
+#include "SS_CharTypes.h"
+
+namespace soundstretch
+{
 
 #ifndef uint
 typedef unsigned int uint;
-#endif           
+#endif
 
 
 /// WAV audio file 'riff' section header
-typedef struct 
+typedef struct
 {
     char riff_char[4];
     uint package_len;
@@ -56,7 +61,7 @@ typedef struct
 } WavRiff;
 
 /// WAV audio file 'format' section header
-typedef struct 
+typedef struct
 {
     char  fmt[4];
     unsigned int   format_len;
@@ -69,7 +74,7 @@ typedef struct
 } WavFormat;
 
 /// WAV audio file 'fact' section header
-typedef struct 
+typedef struct
 {
     char fact_field[4];
     uint fact_len;
@@ -77,7 +82,7 @@ typedef struct
 } WavFact;
 
 /// WAV audio file 'data' section header
-typedef struct 
+typedef struct
 {
     char  data_field[4];
     uint  data_len;
@@ -85,7 +90,7 @@ typedef struct
 
 
 /// WAV audio file header
-typedef struct 
+typedef struct
 {
     WavRiff   riff;
     WavFormat format;
@@ -118,9 +123,6 @@ private:
     /// File pointer.
     FILE *fptr;
 
-    /// Position within the audio stream
-    long position;
-
     /// Counter of how many bytes of sample data have been read from the file.
     long dataRead;
 
@@ -148,7 +150,7 @@ private:
 public:
     /// Constructor: Opens the given WAV file. If the file can't be opened,
     /// throws 'runtime_error' exception.
-    WavInFile(const char *filename);
+    WavInFile(const STRING& filename);
 
     WavInFile(FILE *file);
 
@@ -164,7 +166,7 @@ public:
     /// 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 
+    /// Get sample data size in bytes. Ahem, this should return same information as
     /// 'getBytesPerSample'...
     uint getDataSizeInBytes() const;
 
@@ -173,7 +175,7 @@ public:
 
     /// 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;
 
@@ -186,14 +188,14 @@ public:
     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 
+    /// 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 
+    /// 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.
@@ -201,7 +203,7 @@ public:
              int maxElems       ///< Size of 'buffer' array (number of array elements).
              );
 
-    /// Reads audio samples from the WAV file to floating point format, converting 
+    /// 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.
@@ -242,9 +244,9 @@ private:
     void writeHeader();
 
 public:
-    /// Constructor: Creates a new WAV file. Throws a 'runtime_error' exception 
+    /// Constructor: Creates a new WAV file. Throws a 'runtime_error' exception
     /// if file creation fails.
-    WavOutFile(const char *fileName,    ///< Filename
+    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)
@@ -255,7 +257,7 @@ public:
     /// Destructor: Finalizes & closes the WAV file.
     ~WavOutFile();
 
-    /// Write data to WAV file. This function works only with 8bit samples. 
+    /// 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.
@@ -274,4 +276,6 @@ public:
                );
 };
 
+ }
+
 #endif
diff --git a/3rdparty/soundtouch/source/SoundTouch/AAFilter.cpp b/3rdparty/soundtouch/source/SoundTouch/AAFilter.cpp
index 71011bb11e..f09720039f 100644
--- a/3rdparty/soundtouch/source/SoundTouch/AAFilter.cpp
+++ b/3rdparty/soundtouch/source/SoundTouch/AAFilter.cpp
@@ -1,9 +1,9 @@
 ////////////////////////////////////////////////////////////////////////////////
 ///
 /// 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 
+/// 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
@@ -54,7 +54,7 @@ using namespace soundtouch;
     static void _DEBUG_SAVE_AAFIR_COEFFS(SAMPLETYPE *coeffs, int len)
     {
         FILE *fptr = fopen("aa_filter_coeffs.txt", "wt");
-        if (fptr == NULL) return;
+        if (fptr == nullptr) return;
 
         for (int i = 0; i < len; i ++)
         {
@@ -128,16 +128,16 @@ void AAFilter::calculateCoeffs()
     tempCoeff = TWOPI / (double)length;
 
     sum = 0;
-    for (i = 0; i < length; i ++) 
+    for (i = 0; i < length; i ++)
     {
         cntTemp = (double)i - (double)(length / 2);
 
         temp = cntTemp * wc;
-        if (temp != 0) 
+        if (temp != 0)
         {
             h = sin(temp) / temp;                     // sinc function
-        } 
-        else 
+        }
+        else
         {
             h = 1.0;
         }
@@ -146,7 +146,7 @@ void AAFilter::calculateCoeffs()
         temp = w * h;
         work[i] = temp;
 
-        // calc net sum of coefficients 
+        // calc net sum of coefficients
         sum += temp;
     }
 
@@ -162,7 +162,7 @@ void AAFilter::calculateCoeffs()
     // divided by 16384
     scaleCoeff = 16384.0f / sum;
 
-    for (i = 0; i < length; i ++) 
+    for (i = 0; i < length; i ++)
     {
         temp = work[i] * scaleCoeff;
         // scale & round to nearest integer
@@ -182,8 +182,8 @@ void AAFilter::calculateCoeffs()
 }
 
 
-// Applies the filter to the given sequence of samples. 
-// Note : The amount of outputted samples is by value of 'filter 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 AAFilter::evaluate(SAMPLETYPE *dest, const SAMPLETYPE *src, uint numSamples, uint numChannels) const
 {
@@ -192,8 +192,8 @@ uint AAFilter::evaluate(SAMPLETYPE *dest, const SAMPLETYPE *src, uint numSamples
 
 
 /// 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' 
+/// 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
 {
diff --git a/3rdparty/soundtouch/source/SoundTouch/AAFilter.h b/3rdparty/soundtouch/source/SoundTouch/AAFilter.h
index 81d836b750..5b63ed6e55 100644
--- a/3rdparty/soundtouch/source/SoundTouch/AAFilter.h
+++ b/3rdparty/soundtouch/source/SoundTouch/AAFilter.h
@@ -1,10 +1,10 @@
 ////////////////////////////////////////////////////////////////////////////////
 ///
-/// Sampled sound tempo changer/time stretch algorithm. Changes the sound tempo 
-/// while maintaining the original pitch by using a time domain WSOLA-like method 
+/// 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 
+/// Anti-alias filter is used to prevent folding of high frequencies when
 /// transposing the sample rate with interpolation.
 ///
 /// Author        : Copyright (c) Olli Parviainen
@@ -61,8 +61,8 @@ public:
 
     ~AAFilter();
 
-    /// Sets new anti-alias filter cut-off edge frequency, scaled to sampling 
-    /// frequency (nyquist frequency = 0.5). The filter will cut off the 
+    /// 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);
 
@@ -71,19 +71,19 @@ public:
 
     uint getLength() const;
 
-    /// Applies the filter to the given sequence of samples. 
-    /// Note : The amount of outputted samples is by value of 'filter 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 evaluate(SAMPLETYPE *dest, 
-                  const SAMPLETYPE *src, 
-                  uint numSamples, 
+    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' 
+    /// 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, 
+    uint evaluate(FIFOSampleBuffer &dest,
                   FIFOSampleBuffer &src) const;
 
 };
diff --git a/3rdparty/soundtouch/source/SoundTouch/BPMDetect.cpp b/3rdparty/soundtouch/source/SoundTouch/BPMDetect.cpp
index 959f36e3f7..f7995c8eab 100644
--- a/3rdparty/soundtouch/source/SoundTouch/BPMDetect.cpp
+++ b/3rdparty/soundtouch/source/SoundTouch/BPMDetect.cpp
@@ -14,10 +14,10 @@
 ///   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 
+/// - 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 
+/// - 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
@@ -76,8 +76,8 @@ static const int XCORR_UPDATE_SEQUENCE = (int)(TARGET_SRATE / 5);
 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 
+/// 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;
@@ -233,16 +233,16 @@ BPMDetect::~BPMDetect()
 }
 
 
-/// convert to mono, low-pass filter & decimate to about 500 Hz. 
+/// 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 
+/// 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 
+/// 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 
+/// (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)
 {
@@ -252,7 +252,7 @@ int BPMDetect::decimate(SAMPLETYPE *dest, const SAMPLETYPE *src, int numsamples)
     assert(channels > 0);
     assert(decimateBy > 0);
     outcount = 0;
-    for (count = 0; count < numsamples; count ++) 
+    for (count = 0; count < numsamples; count ++)
     {
         int j;
 
@@ -264,7 +264,7 @@ int BPMDetect::decimate(SAMPLETYPE *dest, const SAMPLETYPE *src, int numsamples)
         src += j;
 
         decimateCount ++;
-        if (decimateCount >= decimateBy) 
+        if (decimateCount >= decimateBy)
         {
             // Store every Nth sample only
             out = (LONG_SAMPLETYPE)(decimateSum / (decimateBy * channels));
@@ -272,11 +272,11 @@ int BPMDetect::decimate(SAMPLETYPE *dest, const SAMPLETYPE *src, int numsamples)
             decimateCount = 0;
 #ifdef SOUNDTOUCH_INTEGER_SAMPLES
             // check ranges for sure (shouldn't actually be necessary)
-            if (out > 32767) 
+            if (out > 32767)
             {
                 out = 32767;
-            } 
-            else if (out < -32768) 
+            }
+            else if (out < -32768)
             {
                 out = -32768;
             }
@@ -294,7 +294,7 @@ void BPMDetect::updateXCorr(int process_samples)
 {
     int offs;
     SAMPLETYPE *pBuffer;
-    
+
     assert(buffer->numSamples() >= (uint)(process_samples + windowLen));
     assert(process_samples == XCORR_UPDATE_SEQUENCE);
 
@@ -311,13 +311,13 @@ void BPMDetect::updateXCorr(int process_samples)
     }
 
     #pragma omp parallel for
-    for (offs = windowStart; offs < windowLen; offs ++) 
+    for (offs = windowStart; offs < windowLen; offs ++)
     {
         float sum;
         int i;
 
         sum = 0;
-        for (i = 0; i < process_samples; i ++) 
+        for (i = 0; i < process_samples; i ++)
         {
             sum += tmp[i] * pBuffer[i + offs];  // scaling the sub-result shouldn't be necessary
         }
@@ -376,8 +376,6 @@ void BPMDetect::updateBeatPos(int process_samples)
     // detect beats
     for (int i = 0; i < skipstep; i++)
     {
-        LONG_SAMPLETYPE max = 0;
-
         float sum = beatcorr_ringbuff[beatcorr_ringbuffpos];
         sum -= beat_lpf.update(sum);
 
@@ -433,7 +431,7 @@ void BPMDetect::inputSamples(const SAMPLETYPE *samples, int numSamples)
 
     // when the buffer has enough samples for processing...
     int req = max(windowLen + XCORR_UPDATE_SEQUENCE, 2 * XCORR_UPDATE_SEQUENCE);
-    while ((int)buffer->numSamples() >= req) 
+    while ((int)buffer->numSamples() >= req)
     {
         // ... update autocorrelations...
         updateXCorr(XCORR_UPDATE_SEQUENCE);
@@ -504,7 +502,7 @@ void MAFilter(float *dest, const float *source, int start, int end, int N)
 
         double sum = 0;
         for (int j = i1; j < i2; j ++)
-        { 
+        {
             sum += source[j];
         }
         dest[i] = (float)(sum / (i2 - i1));
@@ -550,19 +548,19 @@ float BPMDetect::getBpm()
 }
 
 
-/// Get beat position arrays. Note: The array includes also really low beat detection values 
+/// 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.  
+/// - max_num indicates max.size of "pos" and "values" array.
 ///
-/// You can query a suitable array sized by calling this with NULL in "pos" & "values".
+/// 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 NULL, return just size
+    if ((!pos) || (!values)) return num;    // pos or values nullptr, return just size
 
     for (int i = 0; (i < num) && (i < max_num); i++)
     {
diff --git a/3rdparty/soundtouch/source/SoundTouch/FIFOSampleBuffer.cpp b/3rdparty/soundtouch/source/SoundTouch/FIFOSampleBuffer.cpp
index ad36875466..9e0d5b2473 100644
--- a/3rdparty/soundtouch/source/SoundTouch/FIFOSampleBuffer.cpp
+++ b/3rdparty/soundtouch/source/SoundTouch/FIFOSampleBuffer.cpp
@@ -1,12 +1,12 @@
 ////////////////////////////////////////////////////////////////////////////////
 ///
-/// A buffer class for temporarily storaging sound samples, operates as a 
+/// 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' 
+/// 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 
+/// 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
@@ -50,12 +50,12 @@ FIFOSampleBuffer::FIFOSampleBuffer(int numChannels)
 {
     assert(numChannels > 0);
     sizeInBytes = 0; // reasonable initial value
-    buffer = NULL;
-    bufferUnaligned = NULL;
+    buffer = nullptr;
+    bufferUnaligned = nullptr;
     samplesInBuffer = 0;
     bufferPos = 0;
     channels = (uint)numChannels;
-    ensureCapacity(32);     // allocate initial capacity 
+    ensureCapacity(32);     // allocate initial capacity
 }
 
 
@@ -63,8 +63,8 @@ FIFOSampleBuffer::FIFOSampleBuffer(int numChannels)
 FIFOSampleBuffer::~FIFOSampleBuffer()
 {
     delete[] bufferUnaligned;
-    bufferUnaligned = NULL;
-    buffer = NULL;
+    bufferUnaligned = nullptr;
+    buffer = nullptr;
 }
 
 
@@ -82,11 +82,11 @@ void FIFOSampleBuffer::setChannels(int numChannels)
 
 
 // if output location pointer 'bufferPos' isn't zero, 'rewinds' the buffer and
-// zeroes this pointer by copying samples from the 'bufferPos' pointer 
+// zeroes this pointer by copying samples from the 'bufferPos' pointer
 // location on to the beginning of the buffer.
 void FIFOSampleBuffer::rewind()
 {
-    if (buffer && bufferPos) 
+    if (buffer && bufferPos)
     {
         memmove(buffer, ptrBegin(), sizeof(SAMPLETYPE) * channels * samplesInBuffer);
         bufferPos = 0;
@@ -94,7 +94,7 @@ void FIFOSampleBuffer::rewind()
 }
 
 
-// Adds 'numSamples' pcs of samples from the 'samples' memory position to 
+// Adds 'numSamples' pcs of samples from the 'samples' memory position to
 // the sample buffer.
 void FIFOSampleBuffer::putSamples(const SAMPLETYPE *samples, uint nSamples)
 {
@@ -107,7 +107,7 @@ void FIFOSampleBuffer::putSamples(const SAMPLETYPE *samples, uint nSamples)
 // 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 
+// when accessing the buffer directly with 'ptrEnd' function. Please be
 // careful though!
 void FIFOSampleBuffer::putSamples(uint nSamples)
 {
@@ -119,31 +119,31 @@ void FIFOSampleBuffer::putSamples(uint 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! 
+// 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, 
+// 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 
+// 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) 
+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. 
+// 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 
+// outputted samples from the buffer by calling the
 // 'receiveSamples(numSamples)' function
 SAMPLETYPE *FIFOSampleBuffer::ptrBegin()
 {
@@ -160,13 +160,13 @@ void FIFOSampleBuffer::ensureCapacity(uint capacityRequirement)
 {
     SAMPLETYPE *tempUnaligned, *temp;
 
-    if (capacityRequirement > getCapacity()) 
+    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 == NULL)
+        if (tempUnaligned == nullptr)
         {
             ST_THROW_RT_ERROR("Couldn't allocate memory!\n");
         }
@@ -180,8 +180,8 @@ void FIFOSampleBuffer::ensureCapacity(uint capacityRequirement)
         buffer = temp;
         bufferUnaligned = tempUnaligned;
         bufferPos = 0;
-    } 
-    else 
+    }
+    else
     {
         // simply rewind the buffer (if necessary)
         rewind();
diff --git a/3rdparty/soundtouch/source/SoundTouch/FIRFilter.cpp b/3rdparty/soundtouch/source/SoundTouch/FIRFilter.cpp
index 24cc33bf6f..4cd330e81c 100644
--- a/3rdparty/soundtouch/source/SoundTouch/FIRFilter.cpp
+++ b/3rdparty/soundtouch/source/SoundTouch/FIRFilter.cpp
@@ -1,13 +1,13 @@
 ////////////////////////////////////////////////////////////////////////////////
 ///
-/// General FIR digital filter routines with MMX optimization. 
+/// General FIR digital filter routines with MMX optimization.
 ///
-/// Notes : MMX optimized functions reside in a separate, platform-specific file, 
+/// 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 
+/// 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
 ///
@@ -59,8 +59,8 @@ FIRFilter::FIRFilter()
     resultDivider = 0;
     length = 0;
     lengthDiv8 = 0;
-    filterCoeffs = NULL;
-    filterCoeffsStereo = NULL;
+    filterCoeffs = nullptr;
+    filterCoeffsStereo = nullptr;
 }
 
 
@@ -75,20 +75,16 @@ FIRFilter::~FIRFilter()
 uint FIRFilter::evaluateFilterStereo(SAMPLETYPE *dest, const SAMPLETYPE *src, uint numSamples) const
 {
     int j, end;
-#ifdef SOUNDTOUCH_FLOAT_SAMPLES
-    // when using floating point samples, use a scaler instead of a divider
-    // because division is much slower operation than multiplying.
-    double dScaler = 1.0 / (double)resultDivider;
-#endif
     // hint compiler autovectorization that loop length is divisible by 8
-    int ilength = length & -8;
+    uint ilength = length & -8;
 
-    assert((length != 0) && (length == ilength) && (src != NULL) && (dest != NULL) && (filterCoeffs != NULL));
+    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) 
+    for (j = 0; j < end; j += 2)
     {
         const SAMPLETYPE *ptr;
         LONG_SAMPLETYPE suml, sumr;
@@ -96,7 +92,7 @@ uint FIRFilter::evaluateFilterStereo(SAMPLETYPE *dest, const SAMPLETYPE *src, ui
         suml = sumr = 0;
         ptr = src + j;
 
-        for (int i = 0; i < ilength; i ++)
+        for (uint i = 0; i < ilength; i ++)
         {
             suml += ptr[2 * i] * filterCoeffsStereo[2 * i];
             sumr += ptr[2 * i + 1] * filterCoeffsStereo[2 * i + 1];
@@ -121,11 +117,6 @@ uint FIRFilter::evaluateFilterStereo(SAMPLETYPE *dest, const SAMPLETYPE *src, ui
 uint FIRFilter::evaluateFilterMono(SAMPLETYPE *dest, const SAMPLETYPE *src, uint numSamples) const
 {
     int j, end;
-#ifdef SOUNDTOUCH_FLOAT_SAMPLES
-    // when using floating point samples, use a scaler instead of a divider
-    // because division is much slower operation than multiplying.
-    double dScaler = 1.0 / (double)resultDivider;
-#endif
 
     // hint compiler autovectorization that loop length is divisible by 8
     int ilength = length & -8;
@@ -160,16 +151,10 @@ uint FIRFilter::evaluateFilterMulti(SAMPLETYPE *dest, const SAMPLETYPE *src, uin
 {
     int j, end;
 
-#ifdef SOUNDTOUCH_FLOAT_SAMPLES
-    // when using floating point samples, use a scaler instead of a divider
-    // because division is much slower operation than multiplying.
-    double dScaler = 1.0 / (double)resultDivider;
-#endif
-
     assert(length != 0);
-    assert(src != NULL);
-    assert(dest != NULL);
-    assert(filterCoeffs != NULL);
+    assert(src != nullptr);
+    assert(dest != nullptr);
+    assert(filterCoeffs != nullptr);
     assert(numChannels < 16);
 
     // hint compiler autovectorization that loop length is divisible by 8
@@ -201,7 +186,7 @@ uint FIRFilter::evaluateFilterMulti(SAMPLETYPE *dest, const SAMPLETYPE *src, uin
                 ptr ++;
             }
         }
-        
+
         for (c = 0; c < numChannels; c ++)
         {
 #ifdef SOUNDTOUCH_INTEGER_SAMPLES
@@ -257,11 +242,11 @@ uint FIRFilter::getLength() const
 }
 
 
-// Applies the filter to the given sequence of samples. 
+// Applies the filter to the given sequence of samples.
 //
-// Note : The amount of outputted samples is by value of 'filter_length' 
+// 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) 
+uint FIRFilter::evaluate(SAMPLETYPE *dest, const SAMPLETYPE *src, uint numSamples, uint numChannels)
 {
     assert(length > 0);
     assert(lengthDiv8 * 8 == length);
@@ -272,7 +257,7 @@ uint FIRFilter::evaluate(SAMPLETYPE *dest, const SAMPLETYPE *src, uint numSample
     if (numChannels == 1)
     {
         return evaluateFilterMono(dest, src, numSamples);
-    } 
+    }
     else if (numChannels == 2)
     {
         return evaluateFilterStereo(dest, src, numSamples);
@@ -286,9 +271,9 @@ uint FIRFilter::evaluate(SAMPLETYPE *dest, const SAMPLETYPE *src, uint numSample
 }
 
 
-// Operator 'new' is overloaded so that it automatically creates a suitable instance 
+// 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 s)
+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!");
@@ -301,6 +286,7 @@ FIRFilter * FIRFilter::newInstance()
     uint uExtensions;
 
     uExtensions = detectCPUextensions();
+    (void)uExtensions;
 
     // Check if MMX/SSE instruction set extensions supported by CPU
 
diff --git a/3rdparty/soundtouch/source/SoundTouch/FIRFilter.h b/3rdparty/soundtouch/source/SoundTouch/FIRFilter.h
index cc90feb4f3..0acb199bbf 100644
--- a/3rdparty/soundtouch/source/SoundTouch/FIRFilter.h
+++ b/3rdparty/soundtouch/source/SoundTouch/FIRFilter.h
@@ -1,8 +1,8 @@
 ////////////////////////////////////////////////////////////////////////////////
 ///
-/// General FIR digital filter routines with MMX optimization. 
+/// General FIR digital filter routines with MMX optimization.
 ///
-/// Note : MMX optimized functions reside in a separate, platform-specific file, 
+/// 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
@@ -41,11 +41,11 @@
 namespace soundtouch
 {
 
-class FIRFilter 
+class FIRFilter
 {
 protected:
     // Number of FIR filter taps
-    uint length;    
+    uint length;
     // Number of FIR filter taps divided by 8
     uint lengthDiv8;
 
@@ -59,11 +59,11 @@ protected:
     SAMPLETYPE *filterCoeffs;
     SAMPLETYPE *filterCoeffsStereo;
 
-    virtual uint evaluateFilterStereo(SAMPLETYPE *dest, 
-                                      const SAMPLETYPE *src, 
+    virtual uint evaluateFilterStereo(SAMPLETYPE *dest,
+                                      const SAMPLETYPE *src,
                                       uint numSamples) const;
-    virtual uint evaluateFilterMono(SAMPLETYPE *dest, 
-                                    const SAMPLETYPE *src, 
+    virtual uint evaluateFilterMono(SAMPLETYPE *dest,
+                                    const SAMPLETYPE *src,
                                     uint numSamples) const;
     virtual uint evaluateFilterMulti(SAMPLETYPE *dest, const SAMPLETYPE *src, uint numSamples, uint numChannels);
 
@@ -71,26 +71,26 @@ public:
     FIRFilter();
     virtual ~FIRFilter();
 
-    /// Operator 'new' is overloaded so that it automatically creates a suitable instance 
+    /// 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' 
+    /// 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 evaluate(SAMPLETYPE *dest,
+                  const SAMPLETYPE *src,
+                  uint numSamples,
                   uint numChannels);
 
     uint getLength() const;
 
-    virtual void setCoefficients(const SAMPLETYPE *coeffs, 
-                                 uint newLength, 
+    virtual void setCoefficients(const SAMPLETYPE *coeffs,
+                                 uint newLength,
                                  uint uResultDivFactor);
 };
 
diff --git a/3rdparty/soundtouch/source/SoundTouch/InterpolateCubic.cpp b/3rdparty/soundtouch/source/SoundTouch/InterpolateCubic.cpp
index b37b0fa801..fe4c98a8dd 100644
--- a/3rdparty/soundtouch/source/SoundTouch/InterpolateCubic.cpp
+++ b/3rdparty/soundtouch/source/SoundTouch/InterpolateCubic.cpp
@@ -1,5 +1,5 @@
 ////////////////////////////////////////////////////////////////////////////////
-/// 
+///
 /// Cubic interpolation routine.
 ///
 /// Author        : Copyright (c) Olli Parviainen
@@ -37,7 +37,7 @@
 using namespace soundtouch;
 
 // cubic interpolation coefficients
-static const float _coeffs[]= 
+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,
@@ -56,10 +56,10 @@ void InterpolateCubic::resetRegisters()
 }
 
 
-/// Transpose mono audio. Returns number of produced output samples, and 
+/// 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 InterpolateCubic::transposeMono(SAMPLETYPE *pdest,
+                    const SAMPLETYPE *psrc,
                     int &srcSamples)
 {
     int i;
@@ -101,10 +101,10 @@ int InterpolateCubic::transposeMono(SAMPLETYPE *pdest,
 }
 
 
-/// Transpose stereo audio. Returns number of produced output samples, and 
+/// 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 InterpolateCubic::transposeStereo(SAMPLETYPE *pdest,
+                    const SAMPLETYPE *psrc,
                     int &srcSamples)
 {
     int i;
@@ -148,10 +148,10 @@ int InterpolateCubic::transposeStereo(SAMPLETYPE *pdest,
 }
 
 
-/// Transpose multi-channel audio. Returns number of produced output samples, and 
+/// 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 InterpolateCubic::transposeMulti(SAMPLETYPE *pdest,
+                    const SAMPLETYPE *psrc,
                     int &srcSamples)
 {
     int i;
diff --git a/3rdparty/soundtouch/source/SoundTouch/InterpolateCubic.h b/3rdparty/soundtouch/source/SoundTouch/InterpolateCubic.h
index 0d4ea6c51e..4eae60a685 100644
--- a/3rdparty/soundtouch/source/SoundTouch/InterpolateCubic.h
+++ b/3rdparty/soundtouch/source/SoundTouch/InterpolateCubic.h
@@ -1,5 +1,5 @@
 ////////////////////////////////////////////////////////////////////////////////
-/// 
+///
 /// Cubic interpolation routine.
 ///
 /// Author        : Copyright (c) Olli Parviainen
@@ -38,17 +38,17 @@
 namespace soundtouch
 {
 
-class InterpolateCubic final : public TransposerBase
+class InterpolateCubic : public TransposerBase
 {
 protected:
-    virtual int transposeMono(SAMPLETYPE *dest, 
-                        const SAMPLETYPE *src, 
+    virtual int transposeMono(SAMPLETYPE *dest,
+                        const SAMPLETYPE *src,
                         int &srcSamples) override;
-    virtual int transposeStereo(SAMPLETYPE *dest, 
-                        const SAMPLETYPE *src, 
+    virtual int transposeStereo(SAMPLETYPE *dest,
+                        const SAMPLETYPE *src,
                         int &srcSamples) override;
-    virtual int transposeMulti(SAMPLETYPE *dest, 
-                        const SAMPLETYPE *src, 
+    virtual int transposeMulti(SAMPLETYPE *dest,
+                        const SAMPLETYPE *src,
                         int &srcSamples) override;
 
     double fract;
@@ -58,7 +58,7 @@ public:
 
     virtual void resetRegisters() override;
 
-    int getLatency() const override
+    virtual int getLatency() const override
     {
         return 1;
     }
diff --git a/3rdparty/soundtouch/source/SoundTouch/InterpolateLinear.cpp b/3rdparty/soundtouch/source/SoundTouch/InterpolateLinear.cpp
index 9533e79b79..b4571d68af 100644
--- a/3rdparty/soundtouch/source/SoundTouch/InterpolateLinear.cpp
+++ b/3rdparty/soundtouch/source/SoundTouch/InterpolateLinear.cpp
@@ -1,5 +1,5 @@
 ////////////////////////////////////////////////////////////////////////////////
-/// 
+///
 /// Linear interpolation algorithm.
 ///
 /// Author        : Copyright (c) Olli Parviainen
@@ -38,7 +38,7 @@ using namespace soundtouch;
 //////////////////////////////////////////////////////////////////////////////
 //
 // InterpolateLinearInteger - integer arithmetic implementation
-// 
+//
 
 /// fixed-point interpolation routine precision
 #define SCALE    65536
@@ -47,7 +47,7 @@ using namespace soundtouch;
 // Constructor
 InterpolateLinearInteger::InterpolateLinearInteger() : TransposerBase()
 {
-    // Notice: use local function calling syntax for sake of clarity, 
+    // 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);
@@ -60,8 +60,8 @@ void InterpolateLinearInteger::resetRegisters()
 }
 
 
-// Transposes the sample rate of the given samples using linear interpolation. 
-// 'Mono' version of the routine. Returns the number of samples returned in 
+// 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)
 {
@@ -73,7 +73,7 @@ int InterpolateLinearInteger::transposeMono(SAMPLETYPE *dest, const SAMPLETYPE *
     while (srcCount < srcSampleEnd)
     {
         LONG_SAMPLETYPE temp;
-    
+
         assert(iFract < SCALE);
 
         temp = (SCALE - iFract) * src[0] + iFract * src[1];
@@ -93,8 +93,8 @@ int InterpolateLinearInteger::transposeMono(SAMPLETYPE *dest, const SAMPLETYPE *
 }
 
 
-// Transposes the sample rate of the given samples using linear interpolation. 
-// 'Stereo' version of the routine. Returns the number of samples returned in 
+// 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)
 {
@@ -107,7 +107,7 @@ int InterpolateLinearInteger::transposeStereo(SAMPLETYPE *dest, const SAMPLETYPE
     {
         LONG_SAMPLETYPE temp0;
         LONG_SAMPLETYPE temp1;
-    
+
         assert(iFract < SCALE);
 
         temp0 = (SCALE - iFract) * src[0] + iFract * src[2];
@@ -140,7 +140,7 @@ int InterpolateLinearInteger::transposeMulti(SAMPLETYPE *dest, const SAMPLETYPE
     while (srcCount < srcSampleEnd)
     {
         LONG_SAMPLETYPE temp, vol1;
-    
+
         assert(iFract < SCALE);
         vol1 = (LONG_SAMPLETYPE)(SCALE - iFract);
         for (int c = 0; c < numChannels; c ++)
@@ -164,7 +164,7 @@ int InterpolateLinearInteger::transposeMulti(SAMPLETYPE *dest, const SAMPLETYPE
 }
 
 
-// Sets new target iRate. Normal iRate = 1.0, smaller values represent slower 
+// Sets new target iRate. Normal iRate = 1.0, smaller values represent slower
 // iRate, larger faster iRates.
 void InterpolateLinearInteger::setRate(double newRate)
 {
@@ -176,14 +176,14 @@ void InterpolateLinearInteger::setRate(double newRate)
 //////////////////////////////////////////////////////////////////////////////
 //
 // InterpolateLinearFloat - floating point arithmetic implementation
-// 
+//
 //////////////////////////////////////////////////////////////////////////////
 
 
 // Constructor
 InterpolateLinearFloat::InterpolateLinearFloat() : TransposerBase()
 {
-    // Notice: use local function calling syntax for sake of clarity, 
+    // 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);
@@ -196,8 +196,8 @@ void InterpolateLinearFloat::resetRegisters()
 }
 
 
-// Transposes the sample rate of the given samples using linear interpolation. 
-// 'Mono' version of the routine. Returns the number of samples returned in 
+// 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)
 {
@@ -228,8 +228,8 @@ int InterpolateLinearFloat::transposeMono(SAMPLETYPE *dest, const SAMPLETYPE *sr
 }
 
 
-// Transposes the sample rate of the given samples using linear interpolation. 
-// 'Mono' version of the routine. Returns the number of samples returned in 
+// 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)
 {
@@ -272,7 +272,7 @@ int InterpolateLinearFloat::transposeMulti(SAMPLETYPE *dest, const SAMPLETYPE *s
     while (srcCount < srcSampleEnd)
     {
         float temp, vol1, fract_float;
-    
+
         vol1 = (float)(1.0 - fract);
 		fract_float = (float)fract;
         for (int c = 0; c < numChannels; c ++)
diff --git a/3rdparty/soundtouch/source/SoundTouch/InterpolateLinear.h b/3rdparty/soundtouch/source/SoundTouch/InterpolateLinear.h
index e43fda9321..d0e5c908bb 100644
--- a/3rdparty/soundtouch/source/SoundTouch/InterpolateLinear.h
+++ b/3rdparty/soundtouch/source/SoundTouch/InterpolateLinear.h
@@ -1,5 +1,5 @@
 ////////////////////////////////////////////////////////////////////////////////
-/// 
+///
 /// Linear interpolation routine.
 ///
 /// Author        : Copyright (c) Olli Parviainen
@@ -39,29 +39,29 @@ namespace soundtouch
 {
 
 /// Linear transposer class that uses integer arithmetic
-class InterpolateLinearInteger final : public TransposerBase
+class InterpolateLinearInteger : public TransposerBase
 {
 protected:
     int iFract;
     int iRate;
 
-    virtual int transposeMono(SAMPLETYPE *dest, 
-                       const SAMPLETYPE *src, 
+    virtual int transposeMono(SAMPLETYPE *dest,
+                       const SAMPLETYPE *src,
                        int &srcSamples) override;
-    virtual int transposeStereo(SAMPLETYPE *dest, 
-                         const SAMPLETYPE *src, 
+    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 
+    /// 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;
 
-    int getLatency() const override
+    virtual int getLatency() const override
     {
         return 0;
     }
@@ -69,25 +69,25 @@ public:
 
 
 /// Linear transposer class that uses floating point arithmetic
-class InterpolateLinearFloat final : public TransposerBase
+class InterpolateLinearFloat : public TransposerBase
 {
 protected:
     double fract;
 
-    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;
+    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();
 
-    void resetRegisters() override;
+    virtual void resetRegisters();
 
-    int getLatency() const override
+    int getLatency() const
     {
         return 0;
     }
diff --git a/3rdparty/soundtouch/source/SoundTouch/InterpolateShannon.cpp b/3rdparty/soundtouch/source/SoundTouch/InterpolateShannon.cpp
index 975d872ad6..ac0b81ab8c 100644
--- a/3rdparty/soundtouch/source/SoundTouch/InterpolateShannon.cpp
+++ b/3rdparty/soundtouch/source/SoundTouch/InterpolateShannon.cpp
@@ -1,6 +1,6 @@
 ////////////////////////////////////////////////////////////////////////////////
-/// 
-/// Sample interpolation routine using 8-tap band-limited Shannon interpolation 
+///
+/// Sample interpolation routine using 8-tap band-limited Shannon interpolation
 /// with kaiser window.
 ///
 /// Notice. This algorithm is remarkably much heavier than linear or cubic
@@ -43,7 +43,7 @@ using namespace soundtouch;
 
 /// Kaiser window with beta = 2.0
 /// Values scaled down by 5% to avoid overflows
-static const double _kaiser8[8] = 
+static const double _kaiser8[8] =
 {
    0.41778693317814,
    0.64888025049173,
@@ -71,10 +71,10 @@ void InterpolateShannon::resetRegisters()
 #define PI 3.1415926536
 #define sinc(x) (sin(PI * (x)) / (PI * (x)))
 
-/// Transpose mono audio. Returns number of produced output samples, and 
+/// 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 InterpolateShannon::transposeMono(SAMPLETYPE *pdest,
+                    const SAMPLETYPE *psrc,
                     int &srcSamples)
 {
     int i;
@@ -119,10 +119,10 @@ int InterpolateShannon::transposeMono(SAMPLETYPE *pdest,
 }
 
 
-/// Transpose stereo audio. Returns number of produced output samples, and 
+/// 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 InterpolateShannon::transposeStereo(SAMPLETYPE *pdest,
+                    const SAMPLETYPE *psrc,
                     int &srcSamples)
 {
     int i;
@@ -169,11 +169,11 @@ int InterpolateShannon::transposeStereo(SAMPLETYPE *pdest,
 }
 
 
-/// Transpose stereo audio. Returns number of produced output samples, and 
+/// Transpose stereo audio. Returns number of produced output samples, and
 /// updates "srcSamples" to amount of consumed source samples
-int InterpolateShannon::transposeMulti(SAMPLETYPE *pdest, 
-                    const SAMPLETYPE *psrc, 
-                    int &srcSamples)
+int InterpolateShannon::transposeMulti(SAMPLETYPE *,
+                    const SAMPLETYPE *,
+                    int &)
 {
     // not implemented
     assert(false);
diff --git a/3rdparty/soundtouch/source/SoundTouch/InterpolateShannon.h b/3rdparty/soundtouch/source/SoundTouch/InterpolateShannon.h
index 40265db014..99bd7a622f 100644
--- a/3rdparty/soundtouch/source/SoundTouch/InterpolateShannon.h
+++ b/3rdparty/soundtouch/source/SoundTouch/InterpolateShannon.h
@@ -1,6 +1,6 @@
 ////////////////////////////////////////////////////////////////////////////////
-/// 
-/// Sample interpolation routine using 8-tap band-limited Shannon interpolation 
+///
+/// Sample interpolation routine using 8-tap band-limited Shannon interpolation
 /// with kaiser window.
 ///
 /// Notice. This algorithm is remarkably much heavier than linear or cubic
@@ -43,17 +43,17 @@
 namespace soundtouch
 {
 
-class InterpolateShannon final : public TransposerBase
+class InterpolateShannon : public TransposerBase
 {
 protected:
-    int transposeMono(SAMPLETYPE *dest, 
-                        const SAMPLETYPE *src, 
+    int transposeMono(SAMPLETYPE *dest,
+                        const SAMPLETYPE *src,
                         int &srcSamples) override;
-    int transposeStereo(SAMPLETYPE *dest, 
-                        const SAMPLETYPE *src, 
+    int transposeStereo(SAMPLETYPE *dest,
+                        const SAMPLETYPE *src,
                         int &srcSamples) override;
-    int transposeMulti(SAMPLETYPE *dest, 
-                        const SAMPLETYPE *src, 
+    int transposeMulti(SAMPLETYPE *dest,
+                        const SAMPLETYPE *src,
                         int &srcSamples) override;
 
     double fract;
@@ -63,7 +63,7 @@ public:
 
     void resetRegisters() override;
 
-    int getLatency() const override
+    virtual int getLatency() const override
     {
         return 3;
     }
diff --git a/3rdparty/soundtouch/source/SoundTouch/PeakFinder.cpp b/3rdparty/soundtouch/source/SoundTouch/PeakFinder.cpp
index 44dc937ae7..ebb79ee7db 100644
--- a/3rdparty/soundtouch/source/SoundTouch/PeakFinder.cpp
+++ b/3rdparty/soundtouch/source/SoundTouch/PeakFinder.cpp
@@ -1,8 +1,8 @@
 ////////////////////////////////////////////////////////////////////////////////
 ///
-/// Peak detection routine. 
+/// Peak detection routine.
 ///
-/// The routine detects highest value on an array of values and calculates the 
+/// 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
@@ -80,7 +80,7 @@ int PeakFinder::findTop(const float *data, int peakpos) const
 
 
 // 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 
+// to direction defined by 'direction' until next 'hump' after minimum value will
 // begin
 int PeakFinder::findGround(const float *data, int peakpos, int direction) const
 {
@@ -186,7 +186,7 @@ double PeakFinder::getPeakCenter(const float *data, int peakpos) const
 
     peakLevel = data[peakpos];
 
-    if (gp1 == gp2) 
+    if (gp1 == gp2)
     {
         // avoid rounding errors when all are equal
         assert(gp1 == peakpos);
@@ -210,7 +210,7 @@ double PeakFinder::getPeakCenter(const float *data, int peakpos) const
 }
 
 
-double PeakFinder::detectPeak(const float *data, int aminPos, int amaxPos) 
+double PeakFinder::detectPeak(const float *data, int aminPos, int amaxPos)
 {
 
     int i;
@@ -225,19 +225,19 @@ double PeakFinder::detectPeak(const float *data, int aminPos, int amaxPos)
     peak = data[minPos];
     for (i = minPos + 1; i < maxPos; i ++)
     {
-        if (data[i] > peak) 
+        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 
+    // 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 ++)
@@ -254,7 +254,7 @@ double PeakFinder::detectPeak(const float *data, int aminPos, int amaxPos)
         // calculate mass-center of possible harmonic peak
         peaktmp = getPeakCenter(data, peakpos);
 
-        // accept harmonic peak if 
+        // 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
diff --git a/3rdparty/soundtouch/source/SoundTouch/PeakFinder.h b/3rdparty/soundtouch/source/SoundTouch/PeakFinder.h
index bf46daa17b..106eac80c3 100644
--- a/3rdparty/soundtouch/source/SoundTouch/PeakFinder.h
+++ b/3rdparty/soundtouch/source/SoundTouch/PeakFinder.h
@@ -1,6 +1,6 @@
 ////////////////////////////////////////////////////////////////////////////////
 ///
-/// The routine detects highest value on an array of values and calculates the 
+/// 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
@@ -60,7 +60,7 @@ protected:
     int findTop(const float *data, int peakpos) const;
 
 
-    /// Finds the 'ground' level, i.e. smallest level between two neighbouring peaks, to right- 
+    /// 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.
@@ -71,7 +71,7 @@ protected:
     double getPeakCenter(const float *data, int peakpos) const;
 
 public:
-    /// Constructor. 
+    /// Constructor.
     PeakFinder();
 
     /// Detect exact peak position of the data vector by finding the largest peak 'hump'
diff --git a/3rdparty/soundtouch/source/SoundTouch/RateTransposer.cpp b/3rdparty/soundtouch/source/SoundTouch/RateTransposer.cpp
index 4c202391e0..2b921186c1 100644
--- a/3rdparty/soundtouch/source/SoundTouch/RateTransposer.cpp
+++ b/3rdparty/soundtouch/source/SoundTouch/RateTransposer.cpp
@@ -1,6 +1,6 @@
 ////////////////////////////////////////////////////////////////////////////////
-/// 
-/// Sample rate transposer. Changes sample rate by using linear interpolation 
+///
+/// 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)
 ///
@@ -50,7 +50,7 @@ TransposerBase::ALGORITHM TransposerBase::algorithm = TransposerBase::CUBIC;
 // Constructor
 RateTransposer::RateTransposer() : FIFOProcessor(&outputBuffer)
 {
-    bUseAAFilter = 
+    bUseAAFilter =
 #ifndef SOUNDTOUCH_PREVENT_CLICK_AT_RATE_CROSSOVER
         true;
 #else
@@ -96,7 +96,7 @@ AAFilter *RateTransposer::getAAFilter()
 }
 
 
-// Sets new target iRate. Normal iRate = 1.0, smaller values represent slower 
+// Sets new target iRate. Normal iRate = 1.0, smaller values represent slower
 // iRate, larger faster iRates.
 void RateTransposer::setRate(double newRate)
 {
@@ -105,11 +105,11 @@ void RateTransposer::setRate(double newRate)
     pTransposer->setRate(newRate);
 
     // design a new anti-alias filter
-    if (newRate > 1.0) 
+    if (newRate > 1.0)
     {
         fCutoff = 0.5 / newRate;
-    } 
-    else 
+    }
+    else
     {
         fCutoff = 0.5 * newRate;
     }
@@ -125,14 +125,12 @@ void RateTransposer::putSamples(const SAMPLETYPE *samples, uint nSamples)
 }
 
 
-// Transposes sample rate by applying anti-alias filter to prevent folding. 
+// 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)
 {
-    uint count;
-
     if (nSamples == 0) return;
 
     // Store samples to input buffer
@@ -140,16 +138,16 @@ void RateTransposer::processSamples(const SAMPLETYPE *src, uint nSamples)
 
     // If anti-alias filter is turned off, simply transpose without applying
     // the filter
-    if (bUseAAFilter == false) 
+    if (bUseAAFilter == false)
     {
-        count = pTransposer->transpose(outputBuffer, inputBuffer);
+        (void)pTransposer->transpose(outputBuffer, inputBuffer);
         return;
     }
 
     assert(pAAFilter);
 
     // Transpose with anti-alias filter
-    if (pTransposer->rate < 1.0f) 
+    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.
@@ -159,8 +157,8 @@ void RateTransposer::processSamples(const SAMPLETYPE *src, uint nSamples)
 
         // Apply the anti-alias filter for transposed samples in midBuffer
         pAAFilter->evaluate(outputBuffer, midBuffer);
-    } 
-    else  
+    }
+    else
     {
         // If the parameter 'Rate' value is larger than 1, first apply the
         // anti-alias filter to remove high frequencies (prevent them from folding
@@ -224,7 +222,7 @@ int RateTransposer::getLatency() const
 //////////////////////////////////////////////////////////////////////////////
 //
 // TransposerBase - Base class for interpolation
-// 
+//
 
 // static function to set interpolation algorithm
 void TransposerBase::setAlgorithm(TransposerBase::ALGORITHM a)
@@ -233,7 +231,7 @@ void TransposerBase::setAlgorithm(TransposerBase::ALGORITHM a)
 }
 
 
-// Transposes the sample rate of the given samples using linear interpolation. 
+// 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)
 {
@@ -248,11 +246,11 @@ int TransposerBase::transpose(FIFOSampleBuffer &dest, FIFOSampleBuffer &src)
     {
         numOutput = transposeMono(pdest, psrc, numSrcSamples);
     }
-    else if (numChannels == 2) 
+    else if (numChannels == 2)
     {
         numOutput = transposeStereo(pdest, psrc, numSrcSamples);
-    } 
-    else 
+    }
+    else
 #endif // USE_MULTICH_ALWAYS
     {
         assert(numChannels > 0);
@@ -309,7 +307,7 @@ TransposerBase *TransposerBase::newInstance()
 
         default:
             assert(false);
-            return NULL;
+            return nullptr;
     }
 #endif
 }
diff --git a/3rdparty/soundtouch/source/SoundTouch/RateTransposer.h b/3rdparty/soundtouch/source/SoundTouch/RateTransposer.h
index bd02eff13f..32bbadc18e 100644
--- a/3rdparty/soundtouch/source/SoundTouch/RateTransposer.h
+++ b/3rdparty/soundtouch/source/SoundTouch/RateTransposer.h
@@ -1,10 +1,10 @@
 ////////////////////////////////////////////////////////////////////////////////
-/// 
-/// Sample rate transposer. Changes sample rate by using linear interpolation 
+///
+/// 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 
+/// Use either of the derived classes of 'RateTransposerInteger' or
 /// 'RateTransposerFloat' for corresponding integer/floating point tranposing
 /// algorithm implementation.
 ///
@@ -59,14 +59,14 @@ public:
     };
 
 protected:
-    virtual int transposeMono(SAMPLETYPE *dest, 
-                        const SAMPLETYPE *src, 
+    virtual int transposeMono(SAMPLETYPE *dest,
+                        const SAMPLETYPE *src,
                         int &srcSamples)  = 0;
-    virtual int transposeStereo(SAMPLETYPE *dest, 
-                        const SAMPLETYPE *src, 
+    virtual int transposeStereo(SAMPLETYPE *dest,
+                        const SAMPLETYPE *src,
                         int &srcSamples) = 0;
-    virtual int transposeMulti(SAMPLETYPE *dest, 
-                        const SAMPLETYPE *src, 
+    virtual int transposeMulti(SAMPLETYPE *dest,
+                        const SAMPLETYPE *src,
                         int &srcSamples) = 0;
 
     static ALGORITHM algorithm;
@@ -115,11 +115,11 @@ protected:
     bool bUseAAFilter;
 
 
-    /// Transposes sample rate by applying anti-alias filter to prevent folding. 
+    /// 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, 
+    void processSamples(const SAMPLETYPE *src,
                         uint numSamples);
 
 public:
@@ -138,7 +138,7 @@ public:
     /// Returns nonzero if anti-alias filter is enabled.
     bool isAAFilterEnabled() const;
 
-    /// Sets new target rate. Normal rate = 1.0, smaller values represent slower 
+    /// Sets new target rate. Normal rate = 1.0, smaller values represent slower
     /// rate, larger faster rates.
     virtual void setRate(double newRate);
 
diff --git a/3rdparty/soundtouch/source/SoundTouch/SoundTouch.cpp b/3rdparty/soundtouch/source/SoundTouch/SoundTouch.cpp
index 69fba8b9b5..0eda80ae92 100644
--- a/3rdparty/soundtouch/source/SoundTouch/SoundTouch.cpp
+++ b/3rdparty/soundtouch/source/SoundTouch/SoundTouch.cpp
@@ -1,27 +1,27 @@
 //////////////////////////////////////////////////////////////////////////////
 ///
-/// SoundTouch - main class for tempo/pitch/rate adjusting routines. 
+/// 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 
+/// - 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 
+/// - 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 
+///   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 
+///
+/// - 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 
+///
+/// - 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 
+///   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.
@@ -30,8 +30,8 @@
 ///   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) 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.
 ///
@@ -74,7 +74,7 @@
 #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)
 
@@ -83,7 +83,7 @@ using namespace soundtouch;
 extern "C" void soundtouch_ac_test()
 {
     printf("SoundTouch Version: %s\n",SOUNDTOUCH_VERSION);
-} 
+}
 
 
 SoundTouch::SoundTouch()
@@ -97,8 +97,8 @@ SoundTouch::SoundTouch()
 
     rate = tempo = 0;
 
-    virtualPitch = 
-    virtualRate = 
+    virtualPitch =
+    virtualRate =
     virtualTempo = 1.0;
 
     calcEffectiveRateAndTempo();
@@ -227,9 +227,9 @@ void SoundTouch::calcEffectiveRateAndTempo()
     if (!TEST_FLOAT_EQUAL(tempo, oldTempo)) pTDStretch->setTempo(tempo);
 
 #ifndef SOUNDTOUCH_PREVENT_CLICK_AT_RATE_CROSSOVER
-    if (rate <= 1.0f) 
+    if (rate <= 1.0f)
     {
-        if (output != pTDStretch) 
+        if (output != pTDStretch)
         {
             FIFOSamplePipe *tempoOut;
 
@@ -246,7 +246,7 @@ void SoundTouch::calcEffectiveRateAndTempo()
     else
 #endif
     {
-        if (output != pRateTransposer) 
+        if (output != pRateTransposer)
         {
             FIFOSamplePipe *transOut;
 
@@ -259,7 +259,7 @@ void SoundTouch::calcEffectiveRateAndTempo()
 
             output = pRateTransposer;
         }
-    } 
+    }
 }
 
 
@@ -276,31 +276,31 @@ void SoundTouch::setSampleRate(uint srate)
 // the input of the object.
 void SoundTouch::putSamples(const SAMPLETYPE *samples, uint nSamples)
 {
-    if (bSrateSet == false) 
+    if (bSrateSet == false)
     {
         ST_THROW_RT_ERROR("SoundTouch : Sample rate not defined");
-    } 
-    else if (channels == 0) 
+    }
+    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 
+    // 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) 
+    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 
+    }
+    else
 #endif
     {
-        // evaluate the tempo changer, then transpose the rate up, 
+        // evaluate the tempo changer, then transpose the rate up,
         assert(output == pRateTransposer);
         pTDStretch->putSamples(samples, nSamples);
         pRateTransposer->moveSamples(*pTDStretch);
@@ -327,8 +327,8 @@ void SoundTouch::flush()
 
     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 
+    // 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 ++)
     {
@@ -355,7 +355,7 @@ bool SoundTouch::setSetting(int settingId, int value)
     // read current tdstretch routine parameters
     pTDStretch->getParameters(&sampleRate, &sequenceMs, &seekWindowMs, &overlapMs);
 
-    switch (settingId) 
+    switch (settingId)
     {
         case SETTING_USE_AA_FILTER :
             // enables / disabless anti-alias filter
@@ -401,7 +401,7 @@ int SoundTouch::getSetting(int settingId) const
 {
     int temp;
 
-    switch (settingId) 
+    switch (settingId)
     {
         case SETTING_USE_AA_FILTER :
             return (uint)pRateTransposer->isAAFilterEnabled();
@@ -413,15 +413,15 @@ int SoundTouch::getSetting(int settingId) const
             return (uint)pTDStretch->isQuickSeekEnabled();
 
         case SETTING_SEQUENCE_MS:
-            pTDStretch->getParameters(NULL, &temp, NULL, NULL);
+            pTDStretch->getParameters(nullptr, &temp, nullptr, nullptr);
             return temp;
 
         case SETTING_SEEKWINDOW_MS:
-            pTDStretch->getParameters(NULL, NULL, &temp, NULL);
+            pTDStretch->getParameters(nullptr, nullptr, &temp, nullptr);
             return temp;
 
         case SETTING_OVERLAP_MS:
-            pTDStretch->getParameters(NULL, NULL, NULL, &temp);
+            pTDStretch->getParameters(nullptr, nullptr, nullptr, &temp);
             return temp;
 
         case SETTING_NOMINAL_INPUT_SEQUENCE :
@@ -503,8 +503,8 @@ uint SoundTouch::numUnprocessedSamples() const
 }
 
 
-/// 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 
+/// 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.
@@ -516,8 +516,8 @@ uint SoundTouch::receiveSamples(SAMPLETYPE *output, uint maxSamples)
 }
 
 
-/// Adjusts book-keeping so that given number of samples are removed from beginning of the 
-/// sample buffer without copying them anywhere. 
+/// 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.
@@ -530,7 +530,7 @@ uint SoundTouch::receiveSamples(uint maxSamples)
 
 
 /// Get ratio between input and output audio durations, useful for calculating
-/// processed output duration: if you'll process a stream of N samples, then 
+/// 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()
 {
diff --git a/3rdparty/soundtouch/source/SoundTouch/TDStretch.cpp b/3rdparty/soundtouch/source/SoundTouch/TDStretch.cpp
index c903a92f6b..93ac181ef6 100644
--- a/3rdparty/soundtouch/source/SoundTouch/TDStretch.cpp
+++ b/3rdparty/soundtouch/source/SoundTouch/TDStretch.cpp
@@ -1,15 +1,15 @@
 ///////////////////////////////////////////////////////////////////////////////
-/// 
-/// Sampled sound tempo changer/time stretch algorithm. Changes the sound tempo 
-/// while maintaining the original pitch by using a time domain WSOLA-like 
+///
+/// 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 
+/// 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 
+/// 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
 ///
@@ -54,25 +54,6 @@ using namespace soundtouch;
 
 #define max(x, y) (((x) > (y)) ? (x) : (y))
 
-/*****************************************************************************
- *
- * Constant definitions
- *
- *****************************************************************************/
-
-// Table for the hierarchical mixing position seeking algorithm
-const short _scanOffsets[5][24]={
-    { 124,  186,  248,  310,  372,  434,  496,  558,  620,  682,  744, 806,
-      868,  930,  992, 1054, 1116, 1178, 1240, 1302, 1364, 1426, 1488,   0},
-    {-100,  -75,  -50,  -25,   25,   50,   75,  100,    0,    0,    0,   0,
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,   0},
-    { -20,  -15,  -10,   -5,    5,   10,   15,   20,    0,    0,    0,   0,
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,   0},
-    {  -4,   -3,   -2,   -1,    1,    2,    3,    4,    0,    0,    0,   0,
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,   0},
-    { 121,  114,   97,  114,   98,  105,  108,   32,  104,   99,  117,  111,
-      116,  100,  110,  117,  111,  115,    0,    0,    0,    0,    0,   0}};
-
 /*****************************************************************************
  *
  * Implementation of the class 'TDStretch'
@@ -85,8 +66,8 @@ TDStretch::TDStretch() : FIFOProcessor(&outputBuffer)
     bQuickSeek = false;
     channels = 2;
 
-    pMidBuffer = NULL;
-    pMidBufferUnaligned = NULL;
+    pMidBuffer = nullptr;
+    pMidBufferUnaligned = nullptr;
     overlapLength = 0;
 
     bAutoSeqSetting = true;
@@ -113,11 +94,11 @@ TDStretch::~TDStretch()
 //
 // '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 
+// '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, 
+void TDStretch::setParameters(int aSampleRate, int aSequenceMS,
                               int aSeekWindowMS, int aOverlapMS)
 {
     // accept only positive parameter values - if zero or negative, use old values instead
@@ -133,19 +114,19 @@ void TDStretch::setParameters(int aSampleRate, int aSequenceMS,
     {
         this->sequenceMs = aSequenceMS;
         bAutoSeqSetting = false;
-    } 
+    }
     else if (aSequenceMS == 0)
     {
         // if zero, use automatic setting
         bAutoSeqSetting = true;
     }
 
-    if (aSeekWindowMS > 0) 
+    if (aSeekWindowMS > 0)
     {
         this->seekWindowMs = aSeekWindowMS;
         bAutoSeekSetting = false;
-    } 
-    else if (aSeekWindowMS == 0) 
+    }
+    else if (aSeekWindowMS == 0)
     {
         // if zero, use automatic setting
         bAutoSeekSetting = true;
@@ -162,7 +143,7 @@ void TDStretch::setParameters(int aSampleRate, int aSequenceMS,
 
 
 /// Get routine control parameters, see setParameters() function.
-/// Any of the parameters to this function can be NULL, in such case corresponding parameter
+/// 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
 {
@@ -251,11 +232,11 @@ bool TDStretch::isQuickSeekEnabled() const
 // Seeks for the optimal overlap-mixing position.
 int TDStretch::seekBestOverlapPosition(const SAMPLETYPE *refPos)
 {
-    if (bQuickSeek) 
+    if (bQuickSeek)
     {
         return seekBestOverlapPositionQuick(refPos);
     }
-    else 
+    else
     {
         return seekBestOverlapPositionFull(refPos);
     }
@@ -276,8 +257,8 @@ inline void TDStretch::overlap(SAMPLETYPE *pOutput, const SAMPLETYPE *pInput, ui
     {
         // stereo sound
         overlapStereo(pOutput, pInput + 2 * ovlPos);
-    } 
-    else 
+    }
+    else
 #endif // USE_MULTICH_ALWAYS
     {
         assert(channels > 0);
@@ -292,7 +273,7 @@ inline void TDStretch::overlap(SAMPLETYPE *pOutput, const SAMPLETYPE *pInput, ui
 // 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 TDStretch::seekBestOverlapPositionFull(const SAMPLETYPE *refPos)
 {
     int bestOffs;
     double bestCorr;
@@ -319,7 +300,7 @@ int TDStretch::seekBestOverlapPositionFull(const SAMPLETYPE *refPos)
         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 
+        // as "calcCrossCorr", but saves time by reusing & updating previously stored
         // "norm" value
         corr = calcCrossCorrAccumulate(refPos + channels * i, pMidBuffer, norm);
 #endif
@@ -328,7 +309,7 @@ int TDStretch::seekBestOverlapPositionFull(const SAMPLETYPE *refPos)
         corr = ((corr + 0.1) * (1.0 - 0.25 * tmp * tmp));
 
         // Checks for the highest correlation value
-        if (corr > bestCorr) 
+        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
@@ -353,14 +334,14 @@ int TDStretch::seekBestOverlapPositionFull(const SAMPLETYPE *refPos)
 }
 
 
-// Quick seek algorithm for improved runtime-performance: First roughly scans through the 
+// 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, 
+// - 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)
 {
@@ -379,7 +360,7 @@ int TDStretch::seekBestOverlapPositionQuick(const SAMPLETYPE *refPos)
 
     bestCorr =
     bestCorr2 = -FLT_MAX;
-    bestOffs = 
+    bestOffs =
     bestOffs2 = SCANWIND;
 
     // Scans for the best correlation value by testing each possible position
@@ -387,7 +368,7 @@ int TDStretch::seekBestOverlapPositionQuick(const SAMPLETYPE *refPos)
     // 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 
+    // catch the 'middlepoint' of seekLength vector as that's the a-priori
     // expected best match position
     //
     // Roughly:
@@ -475,7 +456,7 @@ int TDStretch::seekBestOverlapPositionQuick(const SAMPLETYPE *refPos)
 
 
 
-/// For integer algorithm: adapt normalization factor divider with music so that 
+/// 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()
@@ -483,7 +464,7 @@ 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;
 
@@ -504,7 +485,7 @@ void TDStretch::adaptNormalizer()
 }
 
 
-/// clear cross correlation routine state if necessary 
+/// clear cross correlation routine state if necessary
 void TDStretch::clearCrossCorrState()
 {
     // default implementation is empty.
@@ -534,7 +515,7 @@ void TDStretch::calcSeqParameters()
     #define CHECK_LIMITS(x, mi, ma) (((x) < (mi)) ? (mi) : (((x) > (ma)) ? (ma) : (x)))
 
     double seq, seek;
-    
+
     if (bAutoSeqSetting)
     {
         seq = AUTOSEQ_C + AUTOSEQ_K * tempo;
@@ -551,7 +532,7 @@ void TDStretch::calcSeqParameters()
 
     // Update seek window lengths
     seekWindowLength = (sampleRate * sequenceMs) / 1000;
-    if (seekWindowLength < 2 * overlapLength) 
+    if (seekWindowLength < 2 * overlapLength)
     {
         seekWindowLength = 2 * overlapLength;
     }
@@ -560,7 +541,7 @@ void TDStretch::calcSeqParameters()
 
 
 
-// Sets new target tempo. Normal tempo = 'SCALE', smaller values represent slower 
+// Sets new target tempo. Normal tempo = 'SCALE', smaller values represent slower
 // tempo, larger faster tempo.
 void TDStretch::setTempo(double newTempo)
 {
@@ -571,11 +552,11 @@ void TDStretch::setTempo(double newTempo)
     // Calculate new sequence duration
     calcSeqParameters();
 
-    // Calculate ideal skip length (according to tempo value) 
+    // 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 
+    // 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;
@@ -606,18 +587,18 @@ void TDStretch::processNominalTempo()
 {
     assert(tempo == 1.0f);
 
-    if (bMidBufferDirty) 
+    if (bMidBufferDirty)
     {
         // If there are samples in pMidBuffer waiting for overlapping,
-        // do a single sliding overlapping with them in order to prevent a 
+        // do a single sliding overlapping with them in order to prevent a
         // clicking distortion in the output sound
-        if (inputBuffer.numSamples() < overlapLength) 
+        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 
+        // 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);
@@ -642,7 +623,7 @@ void TDStretch::processSamples()
 
     /* Removed this small optimization - can introduce a click to sound when tempo setting
        crosses the nominal value
-    if (tempo == 1.0f) 
+    if (tempo == 1.0f)
     {
         // tempo not changed from the original, so bypass the processing
         processNominalTempo();
@@ -652,15 +633,15 @@ void TDStretch::processSamples()
 
     // Process samples as long as there are enough samples in 'inputBuffer'
     // to form a processing frame.
-    while ((int)inputBuffer.numSamples() >= sampleReq) 
+    while ((int)inputBuffer.numSamples() >= sampleReq)
     {
         if (isBeginning == false)
         {
-            // apart from the very beginning of the track, 
+            // 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 
+            // 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')
@@ -705,11 +686,11 @@ void TDStretch::processSamples()
         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 
+        // 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), 
+        memcpy(pMidBuffer, inputBuffer.ptrBegin() + channels * (offset + temp),
             channels * sizeof(SAMPLETYPE) * overlapLength);
 
         // Remove the processed samples from the input buffer. Update
@@ -757,9 +738,9 @@ void TDStretch::acceptNewOverlapLength(int newOverlapLength)
 }
 
 
-// Operator 'new' is overloaded so that it automatically creates a suitable instance 
+// 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 s)
+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!");
@@ -772,6 +753,7 @@ TDStretch * TDStretch::newInstance()
     uint uExtensions;
 
     uExtensions = detectCPUextensions();
+    (void)uExtensions;
 
     // Check if MMX/SSE instruction set extensions supported by CPU
 
@@ -809,7 +791,7 @@ TDStretch * TDStretch::newInstance()
 
 #ifdef SOUNDTOUCH_INTEGER_SAMPLES
 
-// Overlaps samples in 'midBuffer' with the samples in 'input'. The 'Stereo' 
+// Overlaps samples in 'midBuffer' with the samples in 'input'. The 'Stereo'
 // version of the routine.
 void TDStretch::overlapStereo(short *poutput, const short *input) const
 {
@@ -862,8 +844,8 @@ void TDStretch::calculateOverlapLength(int aoverlapMs)
     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 
+    // 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;
@@ -873,8 +855,8 @@ void TDStretch::calculateOverlapLength(int aoverlapMs)
 
     overlapDividerBitsNorm = overlapDividerBitsPure;
 
-    // calculate sloping divider so that crosscorrelation operation won't 
-    // overflow 32-bit register. Max. sum of the crosscorrelation sum without 
+    // 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;
 }
@@ -898,9 +880,9 @@ double TDStretch::calcCrossCorr(const short *mixingPos, const short *compare, do
     // Same routine for stereo and mono
     for (i = 0; i < ilength; i += 2)
     {
-        corr += (mixingPos[i] * compare[i] + 
+        corr += (mixingPos[i] * compare[i] +
                  mixingPos[i + 1] * compare[i + 1]) >> overlapDividerBitsNorm;
-        lnorm += (mixingPos[i] * mixingPos[i] + 
+        lnorm += (mixingPos[i] * mixingPos[i] +
                   mixingPos[i + 1] * mixingPos[i + 1]) >> overlapDividerBitsNorm;
         // do intermediate scalings to avoid integer overflow
     }
@@ -914,7 +896,7 @@ double TDStretch::calcCrossCorr(const short *mixingPos, const short *compare, do
             maxnorm = lnorm;
         }
     }
-    // Normalize result by dividing by sqrt(norm) - this step is easiest 
+    // 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);
@@ -940,9 +922,9 @@ double TDStretch::calcCrossCorrAccumulate(const short *mixingPos, const short *c
 
     corr = 0;
     // Same routine for stereo and mono.
-    for (i = 0; i < ilength; i += 2) 
+    for (i = 0; i < ilength; i += 2)
     {
-        corr += (mixingPos[i] * compare[i] + 
+        corr += (mixingPos[i] * compare[i] +
                  mixingPos[i + 1] * compare[i + 1]) >> overlapDividerBitsNorm;
     }
 
@@ -959,7 +941,7 @@ double TDStretch::calcCrossCorrAccumulate(const short *mixingPos, const short *c
         maxnorm = (unsigned long)norm;
     }
 
-    // Normalize result by dividing by sqrt(norm) - this step is easiest 
+    // 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);
 }
@@ -986,7 +968,7 @@ void TDStretch::overlapStereo(float *pOutput, const float *pInput) const
     f1 = 0;
     f2 = 1.0f;
 
-    for (i = 0; i < 2 * (int)overlapLength ; i += 2) 
+    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;
@@ -997,7 +979,7 @@ void TDStretch::overlapStereo(float *pOutput, const float *pInput) const
 }
 
 
-// Overlaps samples in 'midBuffer' with the samples in 'input'. 
+// Overlaps samples in 'midBuffer' with the samples in 'input'.
 void TDStretch::overlapMulti(float *pOutput, const float *pInput) const
 {
     int i;
diff --git a/3rdparty/soundtouch/source/SoundTouch/TDStretch.h b/3rdparty/soundtouch/source/SoundTouch/TDStretch.h
index 9062d3deb3..483dd536e2 100644
--- a/3rdparty/soundtouch/source/SoundTouch/TDStretch.h
+++ b/3rdparty/soundtouch/source/SoundTouch/TDStretch.h
@@ -1,10 +1,10 @@
 ////////////////////////////////////////////////////////////////////////////////
-/// 
-/// Sampled sound tempo changer/time stretch algorithm. Changes the sound tempo 
-/// while maintaining the original pitch by using a time domain WSOLA-like method 
+///
+/// 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 
+/// Note : MMX/SSE optimized functions reside in separate, platform-specific files
 /// 'mmx_optimized.cpp' and 'sse_optimized.cpp'
 ///
 /// Author        : Copyright (c) Olli Parviainen
@@ -46,14 +46,14 @@ namespace soundtouch
 {
 
 /// Default values for sound processing parameters:
-/// Notice that the default parameters are tuned for contemporary popular music 
+/// 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 
+/// 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
@@ -68,15 +68,15 @@ namespace soundtouch
 /// 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. 
+/// 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 
+/// 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.
@@ -87,11 +87,11 @@ namespace soundtouch
 /// 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. 
+/// 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 
+/// 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.
@@ -162,27 +162,27 @@ protected:
     /// 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 
+    /// 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. 
+    /// 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 
+    /// Sets new target tempo. Normal tempo = 'SCALE', smaller values represent slower
     /// tempo, larger faster tempo.
     void setTempo(double newTempo);
 
@@ -195,7 +195,7 @@ public:
     /// Sets the number of channels, 1 = mono, 2 = stereo
     void setChannels(int numChannels);
 
-    /// Enables/disables the quick position seeking algorithm. Zero to disable, 
+    /// Enables/disables the quick position seeking algorithm. Zero to disable,
     /// nonzero to enable
     void enableQuickSeek(bool enable);
 
@@ -207,7 +207,7 @@ public:
     //
     /// 'sampleRate' = sample rate of the sound
     /// 'sequenceMS' = one processing sequence length in milliseconds
-    /// 'seekwindowMS' = seeking window length for scanning the best overlapping 
+    /// 'seekwindowMS' = seeking window length for scanning the best overlapping
     ///      position
     /// 'overlapMS' = overlapping length
     void setParameters(int sampleRate,          ///< Samplerate of sound being processed (Hz)
@@ -217,7 +217,7 @@ public:
                        );
 
     /// Get routine control parameters, see setParameters() function.
-    /// Any of the parameters to this function can be NULL, in such case corresponding parameter
+    /// 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;
 
diff --git a/3rdparty/soundtouch/source/SoundTouch/cpu_detect.h b/3rdparty/soundtouch/source/SoundTouch/cpu_detect.h
index 093b6097aa..0794c4483b 100644
--- a/3rdparty/soundtouch/source/SoundTouch/cpu_detect.h
+++ b/3rdparty/soundtouch/source/SoundTouch/cpu_detect.h
@@ -2,8 +2,8 @@
 ///
 /// 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 
+/// 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
diff --git a/3rdparty/soundtouch/source/SoundTouch/cpu_detect_x86.cpp b/3rdparty/soundtouch/source/SoundTouch/cpu_detect_x86.cpp
index 06c6078279..18d88e9ec5 100644
--- a/3rdparty/soundtouch/source/SoundTouch/cpu_detect_x86.cpp
+++ b/3rdparty/soundtouch/source/SoundTouch/cpu_detect_x86.cpp
@@ -2,7 +2,7 @@
 ///
 /// Generic version of the x86 CPU extension detection routine.
 ///
-/// This file is for GNU & other non-Windows compilers, see 'cpu_detect_x86_win.cpp' 
+/// 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
@@ -86,9 +86,9 @@ uint detectCPUextensions(void)
     && 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.
@@ -101,7 +101,7 @@ uint detectCPUextensions(void)
     if (edx & bit_SSE2) res = res | SUPPORT_SSE2;
 
 #else
-    // Window / VS version of cpuid. Notice that Visual Studio 2005 or later required 
+    // Window / VS version of cpuid. Notice that Visual Studio 2005 or later required
     // for __cpuid intrinsic support.
     int reg[4] = {-1};
 
diff --git a/3rdparty/soundtouch/source/SoundTouch/mmx_optimized.cpp b/3rdparty/soundtouch/source/SoundTouch/mmx_optimized.cpp
index 0bc7fe86f7..2fdeeac946 100644
--- a/3rdparty/soundtouch/source/SoundTouch/mmx_optimized.cpp
+++ b/3rdparty/soundtouch/source/SoundTouch/mmx_optimized.cpp
@@ -1,15 +1,15 @@
 ////////////////////////////////////////////////////////////////////////////////
 ///
-/// 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 
+/// 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++ 
+/// 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
@@ -68,14 +68,14 @@ double TDStretchMMX::calcCrossCorr(const short *pV1, const short *pV2, double &d
     __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 
+    // 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 ++)
     {
@@ -126,7 +126,7 @@ double TDStretchMMX::calcCrossCorr(const short *pV1, const short *pV2, double &d
         }
     }
 
-    // Normalize result by dividing by sqrt(norm) - this step is easiest 
+    // Normalize result by dividing by sqrt(norm) - this step is easiest
     // done using floating point operation
     dnorm = (double)norm;
 
@@ -144,7 +144,7 @@ double TDStretchMMX::calcCrossCorrAccumulate(const short *pV1, const short *pV2,
     __m64 accu;
     long corr, lnorm;
     int i;
-   
+
     // cancel first normalizer tap from previous round
     lnorm = 0;
     for (i = 1; i <= channels; i ++)
@@ -158,7 +158,7 @@ double TDStretchMMX::calcCrossCorrAccumulate(const short *pV1, const short *pV2,
     shifter = _m_from_int(overlapDividerBitsNorm);
     accu = _mm_setzero_si64();
 
-    // Process 4 parallel sets of 2 * stereo samples or 4 * mono samples 
+    // 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 ++)
     {
@@ -203,7 +203,7 @@ double TDStretchMMX::calcCrossCorrAccumulate(const short *pV1, const short *pV2,
         maxnorm = lnorm;
     }
 
-    // Normalize result by dividing by sqrt(norm) - this step is easiest 
+    // 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);
 }
@@ -232,7 +232,7 @@ void TDStretchMMX::overlapStereo(short *output, const short *input) const
     // 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);
@@ -245,7 +245,7 @@ void TDStretchMMX::overlapStereo(short *output, const short *input) const
     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
@@ -294,8 +294,8 @@ void TDStretchMMX::overlapStereo(short *output, const short *input) const
 
 FIRFilterMMX::FIRFilterMMX() : FIRFilter()
 {
-    filterCoeffsAlign = NULL;
-    filterCoeffsUnalign = NULL;
+    filterCoeffsAlign = nullptr;
+    filterCoeffsUnalign = nullptr;
 }
 
 
@@ -316,8 +316,8 @@ void FIRFilterMMX::setCoefficients(const short *coeffs, uint newLength, uint uRe
     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) 
+    // 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];
diff --git a/3rdparty/soundtouch/source/SoundTouch/sse_optimized.cpp b/3rdparty/soundtouch/source/SoundTouch/sse_optimized.cpp
index 9c16ea8f89..73658a5da6 100644
--- a/3rdparty/soundtouch/source/SoundTouch/sse_optimized.cpp
+++ b/3rdparty/soundtouch/source/SoundTouch/sse_optimized.cpp
@@ -1,20 +1,20 @@
 ////////////////////////////////////////////////////////////////////////////////
 ///
-/// 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 
+/// 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 
+/// 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 
+/// 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
@@ -51,7 +51,7 @@ using namespace soundtouch;
 
 #ifdef SOUNDTOUCH_ALLOW_SSE
 
-// SSE routines available only with float sample type    
+// SSE routines available only with float sample type
 
 //////////////////////////////////////////////////////////////////////////////
 //
@@ -71,8 +71,8 @@ double TDStretchSSE::calcCrossCorr(const float *pV1, const float *pV2, double &a
     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 
+    // 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).
@@ -81,7 +81,7 @@ double TDStretchSSE::calcCrossCorr(const float *pV1, const float *pV2, double &a
     // for choosing if this little cheating is allowed.
 
 #ifdef ST_SIMD_AVOID_UNALIGNED
-    // Little cheating allowed, return valid correlation only for 
+    // Little cheating allowed, return valid correlation only for
     // aligned locations, meaning every second round for stereo sound.
 
     #define _MM_LOAD    _mm_load_ps
@@ -92,7 +92,7 @@ double TDStretchSSE::calcCrossCorr(const float *pV1, const float *pV2, double &a
     // No cheating allowed, use unaligned load & take the resulting
     // performance hit.
     #define _MM_LOAD    _mm_loadu_ps
-#endif 
+#endif
 
     // ensure overlapLength is divisible by 8
     assert((overlapLength % 8) == 0);
@@ -105,7 +105,7 @@ double TDStretchSSE::calcCrossCorr(const float *pV1, const float *pV2, double &a
 
     // 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 ++) 
+    for (i = 0; i < channels * overlapLength / 16; i ++)
     {
         __m128 vTemp;
         // vSum += pV1[0..3] * pV2[0..3]
@@ -146,7 +146,7 @@ double TDStretchSSE::calcCrossCorr(const float *pV1, const float *pV2, double &a
 
     // Calculates the cross-correlation value between 'pV1' and 'pV2' vectors
     corr = norm = 0.0;
-    for (i = 0; i < channels * overlapLength / 16; i ++) 
+    for (i = 0; i < channels * overlapLength / 16; i ++)
     {
         corr += pV1[0] * pV2[0] +
                 pV1[1] * pV2[1] +
@@ -178,8 +178,8 @@ double TDStretchSSE::calcCrossCorr(const float *pV1, const float *pV2, double &a
 
 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 
+    // 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);
 }
@@ -195,16 +195,16 @@ double TDStretchSSE::calcCrossCorrAccumulate(const float *pV1, const float *pV2,
 
 FIRFilterSSE::FIRFilterSSE() : FIRFilter()
 {
-    filterCoeffsAlign = NULL;
-    filterCoeffsUnalign = NULL;
+    filterCoeffsAlign = nullptr;
+    filterCoeffsUnalign = nullptr;
 }
 
 
 FIRFilterSSE::~FIRFilterSSE()
 {
     delete[] filterCoeffsUnalign;
-    filterCoeffsAlign = NULL;
-    filterCoeffsUnalign = NULL;
+    filterCoeffsAlign = nullptr;
+    filterCoeffsUnalign = nullptr;
 }
 
 
@@ -225,7 +225,7 @@ void FIRFilterSSE::setCoefficients(const float *coeffs, uint newLength, uint uRe
 
     fDivider = (float)resultDivider;
 
-    // rearrange the filter coefficients for mmx routines 
+    // rearrange the filter coefficients for mmx routines
     for (i = 0; i < newLength; i ++)
     {
         filterCoeffsAlign[2 * i + 0] =
@@ -245,10 +245,10 @@ uint FIRFilterSSE::evaluateFilterStereo(float *dest, const float *source, uint n
 
     if (count < 2) return 0;
 
-    assert(source != NULL);
-    assert(dest != NULL);
+    assert(source != nullptr);
+    assert(dest != nullptr);
     assert((length % 8) == 0);
-    assert(filterCoeffsAlign != NULL);
+    assert(filterCoeffsAlign != nullptr);
     assert(((ulongptr)filterCoeffsAlign) % 16 == 0);
 
     // filter is evaluated for two stereo samples with each iteration, thus use of 'j += 2'
@@ -263,13 +263,13 @@ uint FIRFilterSSE::evaluateFilterStereo(float *dest, const float *source, uint n
 
         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 
+        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 ++) 
+        for (i = 0; i < length / 8; i ++)
         {
-            // Unroll loop for efficiency & calculate filter for 2*2 stereo samples 
+            // 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
@@ -302,14 +302,14 @@ uint FIRFilterSSE::evaluateFilterStereo(float *dest, const float *source, uint n
     }
 
     // Ideas for further improvement:
-    // 1. If it could be guaranteed that 'source' were always aligned to 16-byte 
+    // 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 
+    // 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 
+    /* original routine in C-language. please notice the C-version has differently
        organized coefficients though.
     double suml1, suml2;
     double sumr1, sumr2;
@@ -324,26 +324,26 @@ uint FIRFilterSSE::evaluateFilterStereo(float *dest, const float *source, uint n
         suml2 = sumr2 = 0.0;
         ptr = src;
         pFil = filterCoeffs;
-        for (i = 0; i < lengthLocal; i ++) 
+        for (i = 0; i < lengthLocal; i ++)
         {
             // unroll loop for efficiency.
 
-            suml1 += ptr[0] * pFil[0] + 
+            suml1 += ptr[0] * pFil[0] +
                      ptr[2] * pFil[2] +
                      ptr[4] * pFil[4] +
                      ptr[6] * pFil[6];
 
-            sumr1 += ptr[1] * pFil[1] + 
+            sumr1 += ptr[1] * pFil[1] +
                      ptr[3] * pFil[3] +
                      ptr[5] * pFil[5] +
                      ptr[7] * pFil[7];
 
-            suml2 += ptr[8] * pFil[0] + 
+            suml2 += ptr[8] * pFil[0] +
                      ptr[10] * pFil[2] +
                      ptr[12] * pFil[4] +
                      ptr[14] * pFil[6];
 
-            sumr2 += ptr[9] * pFil[1] + 
+            sumr2 += ptr[9] * pFil[1] +
                      ptr[11] * pFil[3] +
                      ptr[13] * pFil[5] +
                      ptr[15] * pFil[7];
