From 8badcacf087ff8b95008bf016673d38a3b4b842f Mon Sep 17 00:00:00 2001
From: Jonas Stienen <jst@akustik.rwth-aachen.de>
Date: Thu, 5 Jan 2017 21:43:22 +0100
Subject: [PATCH] Moving ITAHDFTSpectra and some useful methods for sampleframe
 and -buffer.

---
 CMakeLists.txt            |   2 +
 include/ITAHDFTSpectra.h  | 106 +++++++++
 include/ITASampleBuffer.h |   3 +
 include/ITASampleFrame.h  |  12 +-
 src/ITAHDFTSpectra.cpp    | 179 ++++++++++++++++
 src/ITASampleBuffer.cpp   |   8 +-
 src/ITASampleFrame.cpp    | 440 ++++++++++++++++++++++----------------
 7 files changed, 564 insertions(+), 186 deletions(-)
 create mode 100644 include/ITAHDFTSpectra.h
 create mode 100644 src/ITAHDFTSpectra.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index a635e75..45bc33a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -69,6 +69,7 @@ set( ITABaseHeader
 	"include/ITAFade.h"
 	"include/ITAFastMath.h"
 	"include/ITAFileSystemUtils.h"
+	"include/ITAHDFTSpectra.h"
 	"include/ITAHDFTSpectrum.h"
 	"include/ITAFunctors.h"
 	"include/ITALog.h"
@@ -99,6 +100,7 @@ set( ITABaseSources
 	"src/ITAException.cpp"
 	"src/ITAFade.cpp"
 	"src/ITAFileSystemUtils.cpp"
+	"src/ITAHDFTSpectra.cpp"
 	"src/ITAHDFTSpectrum.cpp"
 	"src/ITALog.cpp"
 	"src/ITANumericUtils.cpp"
diff --git a/include/ITAHDFTSpectra.h b/include/ITAHDFTSpectra.h
new file mode 100644
index 0000000..4e2d2c5
--- /dev/null
+++ b/include/ITAHDFTSpectra.h
@@ -0,0 +1,106 @@
+/*
+ * ----------------------------------------------------------------
+ *
+ *		ITA core libs
+ *		(c) Copyright Institute of Technical Acoustics (ITA)
+ *		RWTH Aachen University, Germany, 2015-2017
+ *
+ * ----------------------------------------------------------------
+ *				    ____  __________  _______
+ *				   //  / //__   ___/ //  _   |
+ *				  //  /    //  /    //  /_|  |
+ *				 //  /    //  /    //  ___   |
+ *				//__/    //__/    //__/   |__|
+ *
+ * ----------------------------------------------------------------
+ *
+ */
+
+#ifndef INCLUDE_WATCHER_ITA_HDFT_SPECTRA
+#define INCLUDE_WATCHER_ITA_HDFT_SPECTRA
+
+// ITA includes
+#include <ITABaseDefinitions.h>
+#include <ITAException.h>
+
+// STL includes
+#include <vector>
+
+class ITAHDFTSpectrum;
+
+//! Multi-channel half-sided discrete fourier spectra
+/**
+  *
+  * This class describes DFT spectrum data with variable number channels
+  * and provides functionality for manipulation and math operations.
+  *
+  * This class extends the \ITAHDFTSpectrum for multi-channel applications.
+  *
+  */
+class ITA_BASE_API ITAHDFTSpectra
+{
+public:
+
+	//! Constructor that initializes the
+	ITAHDFTSpectra( const double dSampleRate, const int iNumChannels, const int iDFTSize, const bool bZeroInit=true );
+
+	//! Constructor that uses a non-empty HDFTSpectrum vector
+	ITAHDFTSpectra( const std::vector< ITAHDFTSpectrum* >& vpSpectrumVec );
+
+	//! Standard destructor
+	~ITAHDFTSpectra();
+
+	//! Return number of channels
+	/**
+	  * \return Number of spectra / dimension of filter
+	  */
+	int GetNumChannels() const;
+
+	//! Return DFT size
+	/**
+	  * \return Number of coeffs + 1 for DC value
+	  */
+	int GetDFTSize() const;
+
+	//! Return sampling rate
+	double GetSampleRate() const;
+
+	//! Adds the given spectra channel-wise
+	void add( const ITAHDFTSpectra* );
+
+	//! Subtracts the given spectra channel-wise
+	void sub( const ITAHDFTSpectra* );
+
+	//! Multiplies the given spectra channel-wise
+	void mul( const ITAHDFTSpectra* );
+
+	//! Multiplies the conjugate of the given spectra without data copy channel-wise
+	void mul_conj( const ITAHDFTSpectra* );
+
+	//! Multiplies a scalar
+	void mul_scalar( double );
+
+	//! Divides the given spectra channel-wise
+	void div( const ITAHDFTSpectra* );
+
+	//! Set unity (all coefficiants real one)
+	void SetUnity();
+
+	//! Set unity (all coefficiants real one)
+	void SetZero();
+
+	//! Copy from another Spectra
+	void CopyFrom(const ITAHDFTSpectra* otherSpectra);
+
+	//! Subscript operator gives direct access to spectrum channel
+	const ITAHDFTSpectrum* operator[]( const int ) const;
+	ITAHDFTSpectrum* operator[]( const int );
+
+private:
+	//! Standard constructor
+	ITAHDFTSpectra();
+
+	std::vector< ITAHDFTSpectrum* > m_vpSpectra; //! DFT spectra
+};
+
+#endif // INCLUDE_WATCHER_ITA_HDFT_SPECTRA
diff --git a/include/ITASampleBuffer.h b/include/ITASampleBuffer.h
index a488a37..a671660 100644
--- a/include/ITASampleBuffer.h
+++ b/include/ITASampleBuffer.h
@@ -301,6 +301,9 @@ public:
 	//! Negieren (Multiplikation mit -1 bzw. Phasendrehungum 180�)
 	void Negate();
 
+	//! Normalize data
+	void Normalize();
+
 	//! Read/Write Indizierungsoperator
 	float& operator[]( int iSample );
 
diff --git a/include/ITASampleFrame.h b/include/ITASampleFrame.h
index 1e6ff58..22c90ff 100644
--- a/include/ITASampleFrame.h
+++ b/include/ITASampleFrame.h
@@ -114,7 +114,11 @@ public:
      * \param iLength	L�nge [Anzahl Samples]
 	 * \param bZeroinit	Samples mit Nullen initialisieren?
 	 */
-	void init( int iChannels, int iLength, bool bZeroinit);
+	void Init( int iChannels, int iLength, bool bZeroinit );
+	inline void init( int iChannels, int iLength, bool bZeroinit )
+	{
+		return Init( iChannels, iLength, bZeroinit );
+	}
 
 	void Load( const std::string& sFilePath );
 	void Load( const std::string& sFilePath, double& dSampleRate );
@@ -294,7 +298,11 @@ public:
 	 *
 	 * \return Overall peak value that has been used for normalization (can be negative)
 	 */
-	float normalize();
+	float Normalize();
+	inline float normalize()
+	{
+		return Normalize();
+	};
 
 	//! Read/Write Indizierungsoperator f�r Zugriff auf Kanaldaten
 	ITASampleBuffer& operator[](int iChannel);
diff --git a/src/ITAHDFTSpectra.cpp b/src/ITAHDFTSpectra.cpp
new file mode 100644
index 0000000..4cd7826
--- /dev/null
+++ b/src/ITAHDFTSpectra.cpp
@@ -0,0 +1,179 @@
+#include <ITAHDFTSpectra.h>
+
+#include <ITAAudiofileWriter.h>
+#include <ITAFilesystemUtils.h>
+#include <ITAHDFTSpectrum.h>
+#include <ITASampleFrame.h>
+#include <ITAStringUtils.h>
+
+ITAHDFTSpectra::ITAHDFTSpectra( const double dSampleRate, const int iNumChannels, const int iDFTSize, const bool bZeroInit/*=true*/ )
+{
+	if( iNumChannels < 1 )
+		ITA_EXCEPT1( INVALID_PARAMETER, "At least one DFT channel must be used" );
+	if( iDFTSize < 1 )
+		ITA_EXCEPT1( INVALID_PARAMETER, "Invalid DFT size" );
+
+	for( int i=0; i<iNumChannels; i++ )
+		m_vpSpectra.push_back( new ITAHDFTSpectrum( dSampleRate, iDFTSize, bZeroInit ) );
+}
+
+ITAHDFTSpectra::ITAHDFTSpectra( const std::vector< ITAHDFTSpectrum* >& vpSpectrumVec )
+{
+	if( vpSpectrumVec.size() == 0 )
+		ITA_EXCEPT1( INVALID_PARAMETER, "At least one DFT channel must be used" );
+
+	for( size_t i=0; i<vpSpectrumVec.size(); i++ )
+	{
+		const ITAHDFTSpectrum* pSpectrum( vpSpectrumVec[i] );
+		if( pSpectrum->getDFTSize() <= 0 )
+			ITA_EXCEPT1( INVALID_PARAMETER, "Invalid DFT size in spectrum number " + IntToString( int(i) ) );
+
+		if( pSpectrum->getSamplerate() <= 0 )
+			ITA_EXCEPT1( INVALID_PARAMETER, "Invalid sampling rate in spectrum number " + IntToString( int(i) ) );
+
+		m_vpSpectra.push_back( new ITAHDFTSpectrum( pSpectrum ) ); // copy
+	}
+}
+
+ITAHDFTSpectra::~ITAHDFTSpectra()
+{
+	for( size_t i=0; i<m_vpSpectra.size(); i++ )
+		delete m_vpSpectra[i];
+}
+
+void ITAHDFTSpectra::CopyFrom(const ITAHDFTSpectra *otherSpectra)
+{
+	int iNumChannels=otherSpectra->GetNumChannels();
+	
+	m_vpSpectra.clear();
+	
+	for( int i=0; i<iNumChannels; i++ )
+	{
+        //ITAHDFTSpectrum* tempSpectrum = new ITAHDFTSpectrum(double(otherSpectra->GetSampleRate()),int(otherSpectra->GetDFTSize()));
+        ITAHDFTSpectrum* tempSpectrum = new ITAHDFTSpectrum((*otherSpectra)[i]);
+        //tempSpectrum->copyFrom((*otherSpectra)[i]);
+		m_vpSpectra.push_back(tempSpectrum);
+	}
+}
+
+void ITAHDFTSpectra::SetUnity()
+{
+	for( size_t i=0; i<m_vpSpectra.size(); i++ )
+	{
+		ITAHDFTSpectrum* pSpectrum( m_vpSpectra[i] );
+		pSpectrum->SetUnity();
+	}
+}
+
+void ITAHDFTSpectra::SetZero()
+{
+	for( size_t i=0; i<m_vpSpectra.size(); i++ )
+	{
+		ITAHDFTSpectrum* pSpectrum( m_vpSpectra[i] );
+		pSpectrum->mul( 0.0f );
+	}
+}
+
+int ITAHDFTSpectra::GetNumChannels() const
+{
+	return int( m_vpSpectra.size() );
+}
+
+int ITAHDFTSpectra::GetDFTSize() const
+{
+	return m_vpSpectra[0]->getDFTSize();
+}
+
+double ITAHDFTSpectra::GetSampleRate() const
+{
+	return m_vpSpectra[0]->getSamplerate();
+}
+
+void ITAHDFTSpectra::add( const ITAHDFTSpectra* pSource )
+{
+	if( GetNumChannels() != pSource->GetNumChannels() )
+		ITA_EXCEPT1( INVALID_PARAMETER, "Channel number mismatch" );
+
+	for( int i=0; i<GetNumChannels(); i++ )
+	{
+		ITAHDFTSpectrum* pSpectrum( m_vpSpectra[i] );
+		const ITAHDFTSpectrum* pSourceSpectrum( (*pSource)[i] );
+		pSpectrum->add( pSourceSpectrum );
+	}
+
+	return;
+}
+
+void ITAHDFTSpectra::sub( const ITAHDFTSpectra* pSource )
+{
+	if( GetNumChannels() != pSource->GetNumChannels() )
+		ITA_EXCEPT1( INVALID_PARAMETER, "Channel number mismatch" );
+
+	for( int i=0; i<GetNumChannels(); i++ )
+	{
+		ITAHDFTSpectrum* pSpectrum( m_vpSpectra[i] );
+		const ITAHDFTSpectrum* pSourceSpectrum( (*pSource)[i] );
+		pSpectrum->sub( pSourceSpectrum );
+	}
+
+	return;
+}
+
+void ITAHDFTSpectra::mul( const ITAHDFTSpectra* pSource )
+{
+	if( GetNumChannels() != pSource->GetNumChannels() )
+		ITA_EXCEPT1( INVALID_PARAMETER, "Channel number mismatch" );
+
+	for( int i=0; i<GetNumChannels(); i++ )
+	{
+		ITAHDFTSpectrum* pSpectrum( m_vpSpectra[i] );
+		const ITAHDFTSpectrum* pSourceSpectrum( (*pSource)[i] );
+		pSpectrum->mul( pSourceSpectrum );
+	}
+
+	return;
+}
+
+void ITAHDFTSpectra::mul_conj( const ITAHDFTSpectra* pSource )
+{
+	if( GetNumChannels() != pSource->GetNumChannels() )
+		ITA_EXCEPT1( INVALID_PARAMETER, "Channel number mismatch" );
+
+	for( int i=0; i<GetNumChannels(); i++ )
+	{
+		ITAHDFTSpectrum* pSpectrum( m_vpSpectra[i] );
+		const ITAHDFTSpectrum* pSourceSpectrum( (*pSource)[i] );
+		pSpectrum->mul( pSourceSpectrum );
+	}
+
+	return;
+}
+
+void ITAHDFTSpectra::mul_scalar( double )
+{
+	ITA_EXCEPT0( NOT_IMPLEMENTED );
+}
+
+void ITAHDFTSpectra::div( const ITAHDFTSpectra* pSource )
+{
+	if( GetNumChannels() != pSource->GetNumChannels() )
+		ITA_EXCEPT1( INVALID_PARAMETER, "Channel number mismatch" );
+
+	for( int i=0; i<GetNumChannels(); i++ )
+	{
+		ITAHDFTSpectrum* pSpectrum( m_vpSpectra[i] );
+		const ITAHDFTSpectrum* pSourceSpectrum( (*pSource)[i] );
+		pSpectrum->div( pSourceSpectrum );
+	}
+
+	return;
+}
+
+const ITAHDFTSpectrum* ITAHDFTSpectra::operator[]( const int iIdx ) const
+{
+	return m_vpSpectra[iIdx];
+}
+ITAHDFTSpectrum* ITAHDFTSpectra::operator[]( const int iIdx )
+{
+	return m_vpSpectra[iIdx];
+}
diff --git a/src/ITASampleBuffer.cpp b/src/ITASampleBuffer.cpp
index 6898887..1610a0c 100644
--- a/src/ITASampleBuffer.cpp
+++ b/src/ITASampleBuffer.cpp
@@ -562,7 +562,13 @@ float ITASampleBuffer::FindPeak( int* piPeakIndex )
 
 void ITASampleBuffer::Negate()
 {
-	mul_scalar( -1 );
+	mul_scalar( -1.0f );
+}
+
+
+void ITASampleBuffer::Normalize()
+{
+	mul_scalar( FindPeak() );
 }
 
 float& ITASampleBuffer::operator[]( int iSample )
diff --git a/src/ITASampleFrame.cpp b/src/ITASampleFrame.cpp
index 78532d3..17ee134 100644
--- a/src/ITASampleFrame.cpp
+++ b/src/ITASampleFrame.cpp
@@ -8,23 +8,26 @@
 #include <ITAException.h>
 
 ITASampleFrame::ITASampleFrame()
-: m_iChannels(0), m_iLength(0) {}
+	: m_iChannels( 0 ), m_iLength( 0 ) {}
 
-ITASampleFrame::ITASampleFrame(int iChannels, int iLength, bool bZeroinit)
-: m_iChannels(0), m_iLength(0)
+ITASampleFrame::ITASampleFrame( int iChannels, int iLength, bool bZeroinit )
+	: m_iChannels( 0 )
+	, m_iLength( 0 )
 {
-	init( iChannels, iLength, bZeroinit);
+	Init( iChannels, iLength, bZeroinit );
 }
 
 
-ITASampleFrame::ITASampleFrame(const ITASampleFrame* pSource)
-: m_iChannels(0), m_iLength(0)
+ITASampleFrame::ITASampleFrame( const ITASampleFrame* pSource )
+	: m_iChannels( 0 )
+	, m_iLength( 0 )
 {
 	*this = *pSource;
 }
 
-ITASampleFrame::ITASampleFrame(const ITASampleFrame& sbSource)
-: m_iChannels(0), m_iLength(0)
+ITASampleFrame::ITASampleFrame( const ITASampleFrame& sbSource )
+	: m_iChannels( 0 )
+	, m_iLength( 0 )
 {
 	*this = sbSource;
 }
@@ -38,32 +41,36 @@ ITASampleFrame::~ITASampleFrame()
 {
 }
 
-bool ITASampleFrame::empty() const {
-	return ((m_iChannels == 0) || (m_iLength == 0));
+bool ITASampleFrame::empty() const
+{
+	return ( ( m_iChannels == 0 ) || ( m_iLength == 0 ) );
 }
 
-int ITASampleFrame::channels() const {
+int ITASampleFrame::channels() const
+{
 	return m_iChannels;
 }
 
-int ITASampleFrame::length() const {
+int ITASampleFrame::length() const
+{
 	return m_iLength;
 }
 
-void ITASampleFrame::init( int iChannels, int iLength, bool bZeroinit)
+void ITASampleFrame::Init( int iChannels, int iLength, bool bZeroinit )
 {
 	assert( iChannels >= 0 );
 	assert( iLength >= 0 );
 
 	// TODO: Mit ein wenig cleverness k�nnte dies ohne Vollst�ndiges Abr�umen gehen.
 	//       Die Frage ist: Wer's braucht?
-	if ((m_iChannels > 0) || (m_iLength > 0)) free();
+	if( ( m_iChannels > 0 ) || ( m_iLength > 0 ) ) free();
 
-	m_vChannels.resize(iChannels);
-	for (int i=0; i<iChannels; i++) {
-		m_vChannels[i].m_pParent = NULL;
-		m_vChannels[i].Init( iLength, bZeroinit);
-		m_vChannels[i].m_pParent = this;
+	m_vChannels.resize( iChannels );
+	for( int i = 0; i < iChannels; i++ )
+	{
+		m_vChannels[ i ].m_pParent = NULL;
+		m_vChannels[ i ].Init( iLength, bZeroinit );
+		m_vChannels[ i ].m_pParent = this;
 	}
 
 	m_iChannels = iChannels;
@@ -121,10 +128,10 @@ void ITASampleFrame::Store( const std::string& sFilePath, double dSamplingRate )
 		oProps.dSampleRate = dSamplingRate;
 		oProps.eDomain = ITADomain::ITA_TIME_DOMAIN;
 		oProps.eQuantization = ITAQuantization::ITA_FLOAT;
-		oProps.iChannels = (unsigned int) m_iChannels;
-		oProps.iLength = (unsigned int) m_iLength;
+		oProps.iChannels = ( unsigned int ) m_iChannels;
+		oProps.iLength = ( unsigned int ) m_iLength;
 		pWriter = ITAAudiofileWriter::create( sFilePath, oProps );
-	
+
 		std::vector< const float* > vpfDest( oProps.iChannels );
 		for( int i = 0; i < oProps.iChannels; i++ )
 			vpfDest[ i ] = m_vChannels[ i ].data();
@@ -132,7 +139,7 @@ void ITASampleFrame::Store( const std::string& sFilePath, double dSamplingRate )
 		pWriter->write( oProps.iLength, vpfDest );
 
 	}
-	catch (...)
+	catch( ... )
 	{
 		delete pWriter;
 		throw;
@@ -154,212 +161,264 @@ void ITASampleFrame::free()
 
 void ITASampleFrame::fill( float fValue )
 {
-	for (ch_it it=m_vChannels.begin(); it!=m_vChannels.end(); ++it)
-		it->Fill(fValue);
+	for( ch_it it = m_vChannels.begin(); it != m_vChannels.end(); ++it )
+		it->Fill( fValue );
 }
 
-void ITASampleFrame::fill(int iOffset, int iCount, float fValue) {
-	for (ch_it it=m_vChannels.begin(); it!=m_vChannels.end(); ++it)
-		it->Fill(iOffset, iCount, fValue);	
+void ITASampleFrame::fill( int iOffset, int iCount, float fValue )
+{
+	for( ch_it it = m_vChannels.begin(); it != m_vChannels.end(); ++it )
+		it->Fill( iOffset, iCount, fValue );
 }
 
 void ITASampleFrame::zero() {
-	fill(0);
+	fill( 0 );
 }
 
-void ITASampleFrame::zero(int iOffset, int iCount )
+void ITASampleFrame::zero( int iOffset, int iCount )
 {
-	fill(iOffset, iCount, 0.0f);
+	fill( iOffset, iCount, 0.0f );
 }
 
 void ITASampleFrame::identity() {
-	for (ch_it it=m_vChannels.begin(); it!=m_vChannels.end(); ++it)
-		it->Identity();	
+	for( ch_it it = m_vChannels.begin(); it != m_vChannels.end(); ++it )
+		it->Identity();
 }
 
-void ITASampleFrame::fade(int iOffset, int iCount, int iFadeDirection, int iFadeFunction) {
-	for (int i=0; i<m_iChannels; i++)
-		m_vChannels[i].Fade( iOffset, iCount, iFadeDirection, iFadeFunction );
+void ITASampleFrame::fade( int iOffset, int iCount, int iFadeDirection, int iFadeFunction )
+{
+	for( int i = 0; i < m_iChannels; i++ )
+		m_vChannels[ i ].Fade( iOffset, iCount, iFadeDirection, iFadeFunction );
 }
 
-void ITASampleFrame::crossfade(const ITASampleFrame* psfSrc, int iOffset, int iCount, int iFadeDirection, int iFadeFunction) {
-	if (!psfSrc) ITA_EXCEPT1(INVALID_PARAMETER, "Nullpointer passed");
-	if (psfSrc->channels() != m_iChannels)  ITA_EXCEPT1(INVALID_PARAMETER, "Number of channels do not match");
+void ITASampleFrame::crossfade( const ITASampleFrame* psfSrc, int iOffset, int iCount, int iFadeDirection, int iFadeFunction )
+{
+	if( !psfSrc ) ITA_EXCEPT1( INVALID_PARAMETER, "Nullpointer passed" );
+	if( psfSrc->channels() != m_iChannels )  ITA_EXCEPT1( INVALID_PARAMETER, "Number of channels do not match" );
 
-	for (int i=0; i<m_iChannels; i++)
-		m_vChannels[i].Crossfade( (*psfSrc)[i], iOffset, iCount, iFadeDirection, iFadeFunction );
+	for( int i = 0; i < m_iChannels; i++ )
+		m_vChannels[ i ].Crossfade( ( *psfSrc )[ i ], iOffset, iCount, iFadeDirection, iFadeFunction );
 }
 
-void ITASampleFrame::crossfade(const ITASampleFrame& sfSrc, int iOffset, int iCount, int iFadeDirection, int iFadeFunction) {
+void ITASampleFrame::crossfade( const ITASampleFrame& sfSrc, int iOffset, int iCount, int iFadeDirection, int iFadeFunction )
+{
 	crossfade( &sfSrc, iOffset, iCount, iFadeDirection, iFadeFunction );
 }
 
-void ITASampleFrame::envelope(float fGain0, float fGain1) {
-	if (empty()) return;
+void ITASampleFrame::envelope( float fGain0, float fGain1 ) {
+	if( empty() ) return;
 
-	for (int i=0; i<m_iChannels; i++)
-		m_vChannels[i].Envelope( fGain0, fGain1 );
+	for( int i = 0; i < m_iChannels; i++ )
+		m_vChannels[ i ].Envelope( fGain0, fGain1 );
 }
 
-void ITASampleFrame::write(const ITASampleFrame* psfSrc, int iCount, int iSrcOffset, int iDestOffset) {
-	if (!psfSrc) ITA_EXCEPT1(INVALID_PARAMETER, "Nullpointer passed");
-	if (psfSrc->channels() != m_iChannels)  ITA_EXCEPT1(INVALID_PARAMETER, "Number of channels do not match");
+void ITASampleFrame::write( const ITASampleFrame* psfSrc, int iCount, int iSrcOffset, int iDestOffset )
+{
+	if( !psfSrc ) ITA_EXCEPT1( INVALID_PARAMETER, "Nullpointer passed" );
+	if( psfSrc->channels() != m_iChannels )  ITA_EXCEPT1( INVALID_PARAMETER, "Number of channels do not match" );
 
-	for (int i=0; i<m_iChannels; i++)
-		m_vChannels[i].write( (*psfSrc)[i], iCount, iSrcOffset, iDestOffset );
+	for( int i = 0; i < m_iChannels; i++ )
+		m_vChannels[ i ].write( ( *psfSrc )[ i ], iCount, iSrcOffset, iDestOffset );
 }
 
-void ITASampleFrame::write(const ITASampleFrame& sfSrc, int iCount, int iSrcOffset, int iDestOffset) {
-	write(&sfSrc, iCount, iSrcOffset, iDestOffset);
+void ITASampleFrame::write( const ITASampleFrame& sfSrc, int iCount, int iSrcOffset, int iDestOffset )
+{
+	write( &sfSrc, iCount, iSrcOffset, iDestOffset );
 }
 
-void ITASampleFrame::cyclic_write(const ITASampleFrame* psfSrc, int iCount, int iSrcOffset, int iDestOffset) {
-	if (!psfSrc) ITA_EXCEPT1(INVALID_PARAMETER, "Nullpointer passed");
-	if (psfSrc->channels() != m_iChannels)  ITA_EXCEPT1(INVALID_PARAMETER, "Number of channels do not match");
+void ITASampleFrame::cyclic_write( const ITASampleFrame* psfSrc, int iCount, int iSrcOffset, int iDestOffset )
+{
+	if( !psfSrc ) ITA_EXCEPT1( INVALID_PARAMETER, "Nullpointer passed" );
+	if( psfSrc->channels() != m_iChannels )  ITA_EXCEPT1( INVALID_PARAMETER, "Number of channels do not match" );
 
-	for (int i=0; i<m_iChannels; i++)
-		m_vChannels[i].cyclic_write( &((*psfSrc)[i]), iCount, iSrcOffset, iDestOffset );
+	for( int i = 0; i < m_iChannels; i++ )
+		m_vChannels[ i ].cyclic_write( &( ( *psfSrc )[ i ] ), iCount, iSrcOffset, iDestOffset );
 }
 
-void ITASampleFrame::cyclic_write(const ITASampleFrame& sfSrc, int iCount, int iSrcOffset, int iDestOffset) {
-	cyclic_write(&sfSrc, iCount, iSrcOffset, iDestOffset);
+void ITASampleFrame::cyclic_write( const ITASampleFrame& sfSrc, int iCount, int iSrcOffset, int iDestOffset )
+{
+	cyclic_write( &sfSrc, iCount, iSrcOffset, iDestOffset );
 }
 
-void ITASampleFrame::CyclicShift( int iCount)
+void ITASampleFrame::CyclicShift( int iCount )
 {
-	for (int i = 0; i < m_iChannels; i++)
-		m_vChannels[i].CyclicShift(iCount);
+	for( int i = 0; i < m_iChannels; i++ )
+		m_vChannels[ i ].CyclicShift( iCount );
 }
 
-void ITASampleFrame::add_scalar(float fValue) {
-	for (ch_it it=m_vChannels.begin(); it!=m_vChannels.end(); ++it)
-		it->add_scalar(fValue);
+void ITASampleFrame::add_scalar( float fValue )
+{
+	for( ch_it it = m_vChannels.begin(); it != m_vChannels.end(); ++it )
+		it->add_scalar( fValue );
 }
 
-void ITASampleFrame::sub_scalar(float fValue) {
-	for (ch_it it=m_vChannels.begin(); it!=m_vChannels.end(); ++it)
-		it->sub_scalar(fValue);
+void ITASampleFrame::sub_scalar( float fValue )
+{
+	for( ch_it it = m_vChannels.begin(); it != m_vChannels.end(); ++it )
+		it->sub_scalar( fValue );
 }
 
-void ITASampleFrame::mul_scalar(float fValue) {
-	for (ch_it it=m_vChannels.begin(); it!=m_vChannels.end(); ++it)
-		it->mul_scalar(fValue);
+void ITASampleFrame::mul_scalar( float fValue )
+{
+	for( ch_it it = m_vChannels.begin(); it != m_vChannels.end(); ++it )
+		it->mul_scalar( fValue );
 }
 
-void ITASampleFrame::div_scalar(float fValue) {
-	for (ch_it it=m_vChannels.begin(); it!=m_vChannels.end(); ++it)
-		it->div_scalar(fValue);
+void ITASampleFrame::div_scalar( float fValue )
+{
+	for( ch_it it = m_vChannels.begin(); it != m_vChannels.end(); ++it )
+		it->div_scalar( fValue );
+}
+
+void ITASampleFrame::add_buf( const ITASampleBuffer* psbSource )
+{
+	if( !psbSource ) ITA_EXCEPT1( INVALID_PARAMETER, "Nullpointer passed" );
+	if( psbSource->GetLength() != m_iLength )  ITA_EXCEPT1( INVALID_PARAMETER, "Lengths do not match" );
+
+	for( ch_it it = m_vChannels.begin(); it != m_vChannels.end(); ++it )
+		it->add_buf( psbSource );
 }
 
-void ITASampleFrame::add_buf(const ITASampleBuffer* psbSource) {
-	if (!psbSource) ITA_EXCEPT1(INVALID_PARAMETER, "Nullpointer passed");
-	if (psbSource->GetLength() != m_iLength)  ITA_EXCEPT1(INVALID_PARAMETER, "Lengths do not match");
+void ITASampleFrame::sub_buf( const ITASampleBuffer* psbSource )
+{
+	if( !psbSource ) ITA_EXCEPT1( INVALID_PARAMETER, "Nullpointer passed" );
+	if( psbSource->GetLength() != m_iLength )  ITA_EXCEPT1( INVALID_PARAMETER, "Lengths do not match" );
 
-	for (ch_it it=m_vChannels.begin(); it!=m_vChannels.end(); ++it)
-		it->add_buf(psbSource);
+	for( ch_it it = m_vChannels.begin(); it != m_vChannels.end(); ++it )
+		it->sub_buf( psbSource );
 }
 
-void ITASampleFrame::sub_buf(const ITASampleBuffer* psbSource) {
-	if (!psbSource) ITA_EXCEPT1(INVALID_PARAMETER, "Nullpointer passed");
-	if (psbSource->GetLength() != m_iLength)  ITA_EXCEPT1(INVALID_PARAMETER, "Lengths do not match");
+void ITASampleFrame::mul_buf( const ITASampleBuffer* psbSource )
+{
+	if( !psbSource ) ITA_EXCEPT1( INVALID_PARAMETER, "Nullpointer passed" );
+	if( psbSource->GetLength() != m_iLength )  ITA_EXCEPT1( INVALID_PARAMETER, "Lengths do not match" );
 
-	for (ch_it it=m_vChannels.begin(); it!=m_vChannels.end(); ++it)
-		it->sub_buf(psbSource);
+	for( ch_it it = m_vChannels.begin(); it != m_vChannels.end(); ++it )
+		it->sub_buf( psbSource );
 }
 
-void ITASampleFrame::mul_buf(const ITASampleBuffer* psbSource) {
-	if (!psbSource) ITA_EXCEPT1(INVALID_PARAMETER, "Nullpointer passed");
-	if (psbSource->GetLength() != m_iLength)  ITA_EXCEPT1(INVALID_PARAMETER, "Lengths do not match");
+void ITASampleFrame::div_buf( const ITASampleBuffer* psbSource )
+{
+	if( !psbSource ) ITA_EXCEPT1( INVALID_PARAMETER, "Nullpointer passed" );
+	if( psbSource->GetLength() != m_iLength )  ITA_EXCEPT1( INVALID_PARAMETER, "Lengths do not match" );
 
-	for (ch_it it=m_vChannels.begin(); it!=m_vChannels.end(); ++it)
-		it->sub_buf(psbSource);
+	for( ch_it it = m_vChannels.begin(); it != m_vChannels.end(); ++it )
+		it->div_buf( psbSource );
 }
 
-void ITASampleFrame::div_buf(const ITASampleBuffer* psbSource) {
-	if (!psbSource) ITA_EXCEPT1(INVALID_PARAMETER, "Nullpointer passed");
-	if (psbSource->GetLength() != m_iLength)  ITA_EXCEPT1(INVALID_PARAMETER, "Lengths do not match");
+void ITASampleFrame::add_buf( const ITASampleBuffer& sbSource )
+{
+	add_buf( &sbSource );
+}
 
-	for (ch_it it=m_vChannels.begin(); it!=m_vChannels.end(); ++it)
-		it->div_buf(psbSource);
+void ITASampleFrame::sub_buf( const ITASampleBuffer& sbSource )
+{
+	sub_buf( &sbSource );
+}
+
+void ITASampleFrame::mul_buf( const ITASampleBuffer& sbSource )
+{
+	mul_buf( &sbSource );
 }
 
-void ITASampleFrame::add_buf(const ITASampleBuffer& sbSource) { add_buf(&sbSource); }
-void ITASampleFrame::sub_buf(const ITASampleBuffer& sbSource) { sub_buf(&sbSource); }
-void ITASampleFrame::mul_buf(const ITASampleBuffer& sbSource) { mul_buf(&sbSource); }
-void ITASampleFrame::div_buf(const ITASampleBuffer& sbSource) { div_buf(&sbSource); }
+void ITASampleFrame::div_buf( const ITASampleBuffer& sbSource )
+{
+	div_buf( &sbSource );
+}
 
-void ITASampleFrame::add_frame(const ITASampleFrame* psfSource) {
-	if (!psfSource) ITA_EXCEPT1(INVALID_PARAMETER, "Nullpointer passed");
-	if (psfSource->m_iChannels != m_iChannels)  ITA_EXCEPT1(INVALID_PARAMETER, "Number of channels do not match");
-	if (psfSource->m_iLength != m_iLength)  ITA_EXCEPT1(INVALID_PARAMETER, "Lengths do not match");
+void ITASampleFrame::add_frame( const ITASampleFrame* psfSource )
+{
+	if( !psfSource ) ITA_EXCEPT1( INVALID_PARAMETER, "Nullpointer passed" );
+	if( psfSource->m_iChannels != m_iChannels )  ITA_EXCEPT1( INVALID_PARAMETER, "Number of channels do not match" );
+	if( psfSource->m_iLength != m_iLength )  ITA_EXCEPT1( INVALID_PARAMETER, "Lengths do not match" );
 
-	for (int i=0; i<m_iChannels; ++i)
-		m_vChannels[i].add_buf( &(psfSource->m_vChannels[i]) );
+	for( int i = 0; i < m_iChannels; ++i )
+		m_vChannels[ i ].add_buf( &( psfSource->m_vChannels[ i ] ) );
 }
 
-void ITASampleFrame::add_frame(const ITASampleFrame* psfSource, int iPos)
+void ITASampleFrame::add_frame( const ITASampleFrame* psfSource, int iPos )
 {
-	if (!psfSource) ITA_EXCEPT1(INVALID_PARAMETER, "Nullpointer passed");
-	if (psfSource->m_iChannels != m_iChannels)  ITA_EXCEPT1(INVALID_PARAMETER, "Number of channels do not match");
-	if ((psfSource->m_iLength+iPos) >= m_iLength)  ITA_EXCEPT1(INVALID_PARAMETER, "Source length + delay exceed length of filter");
-	
-	for (int i=0; i<m_iChannels; ++i)
-		m_vChannels[i].add_buf_pos(&(psfSource->m_vChannels[i]),iPos);
+	if( !psfSource ) ITA_EXCEPT1( INVALID_PARAMETER, "Nullpointer passed" );
+	if( psfSource->m_iChannels != m_iChannels )  ITA_EXCEPT1( INVALID_PARAMETER, "Number of channels do not match" );
+	if( ( psfSource->m_iLength + iPos ) >= m_iLength )  ITA_EXCEPT1( INVALID_PARAMETER, "Source length + delay exceed length of filter" );
+
+	for( int i = 0; i < m_iChannels; ++i )
+		m_vChannels[ i ].add_buf_pos( &( psfSource->m_vChannels[ i ] ), iPos );
 }
 
 
 
-void ITASampleFrame::sub_frame(const ITASampleFrame* psfSource) {
-	if (!psfSource) ITA_EXCEPT1(INVALID_PARAMETER, "Nullpointer passed");
-	if (psfSource->m_iChannels != m_iChannels)  ITA_EXCEPT1(INVALID_PARAMETER, "Number of channels do not match");
-	if (psfSource->m_iLength != m_iLength)  ITA_EXCEPT1(INVALID_PARAMETER, "Lengths do not match");
+void ITASampleFrame::sub_frame( const ITASampleFrame* psfSource )
+{
+	if( !psfSource ) ITA_EXCEPT1( INVALID_PARAMETER, "Nullpointer passed" );
+	if( psfSource->m_iChannels != m_iChannels )  ITA_EXCEPT1( INVALID_PARAMETER, "Number of channels do not match" );
+	if( psfSource->m_iLength != m_iLength )  ITA_EXCEPT1( INVALID_PARAMETER, "Lengths do not match" );
 
-	for (int i=0; i<m_iChannels; ++i)
-		m_vChannels[i].sub_buf( &(psfSource->m_vChannels[i]) );
+	for( int i = 0; i < m_iChannels; ++i )
+		m_vChannels[ i ].sub_buf( &( psfSource->m_vChannels[ i ] ) );
 }
 
-void ITASampleFrame::mul_frame(const ITASampleFrame* psfSource) {
-	if (!psfSource) ITA_EXCEPT1(INVALID_PARAMETER, "Nullpointer passed");
-	if (psfSource->m_iChannels != m_iChannels)  ITA_EXCEPT1(INVALID_PARAMETER, "Number of channels do not match");
-	if (psfSource->m_iLength != m_iLength)  ITA_EXCEPT1(INVALID_PARAMETER, "Lengths do not match");
+void ITASampleFrame::mul_frame( const ITASampleFrame* psfSource )
+{
+	if( !psfSource ) ITA_EXCEPT1( INVALID_PARAMETER, "Nullpointer passed" );
+	if( psfSource->m_iChannels != m_iChannels )  ITA_EXCEPT1( INVALID_PARAMETER, "Number of channels do not match" );
+	if( psfSource->m_iLength != m_iLength )  ITA_EXCEPT1( INVALID_PARAMETER, "Lengths do not match" );
 
-	for (int i=0; i<m_iChannels; ++i)
-		m_vChannels[i].mul_buf( &(psfSource->m_vChannels[i]) );
+	for( int i = 0; i < m_iChannels; ++i )
+		m_vChannels[ i ].mul_buf( &( psfSource->m_vChannels[ i ] ) );
 }
 
-void ITASampleFrame::div_frame(const ITASampleFrame* psfSource) {
-	if (!psfSource) ITA_EXCEPT1(INVALID_PARAMETER, "Nullpointer passed");
-	if (psfSource->m_iChannels != m_iChannels)  ITA_EXCEPT1(INVALID_PARAMETER, "Number of channels do not match");
-	if (psfSource->m_iLength != m_iLength)  ITA_EXCEPT1(INVALID_PARAMETER, "Lengths do not match");
+void ITASampleFrame::div_frame( const ITASampleFrame* psfSource )
+{
+	if( !psfSource ) ITA_EXCEPT1( INVALID_PARAMETER, "Nullpointer passed" );
+	if( psfSource->m_iChannels != m_iChannels )  ITA_EXCEPT1( INVALID_PARAMETER, "Number of channels do not match" );
+	if( psfSource->m_iLength != m_iLength )  ITA_EXCEPT1( INVALID_PARAMETER, "Lengths do not match" );
 
-	for (int i=0; i<m_iChannels; ++i)
-		m_vChannels[i].div_buf( &(psfSource->m_vChannels[i]) );
+	for( int i = 0; i < m_iChannels; ++i )
+		m_vChannels[ i ].div_buf( &( psfSource->m_vChannels[ i ] ) );
 }
 
-void ITASampleFrame::add_frame(const ITASampleFrame& sfSource) { add_frame(&sfSource); }
-void ITASampleFrame::sub_frame(const ITASampleFrame& sfSource) { sub_frame(&sfSource); }
-void ITASampleFrame::mul_frame(const ITASampleFrame& sfSource) { mul_frame(&sfSource); }
-void ITASampleFrame::div_frame(const ITASampleFrame& sfSource) { div_frame(&sfSource); }
+void ITASampleFrame::add_frame( const ITASampleFrame& sfSource )
+{
+	add_frame( &sfSource );
+}
 
-void ITASampleFrame::muladd_frame(const ITASampleFrame* psfSource, float fScalar, int iSrcOffset, int iDestOffset, int iCount) {
-	if (!psfSource) ITA_EXCEPT1(INVALID_PARAMETER, "Nullpointer passed");
-	if (psfSource->m_iChannels != m_iChannels)  ITA_EXCEPT1(INVALID_PARAMETER, "Number of channels do not match");
+void ITASampleFrame::sub_frame( const ITASampleFrame& sfSource )
+{
+	sub_frame( &sfSource );
+}
 
-	for (int i=0; i<m_iChannels; i++)
-		m_vChannels[i].MulAdd( (*psfSource)[i], fScalar, iSrcOffset, iDestOffset, iCount );
+void ITASampleFrame::mul_frame( const ITASampleFrame& sfSource )
+{
+	mul_frame( &sfSource );
+}
+
+void ITASampleFrame::div_frame( const ITASampleFrame& sfSource )
+{
+	div_frame( &sfSource );
 }
 
-void ITASampleFrame::muladd_frame(const ITASampleFrame& sfSource, float fScalar, int iSrcOffset, int iDestOffset, int iCount) {
+void ITASampleFrame::muladd_frame( const ITASampleFrame* psfSource, float fScalar, int iSrcOffset, int iDestOffset, int iCount )
+{
+	if( !psfSource ) ITA_EXCEPT1( INVALID_PARAMETER, "Nullpointer passed" );
+	if( psfSource->m_iChannels != m_iChannels )  ITA_EXCEPT1( INVALID_PARAMETER, "Number of channels do not match" );
+
+	for( int i = 0; i < m_iChannels; i++ )
+		m_vChannels[ i ].MulAdd( ( *psfSource )[ i ], fScalar, iSrcOffset, iDestOffset, iCount );
+}
+
+void ITASampleFrame::muladd_frame( const ITASampleFrame& sfSource, float fScalar, int iSrcOffset, int iDestOffset, int iCount )
+{
 	muladd_frame( &sfSource, fScalar, iSrcOffset, iDestOffset, iCount );
 }
 
-float ITASampleFrame::findPeak(int* piChannel, int* piPeakIndex)
+float ITASampleFrame::findPeak( int* piChannel, int* piPeakIndex )
 {
-	if ((m_iChannels == 0) || (m_iLength == 0))
+	if( ( m_iChannels == 0 ) || ( m_iLength == 0 ) )
 	{
-		if (piChannel)
+		if( piChannel )
 			*piChannel = 0;
-		if (piPeakIndex)
+		if( piPeakIndex )
 			*piPeakIndex = 0;
 
 		return 0;
@@ -381,26 +440,29 @@ float ITASampleFrame::findPeak(int* piChannel, int* piPeakIndex)
 		}
 	}
 
-	if (piChannel)
+	if( piChannel )
 		*piChannel = iChannel;
 
-	if (piPeakIndex)
+	if( piPeakIndex )
 		*piPeakIndex = iPeakIndex;
 
 	return fPeak;
 }
 
-void ITASampleFrame::negate() {
-	for (ch_it it=m_vChannels.begin(); it!=m_vChannels.end(); ++it)
+void ITASampleFrame::negate()
+{
+	for( ch_it it = m_vChannels.begin(); it != m_vChannels.end(); ++it )
 		it->Negate();
 };
 
-ITASampleBuffer& ITASampleFrame::operator[](int iChannel) {
-	return m_vChannels[iChannel];
+ITASampleBuffer& ITASampleFrame::operator[]( int iChannel )
+{
+	return m_vChannels[ iChannel ];
 }
 
-const ITASampleBuffer& ITASampleFrame::operator[](int iChannel) const {
-	return m_vChannels[iChannel];
+const ITASampleBuffer& ITASampleFrame::operator[]( int iChannel ) const
+{
+	return m_vChannels[ iChannel ];
 }
 
 ITASampleFrame& ITASampleFrame::operator=( const ITASampleFrame& rhs )
@@ -417,71 +479,83 @@ ITASampleFrame& ITASampleFrame::operator=( const ITASampleFrame& rhs )
 	return *this;
 }
 
-ITASampleFrame& ITASampleFrame::operator+=(const float rhs) {
-	add_scalar(rhs);
+ITASampleFrame& ITASampleFrame::operator+=( const float rhs )
+{
+	add_scalar( rhs );
 	return *this;
 }
 
-ITASampleFrame& ITASampleFrame::operator-=(const float rhs) {
-	sub_scalar(rhs);
+ITASampleFrame& ITASampleFrame::operator-=( const float rhs )
+{
+	sub_scalar( rhs );
 	return *this;
 }
 
-ITASampleFrame& ITASampleFrame::operator*=(const float rhs) {
-	mul_scalar(rhs);
+ITASampleFrame& ITASampleFrame::operator*=( const float rhs )
+{
+	mul_scalar( rhs );
 	return *this;
 
 }
 
-ITASampleFrame& ITASampleFrame::operator/=(const float rhs) {
-	div_scalar(rhs);
+ITASampleFrame& ITASampleFrame::operator/=( const float rhs )
+{
+	div_scalar( rhs );
 	return *this;
 }
 
-ITASampleFrame& ITASampleFrame::operator+=(const ITASampleBuffer& rhs) {
-	add_buf(rhs);
+ITASampleFrame& ITASampleFrame::operator+=( const ITASampleBuffer& rhs )
+{
+	add_buf( rhs );
 	return *this;
 }
 
-ITASampleFrame& ITASampleFrame::operator-=(const ITASampleBuffer& rhs) {
-	sub_buf(rhs);
+ITASampleFrame& ITASampleFrame::operator-=( const ITASampleBuffer& rhs )
+{
+	sub_buf( rhs );
 	return *this;
 }
 
-ITASampleFrame& ITASampleFrame::operator*=(const ITASampleBuffer& rhs) {
-	mul_buf(rhs);
+ITASampleFrame& ITASampleFrame::operator*=( const ITASampleBuffer& rhs )
+{
+	mul_buf( rhs );
 	return *this;
 }
 
-ITASampleFrame& ITASampleFrame::operator/=(const ITASampleBuffer& rhs) {
-	div_buf(rhs);
+ITASampleFrame& ITASampleFrame::operator/=( const ITASampleBuffer& rhs )
+{
+	div_buf( rhs );
 	return *this;
 }
 
-ITASampleFrame& ITASampleFrame::operator+=(const ITASampleFrame& rhs) {
-	add_frame(rhs);
+ITASampleFrame& ITASampleFrame::operator+=( const ITASampleFrame& rhs )
+{
+	add_frame( rhs );
 	return *this;
 }
 
-ITASampleFrame& ITASampleFrame::operator-=(const ITASampleFrame& rhs) {
-	sub_frame(rhs);
+ITASampleFrame& ITASampleFrame::operator-=( const ITASampleFrame& rhs )
+{
+	sub_frame( rhs );
 	return *this;
 }
 
-ITASampleFrame& ITASampleFrame::operator*=(const ITASampleFrame& rhs) {
-	mul_frame(rhs);
+ITASampleFrame& ITASampleFrame::operator*=( const ITASampleFrame& rhs ) {
+	mul_frame( rhs );
 	return *this;
 }
 
-ITASampleFrame& ITASampleFrame::operator/=(const ITASampleFrame& rhs) {
-	div_frame(rhs);
+ITASampleFrame& ITASampleFrame::operator/=( const ITASampleFrame& rhs )
+{
+	div_frame( rhs );
 	return *this;
 }
 
-std::string ITASampleFrame::toString() const {
+std::string ITASampleFrame::toString() const
+{
 	std::stringstream ss;
 	ss << "Sample frame { ";
-	if (empty())
+	if( empty() )
 		ss << "emtpy";
 	else
 		ss << m_iChannels << " channels of " << m_iLength << " samples";
@@ -489,13 +563,13 @@ std::string ITASampleFrame::toString() const {
 	return ss.str();
 }
 
-float ITASampleFrame::normalize()
+float ITASampleFrame::Normalize()
 {
-	int c,s;
+	int c, s;
 	findPeak( &c, &s );
-	float fP = m_vChannels[c][s];
-	for (int i=0; i<m_iChannels; i++)
-		m_vChannels[i].div_scalar( fP );
+	float fP = m_vChannels[ c ][ s ];
+	for( int i = 0; i < m_iChannels; i++ )
+		m_vChannels[ i ].div_scalar( fP );
 
 	return fP;
 }
-- 
GitLab