Cubic.h

#ifndef STK_CUBIC_H
#define STK_CUBIC_H
 
#include "Function.h"
#include <cmath>
 
namespace stk {
 
/***************************************************/
/***************************************************/
 
class Cubic : public Function
{
public:
  Cubic( void ) : a1_(0.5), a2_(0.5), a3_(0.5), gain_(1.0), threshold_(1.0) {};
 
  void setA1( StkFloat a1 ) { a1_ = a1; };
 
  void setA2( StkFloat a2 )  { a2_ = a2; };
 
  void setA3( StkFloat a3 )  { a3_ = a3; };
 
  void setGain( StkFloat gain ) { gain_ = gain; };
 
  void setThreshold( StkFloat threshold ) { threshold_ = threshold; };
 
  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:
 
  StkFloat a1_;
  StkFloat a2_;
  StkFloat a3_;
  StkFloat gain_; 
  StkFloat threshold_;
};
 
inline StkFloat Cubic :: tick( StkFloat input )
{
  StkFloat inSquared = input * input;
  StkFloat inCubed = inSquared * input;
 
  lastFrame_[0] = gain_ * (a1_ * input + a2_ * inSquared + a3_ * inCubed);
 
  // Apply threshold if we are out of range.
  if ( fabs( lastFrame_[0] ) > threshold_ ) {
    lastFrame_[0] = ( lastFrame_[0] < 0 ? -threshold_ : threshold_ );
  }
 
  return lastFrame_[0];
}
 
inline StkFrames& Cubic :: tick( StkFrames& frames, unsigned int channel )
{
#if defined(_STK_DEBUG_)
  if ( channel >= frames.channels() ) {
    oStream_ << "Cubic::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 )
    *samples = tick( *samples );
 
  lastFrame_[0] = *(samples-hop);
  return frames;
}
 
inline StkFrames& Cubic :: tick( StkFrames& iFrames, StkFrames& oFrames, unsigned int iChannel, unsigned int oChannel )
{
#if defined(_STK_DEBUG_)
  if ( iChannel >= iFrames.channels() || oChannel >= oFrames.channels() ) {
    oStream_ << "Cubic::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 )
    *oSamples = tick( *iSamples );
 
  lastFrame_[0] = *(oSamples-oHop);
  return iFrames;
}
 
} // stk namespace
 
#endif