The Synthesis ToolKit in C++ (STK)

Home Information Classes Download Usage Mail List Requirements Links FAQ Tutorial

Mandolin.h
1 #ifndef STK_MANDOLIN_H
2 #define STK_MANDOLIN_H
3
4 #include "Instrmnt.h"
5 #include "Twang.h"
6 #include "FileWvIn.h"
7
8 namespace stk {
9
10 /***************************************************/
36 /***************************************************/
37
38 class Mandolin : public Instrmnt
39 {
40 public:
42 Mandolin( StkFloat lowestFrequency );
43
45 ~Mandolin( void );
46
48 void clear( void );
49
51 void setDetune( StkFloat detune );
52
54 void setBodySize( StkFloat size );
55
57 void setPluckPosition( StkFloat position );
58
60 void setFrequency( StkFloat frequency );
61
63 void pluck( StkFloat amplitude );
64
66 void pluck( StkFloat amplitude,StkFloat position );
67
69 void noteOn( StkFloat frequency, StkFloat amplitude );
70
72 void noteOff( StkFloat amplitude );
73
75 void controlChange( int number, StkFloat value );
76
78 StkFloat tick( unsigned int channel = 0 );
79
81
88 StkFrames& tick( StkFrames& frames, unsigned int channel = 0 );
89
90 protected:
91
92 Twang strings_[2];
93 FileWvIn soundfile_[12];
94
95 int mic_;
96 StkFloat detuning_;
97 StkFloat frequency_;
98 StkFloat pluckAmplitude_;
99 };
100
101 inline StkFloat Mandolin :: tick( unsigned int )
102 {
103 StkFloat temp = 0.0;
104 if ( !soundfile_[mic_].isFinished() )
105 temp = soundfile_[mic_].tick() * pluckAmplitude_;
106
107 lastFrame_[0] = strings_[0].tick( temp );
108 lastFrame_[0] += strings_[1].tick( temp );
109 lastFrame_[0] *= 0.2;
110
111 return lastFrame_[0];
112 }
113
114 inline StkFrames& Mandolin :: tick( StkFrames& frames, unsigned int channel )
115 {
116 unsigned int nChannels = lastFrame_.channels();
117 #if defined(_STK_DEBUG_)
118 if ( channel > frames.channels() - nChannels ) {
119 oStream_ << "Mandolin::tick(): channel and StkFrames arguments are incompatible!";
120 handleError( StkError::FUNCTION_ARGUMENT );
121 }
122 #endif
123
124 StkFloat *samples = &frames[channel];
125 unsigned int j, hop = frames.channels() - nChannels;
126 if ( nChannels == 1 ) {
127 for ( unsigned int i=0; i<frames.frames(); i++, samples += hop )
128 *samples++ = tick();
129 }
130 else {
131 for ( unsigned int i=0; i<frames.frames(); i++, samples += hop ) {
132 *samples++ = tick();
133 for ( j=1; j<nChannels; j++ )
134 *samples++ = lastFrame_[j];
135 }
136 }
137
138 return frames;
139 }
140
141 } // stk namespace
142
143 #endif
stk::Mandolin::setFrequency
void setFrequency(StkFloat frequency)
Set instrument parameters for a particular frequency.
stk::FileWvIn
STK audio file input class.
Definition: FileWvIn.h:53
stk::Mandolin::setPluckPosition
void setPluckPosition(StkFloat position)
Set the pluck or "excitation" position along the string (0.0 - 1.0).
stk::StkFrames::frames
unsigned int frames(void) const
Return the number of sample frames represented by the data.
Definition: Stk.h:407
stk::Mandolin::noteOn
void noteOn(StkFloat frequency, StkFloat amplitude)
Start a note with the given frequency and amplitude (0.0 - 1.0).
stk::Twang
STK enhanced plucked string class.
Definition: Twang.h:35
stk::Mandolin
STK mandolin instrument model class.
Definition: Mandolin.h:39
stk::Mandolin::setBodySize
void setBodySize(StkFloat size)
Set the body size (a value of 1.0 produces the "default" size).
stk::Mandolin::clear
void clear(void)
Reset and clear all internal state.
stk::Mandolin::Mandolin
Mandolin(StkFloat lowestFrequency)
Class constructor, taking the lowest desired playing frequency.
stk::StkFrames
An STK class to handle vectorized audio data.
Definition: Stk.h:276
stk::Mandolin::noteOff
void noteOff(StkFloat amplitude)
Stop a note with the given amplitude (speed of decay).
stk::StkFrames::channels
unsigned int channels(void) const
Return the number of channels represented by the data.
Definition: Stk.h:404
stk::Stk::handleError
static void handleError(const char *message, StkError::Type type)
Static function for error reporting and handling using c-strings.
stk::Mandolin::~Mandolin
~Mandolin(void)
Class destructor.
stk::Twang::tick
StkFloat tick(StkFloat input)
Compute and return one output sample.
Definition: Twang.h:113
stk::Mandolin::pluck
void pluck(StkFloat amplitude, StkFloat position)
Pluck the strings with the given amplitude (0.0 - 1.0) and position (0.0 - 1.0).
stk::Mandolin::controlChange
void controlChange(int number, StkFloat value)
Perform the control change specified by number and value (0.0 - 128.0).
stk
The STK namespace.
Definition: ADSR.h:6
stk::Instrmnt
STK instrument abstract base class.
Definition: Instrmnt.h:20
stk::Mandolin::setDetune
void setDetune(StkFloat detune)
Detune the two strings by the given factor. A value of 1.0 produces unison strings.
stk::Mandolin::tick
StkFloat tick(unsigned int channel=0)
Compute and return one output sample.
Definition: Mandolin.h:101
stk::FileWvIn::tick
virtual StkFloat tick(unsigned int channel=0)
Compute a sample frame and return the specified channel value.
stk::Mandolin::pluck
void pluck(StkFloat amplitude)
Pluck the strings with the given amplitude (0.0 - 1.0) using the current frequency.

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