Filter.h

#ifndef STK_FILTER_H
#define STK_FILTER_H
 
#include "Stk.h"
#include <vector>
#include <cmath>
 
namespace stk {
 
/***************************************************/
/***************************************************/
 
class Filter : public Stk
{
public:
  Filter( void ) { gain_ = 1.0; channelsIn_ = 1; lastFrame_.resize( 1, 1, 0.0 ); };
 
  unsigned int channelsIn( void ) const { return channelsIn_; };
 
  unsigned int channelsOut( void ) const { return lastFrame_.channels(); };
 
  virtual void clear( void );
 
 
  void setGain( StkFloat gain ) { gain_ = gain; };
 
  StkFloat getGain( void ) const { return gain_; };
 
 
  StkFloat phaseDelay( StkFloat frequency );
 
  const StkFrames& lastFrame( void ) const { return lastFrame_; };
 
 
  virtual StkFrames& tick( StkFrames& frames, unsigned int channel = 0 ) = 0;
 
protected:
 
  StkFloat gain_;
  unsigned int channelsIn_;
  StkFrames lastFrame_;
 
  std::vector<StkFloat> b_;
  std::vector<StkFloat> a_;
  StkFrames outputs_;
  StkFrames inputs_;
 
};
 
inline void Filter :: clear( void )
{
  unsigned int i;
  for ( i=0; i<inputs_.size(); i++ )
    inputs_[i] = 0.0;
  for ( i=0; i<outputs_.size(); i++ )
    outputs_[i] = 0.0;
  for ( i=0; i<lastFrame_.size(); i++ )
    lastFrame_[i] = 0.0;  
}
 
inline StkFloat Filter :: phaseDelay( StkFloat frequency )
{
  if ( frequency <= 0.0 || frequency > 0.5 * Stk::sampleRate() ) {
    oStream_ << "Filter::phaseDelay: argument (" << frequency << ") is out of range!";
    handleError( StkError::WARNING ); return 0.0;
  }
 
  StkFloat omegaT = 2 * PI * frequency / Stk::sampleRate();
  StkFloat real = 0.0, imag = 0.0;
  for ( unsigned int i=0; i<b_.size(); i++ ) {
    real += b_[i] * std::cos( i * omegaT );
    imag -= b_[i] * std::sin( i * omegaT );
  }
  real *= gain_;
  imag *= gain_;
 
  StkFloat phase = atan2( imag, real );
 
  real = 0.0, imag = 0.0;
  for ( unsigned int i=0; i<a_.size(); i++ ) {
    real += a_[i] * std::cos( i * omegaT );
    imag -= a_[i] * std::sin( i * omegaT );
  }
 
  phase -= std::atan2( imag, real );
  phase = std::fmod( -phase, 2 * PI );
  return phase / omegaT;
}
 
} // stk namespace
 
#endif