comparison SimpleCepstrum.cpp @ 33:fb862b3418f3

Update to use Vamp SDK 2.4 FFT implementation

     WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
 #include "SimpleCepstrum.h"
 
+#include "vamp-sdk/FFT.h"
+
 #include <vector>
 #include <algorithm>
 
 #include <cstdio>
 #include <cmath>
 #include <complex>
+
+#if ( VAMP_SDK_MAJOR_VERSION < 2 || ( VAMP_SDK_MAJOR_VERSION == 2 && VAMP_SDK_MINOR_VERSION < 4 ) )
+#error Vamp SDK version 2.4 or newer required
+#endif
 
 using std::string;
 
 SimpleCepstrum::SimpleCepstrum(float inputSampleRate) :
     Plugin(inputSampleRate),

 
     double *env = new double[bs];
     double *io = new double[bs];
 
     //!!! This is only right if the previous transform was an inverse one!
-    fft(bs, false, ecep, 0, env, io);
+    Vamp::FFT::forward(bs, ecep, 0, env, io);
 
     for (int i = 0; i < hs; ++i) {
         env[i] = exp(env[i]);
     }
     Feature envf;

         }
 
         if (m_method == InverseSymmetric ||
             m_method == InverseAsymmetric) {
 
-            fft(bs, true, logmag, 0, rawcep, io);
+            Vamp::FFT::inverse(bs, logmag, 0, rawcep, io);
 
         } else {
 
-            fft(bs, false, logmag, 0, rawcep, io);
+            Vamp::FFT::forward(bs, logmag, 0, rawcep, io);
 
             if (m_method == ForwardDifference) {
                 for (int i = 0; i < hs; ++i) {
                     rawcep[i] = fabs(io[i]) - fabs(rawcep[i]);
                 }

                 ri[bs - i] = ri[i];
                 ii[bs - i] = -ii[i];
             }
         }
 
-        fft(bs, true, ri, ii, rawcep, io);
+        Vamp::FFT::inverse(bs, ri, ii, rawcep, io);
 
         delete[] ri;
         delete[] ii;
     }
 

 SimpleCepstrum::getRemainingFeatures()
 {
     FeatureSet fs;
     return fs;
 }
-
-void
-SimpleCepstrum::fft(unsigned int n, bool inverse,
-                    double *ri, double *ii, double *ro, double *io)
-{
-    if (!ri || !ro || !io) return;
-
-    unsigned int bits;
-    unsigned int i, j, k, m;
-    unsigned int blockSize, blockEnd;
-
-    double tr, ti;
-
-    if (n < 2) return;
-    if (n & (n-1)) return;
-
-    double angle = 2.0 * M_PI;
-    if (inverse) angle = -angle;
-
-    for (i = 0; ; ++i) {
-	if (n & (1 << i)) {
-	    bits = i;
-	    break;
-	}
-    }
-
-    static unsigned int tableSize = 0;
-    static int *table = 0;
-
-    if (tableSize != n) {
-
-	delete[] table;
-
-	table = new int[n];
-
-	for (i = 0; i < n; ++i) {
-	
-	    m = i;
-
-	    for (j = k = 0; j < bits; ++j) {
-		k = (k << 1) | (m & 1);
-		m >>= 1;
-	    }
-
-	    table[i] = k;
-	}
-
-	tableSize = n;
-    }
-
-    if (ii) {
-	for (i = 0; i < n; ++i) {
-	    ro[table[i]] = ri[i];
-	    io[table[i]] = ii[i];
-	}
-    } else {
-	for (i = 0; i < n; ++i) {
-	    ro[table[i]] = ri[i];
-	    io[table[i]] = 0.0;
-	}
-    }
-
-    blockEnd = 1;
-
-    for (blockSize = 2; blockSize <= n; blockSize <<= 1) {
-
-	double delta = angle / (double)blockSize;
-	double sm2 = -sin(-2 * delta);
-	double sm1 = -sin(-delta);
-	double cm2 = cos(-2 * delta);
-	double cm1 = cos(-delta);
-	double w = 2 * cm1;
-	double ar[3], ai[3];
-
-	for (i = 0; i < n; i += blockSize) {
-
-	    ar[2] = cm2;
-	    ar[1] = cm1;
-
-	    ai[2] = sm2;
-	    ai[1] = sm1;
-
-	    for (j = i, m = 0; m < blockEnd; j++, m++) {
-
-		ar[0] = w * ar[1] - ar[2];
-		ar[2] = ar[1];
-		ar[1] = ar[0];
-
-		ai[0] = w * ai[1] - ai[2];
-		ai[2] = ai[1];
-		ai[1] = ai[0];
-
-		k = j + blockEnd;
-		tr = ar[0] * ro[k] - ai[0] * io[k];
-		ti = ar[0] * io[k] + ai[0] * ro[k];
-
-		ro[k] = ro[j] - tr;
-		io[k] = io[j] - ti;
-
-		ro[j] += tr;
-		io[j] += ti;
-	    }
-	}
-
-	blockEnd = blockSize;
-    }
-}
-
-