Commit 9a3b0f3e authored by Jonas Stienen's avatar Jonas Stienen

Adding initial data

parent b6a4e6fb
cmake_minimum_required( VERSION 2.8 )
project( ITABase )
list( APPEND CMAKE_MODULE_PATH "$ENV{VISTA_CMAKE_COMMON}" )
include( VistaCommon )
# dependencies
vista_use_package( VistaCoreLibs REQUIRED FIND_DEPENDENCIES COMPONENTS VistaInterProcComm VistaTools )
vista_use_package( sndfile )
vista_use_package( IPP QUIET )
vista_use_package( PCRE QUIET )
vista_use_package( SimpleIni QUIET )
if( NOT DEFINED ITA_BASE_WITH_FASTMATH_IPP )
set( ITA_BASE_WITH_FASTMATH_IPP OFF CACHE BOOL "Build with IPP implementation of fast math ops" )
endif( NOT DEFINED ITA_BASE_WITH_FASTMATH_IPP )
if( NOT DEFINED ITA_BASE_WITH_FASTMATH_ASSEMBLER )
set( ITA_BASE_WITH_FASTMATH_ASSEMBLER OFF CACHE BOOL "Build with assembler implementation of fast math ops" )
endif( NOT DEFINED ITA_BASE_WITH_FASTMATH_ASSEMBLER )
if( NOT DEFINED ITA_BASE_WITH_SNDFILE )
set( ITA_BASE_WITH_SNDFILE ON CACHE BOOL "Build with libsndfile to read/write audio samples for ITASampleFrame" )
endif( NOT DEFINED ITA_BASE_WITH_SNDFILE )
if( NOT DEFINED ITA_BASE_WITH_OLD_ATOMICS )
set( ITA_BASE_WITH_OLD_ATOMICS OFF CACHE BOOL "Build with legacy atomic code for non-C++11 compatible compilers" )
endif( NOT DEFINED ITA_BASE_WITH_OLD_ATOMICS )
if( NOT DEFINED ITA_BASE_WITH_REGULAR_EXPRESSIONS )
set( ITA_BASE_WITH_REGULAR_EXPRESSIONS OFF CACHE BOOL "Build with legacy regular expressions code for string manipulation" )
endif( NOT DEFINED ITA_BASE_WITH_REGULAR_EXPRESSIONS )
if( NOT DEFINED ITA_BASE_WITH_CONFIG_OLD_IMPL )
set( ITA_BASE_WITH_CONFIG_OLD_IMPL OFF CACHE BOOL "Build with legacy INI file configuration implementation (uses legacy regular expressions)" )
endif( NOT DEFINED ITA_BASE_WITH_CONFIG_OLD_IMPL )
# includes
include_directories( "include" )
# files
set( ITABaseHeader
"include/ITAASCIITable.h"
"include/ITABaseDefinitions.h"
"include/ITABufferedAudioFileWriter.h"
"include/ITAClock.h"
"include/ITAConstants.h"
"include/ITACriticalSection.h"
"include/ITADataLog.h"
"include/ITAEndianness.h"
"include/ITAException.h"
"include/ITAFade.h"
"include/ITAFastMath.h"
"include/ITAFileSystemUtils.h"
"include/ITAHDFTSpectrum.h"
"include/ITAFunctors.h"
"include/ITAHPT.h"
"include/ITAMutex.h"
"include/ITANumericUtils.h"
"include/ITASampleBuffer.h"
"include/ITASampleFrame.h"
"include/ITASampleTypeConversion.h"
"include/ITAStopWatch.h"
"include/ITAStringUtils.h"
"include/ITATimer.h"
"include/ITATimeSeriesAnalyzer.h"
"include/ITATypes.h"
"include/ITAUncopyable.h"
"include/ITAWinPCClock.h"
"include/spline.h"
)
set( ITABaseSources
"src/ITAASCIITable.cpp"
"src/ITABufferedAudioFileWriter.cpp"
"src/ITAClock.cpp"
"src/ITACriticalSection.cpp"
"src/ITACriticalSectionImpl.h"
"src/ITACriticalSectionPosixImpl.h"
"src/ITACriticalSectionWin32Impl.h"
"src/ITAEndianness.cpp"
"src/ITAException.cpp"
"src/ITAFade.cpp"
"src/ITAFileSystemUtils.cpp"
"src/ITAHDFTSpectrum.cpp"
"src/ITAHPT.cpp"
"src/ITAMutex.cpp"
"src/ITANumericUtils.cpp"
"src/ITASampleBuffer.cpp"
"src/ITASampleFrame.cpp"
"src/ITASampleTypeConversion.cpp"
"src/ITAStopWatch.cpp"
"src/ITATimer.cpp"
"src/ITAWinPCClock.cpp"
"src/spline.cpp"
)
if( VSNDFILE_FOUND AND ITA_BASE_WITH_SNDFILE )
set( ITABaseHeader "${ITABaseHeader}"
"include/ITAAudiofileCommon.h"
"include/ITAAudiofileReader.h"
"include/ITAAudiofileWriter.h"
)
set( ITABaseSources "${ITABaseSources}"
"src/ITAAudiofileCommon.cpp"
"src/ITAAudiofileReader.cpp"
"src/ITAAudiofileWriter.cpp"
"src/libsndfileAudiofileReader.cpp"
"src/libsndfileAudiofileWriter.cpp"
)
endif( VSNDFILE_FOUND AND ITA_BASE_WITH_SNDFILE )
if( VIPP_FOUND AND ITA_BASE_WITH_FASTMATH_IPP )
set( ITABaseSources "${ITABaseSources}" "src/ITAFastMathImplIPP.cpp" )
elseif( ITA_BASE_WITH_FASTMATH_ASSEMBLER )
set( ITABaseSources "${ITABaseSources}" "src/ITAFastMathImplAssembler.cpp" ) # not recommended
else( VIPP_FOUND AND ITA_BASE_WITH_FASTMATH_IPP )
set( ITABaseSources "${ITABaseSources}" "src/ITAFastMathImpl.cpp" )
endif( VIPP_FOUND AND ITA_BASE_WITH_FASTMATH_IPP )
if( ITA_BASE_WITH_OLD_ATOMICS )
set( ITABaseHeader "${ITABaseHeader}" "include/ITAAtomicOps.h" "include/ITAAtomicPrimitives.h")
if( WIN32 )
set( ITABaseSources "${ITABaseSources}" "src/ITAAtomicOpsWin32Impl.cpp" )
else( WIN32 )
set( ITABaseSources "${ITABaseSources}" "src/ITAAtomicOpsGCCBuiltinsImpl.cpp" )
endif( WIN32 )
endif( ITA_BASE_WITH_OLD_ATOMICS )
if( VPCRE_FOUND AND ITA_BASE_WITH_REGULAR_EXPRESSIONS )
list( APPEND ITABaseHeader "include/ITAConfigUtils.h" )
list( APPEND ITABaseSources "src/ITAConfigUtils.cpp" "src/ITAStringUtilsPCRE.cpp" )
add_definitions( -DPCRE_STATIC )
else( VPCRE_FOUND AND ITA_BASE_WITH_REGULAR_EXPRESSIONS )
list( APPEND ITABaseSources "src/ITAStringUtils.cpp" )
endif( VPCRE_FOUND AND ITA_BASE_WITH_REGULAR_EXPRESSIONS )
if( VSIMPLEINI_FOUND AND ITA_BASE_WITH_CONFIG_SIMPLE_INI )
if( NOT ITA_BASE_WITH_REGULAR_EXPRESSIONS )
message( FATAL_ERROR "ITABase old config implementation requires regular expressions. Please activate." )
endif( NOT ITA_BASE_WITH_REGULAR_EXPRESSIONS )
list( APPEND ITABaseSources "src/ITAConfigUtilsSimpleIniImpl.cpp" )
endif( VSIMPLEINI_FOUND AND ITA_BASE_WITH_CONFIG_SIMPLE_INI )
if( ITA_BASE_WITH_CONFIG_OLD_IMPL AND NOT ITA_BASE_WITH_CONFIG_SIMPLE_INI )
if( NOT ITA_BASE_WITH_REGULAR_EXPRESSIONS )
message( FATAL_ERROR "ITABase old config implementation requires regular expressions. Please activate." )
endif( NOT ITA_BASE_WITH_REGULAR_EXPRESSIONS )
list( APPEND ITABaseSources "src/ITAConfigUtilsWin32Impl.cpp" )
endif( ITA_BASE_WITH_CONFIG_OLD_IMPL AND NOT ITA_BASE_WITH_CONFIG_SIMPLE_INI )
# compiler
add_definitions( -DITA_BASE_DLL -DITA_BASE_EXPORT )
# linker
add_library( ITABase SHARED ${ITABaseHeader} ${ITABaseSources} )
target_link_libraries( ITABase ${VISTA_USE_PACKAGE_LIBRARIES} )
# configure
vista_configure_lib( ITABase )
vista_install( ITABase )
set( ITABASE_INCLUDE_OUTDIR "${CMAKE_CURRENT_SOURCE_DIR}/include" )
vista_create_cmake_configs( ITABase )
vista_create_default_info_file( ITABase )
set_property( TARGET ITABase PROPERTY FOLDER "ITACoreLibs" )
# tests
set( ITABASE_COMMON_BUILD TRUE )
add_subdirectory( "${CMAKE_CURRENT_SOURCE_DIR}/tests" )
/*
+-----------------------------------------------------------------------+
| |
| ITAToolkit |
| |
| (c) Copyright Institut fr technische Akustik (ITA) |
| RWTH Aachen University of Technology |
| |
+-----------------------------------------------------------------------+
| |
| File: ITAASCIITable.h |
| Purpose: Klasse zur Darstellung von Tabellen als Zeichenketten |
| Authors: Frank Wefers |
| |
+-----------------------------------------------------------------------+
*/
// $Id: ITAASCIITable.h 3881 2014-12-08 15:03:26Z fwefers $
#ifndef INCLUDE_WATCHER_ITA_ASCII_TABLE
#define INCLUDE_WATCHER_ITA_ASCII_TABLE
#include <ITABaseDefinitions.h>
#include <ostream>
#include <string>
#include <vector>
/**
* Diese Hilfsklasse ermglicht die komfortable Ausgabe von Tabellendaten
* als Text (wie z.B. auf der Konsole). Sie kapselt die Tabellendaten und
* stellt eine Rendering-Methode zur Verfgung um die Zeichenketten-
* Darstellung der Tabelle zu erhalten. Spaltenausrichtungen knnen gesetzt
* werden und mehrzeile Spaltenberschriften, sowie Felder werden untersttzt
*/
class ITA_BASE_API ITAASCIITable
{
public:
//! Literal fr Zeilen-/Spaltenenden
static const unsigned int END = 0xFFFFFFFF;
//! Literale fr Ausrichtungen
enum {
LEFT = 0,
CENTER = 1,
RIGHT = 2
};
//! Formate
enum {
TEXT = 0, //!< Ausgabe als Text
DAT, //!< Datenformat
CSV, //!< CSV Format
};
static const int DEFAULT_FORMAT = TEXT;
//! Konstruktor (leere Tabelle)
ITAASCIITable();
//! Konstruktor (Vorgabe der Anzahl Zeilen/Spalten)
ITAASCIITable(unsigned int uiRows, unsigned int uiColumns);
//! Destruktor
virtual ~ITAASCIITable();
//! Anzahl Zeilen zurckgeben
unsigned int rows() const;
//! Anzahl Zeilen zurckgeben
unsigned int columns() const;
//! Eine Zeile einfgen
/**
* \param uiIndex Index der Zeile, nach der die neue Zeile eingefgt wird (optional)
*/
void addRow(unsigned int uiPosition=END);
//! Eine Zeile entfernen
/**
* \param uiIndex Index der Zeile die entfernt werden soll
*/
void removeRow(unsigned int uiRow);
//! Eine Spalte einfgen
/**
* \param uiIndex Index der Spalte, nach der die neue Spalte eingefgt wird (optional)
*/
void addColumn(unsigned int uiPosition=END);
void addColumn(const std::string& sColumnTitle, unsigned int uiPosition=END);
//! Eine Spalte entfernen
/**
* \param uiIndex Index der Zeile die entfernt werden soll
*/
void removeColumn(unsigned int uiColumn);
//! Ausrichtung einer Spalte zurckgeben
unsigned int getColumnJustify(unsigned int uiColumn);
//! Ausrichtung einer Spalte setzen
void setColumnJustify(unsigned int uiColumn, unsigned int uiJustify);
//! Titel einer Spalte zurckgeben
std::string getColumnTitle(unsigned int uiColumn);
//! Titel einer Spalte setzen
void setColumnTitle(unsigned int uiColumn, const std::string& sTitle);
//! Ausrichtung des Titels einer Spalte zurckgeben
unsigned int getColumnTitleJustify(unsigned int uiColumn);
//! Ausrichtung des Titels einer Spalte setzen
void setColumnTitleJustify(unsigned int uiColumn, unsigned int uiJustify);
//! Zelleinhalt zurckgeben
std::string getContent(unsigned int uiRow, unsigned int uiColumn);
//! Zellinhalt setzen
void setContent(unsigned int uiRow, unsigned int uiColumn, const std::string& sContent);
void setContent(unsigned int uiRow, unsigned int uiColumn, const char* pszContent);
void setContent(unsigned int uiRow, unsigned int uiColumn, const bool& bContent);
void setContent(unsigned int uiRow, unsigned int uiColumn, const unsigned int& uiContent);
void setContent(unsigned int uiRow, unsigned int uiColumn, const int& iContent);
void setContent(unsigned int uiRow, unsigned int uiColumn, const float& fContent, int iPrecision=-1);
void setContent(unsigned int uiRow, unsigned int uiColumn, const double& dContent, int iPrecision=-1);
//! Die ASCII-Tabelle rendern
std::ostream& render(std::ostream& os, int iFormat=DEFAULT_FORMAT);
std::ostream& renderText(std::ostream& os);
std::ostream& renderDAT(std::ostream& os);
std::ostream& renderCSV(std::ostream& os);
//! Die ASCII-Tabelle rendern
std::string toString();
protected:
class ITAASCIITableColumn
{
public:
unsigned int uiTitleJustify; // Ausrichtung des Titels
std::string sTitle; // Titel
unsigned int uiJustify; // Ausrichtung der Zellen
std::vector< std::string > vsCells; // Inhalt der Zellen
unsigned int uiMaxWidth; // Maximale Zellenbreite
ITAASCIITableColumn() {
uiJustify = uiTitleJustify = LEFT;
uiMaxWidth = 0;
}
};
std::vector<ITAASCIITableColumn> m_vColumns;
void splitLines(const std::string& sText, std::vector< std::string >& vsDest);
};
#endif // INCLUDE_WATCHER_ITA_ASCII_TABLE
/*
* ----------------------------------------------------------------
*
* ITA core libs
* (c) Copyright Institute of Technical Acoustics (ITA)
* RWTH Aachen University, Germany, 2015-2016
*
* ----------------------------------------------------------------
* ____ __________ _______
* // / //__ ___/ // _ |
* // / // / // /_| |
* // / // / // ___ |
* //__/ //__/ //__/ |__|
*
* ----------------------------------------------------------------
*
*/
// $Id: ITAAtomicOps.h,v 1.7 2009-01-18 02:04:10 stienen Exp $
#ifndef INCLUDE_WATCHER_ITA_ATOMIC_OPS
#define INCLUDE_WATCHER_ITA_ATOMIC_OPS
#include <ITABaseDefinitions.h>
//! Atomare Leseoperationen
/**
* Diese Funktionen realisieren atomare Leseoperationen.
* Sie lesen den Wert eines Speicherinhaltes und stellen sicher,
* das w�hrend des Lesens kein anderweitiger Schreibzugriff
* auf diesen Speicherinhalt erfolgt.
*/
ITA_BASE_API int atomic_read_int( volatile const int* src );
ITA_BASE_API long atomic_read_long( volatile const long* src );
ITA_BASE_API float atomic_read_float( volatile const float* src );
//extern inline double atomic_read_double(volatile double* dest);
ITA_BASE_API void* atomic_read_ptr( volatile const void** src );
//! Atomare Schreiboperationen
/**
* Diese Funktionen realisieren atomare Schreiboperationen.
* Sie schreiben einen neuen Wert in den gegebenen Speicherinhalt
* und stellen sicher, das w�hrend des Schreibens kein anderweitiger
* Lesezugriff auf diesen Speicherinhalt erfolgt.
*/
ITA_BASE_API void atomic_write_int( volatile int* dest, int value );
ITA_BASE_API void atomic_write_long( volatile long* dest, long value );
ITA_BASE_API void atomic_write_float( volatile float* dest, float value );
//void atomic_write_double(volatile double* dest, double value);
ITA_BASE_API void atomic_write_ptr( volatile void** dest, void* value );
//! Atomares Inkrement und Dekrement (Rückgabe: Wert nach Operation)
ITA_BASE_API int atomic_inc_int( volatile int* dest );
ITA_BASE_API int atomic_dec_int( volatile int* dest );
//! Atomares compare-and-swap (CAS)
/**
* Diese Funktionen realisieren eine der wichtigsten Grundoperationen
* f�r non-blocking Algorithmen: Atomares Compare-and-swap (CAS).
*
* Alle geben 'true' zur�ck falls der Wert ausgetauscht wurde.
* \todo Doku
*/
//bool atomic_CAS_Ptr(void** dest, void* expected_value, void* new_value);
ITA_BASE_API bool atomic_cas_int( volatile int* dest, int expected_value, int new_value );
ITA_BASE_API bool atomic_cas_long( volatile long* dest, long expected_value, long new_value );
//bool atomic_cas_float(volatile float* dest, float expected_value, float new_value);
//bool atomic_cas_double(volatile double* dest, double expected_value, double new_value);
ITA_BASE_API bool atomic_cas_ptr( volatile void** dest, void* expected_value, void* new_value );
// --= Ungetypte Operationen =--
// Atomares Lesen für 32-Bit (4 Bytes)
ITA_BASE_API void atomic_read32( volatile void* src, void* dest );
// Atomares Schreiben für 32-Bit (4 Bytes)
ITA_BASE_API void atomic_write32( volatile void* dest, void* new_value );
// Atomares Compare-And-Swap (CAS) für 32-Bit (4 Bytes) - Rückgabe: true falls ausgetauscht wurde
ITA_BASE_API bool atomic_cas32( volatile void* dest, void* expected_value, void* new_value );
#endif // INCLUDE_WATCHER_ITA_ATOMIC_OPS
This diff is collapsed.
/*
* ----------------------------------------------------------------
*
* ITA core libs
* (c) Copyright Institute of Technical Acoustics (ITA)
* RWTH Aachen University, Germany, 2015-2016
*
* ----------------------------------------------------------------
* ____ __________ _______
* // / //__ ___/ // _ |
* // / // / // /_| |
* // / // / // ___ |
* //__/ //__/ //__/ |__|
*
* ----------------------------------------------------------------
*
*/
// $Id: ITAAudiofileCommon.h,v 1.7 2009-01-18 02:04:10 stienen Exp $
#ifndef INCLUDE_WATCHER_ITA_AUDIOFILE_COMMON
#define INCLUDE_WATCHER_ITA_AUDIOFILE_COMMON
#include <ITABaseDefinitions.h>
#include <string>
ITA_BASE_API typedef enum
{
ITA_UNKNOWN_QUANTIZATION,
ITA_INT16,
ITA_INT20,
ITA_INT24,
ITA_INT32,
ITA_FLOAT,
ITA_DOUBLE
} ITAQuantization;
// Name einer Quantisierung als Zeichenkette (Deutsch) zurckgeben
ITA_BASE_API std::string toString(ITAQuantization eQuantization);
ITA_BASE_API typedef enum
{
ITA_UNKNOWN_DOMAIN,
ITA_TIME_DOMAIN,
ITA_FREQUENCY_DOMAIN
} ITADomain;
// Name einer Domne als Zeichenkette (Deutsch) zurckgeben
ITA_BASE_API std::string toString(ITADomain eDomain);
ITA_BASE_API typedef struct
{
ITAQuantization eQuantization;
ITADomain eDomain;
unsigned int uiChannels;
double dSamplerate;
unsigned int uiLength;
std::string sComment;
} ITAAudiofileProperties;
//! Audiodateieigenschaften auf der Konsole ausgeben
ITA_BASE_API void print(const ITAAudiofileProperties& props);
#endif // INCLUDE_WATCHER_ITA_AUDIOFILE_COMMON
/*
* ----------------------------------------------------------------
*
* ITA core libs
* (c) Copyright Institute of Technical Acoustics (ITA)
* RWTH Aachen University, Germany, 2015-2016
*
* ----------------------------------------------------------------
* ____ __________ _______
* // / //__ ___/ // _ |
* // / // / // /_| |
* // / // / // ___ |
* //__/ //__/ //__/ |__|
*
* ----------------------------------------------------------------
*
*/
// $Id: ITAAudiofileReader.h,v 1.3 2006-05-21 12:29:29 wefers Exp $
#ifndef INCLUDE_WATHER_ITA_AUDIOFILE_READER
#define INCLUDE_WATHER_ITA_AUDIOFILE_READER
#include <ITABaseDefinitions.h>
#include <ITAAudiofileCommon.h>
// Includes der Standard Template Library (STL)
#include <string>
#include <vector>
/**
* Abstrakte Klasse welche allgemeine Leser für Audiodateien realisiert
*/
class ITA_BASE_API ITAAudiofileReader
{
public:
//! Factory-Method (Lader erzeugen)
/**
* \note Gibt niemals NULL zurück. Löst aber ggf. eine ITAException aus
*/
static ITAAudiofileReader* create(std::string sFilename);
//! Destruktor
virtual ~ITAAudiofileReader();
//! Eigenschaften zurückgeben
ITAAudiofileProperties getAudiofileProperties() const;
//! Quantisierungstyp zurückgeben
ITAQuantization getQuantization() const;
//! Domäne zurückgeben
ITADomain getDomain() const;
//! Anzahl der Kanäle zurückgeben
unsigned int getNumberOfChannels() const;
//! Samplerate zurückgeben
double getSamplerate() const;
//! Länge der Audiodatei in Samples zurückgeben
unsigned int getLength() const;
//! Aktuelle Position in der Audiodatei zurückgeben
unsigned int getCursor() const;
//! Kommentar der Audio zurückgeben
std::string getComment() const;
//! An eine Position in der Datei springen
virtual void seek(unsigned int uiOffset)=0;
//! Lesen und Zielpuffer erzeugen
/**
* Ließt uiLength Samples aus der Audiodatei in Float-Puffer,
* welche automatisch von der Methode erzeugt werden. Die Anzahl
* der Float-Puffer ist gleich der Anzahl der Kanäle der Audiodatei.
*
* \param uiLength Anzahl der zu lesenden Samples
* \return Vektor mit den Allozierten und mit Daten gefüllten Float-Puffern
*
* \note Im Fehlerfall löst die Methode eine Ausnahme des Typs ITAException aus
*/
std::vector<float*> read(unsigned int uiLength);
//! Lesen in vorgegebene Zielpuffer
/**
* Ließt uiLength Samples aus der Audiodatei in Float-Puffer,
* welche der Methode als Parameter übergeben werden. Die Anzahl
* der Float-Puffer ist muss <b>nicht</b> gleich der Anzahl der Kanäle
* der Audiodatei sein, darf diese Anzahl aber nicht überschreiten.
* Enthält der übergebene Vektor weniger Zeiger als die Audiodatei
* Kanäle hat, werden nur die ersten Kanäle gelesen.
* Ferner kann man den Lader anweisen, nur gewisse Kanäle zu laden,
* indem man in den Vektor Nullzeiger einfügt. Ist ein Zeiger Null,
* so ignoriert der Lader diesen.
*
* \param uiLength Anzahl der zu lesenden Samples
* \param vpfDest Vektor mit Zeigern auf die Puffer,
* in denen die Daten abgelegt werden sollen.
*
* \note Im Fehlerfall löst die Methode eine Ausnahme des Typs ITAException aus
*/
virtual void read(unsigned int uiLength, std::vector<float*> vpfDest)=0;
protected:
ITAQuantization _eQuantization;
ITADomain _eDomain;
unsigned int _uiChannels;
double _dSamplerate;
unsigned int _uiLength;
unsigned int _uiCursor;
std::string _sComment;
};
//! Schnüffelfunktion (Nur die Eigenschaften einer Audiodatei ermitteln)
ITA_BASE_API void sneakAudiofile(std::string sFilename, ITAAudiofileProperties& props);
//! Audiodatei in Puffer laden (Puffer werden erzeugt)
ITA_BASE_API std::vector<float*> readAudiofile(std::string sFilename, ITAAudiofileProperties& props);
//! Audiodatei in Puffer laden (Puffer sind vorgegeben)
ITA_BASE_API void readAudiofile(std::string sFilename, ITAAudiofileProperties& props, std::vector<float*>& vpfData);
#endif // INCLUDE_WATHER_ITA_AUDIOFILE_READER
/*
* ----------------------------------------------------------------
*
* ITA core libs
* (c) Copyright Institute of Technical Acoustics (ITA)
* RWTH Aachen University, Germany, 2015-2016
*
* ----------------------------------------------------------------
* ____ __________ _______
* // / //__ ___/ // _ |
* // / // / // /_| |
* // / // / // ___ |
* //__/ //__/ //__/ |__|
*
* ----------------------------------------------------------------
*
*/
// $Id: ITAAudiofileWriter.h,v 1.5 2010-02-22 09:53:46 schluetter Exp $
#ifndef INCLUDE_WATHER_ITA_AUDIOFILE_WRITER
#define INCLUDE_WATHER_ITA_AUDIOFILE_WRITER
#include <ITABaseDefinitions.h>
#include <ITAAudiofileCommon.h>
// Includes der Standard Template Library (STL)
#include <string>
#include <vector>
// Vorwärtsdeklarationen
class ITASampleBuffer;
class ITASampleFrame;
/**
* Abstrakte Klasse welche allgemeine Schreiber für Audiodateien realisiert
*/
class ITA_BASE_API ITAAudiofileWriter
{
public:
//! Factory-Method (Lader erzeugen)
/**
* \note Das Feld uiLength in props wird ignoriert!
* \note Gibt niemals NULL zurück. Löst aber ggf. eine ITAException aus
*/
static ITAAudiofileWriter* create(std::string sFilename,
const ITAAudiofileProperties& props);
//! Destruktor
virtual ~ITAAudiofileWriter();
//! Schreiben
/**
* Schreibt uiLength Samples aus den im �bergebenen Vektor enthaltenen
* Float-Puffern in die Audiodatei. Die Anzahl der Float-Puffer ist muss
* <b>nicht</b> gleich der Anzahl der Kan�le der Audiodatei sein,
* darf diese Anzahl aber nicht �berschreiten.
* Enth�lt der �bergebene Vektor weniger Zeiger als die Audiodatei
* Kan�le hat, werden nur die ersten Kan�le geschrieben. Alle weiteren
* Kan�le werden mit Nullsamples belegt.
* Ferner kann man den Schreiber anweisen, nur gewisse Kan�le zu schreiben,