comparison vamp-sdk/FFT.h @ 446:d132b92ec65d vampipe

Add FFTComplex class by analogy to FFTReal

 /**
  * A simple FFT implementation provided for convenience of plugin
  * authors. This class provides one-shot (i.e. fixed table state is
  * recalculated every time) double-precision complex-complex
  * transforms. For repeated transforms from real time-domain data, use
- * an FFTReal object instead.
+ * an FFTComplex or FFTReal object instead.
+ *
+ * Note: If the SDK has been compiled with the SINGLE_PRECISION_FFT
+ * flag, then all FFTs will use single precision internally. The
+ * default is double precision. The API uses doubles in either case.
  *
  * The forward transform is unscaled; the inverse transform is scaled
  * by 1/n.
  */
 class FFT
 {
 public:
     /**
      * Calculate a one-shot forward transform of size n.
-     * n must be a power of 2, greater than 1.
+     * n must be a multiple of 2.
      *
      * ri and ii must point to the real and imaginary component arrays
      * of the input. For real input, ii may be NULL.
      *
      * ro and io must point to enough space to receive the real and

      * All input and output arrays are of size n.
      */
     static void inverse(unsigned int n,
                         const double *ri, const double *ii,
                         double *ro, double *io);
+};
+
+/**
+ * A simple FFT implementation provided for convenience of plugin
+ * authors. This class provides double-precision complex-complex
+ * transforms.
+ *
+ * Note: If the SDK has been compiled with the SINGLE_PRECISION_FFT
+ * flag, then all FFTs will use single precision internally. The
+ * default is double precision. The API uses doubles in either case.
+ *
+ * The forward transform is unscaled; the inverse transform is scaled
+ * by 1/n.
+ */
+class FFTComplex
+{
+    /**
+     * Prepare to calculate transforms of size n.
+     * n must be a multiple of 2.
+     */
+    FFTComplex(unsigned int n);
+
+    ~FFTComplex();
+
+    /**
+     * Calculate a forward transform of size n.
+     *
+     * ci must point to the interleaved complex input data of size n
+     * (that is, 2n doubles in total).
+     *
+     * co must point to enough space to receive an interleaved complex
+     * output array of size n (that is, 2n doubles in total).
+     */
+    void forward(const double *ci, double *co);
+
+    /**
+     * Calculate an inverse transform of size n.
+     *
+     * ci must point to an interleaved complex input array of size n
+     * (that is, 2n doubles in total).
+     *
+     * co must point to enough space to receive the interleaved
+     * complex output data of size n (that is, 2n doubles in
+     * total). The output is scaled by 1/n.
+     */
+    void inverse(const double *ci, double *co);
+
+private:
+    class D;
+    D *m_d;
 };
 
 /**
  * A simple FFT implementation provided for convenience of plugin
  * authors. This class provides transforms between double-precision
  * real time-domain and double-precision complex frequency-domain
  * data.
  *
+ * Note: If the SDK has been compiled with the SINGLE_PRECISION_FFT
+ * flag, then all FFTs will use single precision internally. The
+ * default is double precision. The API uses doubles in either case.
+ *
  * The forward transform is unscaled; the inverse transform is scaled
  * by 1/n.
  */
 class FFTReal
 {
     /**
      * Prepare to calculate transforms of size n.
-     * n must be a power of 2, greater than 1.
+     * n must be a multiple of 2.
      */
     FFTReal(unsigned int n);
 
     ~FFTReal();
 

      * Calculate a forward transform of size n.
      *
      * ri must point to the real input data of size n.
      *
      * co must point to enough space to receive an interleaved complex
-     * output array of size n/2+1.
+     * output array of size n/2+1 (that is, n+2 doubles in total).
      */
     void forward(const double *ri, double *co);
 
     /**
      * Calculate an inverse transform of size n.
      *
-     * ci must point to an interleaved complex input array of size n/2+1.
+     * ci must point to an interleaved complex input array of size
+     * n/2+1 (that is, n+2 doubles in total).
      *
      * ro must point to enough space to receive the real output data
      * of size n. The output is scaled by 1/n and only the real part
      * is returned.
      */