Voicer.h

#ifndef STK_VOICER_H
#define STK_VOICER_H
 
#include "Instrmnt.h"
#include <vector>
 
namespace stk {
 
/***************************************************/
/***************************************************/
 
class Voicer : public Stk
{
 public:
  Voicer( StkFloat decayTime = 0.2 );
 
 
  void addInstrument( Instrmnt *instrument, int group=0 );
 
 
  void removeInstrument( Instrmnt *instrument );
 
 
  long noteOn( StkFloat noteNumber, StkFloat amplitude, int group=0 );
 
 
  void noteOff( StkFloat noteNumber, StkFloat amplitude, int group=0 );
 
 
  void noteOff( long tag, StkFloat amplitude );
 
 
  void setFrequency( StkFloat noteNumber, int group=0 );
 
 
  void setFrequency( long tag, StkFloat noteNumber );
 
  void pitchBend( StkFloat value, int group=0 );
 
  void pitchBend( long tag, StkFloat value );
 
  void controlChange( int number, StkFloat value, int group=0 );
 
  void controlChange( long tag, int number, StkFloat value );
 
  void silence( void );
 
  unsigned int channelsOut( void ) const { return lastFrame_.channels(); };
 
  const StkFrames& lastFrame( void ) const { return lastFrame_; };
 
 
  StkFloat lastOut( unsigned int channel = 0 );
 
 
  StkFloat tick( unsigned int channel = 0 );
 
 
  StkFrames& tick( StkFrames& frames, unsigned int channel = 0 );
 
 protected:
 
  struct Voice {
    Instrmnt *instrument;
    long tag;
    StkFloat noteNumber;
    StkFloat frequency;
    int sounding;
    int group;
 
    // Default constructor.
    Voice()
      :instrument(0), tag(0), noteNumber(-1.0), frequency(0.0), sounding(0), group(0) {}
  };
 
  std::vector<Voice> voices_;
  long tags_;
  int muteTime_;
  StkFrames lastFrame_;
};
 
inline StkFloat Voicer :: lastOut( unsigned int channel )
{
#if defined(_STK_DEBUG_)
  if ( channel >= lastFrame_.channels() ) {
    oStream_ << "Voicer::lastOut(): channel argument is invalid!";
    handleError( StkError::FUNCTION_ARGUMENT );
  }
#endif
 
  return lastFrame_[channel];
}
 
 
inline StkFloat Voicer :: tick( unsigned int channel )
{
  unsigned int j;
  for ( j=0; j<lastFrame_.channels(); j++ ) lastFrame_[j] = 0.0;
  for ( unsigned int i=0; i<voices_.size(); i++ ) {
    if ( voices_[i].sounding != 0 ) {
      voices_[i].instrument->tick();
      for ( j=0; j<voices_[i].instrument->channelsOut(); j++ ) lastFrame_[j] += voices_[i].instrument->lastOut( j );
    }
    if ( voices_[i].sounding < 0 )
      voices_[i].sounding++;
    if ( voices_[i].sounding == 0 )
      voices_[i].noteNumber = -1;
  }
 
  return lastFrame_[channel];
}
 
inline StkFrames& Voicer :: tick( StkFrames& frames, unsigned int channel )
{
  unsigned int nChannels = lastFrame_.channels();
#if defined(_STK_DEBUG_)
  if ( channel > frames.channels() - nChannels ) {
    oStream_ << "Voicer::tick(): channel and StkFrames arguments are incompatible!";
    handleError( StkError::FUNCTION_ARGUMENT );
  }
#endif
 
  StkFloat *samples = &frames[channel];
  unsigned int j, hop = frames.channels() - nChannels;
  for ( unsigned int i=0; i<frames.frames(); i++, samples += hop ) {
    tick();
    for ( j=0; j<nChannels; j++ )
      *samples++ = lastFrame_[j];
  }
 
  return frames;
}
 
} // stk namespace
 
#endif