Commit 6230e155 authored by Jonas Stienen's avatar Jonas Stienen

Initial checkin

parents
cmake_minimum_required( VERSION 2.8 )
project( ITASampler )
list( APPEND CMAKE_MODULE_PATH "$ENV{VISTA_CMAKE_COMMON}" )
include( VistaCommon )
# dependencies
vista_use_package( ITABase REQUIRED FIND_DEPENDENCIES )
vista_use_package( ITADataSources REQUIRED FIND_DEPENDENCIES )
# includes
include_directories( "include" )
# sources
set( ITASamplerHeader
"include/ITASampleClock.h"
"include/ITASamplerDefinition.h"
"include/ITASoundSample.h"
"include/ITASoundSamplePool.h"
"include/ITASoundSampler.h"
)
set( ITASamplerSources
"src/ITASoundSampler.cpp"
"src/ITASoundSampleImpl.cpp"
"src/ITASoundSampleImpl.h"
"src/ITASoundSamplePool.cpp"
"src/ITASoundSamplePoolImpl.cpp"
"src/ITASoundSamplePoolImpl.h"
"src/ITASoundSamplerImpl.h"
"src/ITASoundSamplerImpl.cpp"
"src/ITASoundSamplerImpl.h"
"src/ITASoundSamplerImpl.cpp"
"src/ITASoundSamplerPlayback.h"
"src/ITASoundSamplerSlot.h"
"src/ITASoundSamplerSlotbuffer.h"
"src/ITASoundSamplerSlotbuffer.cpp"
"src/PlaybackIDGenerator.cpp"
"src/PlaybackIDGenerator.h"
)
# compiler
add_definitions( -DITA_BASE_DLL -DITA_SAMPLER_DLL -DITA_SAMPLER_EXPORT )
# linker
add_library( ITASampler SHARED ${ITASamplerHeader} ${ITASamplerSources} )
target_link_libraries( ITASampler ${VISTA_USE_PACKAGE_LIBRARIES} )
# config
vista_configure_lib( ITASampler )
vista_install( ITASampler )
set( ITASAMPLER_INCLUDE_OUTDIR "${CMAKE_CURRENT_SOURCE_DIR}/include" )
vista_create_cmake_configs( ITASampler )
vista_create_default_info_file( ITASampler )
set_property( TARGET ITASampler PROPERTY FOLDER "ITACoreLibs" )
# tests
set( ITASAMPLER_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: ITASampleClock.h 2900 2012-09-17 08:42:42Z fwefers $
#ifndef INCLUDE_WATCHER_ITA_SAMPLE_CLOCK
#define INCLUDE_WATCHER_ITA_SAMPLE_CLOCK
#include <ITAHPT.h>
#include <ITASamplerDefinition.h>
/**
* Diese Klasse definiert eine Schnittstelle die es erlaubt
* Zeitangaben eines ... in Sample-Indizes
* eines Audio-Datenstroms umzurechnen und umgekehrt.
*/
class ITA_SAMPLER_API ITASampleClock
{
public:
inline ITASampleClock( double dSamplerate, double dScale = 1.0 ) : m_dSamplerate( dSamplerate ), m_dScale( dScale ), m_ttRef( ITAHPT_now() ) {};
inline virtual ~ITASampleClock() {};
//! Skalierung [in Sekunden] zurckgeben
inline double GetScale() { return m_dScale; };
//! Zeitpunkt eines gewissen Samples setzen [Timerticks]
inline void Adjust( int iSample, ITATimerTicks ttRef ) {
// Timerticks bei Sample 0 berechnen
m_ttRef = ttRef - toTimerTicks( (double) iSample / m_dSamplerate );
};
//! Sample-Index in Zeitmarke umrechnen
inline double GetTimeForSample( int iSample ) {
return (double) iSample / m_dSamplerate / m_dScale;
};
//! Zeitmarke in Sample-Index umrechnen
inline int GetSampleForTime( double dTime ) {
// Auf nchstgelegenen Wert runden
return (int) ( dTime * m_dScale * m_dSamplerate );
};
//! Sample-Index in Timerticks umrechnen
inline ITATimerTicks GetTicksForSample( int iSample ) {
return m_ttRef + toTimerTicks( (double) iSample / m_dSamplerate );
};
//! Zeitmarke in Timerticks umrechnen
inline ITATimerTicks GetTicksForTime( double dTime ) {
return m_ttRef + toTimerTicks( dTime * m_dScale );
};
protected:
double m_dSamplerate;
double m_dScale;
ITATimerTicks m_ttRef; // Reference: timer ticks at sample 0
};
#endif // INCLUDE_WATCHER_ITA_SAMPLE_CLOCK
/*
* ----------------------------------------------------------------
*
* ITA core libs
* (c) Copyright Institute of Technical Acoustics (ITA)
* RWTH Aachen University, Germany, 2015-2016
*
* ----------------------------------------------------------------
* ____ __________ _______
* // / //__ ___/ // _ |
* // / // / // /_| |
* // / // / // ___ |
* //__/ //__/ //__/ |__|
*
* ----------------------------------------------------------------
*
*/
// $Id: ITASamplerDefinitions.h 2900 2012-09-17 08:42:42Z fwefers $
#ifndef INCLUDE_WATCHER_ITA_SAMPLER_DEFINITIONS
#define INCLUDE_WATCHER_ITA_SAMPLER_DEFINITIONS
#ifdef ITA_SAMPLER_DLL
#ifdef ITA_SAMPLER_EXPORT
#define ITA_SAMPLER_API __declspec(dllexport)
#else
#define ITA_SAMPLER_API __declspec(dllimport)
#endif
#else
#define ITA_SAMPLER_API
#endif
#endif // INCLUDE_WATCHER_ITA_SAMPLER_DEFINITIONS
/*
* ----------------------------------------------------------------
*
* ITA core libs
* (c) Copyright Institute of Technical Acoustics (ITA)
* RWTH Aachen University, Germany, 2015-2016
*
* ----------------------------------------------------------------
* ____ __________ _______
* // / //__ ___/ // _ |
* // / // / // /_| |
* // / // / // ___ |
* //__/ //__/ //__/ |__|
*
* ----------------------------------------------------------------
*
*/
/*
* +------------------+
* --->| ITA Sampler |--->
* --->| o o o o /// |--->
* +------------------+
*
* ITASampler ist eine C++ Bibliothek die einen Sound sampler zur wavetable-basierten
* Klangsynthese bereitstellt. Der Begriff "sampler" bezieht sich hier auf den Terminus
* aus der Musikproduktion und nicht auf Abtastwerte.
*
* Datei: ITASoundSample.h
* Zweck: Schnittstellendefinition fr sound samples
* Autoren: Frank Wefers (Frank.Wefers@akustik.rwth-aachen.de)
* CVS-Datum: $Id: ITASoundSample.h,v 1.1 2008-12-10 14:15:03 fwefers Exp $
*
* (c) Copyright Institut fr Technische Akustik (ITA) RWTH Aachen, 2008
*/
#ifndef INCLUDE_WATCHER_ITA_SOUND_SAMPLE
#define INCLUDE_WATCHER_ITA_SOUND_SAMPLE
#include <string>
#include <vector>
/**
* Diese abstrakte Klasse definiert die Zugriffsschnittstelle
* zu einzelnen Samples im SamplePool.
*/
class ITASoundSample
{
public:
//! Destruktor
inline virtual ~ITASoundSample() {};
//! Gibt zurck ob dieses Sample aus einer Datei geladen wurde
virtual bool OriginFile() const=0;
//! Name zurckgeben
virtual std::string GetName() const=0;
//! Name setzen
void SetName(const std::string& sName);
//! Dateiname zurckgeben (nur bei Samples die aus Dateien geladen wurden)
virtual std::string GetFilename() const=0;
//! Anzahl Kanle zurckgeben
virtual int GetNumberOfChannels() const=0;
//! Lnge [Anzahl Samples]
virtual int GetLength() const=0;
// Zeiger auf die Daten eines Kanals zurckgeben
virtual const float* GetChannelData(int iChannel) const=0;
};
#endif // INCLUDE_WATCHER_ITA_SOUND_SAMPLE
/*
* ----------------------------------------------------------------
*
* ITA core libs
* (c) Copyright Institute of Technical Acoustics (ITA)
* RWTH Aachen University, Germany, 2015-2016
*
* ----------------------------------------------------------------
* ____ __________ _______
* // / //__ ___/ // _ |
* // / // / // /_| |
* // / // / // ___ |
* //__/ //__/ //__/ |__|
*
* ----------------------------------------------------------------
*
*/
/*
* +------------------+
* --->| ITA Sampler |--->
* --->| o o o o /// |--->
* +------------------+
*
* ITASampler ist eine C++ Bibliothek die einen Sound sampler zur wavetable-basierten
* Klangsynthese bereitstellt. Der Begriff "sampler" bezieht sich hier auf den Terminus
* aus der Musikproduktion und nicht auf Abtastwerte.
*
* Datei: ITASoundSamplePool.h
* Zweck: Schnittstellendefinition fr Kontainer/Verwalter von sound samples
* Autoren: Frank Wefers (Frank.Wefers@akustik.rwth-aachen.de)
* CVS-Datum: $Id: ITASoundSamplePool.h,v 1.1 2008-12-10 14:15:03 fwefers Exp $
*
* (c) Copyright Institut fr Technische Akustik (ITA) RWTH Aachen, 2008
*/
#ifndef INCLUDE_WATCHER_ITA_SOUND_SAMPLE_POOL
#define INCLUDE_WATCHER_ITA_SOUND_SAMPLE_POOL
#include <ITASamplerDefinition.h>
#include <string>
#include <vector>
// Vorwrtsdeklarationen
class ITASoundSample;
/**
* Diese Klasse realisiert eine Verwaltung fr Samples.
* Die Trennung von der Klasse ITASampler ermglicht es mehrer
* Sampler mit einem SamplePool zu betreiben. So kann vermieden
* werden mehrere gleiche Samples mehrfach zu laden und den
* Speicher unntig zu belasten.
*/
class ITA_SAMPLER_API ITASoundSamplePool
{
public:
//! Factory method
static ITASoundSamplePool* Create(int iMaxNumberOfChannels, double dSamplerate);
//! Destruktor
inline virtual ~ITASoundSamplePool() {};
//! Maximale Anzahl Kanle zurckgeben
virtual int GetMaximumNumberOfChannels() const=0;
//! Abtastrate [Hz] zurckgeben
virtual double GetSamplerate() const=0;
//! Mono-Sample aus Puffer erzeugen
virtual int CreateSample(const float* pfData, int iLength, double dSamplerate, std::string sName="")=0;
//! Stereo-Sample aus Puffer erzeugen
virtual int CreateSample(const float* pfLeftChannelData, const float* pfRightChannelData, int iLength, double dSamplerate, std::string sName="")=0;
//! Sample aus Puffer erzeugen
virtual int CreateSample(const float** ppfChannelData, int iNumChannels, int iLength, double dSamplerate, std::string sName="")=0;
//! Sample aus Puffer erzeugen
virtual int CreateSample(std::vector<float*> vpfChannelData, int iLength, double dSamplerate, std::string sName="")=0;
//! Sample aus Datei laden
virtual int LoadSample(const std::string& sFilename, std::string sName="")=0;
//! Sample freigeben
virtual void FreeSample(int iSampleID)=0;
//! IDs aller enthaltenen Samples zurckgeben
virtual void GetSampleIDs(std::vector<int>& viSampleIDs) const=0;
//! Sample-Objekt zurckgeben
virtual const ITASoundSample* GetSample(int iSampleID, bool bAddPlaybackReference)=0;
};
#endif // INCLUDE_WATCHER_ITA_SOUND_SAMPLE_POOL
/*
* ----------------------------------------------------------------
*
* ITA core libs
* (c) Copyright Institute of Technical Acoustics (ITA)
* RWTH Aachen University, Germany, 2015-2016
*
* ----------------------------------------------------------------
* ____ __________ _______
* // / //__ ___/ // _ |
* // / // / // /_| |
* // / // / // ___ |
* //__/ //__/ //__/ |__|
*
* ----------------------------------------------------------------
*
*/
/*
* +------------------+
* --->| ITA Sampler |--->
* --->| o o o o /// |--->
* +------------------+
*
* ITASampler ist eine C++ Bibliothek die einen Sound sampler zur wavetable-basierten
* Klangsynthese bereitstellt. Der Begriff "sampler" bezieht sich hier auf den Terminus
* aus der Musikproduktion und nicht auf Abtastwerte.
*
* Datei: ITASoundSampler.h
* Zweck: Schnittstellendefinition des sound samplers selbst
* Autoren: Frank Wefers (Frank.Wefers@akustik.rwth-aachen.de)
* CVS-Datum: $Id: ITASoundSampler.h,v 1.2 2008-12-11 20:34:34 fwefers Exp $
*
* (c) Copyright Institut fr Technische Akustik (ITA) RWTH Aachen, 2008
*/
#ifndef INCLUDE_WATCHER_ITA_SOUND_SAMPLER
#define INCLUDE_WATCHER_ITA_SOUND_SAMPLER
#include <ITASamplerDefinition.h>
#include <ITADataSource.h>
#include <string>
#include <vector>
class ITASampleClock;
class ITASoundSampler;
class ITASoundSamplePool;
class ITA_SAMPLER_API ITASoundSamplerEventHandler
{
public:
inline virtual ~ITASoundSamplerEventHandler() {};
virtual void HandleSamplerEvent(ITASoundSampler* pSource, double dTimecode, int iTag, void* pParam)=0;
};
/**
*
*
* - Playback-ID global eindeutig. Eine Playback-ID existiert niemals auf mehreren Samplern.
* So kann anhand der Playback-ID eindeutig auf den Sampler zurckgeschlossen werden, sofern
* man die Playback-IDs mit ihren Samplern assoziiert.
* - Sample-ID sind nur lokal (in ihrem Samplepool) eindeutig, nicht aber global.
* - Track-ID sind nur lokal (in ihrem Sampler) eindeutig, nicht aber global.
*/
class ITA_SAMPLER_API ITASoundSampler : public ITADatasource
{
public:
/*
//! Return values / errorcodes for class methods
enum {
NOERROR = 0, //! Kein Fehler - Alles in Ordnung
INVALID_ID = 1, //! Ungltige Sample-/Playback-ID
};
*/
//! Factory method
static ITASoundSampler* Create(int iOutputChannels, double dSamplerate, int iBlocklength, ITASoundSamplePool* pSamplePool=NULL);
//! Destruktor
inline virtual ~ITASoundSampler() {};
//! Sampleclock (Umrechnung Timecode -> Sample im Datenstrom) setzen
virtual void SetSampleClock(ITASampleClock* pClock)=0;
//! Samplepool zurckgeben
virtual ITASoundSamplePool* GetSamplePool() const=0;
//! Samplezhler zurcksetzen
/**
* Setzt den internen Samplezhler des Sampler zurck.
* Dies bewirkt das das erste Samples des als nchstes zurckgegeben Block
* den Index 0 zugewiesen bekommt.
*/
virtual void ResetSampleCount()=0;
//! Nchstabzuspielendes Sample zurckgeben
/**
* Gibt den Index das ersten Samples im als nchstes zurckgegeben Block zurck.
* Der Wert ist deshalb immer ein Vielfaches der Blocklnge.
*/
virtual int GetSampleCount()=0;
//! Spur hinzufgen
virtual int AddTrack(int iTrackChannels)=0;
//! Kanle einer Spur mit Ausgangskanlen verbinden
virtual void RouteTrackChannel(int iTrackID, int iTrackChannel, int iOutputChannel)=0;
//! Mono-Spur hinzufgen
virtual int AddMonoTrack(int iOutputChannel=0)=0;
//! Stereo-Spur hinzufgen
virtual int AddStereoTrack(int iLeftOutputChannel=0, int iRightOutputChannel=1)=0;
//! Spur entfernen
virtual void RemoveTrack(int iTrackID)=0;
//! Namen einer Spur zurckgeben
virtual std::string GetTrackName(int iTrackID)=0;
//! Namen einer Spur setzen
virtual void SetTrackName(int iTrackID, const std::string& sName)=0;
//! Anzahl der Kanle einer Spur zurckgeben
virtual int GetTrackNumberOfChannels(int iTrackID)=0;
//! Gesamtlautstrke zurckgeben
virtual double GetMasterGain()=0;
//! Gesamtlautstrke setzen
virtual void SetMasterGain(double dGain)=0;
//! Lautstrke einer Spur zurckgeben
virtual double GetTrackGain(int iTrackID)=0;
//! Lautstrke einer Spur setzen
virtual void SetTrackGain(int iTrackID, double dGain)=0;
//! Lautstrke eines Kanals einer Spur zurckgeben
virtual double GetTrackChannelGain(int iTrackID, int iTrackChannel)=0;
//! Lautstrke eines Kanals einer Spur setzen
virtual void SetTrackChannelGain(int iTrackID, int iTrackChannel, double dGain)=0;
//! Mono-Sample aus Puffer erzeugen
virtual int CreateSample(const float* pfData, int iLength, double dSamplerate, std::string sName="")=0;
//! Stereo-Sample aus Puffer erzeugen
virtual int CreateSample(const float* pfLeftChannelData, const float* pfRightChannelData, int iLength, double dSamplerate, std::string sName="")=0;
//! Sample aus Puffer erzeugen
virtual int CreateSample(const float** ppfChannelData, int iNumChannels, int iLength, double dSamplerate, std::string sName="")=0;
//! Sample aus Puffer erzeugen
virtual int CreateSample(std::vector<float*> vpfChannelData, int iLength, double dSamplerate, std::string sName="")=0;
//! Sample aus Datei laden
virtual int LoadSample(const std::string& sFilename, std::string sName="")=0;
//! Sample freigeben
virtual void FreeSample(int iSampleID)=0;
//! Wiedergabe eines Samples in einer Spur platzieren (auf Basis des Samplecount)
/**
* - iSamplecount = 0 -> Sofort abspielen!
* - iSamplecount < 0 -> -iSamplecount Samples nach Beginn des nchsten Blocks abspielen
* - bSetPaused = true -> Hinzugefgtes Sample direkt pausiert setzen.
*/
virtual int AddPlaybackBySamplecount(int iSampleID, int iTrackID, int iSamplecount, bool bSetPaused=false, double dGain=1.0)=0;
//! Wiedergabe eines Samples in einer Spur platzieren (auf Basis des Timecode)
/**
* - dTimecode = 0 -> Sofort abspielen!
* - bSetPaused = true -> Hinzugefgtes Sample direkt pausiert setzen.
*/
virtual int AddPlaybackByTimecode(int iSampleID, int iTrackID, double dTimecode, bool bSetPaused=false, double dGain=1.0)=0;
//! Wiedergabe eines Samples entfernen
/**
* Entfernt die Platzierung eines Samples.
* Diese Methode wirft niemals eine Ausnahme (ITAException, u.A.).
* Die Methode arbeitet wiefolgt:
*
* - Playback mit angegebener ID existiert -> Playback wird gelscht. Danach ist die ID ungltig.
* - Angegebene ID existiert nicht (mehr) -> Verlassen der Funktion ohne Fehler.
*/
virtual void RemovePlayback(int iPlaybackID)=0;
//! Alle Wiedergaben in einer Spur entfernen
/**
* Entfernt alle Wiedergaben innerhalb einer Spur des Samplers.
* Diese Methode wirft eine Ausnahme wenn die Track-ID ungltig ist
*/
virtual void RemovePlaybacksOfTrack(int iTrackID)=0;
//! Alle Wiedergaben aller Spuren entfernen
virtual void RemoveAllPlaybacks()=0;
//! Gibt zurck ob die Wiedergabe eines Samples pausiert wird
/**
* \return true Falls das Playback existiert und pausiert ist
* false Sonst (einschlielich dem Fall das die ID ungltig ist)
*/
virtual bool IsPlaybackPaused(int iPlaybackID)=0;
//! Wiedergabe eines Playbacks pausieren bzw. Fortsetzen
/**
* Kombinierte Methode zum Pausieren bzw. Fortsetzen einer Wiedergabe.
* Funktionsweise siehe PausePlayback und ResumePlayback.
*
* \param bPaused true -> Wiedergabe pausieren,
* false -> Wiedergabe fortsetzen
*/
virtual void SetPlaybackPaused(int iPlaybackID, bool bPaused)=0;
//! Wiedergabe eines Samples pausieren
/**
* Unterbricht die Wiedergabe eines Samples. Der Wiedergabezeitpunkt eines
* jeden Samples bleibt stets unberhrt. Die Methode arbeitet wiefolgt:
*
* - Die Wiedergabe wird ausgesetzt, solange bis die Pause aufgehoben wird.
* - Wird die Pause aufgehoben, so wird das Sample abgespielt auch wenn
* der tatschliche Wiedergabezeitpunkt bzw. der Zeitpunkt des Endes
* der Wiedergabe hinter dem ursprnglichen Zeitpunkt (ohne Pause) liegt.
*
* Beispiel 1)
*
* - Planung: Spiele Sample bei t=5s
* - Pause bei t=2s
* - Aufhebung der Pause bei t=10s -> Wiedergabe beginnt bei t=10s
*
* Beispiel 2)
*
* - Planung: Spiele Sample bei t=5s
* - Pause bei t=2s
* - Aufhebung der Pause bei t=3s
* -> Wiedergabe des Samples beginnt wie geplant bei t=5s
*
*/
virtual void PausePlayback(int iPlaybackID)=0;
//! Wiedergabe eines pausierten Playbacks wieder aufnehmen
virtual void ResumePlayback(int iPlaybackID)=0;
//! Ereignis platzieren
virtual int AddEvent(double dTimecode, ITASoundSamplerEventHandler* pHandler, int iTag, void* pParam)=0;
//! Ereignis entfernen
virtual void RemoveEvent(int iPlaybackID)=0;
//! Informationen auf der Console ausgeben
virtual void Print()=0;
};
#endif // INCLUDE_WATCHER_ITA_SOUND_SAMPLER
#include "Sample.h"
#include <ITAAudiofileReader.h>
#include <ITAException.h>
#include <ITAFunctors.h>
#include <algorithm>
Sample::Sample(const std::string& sFilename, int iMaxNumberOfChannels, double dRequiredSamplerate) : m_sFilename(sFilename), m_iLength(0) {
ITAAudiofileReader* pReader = ITAAudiofileReader::create(sFilename);
if (pReader->getDomain() != ITA_TIME_DOMAIN) {
delete pReader;
ITA_EXCEPT1(INVALID_PARAMETER, "Audiofile is not in time domain");
}
if (pReader->getNumberOfChannels() > (unsigned) iMaxNumberOfChannels) {
delete pReader;
ITA_EXCEPT1(INVALID_PARAMETER, "Audiofile has too much channels");
}
if (pReader->getSamplerate() != dRequiredSamplerate) {
delete pReader;
ITA_EXCEPT1(INVALID_PARAMETER, "Audiofile has invalid sampling rate");
}
m_iLength = (signed) pReader->getLength();
m_vpData = pReader->read(pReader->getLength());
delete pReader;
}
Sample::~Sample() {
std::for_each(m_vpData.begin(), m_vpData.end(), arrayDeleteFunctor<float>);
}
std::string Sample::GetFilename() {
return m_sFilename;
}
int Sample::GetNumberOfChannels() {
return (int) m_vpData.size();
}
int Sample::GetLength() {
return m_iLength;
}
float* Sample::GetChannelData(int iChannel) {
return m_vpData[iChannel];
}
/*
* +------------------+
* --->| ITA Sampler |--->
* --->| o o o o /// |--->
* +------------------+
*
* ITASampler ist eine C++ Bibliothek die einen Sound sampler zur wavetable-basierten
* Klangsynthese bereitstellt. Der Begriff "sampler" bezieht sich hier auf den Terminus
* aus der Musikproduktion und nicht auf Abtastwerte.
*
* Datei: ITASoundSamplerImpl.cpp
* Zweck: Implementierungsklasse des sound samplers
* Autoren: Frank Wefers (Frank.Wefers@akustik.rwth-aachen.de)
* CVS-Datum: $Id: ITASoundSampleImpl.cpp,v 1.1 2008-12-10 14:15:03 fwefers Exp $
*
* (c) Copyright Institut fr Technische Akustik (ITA) RWTH Aachen, 2008
*/
#include "ITASoundSampleImpl.h"
#include <ITAAudiofileReader.h>
#include <ITAException.h>
#include <ITAFunctors.h>
#include <algorithm>
ITASoundSampleImpl::ITASoundSampleImpl(const std::string& sFilename, int iMaxNumberOfChannels, double dRequiredSamplerate, std::string sName)
: m_sName(sName), m_sFilename(sFilename), m_iLength(0), m_iPlaybackRefCount(0), m_bOriginFile(true) {
ITAAudiofileReader* pReader = ITAAudiofileReader::create(sFilename);
if (pReader->getDomain() != ITA_TIME_DOMAIN) {
delete pReader;
ITA_EXCEPT1(INVALID_PARAMETER, "Audiofile is not in time domain");
}
if (pReader->getNumberOfChannels() > (unsigned) iMaxNumberOfChannels) {
delete pReader;
ITA_EXCEPT1(INVALID_PARAMETER, "Audiofile has too much channels");
}
if (pReader->getSamplerate() != dRequiredSamplerate) {
delete pReader;
ITA_EXCEPT1(INVALID_PARAMETER, "Audiofile has invalid sampling rate");
}
m_iLength = (signed) pReader->getLength();
m_vpData = pReader->read(pReader->getLength());
delete pReader;
}
ITASoundSampleImpl::ITASoundSampleImpl(const float** ppfChannelData, int iNumberOfChannels, int iLength, std::string sName)
: m_sName(sName), m_iLength(iLength), m_iPlaybackRefCount(0), m_bOriginFile(false) {
// Kopie der Daten erzeugen
m_vpData.resize(iNumberOfChannels, NULL);
for (int i=0; i<iNumberOfChannels; i++) {
m_vpData[i] = new float[iLength];
memcpy(m_vpData[i], ppfChannelData[i], iLength*sizeof(float));
}
}
ITASoundSampleImpl::~ITASoundSampleImpl() {
std::for_each(m_vpData.begin(), m_vpData.end(), arrayDeleteFunctor<float>);
}
bool ITASoundSampleImpl::OriginFile() const {
return m_bOriginFile;
}
std::string ITASoundSampleImpl::GetName() const {
return m_sName;
}
void ITASoundSampleImpl::SetName(const std::string& sName) {
m_sName = sName;
}
std::string ITASoundSampleImpl::GetFilename() const {
return m_sFilename;
}
int ITASoundSampleImpl::GetNumberOfChannels() const {
return (int) m_vpData.size();
}