Initial checkin

CMakeLists.txt

+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" )

include/ITASampleClock.h

+/*
+* ----------------------------------------------------------------
+*
+*		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

include/ITASamplerDefinition.h

+/*
+* ----------------------------------------------------------------
+*
+*		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

include/ITASoundSample.h

+/*
+* ----------------------------------------------------------------
+*
+*		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

include/ITASoundSamplePool.h

+/*
+* ----------------------------------------------------------------
+*
+*		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

include/ITASoundSampler.h

+/*
+* ----------------------------------------------------------------
+*
+*		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

src/ITASample.cpp

+#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];
+}

src/ITASoundSampleImpl.cpp

+/*
+ *      +------------------+
+ *  --->| 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();
+}