comparison src/vamp-sdk/FFT.cpp @ 510:8742125177ae

Merge from branch vamp-kiss-naming

 
 #include "FFTimpl.cpp"
 
 namespace Vamp {
 
+using namespace Kiss;
+
 void
 FFT::forward(unsigned int un,
 	     const double *ri, const double *ii,
 	     double *ro, double *io)
 {
     int n(un);
-    Kiss::kiss_fft_cfg c = Kiss::kiss_fft_alloc(n, false, 0, 0);
-    Kiss::kiss_fft_cpx *in = new Kiss::kiss_fft_cpx[n];
-    Kiss::kiss_fft_cpx *out = new Kiss::kiss_fft_cpx[n];
+    vamp_kiss_fft_cfg c = vamp_kiss_fft_alloc(n, false, 0, 0);
+    vamp_kiss_fft_cpx *in = new vamp_kiss_fft_cpx[n];
+    vamp_kiss_fft_cpx *out = new vamp_kiss_fft_cpx[n];
     for (int i = 0; i < n; ++i) {
         in[i].r = ri[i];
         in[i].i = 0;
     }
     if (ii) {
         for (int i = 0; i < n; ++i) {
             in[i].i = ii[i];
         }
     }
-    kiss_fft(c, in, out);
+    vamp_kiss_fft(c, in, out);
     for (int i = 0; i < n; ++i) {
         ro[i] = out[i].r;
         io[i] = out[i].i;
     }
-    Kiss::kiss_fft_free(c);
+    vamp_kiss_fft_free(c);
     delete[] in;
     delete[] out;
 }
 
 void
 FFT::inverse(unsigned int un,
 	     const double *ri, const double *ii,
 	     double *ro, double *io)
 {
     int n(un);
-    Kiss::kiss_fft_cfg c = Kiss::kiss_fft_alloc(n, true, 0, 0);
-    Kiss::kiss_fft_cpx *in = new Kiss::kiss_fft_cpx[n];
-    Kiss::kiss_fft_cpx *out = new Kiss::kiss_fft_cpx[n];
+    vamp_kiss_fft_cfg c = vamp_kiss_fft_alloc(n, true, 0, 0);
+    vamp_kiss_fft_cpx *in = new vamp_kiss_fft_cpx[n];
+    vamp_kiss_fft_cpx *out = new vamp_kiss_fft_cpx[n];
     for (int i = 0; i < n; ++i) {
         in[i].r = ri[i];
         in[i].i = 0;
     }
     if (ii) {
         for (int i = 0; i < n; ++i) {
             in[i].i = ii[i];
         }
     }
-    kiss_fft(c, in, out);
+    vamp_kiss_fft(c, in, out);
     double scale = 1.0 / double(n);
     for (int i = 0; i < n; ++i) {
         ro[i] = out[i].r * scale;
         io[i] = out[i].i * scale;
     }
-    Kiss::kiss_fft_free(c);
+    vamp_kiss_fft_free(c);
     delete[] in;
     delete[] out;
 }
 
 class FFTComplex::D
 {
 public:
     D(int n) :
         m_n(n),
-        m_fconf(Kiss::kiss_fft_alloc(n, false, 0, 0)),
-        m_iconf(Kiss::kiss_fft_alloc(n, true, 0, 0)),
-        m_ci(new Kiss::kiss_fft_cpx[m_n]),
-        m_co(new Kiss::kiss_fft_cpx[m_n]) { }
+        m_fconf(vamp_kiss_fft_alloc(n, false, 0, 0)),
+        m_iconf(vamp_kiss_fft_alloc(n, true, 0, 0)),
+        m_ci(new vamp_kiss_fft_cpx[m_n]),
+        m_co(new vamp_kiss_fft_cpx[m_n]) { }
 
     ~D() {
-        Kiss::kiss_fftr_free(m_fconf);
-        Kiss::kiss_fftr_free(m_iconf);
+        vamp_kiss_fftr_free(m_fconf);
+        vamp_kiss_fftr_free(m_iconf);
         delete[] m_ci;
         delete[] m_co;
     }
 
     void forward(const double *ci, double *co) {
         for (int i = 0; i < m_n; ++i) {
             m_ci[i].r = ci[i*2];
             m_ci[i].i = ci[i*2+1];
         }
-        Kiss::kiss_fft(m_fconf, m_ci, m_co);
+        vamp_kiss_fft(m_fconf, m_ci, m_co);
         for (int i = 0; i < m_n; ++i) {
             co[i*2] = m_co[i].r;
             co[i*2+1] = m_co[i].i;
         }
     }

     void inverse(const double *ci, double *co) {
         for (int i = 0; i < m_n; ++i) {
             m_ci[i].r = ci[i*2];
             m_ci[i].i = ci[i*2+1];
         }
-        Kiss::kiss_fft(m_iconf, m_ci, m_co);
+        vamp_kiss_fft(m_iconf, m_ci, m_co);
         double scale = 1.0 / double(m_n);
         for (int i = 0; i < m_n; ++i) {
             co[i*2] = m_co[i].r * scale;
             co[i*2+1] = m_co[i].i * scale;
         }
     }
     
 private:
     int m_n;
-    Kiss::kiss_fft_cfg m_fconf;
-    Kiss::kiss_fft_cfg m_iconf;
-    Kiss::kiss_fft_cpx *m_ci;
-    Kiss::kiss_fft_cpx *m_co;
+    vamp_kiss_fft_cfg m_fconf;
+    vamp_kiss_fft_cfg m_iconf;
+    vamp_kiss_fft_cpx *m_ci;
+    vamp_kiss_fft_cpx *m_co;
 };
 
 FFTComplex::FFTComplex(unsigned int n) :
     m_d(new D(n))
 {

 class FFTReal::D
 {
 public:
     D(int n) :
         m_n(n),
-        m_fconf(Kiss::kiss_fftr_alloc(n, false, 0, 0)),
-        m_iconf(Kiss::kiss_fftr_alloc(n, true, 0, 0)),
-        m_ri(new Kiss::kiss_fft_scalar[m_n]),
-        m_ro(new Kiss::kiss_fft_scalar[m_n]),
-        m_freq(new Kiss::kiss_fft_cpx[n/2+1]) { }
+        m_fconf(vamp_kiss_fftr_alloc(n, false, 0, 0)),
+        m_iconf(vamp_kiss_fftr_alloc(n, true, 0, 0)),
+        m_ri(new vamp_kiss_fft_scalar[m_n]),
+        m_ro(new vamp_kiss_fft_scalar[m_n]),
+        m_freq(new vamp_kiss_fft_cpx[n/2+1]) { }
 
     ~D() {
-        Kiss::kiss_fftr_free(m_fconf);
-        Kiss::kiss_fftr_free(m_iconf);
+        vamp_kiss_fftr_free(m_fconf);
+        vamp_kiss_fftr_free(m_iconf);
         delete[] m_ri;
         delete[] m_ro;
         delete[] m_freq;
     }
 
     void forward(const double *ri, double *co) {
         for (int i = 0; i < m_n; ++i) {
-            // in case kiss_fft_scalar is float
+            // in case vamp_kiss_fft_scalar is float
             m_ri[i] = ri[i];
         }
-        Kiss::kiss_fftr(m_fconf, m_ri, m_freq);
+        vamp_kiss_fftr(m_fconf, m_ri, m_freq);
         int hs = m_n/2 + 1;
         for (int i = 0; i < hs; ++i) {
             co[i*2] = m_freq[i].r;
             co[i*2+1] = m_freq[i].i;
         }

         int hs = m_n/2 + 1;
         for (int i = 0; i < hs; ++i) {
             m_freq[i].r = ci[i*2];
             m_freq[i].i = ci[i*2+1];
         }
-        Kiss::kiss_fftri(m_iconf, m_freq, m_ro);
+        vamp_kiss_fftri(m_iconf, m_freq, m_ro);
         double scale = 1.0 / double(m_n);
         for (int i = 0; i < m_n; ++i) {
             ro[i] = m_ro[i] * scale;
         }
     }
     
 private:
     int m_n;
-    Kiss::kiss_fftr_cfg m_fconf;
-    Kiss::kiss_fftr_cfg m_iconf;
-    Kiss::kiss_fft_scalar *m_ri;
-    Kiss::kiss_fft_scalar *m_ro;
-    Kiss::kiss_fft_cpx *m_freq;
+    vamp_kiss_fftr_cfg m_fconf;
+    vamp_kiss_fftr_cfg m_iconf;
+    vamp_kiss_fft_scalar *m_ri;
+    vamp_kiss_fft_scalar *m_ro;
+    vamp_kiss_fft_cpx *m_freq;
 };
 
 FFTReal::FFTReal(unsigned int n) :
     m_d(new D(n))
 {