1 files changed, 145 insertions, 141 deletions
diff --git a/gr-fft/include/gnuradio/fft/fft.h b/gr-fft/include/gnuradio/fft/fft.h
index 81cd51de21..d6f52d4c7d 100644
--- a/gr-fft/include/gnuradio/fft/fft.h
+++ b/gr-fft/include/gnuradio/fft/fft.h
@@ -32,168 +32,172 @@
 #include <boost/thread.hpp>
 
 namespace gr {
-  namespace fft {
+namespace fft {
 
 
-    /*! \brief Helper function for allocating complex* buffers
+/*! \brief Helper function for allocating complex* buffers
+ */
+FFT_API gr_complex* malloc_complex(int size);
+
+/*! \brief Helper function for allocating float* buffers
+ */
+FFT_API float* malloc_float(int size);
+
+/*! \brief Helper function for allocating double* buffers
+ */
+FFT_API double* malloc_double(int size);
+
+/*! \brief Helper function for freeing fft buffers
+ */
+FFT_API void free(void* b);
+
+/*!
+ * \brief Export reference to planner mutex for those apps that
+ * want to use FFTW w/o using the fft_impl_fftw* classes.
+ */
+class FFT_API planner
+{
+public:
+    typedef boost::mutex::scoped_lock scoped_lock;
+    /*!
+     * Return reference to planner mutex
+     */
+    static boost::mutex& mutex();
+};
+
+/*!
+ * \brief FFT: complex in, complex out
+ * \ingroup misc
+ */
+class FFT_API fft_complex
+{
+    int d_fft_size;
+    int d_nthreads;
+    gr_complex* d_inbuf;
+    gr_complex* d_outbuf;
+    void* d_plan;
+
+public:
+    fft_complex(int fft_size, bool forward = true, int nthreads = 1);
+    virtual ~fft_complex();
+
+    /*
+     * These return pointers to buffers owned by fft_impl_fft_complex
+     * into which input and output take place. It's done this way in
+     * order to ensure optimal alignment for SIMD instructions.
+     */
+    gr_complex* get_inbuf() const { return d_inbuf; }
+    gr_complex* get_outbuf() const { return d_outbuf; }
+
+    int inbuf_length() const { return d_fft_size; }
+    int outbuf_length() const { return d_fft_size; }
+
+    /*!
+     *  Set the number of threads to use for caclulation.
+     */
+    void set_nthreads(int n);
+
+    /*!
+     *  Get the number of threads being used by FFTW
      */
-    FFT_API gr_complex* malloc_complex(int size);
+    int nthreads() const { return d_nthreads; }
 
-    /*! \brief Helper function for allocating float* buffers
+    /*!
+     * compute FFT. The input comes from inbuf, the output is placed in
+     * outbuf.
+     */
+    void execute();
+};
+
+/*!
+ * \brief FFT: real in, complex out
+ * \ingroup misc
+ */
+class FFT_API fft_real_fwd
+{
+    int d_fft_size;
+    int d_nthreads;
+    float* d_inbuf;
+    gr_complex* d_outbuf;
+    void* d_plan;
+
+public:
+    fft_real_fwd(int fft_size, int nthreads = 1);
+    virtual ~fft_real_fwd();
+
+    /*
+     * These return pointers to buffers owned by fft_impl_fft_real_fwd
+     * into which input and output take place. It's done this way in
+     * order to ensure optimal alignment for SIMD instructions.
      */
-    FFT_API float* malloc_float(int size);
+    float* get_inbuf() const { return d_inbuf; }
+    gr_complex* get_outbuf() const { return d_outbuf; }
 
-    /*! \brief Helper function for allocating double* buffers
+    int inbuf_length() const { return d_fft_size; }
+    int outbuf_length() const { return d_fft_size / 2 + 1; }
+
+    /*!
+     *  Set the number of threads to use for caclulation.
      */
-    FFT_API double* malloc_double(int size);
+    void set_nthreads(int n);
 
-    /*! \brief Helper function for freeing fft buffers
+    /*!
+     *  Get the number of threads being used by FFTW
      */
-    FFT_API void free(void *b);
+    int nthreads() const { return d_nthreads; }
 
     /*!
-     * \brief Export reference to planner mutex for those apps that
-     * want to use FFTW w/o using the fft_impl_fftw* classes.
+     * compute FFT. The input comes from inbuf, the output is placed in
+     * outbuf.
+     */
+    void execute();
+};
+
+/*!
+ * \brief FFT: complex in, float out
+ * \ingroup misc
+ */
+class FFT_API fft_real_rev
+{
+    int d_fft_size;
+    int d_nthreads;
+    gr_complex* d_inbuf;
+    float* d_outbuf;
+    void* d_plan;
+
+public:
+    fft_real_rev(int fft_size, int nthreads = 1);
+    virtual ~fft_real_rev();
+
+    /*
+     * These return pointers to buffers owned by fft_impl_fft_real_rev
+     * into which input and output take place. It's done this way in
+     * order to ensure optimal alignment for SIMD instructions.
      */
-    class FFT_API planner {
-    public:
-      typedef boost::mutex::scoped_lock scoped_lock;
-      /*!
-       * Return reference to planner mutex
-       */
-      static boost::mutex &mutex();
-    };
+    gr_complex* get_inbuf() const { return d_inbuf; }
+    float* get_outbuf() const { return d_outbuf; }
+
+    int inbuf_length() const { return d_fft_size / 2 + 1; }
+    int outbuf_length() const { return d_fft_size; }
 
     /*!
-     * \brief FFT: complex in, complex out
-     * \ingroup misc
+     *  Set the number of threads to use for caclulation.
      */
-    class FFT_API fft_complex {
-      int         d_fft_size;
-      int         d_nthreads;
-      gr_complex *d_inbuf;
-      gr_complex *d_outbuf;
-      void       *d_plan;
-
-    public:
-      fft_complex(int fft_size, bool forward = true, int nthreads=1);
-      virtual ~fft_complex();
-
-      /*
-       * These return pointers to buffers owned by fft_impl_fft_complex
-       * into which input and output take place. It's done this way in
-       * order to ensure optimal alignment for SIMD instructions.
-       */
-      gr_complex *get_inbuf()  const { return d_inbuf; }
-      gr_complex *get_outbuf() const { return d_outbuf; }
-
-      int inbuf_length()  const { return d_fft_size; }
-      int outbuf_length() const { return d_fft_size; }
-
-      /*!
-       *  Set the number of threads to use for caclulation.
-       */
-      void set_nthreads(int n);
-
-      /*!
-       *  Get the number of threads being used by FFTW
-       */
-      int nthreads() const { return d_nthreads; }
-
-      /*!
-       * compute FFT. The input comes from inbuf, the output is placed in
-       * outbuf.
-       */
-      void execute();
-    };
+    void set_nthreads(int n);
 
     /*!
-     * \brief FFT: real in, complex out
-     * \ingroup misc
+     *  Get the number of threads being used by FFTW
      */
-    class FFT_API fft_real_fwd {
-      int     d_fft_size;
-      int         d_nthreads;
-      float  *d_inbuf;
-      gr_complex *d_outbuf;
-      void   *d_plan;
-
-    public:
-      fft_real_fwd (int fft_size, int nthreads=1);
-      virtual ~fft_real_fwd ();
-
-      /*
-       * These return pointers to buffers owned by fft_impl_fft_real_fwd
-       * into which input and output take place. It's done this way in
-       * order to ensure optimal alignment for SIMD instructions.
-       */
-      float *get_inbuf()      const { return d_inbuf; }
-      gr_complex *get_outbuf() const { return d_outbuf; }
-
-      int inbuf_length()  const { return d_fft_size; }
-      int outbuf_length() const { return d_fft_size / 2 + 1; }
-
-      /*!
-       *  Set the number of threads to use for caclulation.
-       */
-      void set_nthreads(int n);
-
-      /*!
-       *  Get the number of threads being used by FFTW
-       */
-      int nthreads() const { return d_nthreads; }
-
-      /*!
-       * compute FFT. The input comes from inbuf, the output is placed in
-       * outbuf.
-       */
-      void execute();
-    };
+    int nthreads() const { return d_nthreads; }
 
     /*!
-     * \brief FFT: complex in, float out
-     * \ingroup misc
+     * compute FFT. The input comes from inbuf, the output is placed in
+     * outbuf.
      */
-    class FFT_API fft_real_rev {
-      int         d_fft_size;
-      int         d_nthreads;
-      gr_complex *d_inbuf;
-      float      *d_outbuf;
-      void       *d_plan;
-
-    public:
-      fft_real_rev(int fft_size, int nthreads=1);
-      virtual ~fft_real_rev();
-
-      /*
-       * These return pointers to buffers owned by fft_impl_fft_real_rev
-       * into which input and output take place. It's done this way in
-       * order to ensure optimal alignment for SIMD instructions.
-       */
-      gr_complex *get_inbuf() const { return d_inbuf; }
-      float *get_outbuf() const { return d_outbuf; }
-
-      int inbuf_length()  const { return d_fft_size / 2 + 1; }
-      int outbuf_length() const { return d_fft_size; }
-
-      /*!
-       *  Set the number of threads to use for caclulation.
-       */
-      void set_nthreads(int n);
-
-      /*!
-       *  Get the number of threads being used by FFTW
-       */
-      int nthreads() const { return d_nthreads; }
-
-      /*!
-       * compute FFT. The input comes from inbuf, the output is placed in
-       * outbuf.
-       */
-      void execute();
-    };
-
-  } /* namespace fft */
+    void execute();
+};
+
+} /* namespace fft */
 } /*namespace gr */
 
 #endif /* _FFT_FFT_H_ */