The Synthesis ToolKit in C++ (STK)

Home Information Classes Download Usage Mail List Requirements Links FAQ Tutorial

# DelayA.h

    00001 #ifndef STK_DELAYA_H
    00002 #define STK_DELAYA_H
    00003
    00004 #include "Filter.h"
    00005
    00006 namespace stk {
    00007
    00008 /***************************************************/
    00026 /***************************************************/
    00027
    00028 class DelayA : public Filter
    00029 {
    00030 public:
    00031
    00033
    00038   DelayA( StkFloat delay = 0.5, unsigned long maxDelay = 4095 );
    00039
    00041   ~DelayA();
    00042
    00044   void clear( void );
    00045
    00047   unsigned long getMaximumDelay( void ) { return inputs_.size() - 1; };
    00048
    00050
    00057   void setMaximumDelay( unsigned long delay );
    00058
    00060
    00063   void setDelay( StkFloat delay );
    00064
    00066   StkFloat getDelay( void ) const { return delay_; };
    00067
    00069
    00074   StkFloat tapOut( unsigned long tapDelay );
    00075
    00077   void tapIn( StkFloat value, unsigned long tapDelay );
    00078
    00080   StkFloat lastOut( void ) const { return lastFrame_[0]; };
    00081
    00083
    00086   StkFloat nextOut( void );
    00087
    00089   StkFloat tick( StkFloat input );
    00090
    00092
    00100   StkFrames& tick( StkFrames& frames, unsigned int channel = 0 );
    00101
    00103
    00111   StkFrames& tick( StkFrames& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 );
    00112
    00113 protected:
    00114
    00115   unsigned long inPoint_;
    00116   unsigned long outPoint_;
    00117   StkFloat delay_;
    00118   StkFloat alpha_;
    00119   StkFloat coeff_;
    00120   StkFloat apInput_;
    00121   StkFloat nextOutput_;
    00122   bool doNextOut_;
    00123 };
    00124
    00125 inline StkFloat DelayA :: nextOut( void )
    00126 {
    00127   if ( doNextOut_ ) {
    00128     // Do allpass interpolation delay.
    00129     nextOutput_ = -coeff_ * lastFrame_[0];
    00130     nextOutput_ += apInput_ + ( coeff_ * inputs_[outPoint_] );
    00131     doNextOut_ = false;
    00132   }
    00133
    00134   return nextOutput_;
    00135 }
    00136
    00137 inline StkFloat DelayA :: tick( StkFloat input )
    00138 {
    00139   inputs_[inPoint_++] = input * gain_;
    00140
    00141   // Increment input pointer modulo length.
    00142   if ( inPoint_ == inputs_.size() )
    00143     inPoint_ = 0;
    00144
    00145   lastFrame_[0] = nextOut();
    00146   doNextOut_ = true;
    00147
    00148   // Save the allpass input and increment modulo length.
    00149   apInput_ = inputs_[outPoint_++];
    00150   if ( outPoint_ == inputs_.size() )
    00151     outPoint_ = 0;
    00152
    00153   return lastFrame_[0];
    00154 }
    00155
    00156 inline StkFrames& DelayA :: tick( StkFrames& frames, unsigned int channel )
    00157 {
    00158 #if defined(_STK_DEBUG_)
    00159   if ( channel >= frames.channels() ) {
    00160     oStream_ << "DelayA::tick(): channel and StkFrames arguments are incompatible!";
    00161     handleError( StkError::FUNCTION_ARGUMENT );
    00162   }
    00163 #endif
    00164
    00165   StkFloat *samples = &frames[channel];
    00166   unsigned int hop = frames.channels();
    00167   for ( unsigned int i=0; i<frames.frames(); i++, samples += hop ) {
    00168     inputs_[inPoint_++] = *samples * gain_;
    00169     if ( inPoint_ == inputs_.size() ) inPoint_ = 0;
    00170     *samples = nextOut();
    00171     lastFrame_[0] = *samples;
    00172     doNextOut_ = true;
    00173     apInput_ = inputs_[outPoint_++];
    00174     if ( outPoint_ == inputs_.size() ) outPoint_ = 0;
    00175   }
    00176
    00177   return frames;
    00178 }
    00179
    00180 inline StkFrames& DelayA :: tick( StkFrames& iFrames, StkFrames& oFrames, unsigned int iChannel, unsigned int oChannel )
    00181 {
    00182 #if defined(_STK_DEBUG_)
    00183   if ( iChannel >= iFrames.channels() || oChannel >= oFrames.channels() ) {
    00184     oStream_ << "DelayA::tick(): channel and StkFrames arguments are incompatible!";
    00185     handleError( StkError::FUNCTION_ARGUMENT );
    00186   }
    00187 #endif
    00188
    00189   StkFloat *iSamples = &iFrames[iChannel];
    00190   StkFloat *oSamples = &oFrames[oChannel];
    00191   unsigned int iHop = iFrames.channels(), oHop = oFrames.channels();
    00192   for ( unsigned int i=0; i<iFrames.frames(); i++, iSamples += iHop, oSamples += oHop ) {
    00193     inputs_[inPoint_++] = *iSamples * gain_;
    00194     if ( inPoint_ == inputs_.size() ) inPoint_ = 0;
    00195     *oSamples = nextOut();
    00196     lastFrame_[0] = *oSamples;
    00197     doNextOut_ = true;
    00198     apInput_ = inputs_[outPoint_++];
    00199     if ( outPoint_ == inputs_.size() ) outPoint_ = 0;
    00200   }
    00201
    00202   return iFrames;
    00203 }
    00204
    00205 } // stk namespace
    00206
    00207 #endif

The Synthesis ToolKit in C++ (STK)
©1995-2012 Perry R. Cook and Gary P. Scavone. All Rights Reserved.