From 8badcacf087ff8b95008bf016673d38a3b4b842f Mon Sep 17 00:00:00 2001 From: Jonas Stienen 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 +#include + +// STL includes +#include + +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 + +#include +#include +#include +#include +#include + +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& vpSpectrumVec ) +{ + if( vpSpectrumVec.size() == 0 ) + ITA_EXCEPT1( INVALID_PARAMETER, "At least one DFT channel must be used" ); + + for( size_t i=0; igetDFTSize() <= 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; iGetNumChannels(); + + m_vpSpectra.clear(); + + for( int i=0; iGetSampleRate()),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; iSetUnity(); + } +} + +void ITAHDFTSpectra::SetZero() +{ + for( size_t i=0; imul( 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; iadd( pSourceSpectrum ); + } + + return; +} + +void ITAHDFTSpectra::sub( const ITAHDFTSpectra* pSource ) +{ + if( GetNumChannels() != pSource->GetNumChannels() ) + ITA_EXCEPT1( INVALID_PARAMETER, "Channel number mismatch" ); + + for( int i=0; isub( pSourceSpectrum ); + } + + return; +} + +void ITAHDFTSpectra::mul( const ITAHDFTSpectra* pSource ) +{ + if( GetNumChannels() != pSource->GetNumChannels() ) + ITA_EXCEPT1( INVALID_PARAMETER, "Channel number mismatch" ); + + for( int i=0; imul( pSourceSpectrum ); + } + + return; +} + +void ITAHDFTSpectra::mul_conj( const ITAHDFTSpectra* pSource ) +{ + if( GetNumChannels() != pSource->GetNumChannels() ) + ITA_EXCEPT1( INVALID_PARAMETER, "Channel number mismatch" ); + + for( int i=0; imul( 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; idiv( 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 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 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; ichannels() != 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; ichannels() != 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; ichannels() != 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; iadd_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; im_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; im_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; im_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; im_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; im_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; im_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