BiQuad.h

#ifndef STK_BIQUAD_H
#define STK_BIQUAD_H
 
#include "Filter.h"
 
namespace stk {
 
/***************************************************/
/***************************************************/
 
const StkFloat RECIP_SQRT_2 = static_cast<StkFloat>( M_SQRT1_2 );  
class BiQuad : public Filter
{
public:
 
  BiQuad();
 
  ~BiQuad();
 
  void ignoreSampleRateChange( bool ignore = true ) { ignoreSampleRateChange_ = ignore; };
 
  void setCoefficients( StkFloat b0, StkFloat b1, StkFloat b2, StkFloat a1, StkFloat a2, bool clearState = false );
 
  void setB0( StkFloat b0 ) { b_[0] = b0; };
 
  void setB1( StkFloat b1 ) { b_[1] = b1; };
 
  void setB2( StkFloat b2 ) { b_[2] = b2; };
 
  void setA1( StkFloat a1 ) { a_[1] = a1; };
 
  void setA2( StkFloat a2 ) { a_[2] = a2; };
 
 
  void setResonance( StkFloat frequency, StkFloat radius, bool normalize = false );
 
 
  void setNotch( StkFloat frequency, StkFloat radius );
 
 
  void setLowPass( StkFloat fc, StkFloat Q=RECIP_SQRT_2 );
 
 
  void setHighPass( StkFloat fc, StkFloat Q=RECIP_SQRT_2 );
 
 
  void setBandPass( StkFloat fc, StkFloat Q );
 
 
  void setBandReject( StkFloat fc, StkFloat Q );
 
 
  void setAllPass( StkFloat fc, StkFloat Q );
 
 
  void setEqualGainZeroes( void );
 
  StkFloat lastOut( void ) const { return lastFrame_[0]; };
 
  StkFloat tick( StkFloat input );
 
 
  StkFrames& tick( StkFrames& frames, unsigned int channel = 0 );
 
 
  StkFrames& tick( StkFrames& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 );
 
 protected:
 
  virtual void sampleRateChanged( StkFloat newRate, StkFloat oldRate );
  
  // Helper function to update the three intermediate values for the predefined filter types
  // along with the feedback filter coefficients. Performs the debug check for fc and Q-factor arguments.
  void setCommonFilterValues( StkFloat fc, StkFloat Q );
 
  StkFloat K_;
  StkFloat kSqr_;
  StkFloat denom_;
};
 
inline StkFloat BiQuad :: tick( StkFloat input )
{
  inputs_[0] = gain_ * input;
  lastFrame_[0] = b_[0] * inputs_[0] + b_[1] * inputs_[1] + b_[2] * inputs_[2];
  lastFrame_[0] -= a_[2] * outputs_[2] + a_[1] * outputs_[1];
  inputs_[2] = inputs_[1];
  inputs_[1] = inputs_[0];
  outputs_[2] = outputs_[1];
  outputs_[1] = lastFrame_[0];
 
  return lastFrame_[0];
}
 
inline StkFrames& BiQuad :: tick( StkFrames& frames, unsigned int channel )
{
#if defined(_STK_DEBUG_)
  if ( channel >= frames.channels() ) {
    oStream_ << "BiQuad::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] + b_[1] * inputs_[1] + b_[2] * inputs_[2];
    *samples -= a_[2] * outputs_[2] + a_[1] * outputs_[1];
    inputs_[2] = inputs_[1];
    inputs_[1] = inputs_[0];
    outputs_[2] = outputs_[1];
    outputs_[1] = *samples;
  }
 
  lastFrame_[0] = outputs_[1];
  return frames;
}
 
inline StkFrames& BiQuad :: tick( StkFrames& iFrames, StkFrames& oFrames, unsigned int iChannel, unsigned int oChannel )
{
#if defined(_STK_DEBUG_)
  if ( iChannel >= iFrames.channels() || oChannel >= oFrames.channels() ) {
    oStream_ << "BiQuad::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] + b_[1] * inputs_[1] + b_[2] * inputs_[2];
    *oSamples -= a_[2] * outputs_[2] + a_[1] * outputs_[1];
    inputs_[2] = inputs_[1];
    inputs_[1] = inputs_[0];
    outputs_[2] = outputs_[1];
    outputs_[1] = *oSamples;
  }
 
  lastFrame_[0] = outputs_[1];
  return iFrames;
}
 
} // stk namespace
 
#endif