mirror of
https://github.com/HifiExperiments/overte.git
synced 2025-06-18 12:08:46 +02:00
134 lines
4.4 KiB
C++
134 lines
4.4 KiB
C++
#ifndef STK_ONEPOLE_H
|
|
#define STK_ONEPOLE_H
|
|
|
|
#include "Filter.h"
|
|
|
|
namespace stk {
|
|
|
|
/***************************************************/
|
|
/*! \class OnePole
|
|
\brief STK one-pole filter class.
|
|
|
|
This class implements a one-pole digital filter. A method is
|
|
provided for setting the pole position along the real axis of the
|
|
z-plane while maintaining a constant peak filter gain.
|
|
|
|
by Perry R. Cook and Gary P. Scavone, 1995-2012.
|
|
*/
|
|
/***************************************************/
|
|
|
|
class OnePole : public Filter
|
|
{
|
|
public:
|
|
|
|
//! The default constructor creates a low-pass filter (pole at z = 0.9).
|
|
OnePole( StkFloat thePole = 0.9 );
|
|
|
|
//! Class destructor.
|
|
~OnePole();
|
|
|
|
//! Set the b[0] coefficient value.
|
|
void setB0( StkFloat b0 ) { b_[0] = b0; };
|
|
|
|
//! Set the a[1] coefficient value.
|
|
void setA1( StkFloat a1 ) { a_[1] = a1; };
|
|
|
|
//! Set all filter coefficients.
|
|
void setCoefficients( StkFloat b0, StkFloat a1, bool clearState = false );
|
|
|
|
//! Set the pole position in the z-plane.
|
|
/*!
|
|
This method sets the pole position along the real-axis of the
|
|
z-plane and normalizes the coefficients for a maximum gain of one.
|
|
A positive pole value produces a low-pass filter, while a negative
|
|
pole value produces a high-pass filter. This method does not
|
|
affect the filter \e gain value. The argument magnitude should be
|
|
less than one to maintain filter stability.
|
|
*/
|
|
void setPole( StkFloat thePole );
|
|
|
|
//! Return the last computed output value.
|
|
StkFloat lastOut( void ) const { return lastFrame_[0]; };
|
|
|
|
//! Input one sample to the filter and return one output.
|
|
StkFloat tick( StkFloat input );
|
|
|
|
//! Take a channel of the StkFrames object as inputs to the filter and replace with corresponding outputs.
|
|
/*!
|
|
The StkFrames argument reference is returned. The \c channel
|
|
argument must be less than the number of channels in the
|
|
StkFrames argument (the first channel is specified by 0).
|
|
However, range checking is only performed if _STK_DEBUG_ is
|
|
defined during compilation, in which case an out-of-range value
|
|
will trigger an StkError exception.
|
|
*/
|
|
StkFrames& tick( StkFrames& frames, unsigned int channel = 0 );
|
|
|
|
//! Take a channel of the \c iFrames object as inputs to the filter and write outputs to the \c oFrames object.
|
|
/*!
|
|
The \c iFrames object reference is returned. Each channel
|
|
argument must be less than the number of channels in the
|
|
corresponding StkFrames argument (the first channel is specified
|
|
by 0). However, range checking is only performed if _STK_DEBUG_
|
|
is defined during compilation, in which case an out-of-range value
|
|
will trigger an StkError exception.
|
|
*/
|
|
StkFrames& tick( StkFrames& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 );
|
|
|
|
};
|
|
|
|
inline StkFloat OnePole :: tick( StkFloat input )
|
|
{
|
|
inputs_[0] = gain_ * input;
|
|
lastFrame_[0] = b_[0] * inputs_[0] - a_[1] * outputs_[1];
|
|
outputs_[1] = lastFrame_[0];
|
|
|
|
return lastFrame_[0];
|
|
}
|
|
|
|
inline StkFrames& OnePole :: tick( StkFrames& frames, unsigned int channel )
|
|
{
|
|
#if defined(_STK_DEBUG_)
|
|
if ( channel >= frames.channels() ) {
|
|
oStream_ << "OnePole::tick(): channel and StkFrames arguments are incompatible!";
|
|
handleError( StkError::FUNCTION_ARGUMENT );
|
|
}
|
|
#endif
|
|
|
|
StkFloat *samples = &frames[channel];
|
|
unsigned int hop = frames.channels();
|
|
for ( unsigned int i=0; i<frames.frames(); i++, samples += hop ) {
|
|
inputs_[0] = gain_ * *samples;
|
|
*samples = b_[0] * inputs_[0] - a_[1] * outputs_[1];
|
|
outputs_[1] = *samples;
|
|
}
|
|
|
|
lastFrame_[0] = outputs_[1];
|
|
return frames;
|
|
}
|
|
|
|
inline StkFrames& OnePole :: tick( StkFrames& iFrames, StkFrames& oFrames, unsigned int iChannel, unsigned int oChannel )
|
|
{
|
|
#if defined(_STK_DEBUG_)
|
|
if ( iChannel >= iFrames.channels() || oChannel >= oFrames.channels() ) {
|
|
oStream_ << "OnePole::tick(): channel and StkFrames arguments are incompatible!";
|
|
handleError( StkError::FUNCTION_ARGUMENT );
|
|
}
|
|
#endif
|
|
|
|
StkFloat *iSamples = &iFrames[iChannel];
|
|
StkFloat *oSamples = &oFrames[oChannel];
|
|
unsigned int iHop = iFrames.channels(), oHop = oFrames.channels();
|
|
for ( unsigned int i=0; i<iFrames.frames(); i++, iSamples += iHop, oSamples += oHop ) {
|
|
inputs_[0] = gain_ * *iSamples;
|
|
*oSamples = b_[0] * inputs_[0] - a_[1] * outputs_[1];
|
|
outputs_[1] = *oSamples;
|
|
}
|
|
|
|
lastFrame_[0] = outputs_[1];
|
|
return iFrames;
|
|
}
|
|
|
|
} // stk namespace
|
|
|
|
#endif
|