Moving ITAHDFTSpectra and some useful methods for sampleframe and -buffer.

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"

include/ITAHDFTSpectra.h

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

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 );
 

include/ITASampleFrame.h

@@ -114,7 +114,11 @@ public:
      * \param iLength	Lnge [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 fr Zugriff auf Kanaldaten
 	ITASampleBuffer& operator[](int iChannel);

src/ITAHDFTSpectra.cpp

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

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 )

src/ITASampleFrame.cpp

@@ -11,20 +11,23 @@ ITASampleFrame::ITASampleFrame()
 	: m_iChannels( 0 ), m_iLength( 0 ) {}
 
 ITASampleFrame::ITASampleFrame( int iChannels, int iLength, bool bZeroinit )
-: m_iChannels(0), m_iLength(0)
+	: 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)
+	: m_iChannels( 0 )
+	, m_iLength( 0 )
 {
 	*this = *pSource;
 }
 
 ITASampleFrame::ITASampleFrame( const ITASampleFrame& sbSource )
-: m_iChannels(0), m_iLength(0)
+	: m_iChannels( 0 )
+	, m_iLength( 0 )
 {
 	*this = sbSource;
 }
@@ -38,19 +41,22 @@ ITASampleFrame::~ITASampleFrame()
 {
 }
 
-bool ITASampleFrame::empty() const {
+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 );
@@ -60,7 +66,8 @@ void ITASampleFrame::init( int iChannels, int iLength, bool bZeroinit)
 	if( ( m_iChannels > 0 ) || ( m_iLength > 0 ) ) free();
 
 	m_vChannels.resize( iChannels );
-	for (int i=0; i<iChannels; i++) {
+	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;
@@ -158,7 +165,8 @@ void ITASampleFrame::fill( float fValue )
 		it->Fill( fValue );
 }
 
-void ITASampleFrame::fill(int iOffset, int iCount, float 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 );
 }
@@ -177,12 +185,14 @@ void ITASampleFrame::identity() {
 		it->Identity();
 }
 
-void ITASampleFrame::fade(int iOffset, int iCount, int iFadeDirection, int 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) {
+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" );
 
@@ -190,7 +200,8 @@ void ITASampleFrame::crossfade(const ITASampleFrame* psfSrc, int iOffset, int iC
 		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 );
 }
 
@@ -201,7 +212,8 @@ void ITASampleFrame::envelope(float fGain0, float fGain1) {
 		m_vChannels[ i ].Envelope( fGain0, fGain1 );
 }
 
-void ITASampleFrame::write(const ITASampleFrame* psfSrc, int iCount, int iSrcOffset, int iDestOffset) {
+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" );
 
@@ -209,11 +221,13 @@ void ITASampleFrame::write(const ITASampleFrame* psfSrc, int iCount, int iSrcOff
 		m_vChannels[ i ].write( ( *psfSrc )[ i ], iCount, iSrcOffset, iDestOffset );
 }
 
-void ITASampleFrame::write(const ITASampleFrame& sfSrc, int iCount, int iSrcOffset, int 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) {
+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" );
 
@@ -221,7 +235,8 @@ void ITASampleFrame::cyclic_write(const ITASampleFrame* psfSrc, int iCount, int
 		m_vChannels[ i ].cyclic_write( &( ( *psfSrc )[ i ] ), iCount, iSrcOffset, iDestOffset );
 }
 
-void ITASampleFrame::cyclic_write(const ITASampleFrame& sfSrc, int iCount, int iSrcOffset, int iDestOffset) {
+void ITASampleFrame::cyclic_write( const ITASampleFrame& sfSrc, int iCount, int iSrcOffset, int iDestOffset )
+{
 	cyclic_write( &sfSrc, iCount, iSrcOffset, iDestOffset );
 }
 
@@ -231,27 +246,32 @@ void ITASampleFrame::CyclicShift( int iCount)
 		m_vChannels[ i ].CyclicShift( iCount );
 }
 
-void ITASampleFrame::add_scalar(float 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) {
+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) {
+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) {
+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) {
+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" );
 
@@ -259,7 +279,8 @@ void ITASampleFrame::add_buf(const ITASampleBuffer* psbSource) {
 		it->add_buf( psbSource );
 }
 
-void ITASampleFrame::sub_buf(const ITASampleBuffer* 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" );
 
@@ -267,7 +288,8 @@ void ITASampleFrame::sub_buf(const ITASampleBuffer* psbSource) {
 		it->sub_buf( psbSource );
 }
 
-void ITASampleFrame::mul_buf(const ITASampleBuffer* 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" );
 
@@ -275,7 +297,8 @@ void ITASampleFrame::mul_buf(const ITASampleBuffer* psbSource) {
 		it->sub_buf( psbSource );
 }
 
-void ITASampleFrame::div_buf(const ITASampleBuffer* 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" );
 
@@ -283,12 +306,28 @@ void ITASampleFrame::div_buf(const ITASampleBuffer* psbSource) {
 		it->div_buf( psbSource );
 }
 
-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::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::add_frame(const ITASampleFrame* psfSource) {
+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" );
@@ -309,7 +348,8 @@ void ITASampleFrame::add_frame(const ITASampleFrame* psfSource, int iPos)
 
 
 
-void ITASampleFrame::sub_frame(const ITASampleFrame* psfSource) {
+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" );
@@ -318,7 +358,8 @@ void ITASampleFrame::sub_frame(const ITASampleFrame* psfSource) {
 		m_vChannels[ i ].sub_buf( &( psfSource->m_vChannels[ i ] ) );
 }
 
-void ITASampleFrame::mul_frame(const ITASampleFrame* psfSource) {
+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" );
@@ -327,7 +368,8 @@ void ITASampleFrame::mul_frame(const ITASampleFrame* psfSource) {
 		m_vChannels[ i ].mul_buf( &( psfSource->m_vChannels[ i ] ) );
 }
 
-void ITASampleFrame::div_frame(const ITASampleFrame* psfSource) {
+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" );
@@ -336,12 +378,28 @@ void ITASampleFrame::div_frame(const ITASampleFrame* psfSource) {
 		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::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::muladd_frame(const ITASampleFrame* psfSource, 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" );
 
@@ -349,7 +407,8 @@ void ITASampleFrame::muladd_frame(const ITASampleFrame* psfSource, float fScalar
 		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) {
+void ITASampleFrame::muladd_frame( const ITASampleFrame& sfSource, float fScalar, int iSrcOffset, int iDestOffset, int iCount )
+{
 	muladd_frame( &sfSource, fScalar, iSrcOffset, iDestOffset, iCount );
 }
 
@@ -390,16 +449,19 @@ float ITASampleFrame::findPeak(int* piChannel, int* piPeakIndex)
 	return fPeak;
 }
 
-void ITASampleFrame::negate() {
+void ITASampleFrame::negate()
+{
 	for( ch_it it = m_vChannels.begin(); it != m_vChannels.end(); ++it )
 		it->Negate();
 };
 
-ITASampleBuffer& ITASampleFrame::operator[](int iChannel) {
+ITASampleBuffer& ITASampleFrame::operator[]( int iChannel )
+{
 	return m_vChannels[ iChannel ];
 }
 
-const ITASampleBuffer& ITASampleFrame::operator[](int iChannel) const {
+const ITASampleBuffer& ITASampleFrame::operator[]( int iChannel ) const
+{
 	return m_vChannels[ iChannel ];
 }
 
@@ -417,53 +479,63 @@ ITASampleFrame& ITASampleFrame::operator=( const ITASampleFrame& rhs )
 	return *this;
 }
 
-ITASampleFrame& ITASampleFrame::operator+=(const float rhs) {
+ITASampleFrame& ITASampleFrame::operator+=( const float rhs )
+{
 	add_scalar( rhs );
 	return *this;
 }
 
-ITASampleFrame& ITASampleFrame::operator-=(const float rhs) {
+ITASampleFrame& ITASampleFrame::operator-=( const float rhs )
+{
 	sub_scalar( rhs );
 	return *this;
 }
 
-ITASampleFrame& ITASampleFrame::operator*=(const float rhs) {
+ITASampleFrame& ITASampleFrame::operator*=( const float rhs )
+{
 	mul_scalar( rhs );
 	return *this;
 
 }
 
-ITASampleFrame& ITASampleFrame::operator/=(const float rhs) {
+ITASampleFrame& ITASampleFrame::operator/=( const float rhs )
+{
 	div_scalar( rhs );
 	return *this;
 }
 
-ITASampleFrame& ITASampleFrame::operator+=(const ITASampleBuffer& rhs) {
+ITASampleFrame& ITASampleFrame::operator+=( const ITASampleBuffer& rhs )
+{
 	add_buf( rhs );
 	return *this;
 }
 
-ITASampleFrame& ITASampleFrame::operator-=(const ITASampleBuffer& rhs) {
+ITASampleFrame& ITASampleFrame::operator-=( const ITASampleBuffer& rhs )
+{
 	sub_buf( rhs );
 	return *this;
 }
 
-ITASampleFrame& ITASampleFrame::operator*=(const ITASampleBuffer& rhs) {
+ITASampleFrame& ITASampleFrame::operator*=( const ITASampleBuffer& rhs )
+{
 	mul_buf( rhs );
 	return *this;
 }
 
-ITASampleFrame& ITASampleFrame::operator/=(const ITASampleBuffer& rhs) {
+ITASampleFrame& ITASampleFrame::operator/=( const ITASampleBuffer& rhs )
+{
 	div_buf( rhs );
 	return *this;
 }
 
-ITASampleFrame& ITASampleFrame::operator+=(const ITASampleFrame& rhs) {
+ITASampleFrame& ITASampleFrame::operator+=( const ITASampleFrame& rhs )
+{
 	add_frame( rhs );
 	return *this;
 }
 
-ITASampleFrame& ITASampleFrame::operator-=(const ITASampleFrame& rhs) {
+ITASampleFrame& ITASampleFrame::operator-=( const ITASampleFrame& rhs )
+{
 	sub_frame( rhs );
 	return *this;
 }
@@ -473,12 +545,14 @@ ITASampleFrame& ITASampleFrame::operator*=(const ITASampleFrame& rhs) {
 	return *this;
 }
 
-ITASampleFrame& ITASampleFrame::operator/=(const ITASampleFrame& 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() )
@@ -489,7 +563,7 @@ std::string ITASampleFrame::toString() const {
 	return ss.str();
 }
 
-float ITASampleFrame::normalize()
+float ITASampleFrame::Normalize()
 {
 	int c, s;
 	findPeak( &c, &s );