SineWave.h

#ifndef STK_SINEWAVE_H
#define STK_SINEWAVE_H
 
const unsigned long TABLE_SIZE = 2048;
 
#include "Generator.h"
 
namespace stk {
 
/***************************************************/
/***************************************************/
 
class SineWave : public Generator
{
public:
  SineWave( void );
 
  ~SineWave( void );
 
  void reset( void );
 
 
  void setRate( StkFloat rate ) { rate_ = rate; };
 
 
  void setFrequency( StkFloat frequency );
 
  void addTime( StkFloat time );
 
 
  void addPhase( StkFloat phase );
 
 
  void addPhaseOffset( StkFloat phaseOffset );
 
  StkFloat lastOut( void ) const { return lastFrame_[0]; };
 
  StkFloat tick( void );
 
 
  StkFrames& tick( StkFrames& frames, unsigned int channel = 0 );
 
protected:
 
  void sampleRateChanged( StkFloat newRate, StkFloat oldRate );
 
  static StkFrames table_;
  StkFloat time_;
  StkFloat rate_;
  StkFloat phaseOffset_;
  unsigned int iIndex_;
  StkFloat alpha_;
 
};
 
inline StkFloat SineWave :: tick( void )
{
  // Check limits of time address ... if necessary, recalculate modulo
  // TABLE_SIZE.
  while ( time_ < 0.0 )
    time_ += TABLE_SIZE;
  while ( time_ >= TABLE_SIZE )
    time_ -= TABLE_SIZE;
 
  iIndex_ = (unsigned int) time_;
  alpha_ = time_ - iIndex_;
  StkFloat tmp = table_[ iIndex_ ];
  tmp += ( alpha_ * ( table_[ iIndex_ + 1 ] - tmp ) );
 
  // Increment time, which can be negative.
  time_ += rate_;
 
  lastFrame_[0] = tmp;
  return lastFrame_[0];
}
 
inline StkFrames& SineWave :: tick( StkFrames& frames, unsigned int channel )
{
#if defined(_STK_DEBUG_)
  if ( channel >= frames.channels() ) {
    oStream_ << "SineWave::tick(): channel and StkFrames arguments are incompatible!";
    handleError( StkError::FUNCTION_ARGUMENT );
  }
#endif
 
  StkFloat *samples = &frames[channel];
  StkFloat tmp = 0.0;
 
  unsigned int hop = frames.channels();
  for ( unsigned int i=0; i<frames.frames(); i++, samples += hop ) {
 
    // Check limits of time address ... if necessary, recalculate modulo
    // TABLE_SIZE.
    while ( time_ < 0.0 )
      time_ += TABLE_SIZE;
    while ( time_ >= TABLE_SIZE )
      time_ -= TABLE_SIZE;
 
    iIndex_ = (unsigned int) time_;
    alpha_ = time_ - iIndex_;
    tmp = table_[ iIndex_ ];
    tmp += ( alpha_ * ( table_[ iIndex_ + 1 ] - tmp ) );
    *samples = tmp;
 
    // Increment time, which can be negative.
    time_ += rate_;
  }
 
  lastFrame_[0] = tmp;
  return frames;
}
 
} // stk namespace
 
#endif