Granulate.h

#ifndef STK_GRANULATE_H
#define STK_GRANULATE_H
 
#include <vector>
#include "Generator.h"
#include "Envelope.h"
#include "Noise.h"
 
namespace stk {
 
/***************************************************/
/***************************************************/
 
class Granulate: public Generator
{
 public:
  Granulate( void );
 
  Granulate( unsigned int nVoices, std::string fileName, bool typeRaw = false );
 
  ~Granulate( void );
 
 
  void openFile( std::string fileName, bool typeRaw = false );
 
 
  void reset( void );
 
 
  void setVoices( unsigned int nVoices = 1 );
 
 
  void setStretch( unsigned int stretchFactor = 1 );
 
 
  void setGrainParameters( unsigned int duration = 30, unsigned int rampPercent = 50,
                           int offset = 0, unsigned int delay = 0 );
 
 
  void setRandomFactor( StkFloat randomness = 0.1 );
 
 
  StkFloat lastOut( unsigned int channel = 0 );
 
  StkFloat tick( unsigned int channel = 0 );
 
 
  StkFrames& tick( StkFrames& frames, unsigned int channel = 0 );
 
  enum GrainState {
    GRAIN_STOPPED,
    GRAIN_FADEIN,
    GRAIN_SUSTAIN,
    GRAIN_FADEOUT
  };
 
 protected:
 
  struct Grain {
    StkFloat eScaler;
    StkFloat eRate;
    unsigned long attackCount;
    unsigned long sustainCount;
    unsigned long decayCount;
    unsigned long delayCount;
    unsigned long counter;
    //unsigned long pointer;
    StkFloat pointer;
    unsigned long startPointer;
    unsigned int repeats;
    GrainState state;
 
    // Default constructor.
    Grain()
      :eScaler(0.0), eRate(0.0), attackCount(0), sustainCount(0), decayCount(0),
       delayCount(0), counter(0), pointer(0), startPointer(0), repeats(0), state(GRAIN_STOPPED) {}
  };
 
  void calculateGrain( Granulate::Grain& grain );
 
  StkFrames data_;
  std::vector<Grain> grains_;
  Noise noise;
  //long gPointer_;
  StkFloat gPointer_;
 
  // Global grain parameters.
  unsigned int gDuration_;
  unsigned int gRampPercent_;
  unsigned int gDelay_;
  unsigned int gStretch_;
  unsigned int stretchCounter_;
  int gOffset_;
  StkFloat gRandomFactor_;
  StkFloat gain_;
 
};
 
inline StkFloat Granulate :: lastOut( unsigned int channel )
{
#if defined(_STK_DEBUG_)
  if ( channel >= lastFrame_.channels() ) {
    oStream_ << "Granulate::lastOut(): channel argument is invalid!";
    handleError( StkError::FUNCTION_ARGUMENT );
  }
#endif
 
  return lastFrame_[channel];
}
 
inline StkFrames& Granulate :: tick( StkFrames& frames, unsigned int channel )
{
  unsigned int nChannels = lastFrame_.channels();
#if defined(_STK_DEBUG_)
  if ( channel > frames.channels() - nChannels ) {
    oStream_ << "Granulate::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 ) {
    *samples++ = tick();
    for ( j=1; j<nChannels; j++ )
      *samples++ = lastFrame_[j];
  }
 
  return frames;
}
 
} // stk namespace
 
#endif