Guitar.h

#ifndef STK_GUITAR_H
#define STK_GUITAR_H
 
#include "Stk.h"
#include "Twang.h"
#include "OnePole.h"
#include "OneZero.h"
 
namespace stk {
 
/***************************************************/
/***************************************************/
 
class Guitar : public Stk
{
 public:
  Guitar( unsigned int nStrings = 6, std::string bodyfile = "" );
 
  void clear( void );
 
 
  void setBodyFile( std::string bodyfile = "" );
 
 
  void setPluckPosition( StkFloat position, int string = -1 );
 
 
  void setLoopGain( StkFloat gain, int string = -1 );
 
  void setFrequency( StkFloat frequency, unsigned int string = 0 );
 
 
  void noteOn( StkFloat frequency, StkFloat amplitude, unsigned int string = 0 );
 
  void noteOff( StkFloat amplitude, unsigned int string = 0 );
 
 
  void controlChange( int number, StkFloat value, int string = -1 );
 
  StkFloat lastOut( void ) { return lastFrame_[0]; };
 
  StkFloat tick( StkFloat input = 0.0 );
 
 
  StkFrames& tick( StkFrames& frames, unsigned int channel = 0 );
 
 
  StkFrames& tick( StkFrames& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 );
 
 protected:
 
  std::vector< stk::Twang > strings_;
  std::vector< int > stringState_; // 0 = off, 1 = decaying, 2 = on
  std::vector< unsigned int > decayCounter_;
  std::vector< unsigned int > filePointer_;
  std::vector< StkFloat > pluckGains_;
 
  OnePole   pickFilter_;
  OnePole   couplingFilter_;
  StkFloat  couplingGain_;
  StkFrames excitation_;
  StkFrames lastFrame_;
};
 
// NOTE: It is not possible to implement the Smith coupled string model here because the Twang class does
// not currently offer the chance to have access to a traveling-wave component. Thus, the coupling
// implemented here is approximate.
inline StkFloat Guitar :: tick( StkFloat input )
{
  StkFloat temp, output = 0.0;
  lastFrame_[0] = couplingGain_ * couplingFilter_.tick( lastFrame_[0] ) / strings_.size();
  for ( unsigned int i=0; i<strings_.size(); i++ ) {
    if ( stringState_[i] ) {
      temp = input;
      // If pluckGain < 0.2, let string ring but don't pluck it.
      if ( filePointer_[i] < excitation_.frames() && pluckGains_[i] > 0.2 )
        temp += pluckGains_[i] * excitation_[filePointer_[i]++];
      temp += lastFrame_[0]; // bridge coupling
      output += strings_[i].tick( temp );
      // Check if string energy has decayed sufficiently to turn it off.
      if ( stringState_[i] == 1 ) {
        if ( fabs( strings_[i].lastOut() ) < 0.001 ) decayCounter_[i]++;
        else decayCounter_[i] = 0;
        if ( decayCounter_[i] > (unsigned int) floor( 0.1 * Stk::sampleRate() ) ) {
          stringState_[i] = 0;
          decayCounter_[i] = 0;
        }
      }
    }
  }
 
  return lastFrame_[0] = output;
}
 
inline StkFrames& Guitar :: tick( StkFrames& frames, unsigned int channel )
{
#if defined(_STK_DEBUG_)
  if ( channel >= frames.channels() ) {
    oStream_ << "Guitar::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 );
 
  return frames;
}
 
inline StkFrames& Guitar :: tick( StkFrames& iFrames, StkFrames& oFrames, unsigned int iChannel, unsigned int oChannel )
{
#if defined(_STK_DEBUG_)
  if ( iChannel >= iFrames.channels() || oChannel >= oFrames.channels() ) {
    oStream_ << "Guitar::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 );
 
  return iFrames;
}
 
} // stk namespace
 
#endif