TapDelay.h

#ifndef STK_TAPDELAY_H
#define STK_TAPDELAY_H
 
#include "Filter.h"
 
namespace stk {
 
/***************************************************/
/***************************************************/
 
class TapDelay : public Filter
{
 public:
 
 
  TapDelay( std::vector<unsigned long> taps = std::vector<unsigned long>( 1, 0 ), unsigned long maxDelay = 4095 );
 
  ~TapDelay();
 
 
  void setMaximumDelay( unsigned long delay );
 
 
  void setTapDelays( std::vector<unsigned long> taps );
 
  std::vector<unsigned long> getTapDelays( void ) const { return delays_; };
 
 
  StkFloat lastOut( unsigned int tap = 0 ) const;
 
 
  StkFrames& tick( StkFloat input, StkFrames& outputs );
 
 
  StkFrames& tick( StkFrames& frames, unsigned int channel = 0 );
 
 
  StkFrames& tick( StkFrames& iFrames, StkFrames &oFrames, unsigned int iChannel = 0 );
 
 protected:
 
  unsigned long inPoint_;
  std::vector<unsigned long> outPoint_;
  std::vector<unsigned long> delays_;
 
};
 
inline StkFloat TapDelay :: lastOut( unsigned int tap ) const
{
#if defined(_STK_DEBUG_)
  if ( tap >= lastFrame_.size() ) {
    oStream_ << "TapDelay::lastOut(): tap argument and number of taps are incompatible!";
    handleError( StkError::FUNCTION_ARGUMENT );
  }
#endif
 
  return lastFrame_[tap];
}
 
inline StkFrames& TapDelay :: tick( StkFloat input, StkFrames& outputs )
{
#if defined(_STK_DEBUG_)
  if ( outputs.channels() < outPoint_.size() ) {
    oStream_ << "TapDelay::tick(): number of taps > channels in StkFrames argument!";
    handleError( StkError::FUNCTION_ARGUMENT );
  }
#endif
 
  inputs_[inPoint_++] = input * gain_;
 
  // Check for end condition
  if ( inPoint_ == inputs_.size() )
    inPoint_ = 0;
 
  // Read out next values
  StkFloat *outs = &outputs[0];
  for ( unsigned int i=0; i<outPoint_.size(); i++ ) {
    *outs++ = inputs_[outPoint_[i]];
    lastFrame_[i] = *outs;
    if ( ++outPoint_[i] == inputs_.size() )
      outPoint_[i] = 0;
  }
 
  return outputs;
}
 
inline StkFrames& TapDelay :: tick( StkFrames& frames, unsigned int channel )
{
#if defined(_STK_DEBUG_)
  if ( channel >= frames.channels() ) {
    oStream_ << "TapDelay::tick(): channel and StkFrames arguments are incompatible!";
    handleError( StkError::FUNCTION_ARGUMENT );
  }
  if ( frames.channels() < outPoint_.size() ) {
    oStream_ << "TapDelay::tick(): number of taps > channels in StkFrames argument!";
    handleError( StkError::FUNCTION_ARGUMENT );
  }
#endif
 
  StkFloat *iSamples = &frames[channel];
  StkFloat *oSamples = &frames[0];
  std::size_t j;
  unsigned int iHop = frames.channels();
  std::size_t oHop = frames.channels() - outPoint_.size();
  for ( unsigned long i=0; i<frames.frames(); i++, iSamples += iHop, oSamples += oHop ) {
    inputs_[inPoint_++] = *iSamples * gain_;
    if ( inPoint_ == inputs_.size() ) inPoint_ = 0;
    for ( j=0; j<outPoint_.size(); j++ ) {
      *oSamples++ = inputs_[outPoint_[j]];
      if ( ++outPoint_[j] == inputs_.size() ) outPoint_[j] = 0;
    }
  }
 
  oSamples -= frames.channels();
  for ( j=0; j<outPoint_.size(); j++ ) lastFrame_[j] = *oSamples++;
  return frames;
}
 
inline StkFrames& TapDelay :: tick( StkFrames& iFrames, StkFrames& oFrames, unsigned int iChannel )
{
#if defined(_STK_DEBUG_)
  if ( iChannel >= iFrames.channels() ) {
    oStream_ << "TapDelay::tick(): channel and StkFrames arguments are incompatible!";
    handleError( StkError::FUNCTION_ARGUMENT );
  }
  if ( oFrames.channels() < outPoint_.size() ) {
    oStream_ << "TapDelay::tick(): number of taps > channels in output StkFrames argument!";
    handleError( StkError::FUNCTION_ARGUMENT );
  }
#endif
 
  StkFloat *iSamples = &iFrames[iChannel];
  StkFloat *oSamples = &oFrames[0];
  std::size_t j;
  unsigned int iHop = iFrames.channels();
  std::size_t oHop = oFrames.channels() - outPoint_.size();
  for ( unsigned long i=0; i<iFrames.frames(); i++, iSamples += iHop, oSamples += oHop ) {
    inputs_[inPoint_++] = *iSamples * gain_;
    if ( inPoint_ == inputs_.size() ) inPoint_ = 0;
    for ( j=0; j<outPoint_.size(); j++ ) {
      *oSamples++ = inputs_[outPoint_[j]];
      if ( ++outPoint_[j] == inputs_.size() ) outPoint_[j] = 0;
    }
  }
 
  oSamples -= oFrames.channels();
  for ( j=0; j<outPoint_.size(); j++ ) lastFrame_[j] = *oSamples++;
  return iFrames;
}
 
} // stk namespace
 
#endif