Home   Information   Classes   Download   Usage   Mail List   Requirements   Links   FAQ   Tutorial


Flute.h
1 #ifndef STK_FLUTE_H
2 #define STK_FLUTE_H
3 
4 #include "Instrmnt.h"
5 #include "JetTable.h"
6 #include "DelayL.h"
7 #include "OnePole.h"
8 #include "PoleZero.h"
9 #include "Noise.h"
10 #include "ADSR.h"
11 #include "SineWave.h"
12 
13 namespace stk {
14 
15 /***************************************************/
37 /***************************************************/
38 
39 class Flute : public Instrmnt
40 {
41  public:
43 
46  Flute( StkFloat lowestFrequency );
47 
49  ~Flute( void );
50 
52  void clear( void );
53 
55  void setFrequency( StkFloat frequency );
56 
58  void setJetReflection( StkFloat coefficient ) { jetReflection_ = coefficient; };
59 
61  void setEndReflection( StkFloat coefficient ) { endReflection_ = coefficient; };
62 
64  void setJetDelay( StkFloat aRatio );
65 
67  void startBlowing( StkFloat amplitude, StkFloat rate );
68 
70  void stopBlowing( StkFloat rate );
71 
73  void noteOn( StkFloat frequency, StkFloat amplitude );
74 
76  void noteOff( StkFloat amplitude );
77 
79  void controlChange( int number, StkFloat value );
80 
82  StkFloat tick( unsigned int channel = 0 );
83 
85 
92  StkFrames& tick( StkFrames& frames, unsigned int channel = 0 );
93 
94  protected:
95 
96  DelayL jetDelay_;
97  DelayL boreDelay_;
98  JetTable jetTable_;
99  OnePole filter_;
100  PoleZero dcBlock_;
101  Noise noise_;
102  ADSR adsr_;
103  SineWave vibrato_;
104 
105  StkFloat lastFrequency_;
106  StkFloat maxPressure_;
107  StkFloat jetReflection_;
108  StkFloat endReflection_;
109  StkFloat noiseGain_;
110  StkFloat vibratoGain_;
111  StkFloat outputGain_;
112  StkFloat jetRatio_;
113 
114 };
115 
116 inline StkFloat Flute :: tick( unsigned int )
117 {
118  StkFloat pressureDiff;
119  StkFloat breathPressure;
120 
121  // Calculate the breath pressure (envelope + noise + vibrato)
122  breathPressure = maxPressure_ * adsr_.tick();
123  breathPressure += breathPressure * ( noiseGain_ * noise_.tick() + vibratoGain_ * vibrato_.tick() );
124 
125  StkFloat temp = -filter_.tick( boreDelay_.lastOut() );
126  //temp = dcBlock_.tick( temp ); // Block DC on reflection.
127 
128  pressureDiff = breathPressure - (jetReflection_ * temp);
129  pressureDiff = jetDelay_.tick( pressureDiff );
130  //pressureDiff = jetTable_.tick( pressureDiff ) + (endReflection_ * temp);
131  pressureDiff = dcBlock_.tick(jetTable_.tick( pressureDiff )) + (endReflection_ * temp); // moved the DC blocker to after the jet non-linearity (GPS, 29 Jan. 2020)
132  lastFrame_[0] = (StkFloat) 0.3 * boreDelay_.tick( pressureDiff );
133 
134  lastFrame_[0] *= outputGain_;
135  return lastFrame_[0];
136 }
137 
138 inline StkFrames& Flute :: tick( StkFrames& frames, unsigned int channel )
139 {
140  unsigned int nChannels = lastFrame_.channels();
141 #if defined(_STK_DEBUG_)
142  if ( channel > frames.channels() - nChannels ) {
143  oStream_ << "Flute::tick(): channel and StkFrames arguments are incompatible!";
144  handleError( StkError::FUNCTION_ARGUMENT );
145  }
146 #endif
147 
148  StkFloat *samples = &frames[channel];
149  unsigned int j, hop = frames.channels() - nChannels;
150  if ( nChannels == 1 ) {
151  for ( unsigned int i=0; i<frames.frames(); i++, samples += hop )
152  *samples++ = tick();
153  }
154  else {
155  for ( unsigned int i=0; i<frames.frames(); i++, samples += hop ) {
156  *samples++ = tick();
157  for ( j=1; j<nChannels; j++ )
158  *samples++ = lastFrame_[j];
159  }
160  }
161 
162  return frames;
163 }
164 
165 } // stk namespace
166 
167 #endif
STK ADSR envelope class.
Definition: ADSR.h:25
StkFloat tick(void)
Compute and return one output sample.
Definition: ADSR.h:115
STK linear interpolating delay line class.
Definition: DelayL.h:28
StkFloat lastOut(void) const
Return the last computed output value.
Definition: DelayL.h:76
StkFloat tick(StkFloat input)
Input one sample to the filter and return one output.
Definition: DelayL.h:163
STK flute physical model class.
Definition: Flute.h:40
void setJetReflection(StkFloat coefficient)
Set the reflection coefficient for the jet delay (-1.0 - 1.0).
Definition: Flute.h:58
void startBlowing(StkFloat amplitude, StkFloat rate)
Apply breath velocity to instrument with given amplitude and rate of increase.
void clear(void)
Reset and clear all internal state.
void stopBlowing(StkFloat rate)
Decrease breath velocity with given rate of decrease.
~Flute(void)
Class destructor.
void setEndReflection(StkFloat coefficient)
Set the reflection coefficient for the air column delay (-1.0 - 1.0).
Definition: Flute.h:61
void controlChange(int number, StkFloat value)
Perform the control change specified by number and value (0.0 - 128.0).
Flute(StkFloat lowestFrequency)
Class constructor, taking the lowest desired playing frequency.
StkFloat tick(unsigned int channel=0)
Compute and return one output sample.
Definition: Flute.h:116
void setJetDelay(StkFloat aRatio)
Set the length of the jet delay in terms of a ratio of jet delay to air column delay lengths.
void noteOff(StkFloat amplitude)
Stop a note with the given amplitude (speed of decay).
void setFrequency(StkFloat frequency)
Set instrument parameters for a particular frequency.
void noteOn(StkFloat frequency, StkFloat amplitude)
Start a note with the given frequency and amplitude.
STK instrument abstract base class.
Definition: Instrmnt.h:20
STK jet table class.
Definition: JetTable.h:24
StkFloat tick(StkFloat input)
Take one sample input and map to one sample of output.
Definition: JetTable.h:54
STK noise generator.
Definition: Noise.h:22
StkFloat tick(void)
Compute and return one output sample.
Definition: Noise.h:59
STK one-pole filter class.
Definition: OnePole.h:21
StkFloat tick(StkFloat input)
Input one sample to the filter and return one output.
Definition: OnePole.h:80
STK one-pole, one-zero filter class.
Definition: PoleZero.h:22
StkFloat tick(StkFloat input)
Input one sample to the filter and return one output.
Definition: PoleZero.h:79
STK sinusoid oscillator class.
Definition: SineWave.h:26
StkFloat tick(void)
Compute and return one output sample.
Definition: SineWave.h:99
An STK class to handle vectorized audio data.
Definition: Stk.h:279
unsigned int channels(void) const
Return the number of channels represented by the data.
Definition: Stk.h:416
unsigned int frames(void) const
Return the number of sample frames represented by the data.
Definition: Stk.h:419
static void handleError(const char *message, StkError::Type type)
Static function for error reporting and handling using c-strings.
The STK namespace.
Definition: ADSR.h:6

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