Commit 01c250d1 authored by Jonas Stienen's avatar Jonas Stienen

Initial checkin

parents
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" )
/*
* ----------------------------------------------------------------
*
* 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
/*
* ----------------------------------------------------------------
*
* 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
/*
* 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);
}
/*
* 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
#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");
}
void ITAFFT::execute()
{
if (m_pRealization == NULL)
ITA_EXCEPT1(MODAL_EXCEPTION, "Attempt to execute unplanned ITAFFT");
m_pRealization->execute();
}
void ITAFFT::execute(float* in, float* out)
{
if (m_pRealization == NULL)
ITA_EXCEPT1(MODAL_EXCEPTION, "Attempt to execute unplanned ITAFFT");
m_pRealization->execute(in, out);
}
std::string ITAFFT::toString() {
return (m_pRealization == NULL ? std::string("unplanned ITAFFT") : m_pRealization->toString());
}
/*
* 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: ITAFFTBackend.h,v 1.2 2009-02-10 22:37:42 stienen Exp $
#ifndef INCLUDE_WATCHER_ITA_FFT_BACKEND
#define INCLUDE_WATCHER_ITA_FFT_BACKEND
#include <string>
// Vorwrtsdeklarationen
class ITAFFTRealization;
// Diese abstrakte Klasse definiert die Schnittstelle fr die Erzeugung
// von Realisierungen von FFTs, wie sie die Backends bereitstellen.
class ITAFFTBackend {
public:
virtual ~ITAFFTBackend() {};
// Planungsmethode wie in der Klasse ITAFFT
virtual ITAFFTRealization* plan(int type, int size, float* in, float* out, unsigned int uiFlags)=0;
};
#endif // INCLUDE_WATCHER_ITA_FFT_BACKEND
/*
* ITAFFT, eine Wrapper-Bibliothek fr schnelle Fouriertransformationen
*
* Autor: Frank Wefers (Frank.Wefers@akustik.rwth-aachen.de)
*
* (c) Copyright 2008 Institut fr Technische Akustik (ITA), RWTH Aachen
*
*/
// $Id: ITAFFTDLLMain.cpp,v 1.1 2008-06-06 13:27:33 fwefers Exp $
#include <windows.h>
BOOL APIENTRY DllMain(HANDLE hModule, DWORD fdwReason, LPVOID lpReserved) {
return TRUE;
}
/*
* ITAFFT, eine Wrapper-Bibliothek fr schnelle Fouriertransformationen
*
* Autor: Frank Wefers (Frank.Wefers@akustik.rwth-aachen.de)
*
* (c) Copyright 2008 Institut fr Technische Akustik (ITA), RWTH Aachen
*
*/
// $Id: ITAFFTFactory.h,v 1.1 2008-02-07 19:14:44 fwefers Exp $
#ifndef INCLUDE_WATCHER_ITA_FFT_FACTORY
#define INCLUDE_WATCHER_ITA_FFT_FACTORY
// Vorwrtsdeklarationen
class ITAFFT;
/* Diese abstrakte Klasse definiert die Schnittstelle fr die Erzeugung
* von Instanzen der Klasse ITAFFT. Sie wird von den Backends implementiert.
*/
class ITAFFTFactory {
public:
virtual ~ITAFFTFactory() {};
virtual ITAFFT* plan_dft(float* in, float* out, int size, int flags)=0;
virtual ITAFFT* plan_idft(float* in, float* out, int size, int flags)=0;
virtual ITAFFT* plan_dft_r2c(float* in, float* out, int size, int flags)=0;
virtual ITAFFT* plan_idft_c2r(float* in, float* out, int size, int flags)=0;
};
#endif // INCLUDE_WATCHER_ITA_FFT_FACTORY
\ No newline at end of file
/*
* 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: ITAFFTRealization.h,v 1.2 2009-02-10 22:37:42 stienen Exp $
#ifndef INCLUDE_WATCHER_ITA_FFT_REALIZATION
#define INCLUDE_WATCHER_ITA_FFT_REALIZATION
// Vorwärtsdeklarationen
class ITAFFTRealization;
/* Diese abstrakte Klasse definiert die Bibliotheks-intern benutzte Schnittstelle
* für Realisierungen der FFT, welche von den verschiedenen Backends bereitgestellt werden.
*
* Die Methoden und ihre Bedeutungen gleichen denen mit gleichem Namen in der