Initial checkin

CMakeLists.txt

+cmake_minimum_required( VERSION 2.8 )
+
+project( ITAFFT )
+
+list( APPEND CMAKE_MODULE_PATH "$ENV{VISTA_CMAKE_COMMON}" )
+include( VistaCommon )
+
+# dependencies
+vista_use_package( ITABase REQUIRED FIND_DEPENDENCIES )
+vista_use_package( FFTW )
+vista_use_package( MKL )
+#vista_find_package( FFTS )
+
+if( NOT DEFINED ITA_FFT_WITH_FFTW3 )
+	set( ITA_FFT_WITH_FFTW3 ON CACHE BOOL "Build with FFTW3 for fast fourier transforms" )
+endif( NOT DEFINED ITA_FFT_WITH_FFTW3 )
+
+if( NOT DEFINED ITA_FFT_WITH_INTEL_MKL10 )
+	set( ITA_FFT_WITH_INTEL_MKL10 OFF CACHE BOOL "Build with Intel MKL for fast fourier transforms" )
+endif( NOT DEFINED ITA_FFT_WITH_INTEL_MKL10 )
+
+if( NOT DEFINED ITA_FFT_WITH_INTEL_TBB )
+	set( ITA_FFT_WITH_INTEL_TBB OFF CACHE BOOL "Build with Intel TBB for fast fourier transforms" )
+endif( NOT DEFINED ITA_FFT_WITH_INTEL_TBB )
+
+if( NOT DEFINED ITA_FFT_WITH_FFTS )
+	set( ITA_FFT_WITH_FFTS OFF CACHE BOOL "Build with FFTS for fast fourier transforms" )
+endif( NOT DEFINED ITA_FFT_WITH_FFTS )
+
+
+# includes
+include_directories( "include" )
+
+
+# sources
+set( ITAFFTHeader
+	include/ITAFFT.h
+	include/ITAFFTDefinitions.h
+	)
+set( ITAFFTSources
+	src/ITAFFT.cpp
+	src/ITAFFTBackend.h
+	src/ITAFFTFactory.h
+	src/ITAFFTRealization.h
+	)	
+
+if( ITA_FFT_WITH_FFTW3 )
+	set( ITAFFTSources "${ITAFFTSources}" src/FFTW3Backend.h src/FFTW3Backend.cpp )
+	add_definitions( -DITAFFT_WITH_FFTW3 )
+endif( ITA_FFT_WITH_FFTW3 )
+
+if( ITA_FFT_WITH_INTEL_MKL10 )
+	set( ITAFFTSources "${ITAFFTSources}" src/MKL10Backend.h src/MKL10Backend.cpp )
+	add_definitions( -DITAFFT_WITH_MKL10 )
+endif( ITA_FFT_WITH_INTEL_MKL10 )
+	
+
+# compiler
+add_definitions( -DITA_BASE_DLL -DITA_FFT_DLL -DITA_FFT_EXPORT )
+
+
+# linker
+add_library( ITAFFT SHARED ${ITAFFTHeader} ${ITAFFTSources} )
+target_link_libraries( ITAFFT ${VISTA_USE_PACKAGE_LIBRARIES} )
+
+
+# config
+vista_configure_lib( ITAFFT )
+vista_install( ITAFFT )
+set( ITAFFT_INCLUDE_OUTDIR "${CMAKE_CURRENT_SOURCE_DIR}/include" )
+vista_create_cmake_configs( ITAFFT )
+vista_create_default_info_file( ITAFFT )
+
+set_property( TARGET ITAFFT PROPERTY FOLDER "ITACoreLibs" )
+
+	
+# tests
+set( ITAFFT_COMMON_BUILD TRUE )
+add_subdirectory( "${CMAKE_CURRENT_SOURCE_DIR}/tests" )

include/ITAFFT.h

+/*
+* ----------------------------------------------------------------
+*
+*		ITA core libs
+*		(c) Copyright Institute of Technical Acoustics (ITA)
+*		RWTH Aachen University, Germany, 2015-2016
+*
+* ----------------------------------------------------------------
+*				    ____  __________  _______
+*				   //  / //__   ___/ //  _   |
+*				  //  /    //  /    //  /_|  |
+*				 //  /    //  /    //  ___   |
+*				//__/    //__/    //__/   |__|
+*
+* ----------------------------------------------------------------
+*
+*/
+// $Id: ITAFFTDefinitions.h 2900 2012-09-17 08:42:42Z stienen $
+
+#ifndef INCLUDE_WATCHER_ITA_FFT
+#define INCLUDE_WATCHER_ITA_FFT
+
+#include <ITAFFTDefinitions.h>
+
+/*! \mainpage ITAFFT
+ *
+ * \section section_overview überblick
+ *
+ * ITAFFT ist eine Wrapper-Bibliothek für schnelle Fouriertransformationen. Ihre Aufgabe besteht darin,
+ * eine Abstraktion von konkreten FFT-Bibliotheken (FFTW, Intel MKL, usw.) zu schaffen. Dadurch
+ * können verschiedene FFT-Bibliotheken im Anwendungscode mit der gleichen Schnittstelle benutzt
+ * und deshalb leicht ausgetauscht werden. Die Schnittstelle wird durch die Klasse ITAFFT bereitgestellt.
+ * Entwurfsziel ist die einfache Benutzbarkeit. Verschiedene Typen von Fouriertransformationen
+ * werden unterstützt. Folgende Grundprinzipien gelten:
+ *
+ * - Der Datentyp ist immer 32-Bit floating points (float)
+ * - Alle* Transformationen speichern komplexe Fourierkoeffizienten im Fortran-Stil
+ *   (auch interleaved memory layout genannt) der Form
+ *
+ *   Re(0), Im(0), Re(1), Im(1), ... , Re(k), Im(k)
+ *
+ *   d.h. Realteil und Imaginärteil folgen stets direkt aufeinander
+ *
+ * - Grundsätzlich sind alle Rücktransformationen unnormalisiert (Ausnahmen ...)
+ *
+ * \section section_feedback Feedback
+ *
+ * Hast Du Fragen oder Anmerkungen? Hast Du einen Fehler entdeckt?
+ * Kontaktier den Autor: Frank.Wefers@akustik.rwth-aachen.de
+ */
+
+#include <string>
+
+// Vorwärtsdeklarationen
+class ITAFFTRealization;
+
+/**
+ * \section section_intro Aufgabe und Funktion der Klasse
+ *
+ * Dies ist Hauptklasse der Bibliothek. Sie stellt die Schnittstelle für die Arbeit mit schnellen
+ * Fouriertransformationen (FFTs) bereit. Die Klasse kennt zwei Modi: Ungeplant und geplant.
+ * Damit eine FFT/IFFT durchgeführt werden kann, muss sie zunüchst geplant werden.
+ * Dies kann auch direkt bei der Erzeugung von Instanzen durch den Aufruf eines Planungs-
+ * Konstruktors geschehen. Damit die Klasse auch flexibel als konkretes Member anderer Klassen
+ * eingesetzt werden kann, ist auch ein Standardkonstruktor vorhanden, welcher eine
+ * ungeplante Instanz erzeugt. Für die Planung müssen der Transformations-Typ, die Datengröße
+ * sowie die Ein-/Ausgabedaten angegebenen werden. Ist die Transformation geplant, so kann sie
+ * mit einer der execute-Methoden durchgeführt werden.
+ *
+ * \section section_transforms Berechnete Transformation
+ *
+ * Berechnet werden diskrete Fouriertransformationen (DFTs) und deren Rücktransformationen (IDFTs).
+ *
+ * - Komplex-zu-komplex DFT [FFT_C2C]
+ *
+ * \todo Grafik
+ *
+ * - Komplex-zu-komplex IDFT [IFFT_C2C]
+ *
+ * \todo Grafik
+ *
+ * - Reell-zu-komplex DFT [FFT_R2C]
+ *
+ * \todo Grafik
+ *
+ * - Komplex-zu-reell IDFT [IFFT_C2R]
+ *
+ * \todo Grafik
+ *
+ * \section section_usage Anwendungsbeispiele
+ *
+ * Beispiel: Allgemeine Benutzung
+ *
+ * <pre>
+ *  float *A, *B, *C;
+ *  ITAFFT fft(FFT_R2C, 128, A, B);
+ *  ITAFFT ifft(FFT_C2R, 128, B, C);
+ *
+ *  fft.execute();
+ *  // Mach etwas mit den Spektren...
+ *  ifft.execute();
+ * </pre>
+ *
+ * Beispiel: Benutzung von Fouriertransformationen als Member anderer Klassen
+ *
+ * <pre>
+ *  class Filter {
+ *  public:
+ *    Filter();
+ *
+ *    ...
+ *
+ *  private:
+ *    ITAFFT fft;
+ *  };
+ *
+ *  // Entweder (Falls Größe/Daten bereits bekannt) ...
+ *  Filter::Filter() : fft(FFT_R2C, 128, A, B) {
+ *    ...
+ *  }
+ *
+ *  // ... oder (Spätere Planung)
+ *  Filter::Filter() {
+ *    ...
+ *    fft.plan(FFT_R2C, 128, A, B);
+ *  }
+ * </pre>
+ *
+ * \todo Erläuterung zu den Transformationen (Standardformat = Interleaved Format)
+ * Speicherschema: Fortan-Stil (Real gefolgt von Imaginär), CCS complex conjugate symetric
+ *
+ * \note Es werden stets <b>unnormalisierte</b> Rücktransformationen (IFFTs) berechnet.
+ * \note Bei reell-zu-komplex und komplex-zu-reell Fouriertransformationen bezieht sich
+ *       die Grüüe der Transformation immer auf die Anzahl reeller Koeffizienten.
+ */
+
+class ITA_FFT_API ITAFFT
+{
+public:
+	//! Transformationen
+	/** Erläuterungen zu den Transformationen finden sich in ... */
+	static const int FFT_C2C  = 1; //!< Allgemeine DFT (komplex-zu-komplex)
+	static const int IFFT_C2C = 2; //!< Allgemeine unnormalisierte IDFT (komplex-zu-komplex)
+	static const int FFT_R2C  = 3; //!< Reell-zu-komplex DFT (rein reellwertige Eingabedaten)
+	static const int IFFT_C2R = 4; //!< Komplex-zu-reell IDFT (rein reellwertige Ausgabedaten)
+
+	// Nur zur Kompatibilität mit alten Projekten (Sollte man nicht mehr verwenden!)
+	// Gleiche Semantik, wie die alte MKL-Funktion SCFFT1DC!
+	static const int SPLIT_FFT_R2C = 5;      //!< Reell-zu-komplex DFT mit altem C memory layout (Real- und Imaginürteile hintereinander getrennt)
+	static const int SPLIT_IFFT_C2R = 6;     //!< Reell-zu-komplex DFT mit altem C memory layout (Real- und Imaginürteile hintereinander getrennt)
+
+	// Gleiche Semantik, wie die alte MKL-Funktion CSFFT1DC! (Diese spezielle Variante ist normalisiert!)
+	static const int NORMALIZED_SPLIT_IFFT_C2R = 7; //!< Reell-zu-komplex DFT mit altem C memory layout (Real- und Imaginürteile hintereinander getrennt)
+
+	// Aliase für alte MKL-Funktionen
+	static const int MKL_SCFFT1DC = SPLIT_FFT_R2C;
+	static const int MKL_CSFFT1DC = NORMALIZED_SPLIT_IFFT_C2R;
+
+	/*	
+	//! Fehlerbehandlungsrichtlinien
+	enum {
+		DO_NOTHING = 0,	//!< Nichts unternehmen im Fehlerfall. Programmablauf wird nicht unterbrochen
+		//ASSERTION,
+		THROW_EXCEPTION //!< Ausnahme auslösen im Fehlerfall. Programmablauf wird unterbrochen.
+	};
+	*/
+
+	//! Flags zur Planung der FFTs
+	enum {
+		PLAN_USING_MEASUREMENT = 0, //!< Nutzt die genaue Planungsmethode für FFTs (für viele Koeffizienten sehr langsam)
+		PLAN_USING_ESTIMATION  = 1  //!< Nutzt die schätzende Planungsmethode für FFTs (für viele Koeffizienten sehr schnell)
+	} PlanningMethods;
+
+	//! Standardkonstruktor
+	/**
+	 * Erzeugt eine ungeplante Fouriertransformation
+	 */
+	ITAFFT();
+
+	//! Planungskonstruktor
+	/**
+	 * Erzeugt und plant eine Fouriertransformation mit den angegebenen Eigenschaften
+	 *
+	 * \param type  Transformationstyp (\see TransformType)
+	 * \param size  Größe der Transformation (Anzahl der Koeffizienten)
+	 * \param in    Eingabedaten
+	 * \param out   Ausgabedaten
+	 * \param iPlanningMethod Methode der Planung, eines von \PlanningMethods
+	 *
+	 * \note Bei reell-zu-komplex und komplex-zu-reell Fouriertransformationen bezieht sich
+	 *       die Grüüe der Transformation immer auf die Anzahl reeller Koeffizienten.
+	 */
+	ITAFFT(int type, int size, float* in, float* out, int iPlanningMethod=PLAN_USING_MEASUREMENT);
+
+	//! Destruktor
+	virtual ~ITAFFT();
+
+	//! Gibt zurück ob die Transformation bereits geplant wurde
+	bool isPlanned();
+
+	//! Plant die Transformation
+	/**
+	 * Plant eine Fouriertransformation mit den angegebenen Eigenschaften
+	 *
+	 * \param type  Transformationstyp (\see TransformType)
+	 * \param size  Größe der Transformation (Anzahl der Koeffizienten)
+	 * \param in    Eingabedaten
+	 * \param out   Ausgabedaten
+	 * \param iPlanningMethod Methode der Planung, eines von \PlanningMethods
+	 *
+	 * \note Bei reell-zu-komplex und komplex-zu-reell Fouriertransformationen bezieht sich
+	 *       die Grüüe der Transformation immer auf die Anzahl reeller Koeffizienten.
+	 */
+	void plan(int type, int size, float* in, float* out, int iPlannungMethod=PLAN_USING_MEASUREMENT);
+
+	//! Transformation durchführen (auf geplanten Daten)
+	/**
+	 * Führt die Transformation auf den geplanten Daten aus
+	 */
+	void execute();
+
+	//! Transformation durchführen (auf anderen als geplante Daten)
+	/**
+	 * Führt die Transformation auf anderen Ein-/Ausgaben durch, als
+	 * die bei der Planung angegebenen. Allerdings müssen die hier verwendeten
+	 * Datenpuffer die gleichen Eigenschaften aufweisen, wie die bei der
+	 * Planung verwendeten (in-place/out-of-place, SIMD alignment/no SIMD alignment)
+	 */
+	void execute(float* in, float* out);
+
+	//! Gibt Informationen über die Transformation als Zeichenkette zurück
+	std::string toString();
+
+private:
+	// Kopieren der Instanzen verbieten
+	ITAFFT(const ITAFFT& ) {};
+	ITAFFT& operator=(const ITAFFT& ) { return *this; };
+
+	ITAFFTRealization* m_pRealization; //!< Pointer zur Schnittstelle
+};
+
+#endif // INCLUDE_WATCHER_ITA_FFT

include/ITAFFTDefinitions.h

+/*
+* ----------------------------------------------------------------
+*
+*		ITA core libs
+*		(c) Copyright Institute of Technical Acoustics (ITA)
+*		RWTH Aachen University, Germany, 2015-2016
+*
+* ----------------------------------------------------------------
+*				    ____  __________  _______
+*				   //  / //__   ___/ //  _   |
+*				  //  /    //  /    //  /_|  |
+*				 //  /    //  /    //  ___   |
+*				//__/    //__/    //__/   |__|
+*
+* ----------------------------------------------------------------
+*
+*/
+// $Id: ITABaseDefinitions.h 2900 2012-09-17 08:42:42Z stienen $
+
+#ifndef INCLUDE_WATCHER_ITA_FFT_DEFINITIONS
+#define INCLUDE_WATCHER_ITA_FFT_DEFINITIONS
+
+#ifdef ITA_FFT_DLL
+#ifdef ITA_FFT_EXPORT
+#define ITA_FFT_API __declspec(dllexport)
+#else
+#define ITA_FFT_API __declspec(dllimport)
+#endif
+#else
+#define ITA_FFT_API
+#endif
+
+#endif // INCLUDE_WATCHER_ITA_FFT_DEFINITIONS

src/FFTW3Backend.cpp

+/*
+ *  ITAFFT, eine Wrapper-Bibliothek für schnelle Fouriertransformationen
+ *
+ *  Autor: Frank Wefers (Frank.Wefers@akustik.rwth-aachen.de)
+ *
+ *  (c) Copyright Institut für Technische Akustik (ITA), RWTH Aachen
+ *
+ */
+
+// $Id: FFTW3Backend.cpp,v 1.3 2010-01-18 17:19:01 fwefers Exp $
+
+#include "FFTW3Backend.h"
+
+#include <cassert>
+#include <ITACriticalSection.h>
+#include <ITAFFT.h>
+#include <ITAException.h>
+
+ITACriticalSection csFFTW3BackendPlannerLock;
+
+FFTW3Realization::FFTW3Realization(int type, int size, float* in, float* out, unsigned int uiFlags)
+: m_plan(NULL), m_type(type), m_size(size), m_out(out)
+{
+	if ((size <= 0) || (in == NULL) || (out == NULL)) ITA_EXCEPT0(INVALID_PARAMETER);
+
+	fftw_iodim dim, howmany_dim;
+
+	csFFTW3BackendPlannerLock.enter();
+	
+	// [fwe 2010-07-20] Wichtiges Bugfix. Für out-of-place Transformationen die Eingabe unberührt lassen.
+	m_inplace = (in == out);
+	if (m_inplace) uiFlags |= FFTW_PRESERVE_INPUT;
+
+	switch (type) {
+	case ITAFFT::FFT_R2C:
+		m_plan = fftwf_plan_dft_r2c_1d(size, in, (fftwf_complex*) out, uiFlags);
+		m_sInfo = "FFT_R2C [fftw3]";
+		break;
+
+	case ITAFFT::FFT_C2C:
+		m_plan = fftwf_plan_dft_1d(size, (fftwf_complex*) in, (fftwf_complex*) out, FFTW_FORWARD, uiFlags);
+		m_sInfo = "FFT_C2C [fftw3]";
+		break;
+
+	case ITAFFT::IFFT_C2R:
+		m_plan = fftwf_plan_dft_c2r_1d(size, (fftwf_complex*) in, out, uiFlags);
+		m_sInfo = "IFFT_C2R [fftw3]";
+		break;
+
+	case ITAFFT::IFFT_C2C:
+		m_plan = fftwf_plan_dft_1d(size, (fftwf_complex*) in, (fftwf_complex*) out, FFTW_BACKWARD, uiFlags);
+		m_sInfo = "IFFT_C2C [fftw3]";
+		break;
+
+    case ITAFFT::SPLIT_FFT_R2C:
+		dim.n = size;
+		dim.is = dim.os = 1;
+
+		howmany_dim.n = 1;
+		howmany_dim.is = howmany_dim.os = 1;
+
+		m_plan = fftwf_plan_guru_split_dft_r2c(1, &dim, 1, &howmany_dim, in, out, out+(size/2)+1, uiFlags);
+		m_sInfo = "SPLIT_FFT_R2C [fftw3]";
+		break;
+
+	case ITAFFT::SPLIT_IFFT_C2R:
+		dim.n = size;
+		dim.is = dim.os = 1;
+
+		howmany_dim.n = 1;
+		howmany_dim.is = howmany_dim.os = 1;
+
+		m_plan = fftwf_plan_guru_split_dft_c2r(1, &dim, 1, &howmany_dim, in, in+(size/2)+1, out, uiFlags);
+		m_sInfo = "SPLIT_IFFT_C2R [fftw3]";
+		break;
+
+	case ITAFFT::NORMALIZED_SPLIT_IFFT_C2R:
+		dim.n = size;
+		dim.is = dim.os = 1;
+
+		howmany_dim.n = 1;
+		howmany_dim.is = howmany_dim.os = 1;
+
+		m_plan = fftwf_plan_guru_split_dft_c2r(1, &dim, 1, &howmany_dim, in, in+(size/2)+1, out, uiFlags);
+		m_sInfo = "NORMALIZED_SPLIT_IFFT_C2R [fftw3]";
+		break;
+	}
+
+	csFFTW3BackendPlannerLock.leave();
+
+	if (m_plan == NULL) ITA_EXCEPT0(UNKNOWN);
+}
+
+FFTW3Realization::~FFTW3Realization() {
+	if (m_plan != NULL) fftwf_destroy_plan(m_plan);
+}
+
+void FFTW3Realization::execute() {
+	fftwf_execute(m_plan);
+
+	// Sonderfall NORMALIZED_SPLIT_IFFT_C2R: Hier noch die Normalisierung durchführen
+	if (m_type == ITAFFT::NORMALIZED_SPLIT_IFFT_C2R)
+		for (int i=0; i<m_size; i++) m_out[i] /= (float) m_size;
+}
+
+void FFTW3Realization::execute(float* in, float* out) {
+	if (m_inplace) {
+		if (in != out) ITA_EXCEPT1(INVALID_PARAMETER, "Attempt to execute in-place transform out-of-place");
+	} else {
+		if (in == out) ITA_EXCEPT1(INVALID_PARAMETER, "Attempt to execute out-of-place transform in-place");
+	}
+
+	switch (m_type) {
+	case ITAFFT::FFT_R2C:
+		fftwf_execute_dft_r2c(m_plan, in, (fftwf_complex*) out);
+		break;
+
+	case ITAFFT::IFFT_C2R:
+		fftwf_execute_dft_c2r(m_plan, (fftwf_complex*) in, out);
+		break;
+
+	case ITAFFT::FFT_C2C:
+	case ITAFFT::IFFT_C2C:
+		fftwf_execute_dft(m_plan, (fftwf_complex*) in, (fftwf_complex*) out);
+		break;
+
+	case ITAFFT::SPLIT_FFT_R2C:
+		fftwf_execute_split_dft_r2c(m_plan, in, out, (out+(m_size/2)+1));
+		break;
+
+	case ITAFFT::SPLIT_IFFT_C2R:
+		fftwf_execute_split_dft_c2r(m_plan, in, (in+(m_size/2)+1), out);
+		break;
+
+	case ITAFFT::NORMALIZED_SPLIT_IFFT_C2R:
+		fftwf_execute_split_dft_c2r(m_plan, in, (in+(m_size/2)+1), out);
+		
+		// Normalisierung durchführen
+		for (int i=0; i<m_size; i++) out[i] /= (float) m_size;
+		
+		break;
+	}
+}
+
+std::string FFTW3Realization::toString() {
+	return m_sInfo;
+}
+
+// -----------------------------------
+
+FFTW3Backend* FFTW3Backend::m_pInstance = NULL;
+
+FFTW3Backend* FFTW3Backend::getInstance() {
+	if (m_pInstance == NULL) m_pInstance = new FFTW3Backend();
+	return m_pInstance;
+}
+
+ITAFFTRealization* FFTW3Backend::plan(int type, int size, float* in, float* out, unsigned int uiFlags) {
+	return new FFTW3Realization(type, size, in, out, uiFlags);
+}
+

src/FFTW3Backend.h

+/*
+ *  ITAFFT, eine Wrapper-Bibliothek fr schnelle Fouriertransformationen
+ *
+ *  Autor: Frank Wefers (Frank.Wefers@akustik.rwth-aachen.de)
+ *
+ *  (c) Copyright Institut fr Technische Akustik (ITA), RWTH Aachen
+ *
+ */
+
+// $Id: FFTW3Backend.h,v 1.1 2009-12-14 10:19:17 fwefers Exp $
+
+#ifndef INCLUDE_WATCHER_FFTW3_BACKEND
+#define INCLUDE_WATCHER_FFTW3_BACKEND
+
+#include <fftw3.h>
+#include "ITAFFTBackend.h"
+#include "ITAFFTRealization.h"
+
+#ifdef WIN32
+#include <windows.h>
+#endif
+
+class FFTW3Realization : public ITAFFTRealization {
+public:
+	FFTW3Realization(int type, int size, float* in, float* out, unsigned int uiFlag=FFTW_MEASURE);
+	~FFTW3Realization();
+
+	void execute();
+	void execute(float* in, float* out);
+
+	std::string toString();
+
+private:
+	fftwf_plan m_plan;
+	int m_type;
+	int m_size;
+	bool m_inplace;
+	float* m_out;	// Ausgabepuffer (Wird nur fr den Sonderfall NORMALIZED_SPLIT_IFFT_C2R bei execute() bentigt)
+	std::string m_sInfo;
+
+#ifdef WIN32
+	static CRITICAL_SECTION m_csPlannerLock;	// Kritischer Bereich um reentrant calls fr die Planungsroutinen zu verhindern (FFTW Problem!)
+	static volatile bool m_bPlannerLockInit;	// Kritischen Bereich initialisiert?
+#endif
+};
+
+class FFTW3Backend : public ITAFFTBackend {
+public:
+	static FFTW3Backend* getInstance();
+
+	ITAFFTRealization* plan(int type, int size, float* in, float* out, unsigned int uiFlags);
+
+private:
+	static FFTW3Backend* m_pInstance;	// Singleton-Instanz
+};
+
+#endif // INCLUDE_WATCHER_FFTW3_BACKEND
+
+
+
+

src/ITAFFT.cpp

+#include <ITAFFT.h>
+#include "ITAFFTRealization.h"
+
+#include <ITAException.h>
+
+#ifdef ITAFFT_WITH_FFTW3
+#include "FFTW3Backend.h"
+#else
+#define FFTW_MEASURE 0
+#define FFTW_ESTIMATE 1<<6
+#endif
+
+#ifdef ITAFFT_WITH_MKL10
+#include "MKL10Backend.h"
+#endif
+
+
+ITAFFT::ITAFFT() : m_pRealization(NULL) {}
+
+ITAFFT::ITAFFT(int type, int size, float* in, float* out, int iPlannungMethod) : m_pRealization(NULL) {
+	plan(type, size, in, out, iPlannungMethod);
+}
+
+ITAFFT::~ITAFFT()
+{
+	delete m_pRealization;
+}
+
+bool ITAFFT::isPlanned() {
+	return (m_pRealization != NULL);
+}
+
+void ITAFFT::plan(int type, int size, float* in, float* out, int iPlannungMethod) {
+	// Falls bereits geplant wurde, wird der alte Plan verworfen
+	delete m_pRealization;
+
+	unsigned int uiFlags = 0;
+	if (iPlannungMethod == PLAN_USING_MEASUREMENT)
+		uiFlags |= FFTW_MEASURE;
+	if (iPlannungMethod == PLAN_USING_ESTIMATION)
+		uiFlags |= FFTW_ESTIMATE;
+
+#ifdef ITAFFT_WITH_FFTW3
+	m_pRealization = FFTW3Backend::getInstance()->plan(type, size, in, out, uiFlags);
+#endif
+
+#ifdef ITAFFT_WITH_MKL10
+	m_pRealization = MKL10Backend::getInstance()->plan(type, size, in, out, uiFlags);
+#endif
+
+	if (m_pRealization == NULL) ITA_EXCEPT1(UNKNOWN, "Planning of the FFT failed");
+}
+
+