SynthLab SDK
synthvoice.h
1 #ifndef __synthVoice_h__
2 #define __synthVoice_h__
3 
4 // --- we need these
5 #include "synthbase.h"
6 
7 // --- components common to all SynthLab synths
8 #include "modmatrix.h"
9 #include "dca.h"
10 #include "lfo.h"
11 #include "envelopegenerator.h"
12 #include "synthfilter.h"
13 
14 #define SYNTHLAB_WT 1
15 //#define SYNTHLAB_VA 1
16 //#define SYNTHLAB_PCM 1
17 //#define SYNTHLAB_KS 1
18 //#define SYNTHLAB_DX 1
19 //#define SYNTHLAB_WS 1
20 
21 // --- SL_WT
22 #ifdef SYNTHLAB_WT
23 #include "wtoscillator.h"
24 #endif
25 
26 #ifdef SYNTHLAB_VA
27 #include "vaoscillator.h"
28 #endif
29 
30 #ifdef SYNTHLAB_PCM
31 #include "pcmoscillator.h"
32 #endif
33 
34 #ifdef SYNTHLAB_KS
35 #include "ksoscillator.h"
36 #endif
37 
38 #ifdef SYNTHLAB_DX
39 #include "fmoperator.h"
40 #endif
41 
42 #ifdef SYNTHLAB_WS
43 #include "wsoscillator.h"
44 #include "sequencer.h"
45 #endif
46 
47 namespace SynthLab
48 {
49  // --- SYNTHLAB STEP 1: Set Default Cores
50  //
51  // The "default cores" will setup the initial state of the synth's modules.
52  // If you are using dynamic string loading (below) then these will be overwritten.
53 
54  // --- there are 2 built-in LFO cores
55  enum class lfoCoreType { standardLFO, fmLFO };
56 
57  // --- there are 2 built-in EG cores
58  enum class egCoreType { analogEG, dxEG };
59 
60  // --- there are 2 built-in filter cores
61  enum class filterCoreType { virtualAnalog, biQuad };
62 
63  // --- SETUP DEFAULT CORES HERE ------------------------------------ //
64  // --- LFOs
65  const lfoCoreType lfoCores[NUM_LFO] =
66  {
67  lfoCoreType::standardLFO, /* CORE 0 */
68  lfoCoreType::fmLFO /* CORE 1 */
69  };
70 
71  // --- EGs (individually named)
72  const egCoreType ampEGCore = egCoreType::analogEG;
73  const egCoreType filterEGCore = egCoreType::analogEG;
74  const egCoreType auxEGCore = egCoreType::dxEG;
75 
76  // --- FILTERS
77  const filterCoreType filterCores[NUM_FILTER] =
78  {
79  filterCoreType::virtualAnalog, /* CORE 0 */
80  filterCoreType::biQuad /* CORE 1 */
81  };
82 
83  // --- VIRTUAL ANALOG FGN (finite gain at Nyquist)
84  // This option (see book) requires more CPU, VA filters only.
85  // Set this to FALSE for normal bilinear transform opertion
86  // and less CPU usage
87  const bool useAnalogFGN = false;
88 
89  // --- there are 4 wavetable oscillators to choose from
90  enum class wtCoreType { classicWT, morphingWT, soundFXWT, drumWT };
91 
92  // --- wavetable cores (SynthLab-WT only)
93  const wtCoreType wtCores[NUM_OSC] =
94  {
95  wtCoreType::classicWT, /* CORE 0 */
96  wtCoreType::classicWT, /* CORE 1 */
97  wtCoreType::morphingWT, /* CORE 2 */
98  wtCoreType::soundFXWT /* CORE 3 */
99  };
100 
101  // --- there are 4 wavetable oscillators to choose from
102  enum class pcmCoreType { legacyPCM, mellotronPCM, waveslicePCM };
103 
104  // --- wavetable cores (SynthLab-PCM only)
105  const pcmCoreType pcmCores[NUM_OSC] =
106  {
107  pcmCoreType::legacyPCM, /* CORE 0 */
108  pcmCoreType::legacyPCM, /* CORE 1 */
109  pcmCoreType::mellotronPCM, /* CORE 2 */
110  pcmCoreType::waveslicePCM /* CORE 3 */
111  };
112 
113  // --- SYNTHLAB STEP 2: Choose your GUI paradigm
114  /*
115  // -------------------------- //
116  // *** Fixed GUI Strings *** //
117  // -------------------------- //
118  //
119  If you are using the simplest implementation with fixed GUI string lists,
120  then these will be hard-coded and you will NOT provide a GUI interface
121  for selecting a core for any of the modules.
122 
123  - you hardware the GUI control strings when you create the synth GUI:
124  LFO Waveforms
125  Oscillator Waveforms
126  Filter Types
127  EG Contours
128  Mod Knob Labels (A, B, C, D)
129 
130  --------------------------
131  STRING LISTS FOR YOUR GUI
132  --------------------------
133 
134 
135  // --------------------------- //
136  // *** Dynamic GUI Strings *** //
137  // --------------------------- //
138  //
139  This is the advanced mode of operation
140 
141  (1) You provide a GUI control for the module cores for each module. This control
142  has a maximum string count of 4 and you set it up with 4 dummy strings at the start.
143 
144  When the GUI is opening, you dynamically populate these controls with the
145  core name strings.
146 
147  Use the synthVoice->getModuleCoreNames( ) function to retrieve a vector full
148  of these strings and use that to populate the control, overwriting the dummy
149  variables you setup. Note that this happens at run-time when the GUI is opened.
150 
151  std::vector<std::string> SynthVoice::getModuleCoreNames(uint32_t moduleType)
152 
153  The moduleType is an unsigned int, and you can find the list in the synthconstants.h file.
154 
155  To get a list of LFO core names, you would write:
156 
157  // --- vector to fill
158  std::vector<std::string> coreStrings;
159 
160  // --- get LFO core names
161  coreStrings = synthVoice->getModuleCoreNames(LFO_MODULE);
162 
163 
164  (2) You also provide the core string list control that will contain the
165  strings specific to that module. For oscillators, this control will hold
166  waveform name strings. These GUI controls have a maximum string count of 16
167  and you setup the GUI Control with 16 dummy strings as placeholders.
168 
169  When the user selects a core from the core-list, you dynamically populate
170  these controls with these core-specific strings. For an oscillator module,
171  selecting a new core will change the strings in the GUI control.
172 
173  It is important that you manually (in code) select the first core and then
174  populate its liston startup so that the initial state is established.
175 
176  Use the synthVoice->getModuleCoreStrings( ) function to retrieve a vector full
177  of these strings and use that to populate the control, overwriting the dummy
178  variables you setup. Note that this happens at run-time when the GUI is opened
179  and then again whenever the user selects a different core.
180 
181  The function uses an unsigned int mask to parse the information, e.g. LFO1_WAVEFORMS,
182  FILTER1_TYPES, EG2_CONTOUR, etc... as defined in synthconstants.h
183 
184  To retrieve the oscillator 1 waveform strings as a result of the user selecting
185  a new core for that oscillator, write:
186 
187  // --- vector to fill
188  std::vector<std::string> waveforms;
189 
190  // --- get OSC1 waveforms
191  waveforms = synthVoice->getModuleStrings(OSC1_WAVEFORMS, false); // <- false = not-mod knob labels
192 
193 
194  Mod Knob Labels:
195  In addition to the module string list being changed, selecting a new core may
196  also change the A, B, C, D labels above each of the 4 mod knobs. You need to
197  have a GUI library that allows you to change these strings during run-time.
198 
199  Use the synthVoice->getModuleCoreStrings( ) function to retrieve the mod knob
200  names. Set the argument modKnobs = true to retrieve these strings. Use the constants
201  defined in synthconstants.h to select the strings for a particular module.
202 
203  To get the mod knob label strings in a vector (it will return a list of 4 strings)
204  for LFO1, write:
205 
206  // --- vector to fill
207  std::vector<std::string> modKnobLables;
208 
209  // --- get LFO1 mod knobs
210  modKnobLables = synthVoice->getModuleStrings(LFO1_MOD_KNOBS, true); // <- false = not-mod knob labels
211  */
212 
213  // ----------------------------------------------------------------------------------------------------------------------------
234  {
236 
237  // --- synth mode; engine has same variable
238  uint32_t synthModeIndex = enumToInt(SynthMode::kMono);
239 
240  // --- synth mode; engine has same variable
241  uint32_t filterModeIndex = enumToInt(FilterMode::kSeries);
242 
243  // --- portamento (glide)
244  bool enablePortamento = false;// false;
245 
246  // --- glide time
247  double glideTime_mSec = 0.0;
248 
249  // --- legato mode
250  bool legatoMode = false;
251 
252  // --- freerun
253  bool freeRunOscMode = false;
254 
255  // --- unison Detune - each voice will be detuned differently
256  double unisonDetuneCents = 0.0;
257  double unisonStartPhase = 0.0;
258  double unisonPan = 0.0;
259 
260  // --- components SL_WT
261 #ifdef SYNTHLAB_WT
262  std::shared_ptr<WTOscParameters> osc1Parameters = std::make_shared<WTOscParameters>();
263  std::shared_ptr<WTOscParameters> osc2Parameters = std::make_shared<WTOscParameters>();
264  std::shared_ptr<WTOscParameters> osc3Parameters = std::make_shared<WTOscParameters>();
265  std::shared_ptr<WTOscParameters> osc4Parameters = std::make_shared<WTOscParameters>();
266 #elif defined SYNTHLAB_VA
267  std::shared_ptr<VAOscParameters> osc1Parameters = std::make_shared<VAOscParameters>();
268  std::shared_ptr<VAOscParameters> osc2Parameters = std::make_shared<VAOscParameters>();
269  std::shared_ptr<VAOscParameters> osc3Parameters = std::make_shared<VAOscParameters>();
270  std::shared_ptr<VAOscParameters> osc4Parameters = std::make_shared<VAOscParameters>();
271 #elif defined SYNTHLAB_PCM
272  std::shared_ptr<PCMOscParameters> osc1Parameters = std::make_shared<PCMOscParameters>();
273  std::shared_ptr<PCMOscParameters> osc2Parameters = std::make_shared<PCMOscParameters>();
274  std::shared_ptr<PCMOscParameters> osc3Parameters = std::make_shared<PCMOscParameters>();
275  std::shared_ptr<PCMOscParameters> osc4Parameters = std::make_shared<PCMOscParameters>();
276 #elif defined SYNTHLAB_KS
277  std::shared_ptr<KSOscParameters> osc1Parameters = std::make_shared<KSOscParameters>();
278  std::shared_ptr<KSOscParameters> osc2Parameters = std::make_shared<KSOscParameters>();
279  std::shared_ptr<KSOscParameters> osc3Parameters = std::make_shared<KSOscParameters>();
280  std::shared_ptr<KSOscParameters> osc4Parameters = std::make_shared<KSOscParameters>();
281 #elif defined SYNTHLAB_DX
282  // --- fm Algo
283  uint32_t fmAlgorithmIndex = enumToInt(DX100Algo::kFM1);
284  std::shared_ptr<FMOperatorParameters> osc1Parameters = std::make_shared<FMOperatorParameters>();
285  std::shared_ptr<FMOperatorParameters> osc2Parameters = std::make_shared<FMOperatorParameters>();
286  std::shared_ptr<FMOperatorParameters> osc3Parameters = std::make_shared<FMOperatorParameters>();
287  std::shared_ptr<FMOperatorParameters> osc4Parameters = std::make_shared<FMOperatorParameters>();
288 #elif defined SYNTHLAB_WS
289  std::shared_ptr<WaveSequencerParameters> waveSequencerParameters = std::make_shared<WaveSequencerParameters>();
290 
291  std::shared_ptr<WSOscParameters> wsOsc1Parameters = std::make_shared<WSOscParameters>();
292  std::shared_ptr<WSOscParameters> wsOsc2Parameters = std::make_shared<WSOscParameters>();
293 #endif
294 
295  // --- LFOs
296  std::shared_ptr<LFOParameters> lfo1Parameters = std::make_shared<LFOParameters>();
297  std::shared_ptr<LFOParameters> lfo2Parameters = std::make_shared<LFOParameters>();
298 
299  // --- EGs
300  std::shared_ptr<EGParameters> ampEGParameters = std::make_shared<EGParameters>();
301  std::shared_ptr<EGParameters> filterEGParameters = std::make_shared<EGParameters>();
302  std::shared_ptr<EGParameters> auxEGParameters = std::make_shared<EGParameters>();
303 
304  // --- filters
305  std::shared_ptr<FilterParameters> filter1Parameters = std::make_shared<FilterParameters>();
306  std::shared_ptr<FilterParameters> filter2Parameters = std::make_shared<FilterParameters>();
307 
308  // --- DCA
309  std::shared_ptr<DCAParameters> dcaParameters = std::make_shared<DCAParameters>();
310 
311  // --- ModMatrix
312  std::shared_ptr<ModMatrixParameters> modMatrixParameters = std::make_shared<ModMatrixParameters>();
313 
314  // --- Dynamic String suport: you can use these to keep track of the lists and knobs
315  uint32_t updateCodeDroplists = 0;
316  uint32_t updateCodeKnobs = 0;
317  };
318 
319  // --- voice mode: note on or note off states
320  enum class voiceState { kNoteOnState, kNoteOffState };
321 
390  {
391  public:
392  SynthVoice(std::shared_ptr<MidiInputData> _midiInputData,
393  const std::shared_ptr<MidiOutputData> _midiOutputData,
394  std::shared_ptr<SynthVoiceParameters> _parameters,
395  std::shared_ptr<WavetableDatabase> _wavetableDatabase,
396  std::shared_ptr<PCMSampleDatabase> _sampleDatabase,
397  uint32_t _blockSize = 64);
398 
399  virtual ~SynthVoice() {}
400 
402  virtual bool reset(double _sampleRate);
403  virtual bool update();
404  virtual bool render(SynthProcessInfo& synthProcessInfo);
405  virtual bool processMIDIEvent(midiEvent& event);
406  virtual bool initialize(const char* dllPath = nullptr);
407  virtual bool doNoteOn(midiEvent& event);
408  virtual bool doNoteOff(midiEvent& event);
409 
411  bool isVoiceActive() { return voiceIsActive; }
412 
414  voiceState getVoiceState() { return voiceNoteState; }
415 
416  // --- timestamps for determining note age;
417  // public because containing object needs to manipulate them
418  uint32_t getTimestamp() { return timestamp; }
420  void clearTimestamp() { timestamp = 0; }
421 
422  // --- MIDI note stuff
423  unsigned int getMIDINoteNumber() { return voiceMIDIEvent.midiData1; }
424 
425  // --- voice steal
427  bool voiceIsStealing() { return stealPending; }
428 
429  // --- Dynamic Strings
430  // --- these are only for dynamic module loading and can be removed for non ASPiK versions
431  // --- optional for frameworks that can load dynamic GUI stuff
432  std::vector<std::string> getModuleCoreNames(uint32_t moduleType);
433  std::vector<std::string> getModuleStrings(uint32_t mask, bool modKnobs);
434 
435  // --- Dynamic String suport
436  void setAllCustomUpdateCodes();
437 
438  // --- functions to load individual cores, if using this option (see top of file)
439  void loadLFOCore(uint32_t lfoIndex, uint32_t index);
440  void loadFilterCore(uint32_t filterIndex, uint32_t index);
441  void loadOscCore(uint32_t oscIndex, uint32_t index);
442  void loadEGCore(uint32_t egIndex, uint32_t index);
443 
444  // --- DM STUFF ---
445  void setDynamicModules(std::vector<std::shared_ptr<SynthLab::ModuleCore>> modules);
446 
447  protected:
449  std::shared_ptr<SynthVoiceParameters> parameters = nullptr;
450 
451  // --- local storage
452  double sampleRate = 0.0;
453  uint32_t blockSize = 64;
454 
455  // --- interface pointer
456  std::shared_ptr<MidiInputData> midiInputData = nullptr;
457  const std::shared_ptr<MidiOutputData> midiOutputData = nullptr;
458  std::shared_ptr<WavetableDatabase> wavetableDatabase = nullptr;
459  std::shared_ptr<PCMSampleDatabase> sampleDatabase = nullptr;
460 
461  std::shared_ptr<AudioBuffer> mixBuffers = nullptr;
462  void accumulateToMixBuffer(std::shared_ptr<AudioBuffer> oscBuffers, uint32_t samplesInBlock, double scaling);
463  void writeToMixBuffer(std::shared_ptr<AudioBuffer> oscBuffers, uint32_t samplesInBlock, double scaling);
464 
465  // --- voice timestamp, for knowing the age of a voice
466  uint32_t timestamp = 0;
467  int32_t currentMIDINote = -1;
468 
469  // --- note message state
470  voiceState voiceNoteState = voiceState::kNoteOffState;
471 
472  // --- per-voice stuff
473  bool voiceIsActive = false;
475 
476  // --- for voice stealing
477  bool stealPending = false;
479 
480  // --- each voice has a modulation matrix
481  // but rows/columns are shared via matrix parameters
482  std::unique_ptr<ModMatrix> modMatrix;
483 
484 #ifdef SYNTHLAB_WS
485  // --- wave sequencer (only used in SynthLab-WS)
486  std::unique_ptr<WaveSequencer> waveSequencer;
487 
488  // ---- components: 1 WS oscillator
489  enum { MAIN_OSC, DETUNED_OSC, NUM_WS_OSC };
490  std::unique_ptr<WSOscillator> wsOscillator[NUM_WS_OSC] = { nullptr, nullptr };
491  std::unique_ptr<WSOscillator> wsOscillatorDetuned = nullptr;
492 #else
493  // ---- components: 4 oscillators
494  std::unique_ptr<SynthModule> oscillator[NUM_OSC];
495 #endif
496 
497  // --- LFOs
498  std::unique_ptr<SynthLFO> lfo[NUM_LFO];
499 
500  // --- Filters
501  std::unique_ptr<SynthFilter> filter[NUM_FILTER];
502 
503  // --- EGs
504  std::unique_ptr<EnvelopeGenerator> ampEG;
505  std::unique_ptr<EnvelopeGenerator> filterEG;
506  std::unique_ptr<EnvelopeGenerator> auxEG;
507 
508  // --- DCA(s)
509  std::unique_ptr<DCA> dca;
510 
511  };
512 
513 }
514 #endif /* defined(__synthVoice_h__) */
std::vector< std::string > getModuleCoreNames(uint32_t moduleType)
only for dynamic string loading
Definition: synthvoice.cpp:1020
#define enumToInt(ENUM)
macro helper to cast a typed enum to an int
Definition: synthfunctions.h:234
midiEvent voiceMIDIEvent
MIDI note event for current voice.
Definition: synthvoice.h:474
virtual bool initialize(const char *dllPath=nullptr)
Initialize the voice sub-components; this really only applies to PCM oscillators that need DLL path B...
Definition: synthvoice.cpp:351
std::unique_ptr< EnvelopeGenerator > filterEG
filter EG
Definition: synthvoice.h:505
This is the voice object for a software synth.
Definition: synthvoice.h:389
uint32_t midiData1
BYTE data 1 as UINT.
Definition: synthstructures.h:185
std::unique_ptr< ModMatrix > modMatrix
mod matrix for this voice
Definition: synthvoice.h:482
const uint32_t NUM_OSC
Definition: synthconstants.h:84
const uint32_t NUM_LFO
Definition: synthconstants.h:85
void accumulateToMixBuffer(std::shared_ptr< AudioBuffer > oscBuffers, uint32_t samplesInBlock, double scaling)
accumulating voice audio data
Definition: synthvoice.cpp:508
virtual bool reset(double _sampleRate)
Reset all SynthModules on init or when sample rate changes.
Definition: synthvoice.cpp:376
std::unique_ptr< SynthLFO > lfo[NUM_LFO]
LFOs.
Definition: synthvoice.h:498
std::shared_ptr< SynthVoiceParameters > parameters
Definition: synthvoice.h:449
int32_t currentMIDINote
voice timestamp, for knowing the age of a voice
Definition: synthvoice.h:467
unsigned int getStealMIDINoteNumber()
note is data byte 1, velocity is byte 2
Definition: synthvoice.h:426
std::unique_ptr< SynthFilter > filter[NUM_FILTER]
filters
Definition: synthvoice.h:501
void clearTimestamp()
reset timestamp after voice is turned off
Definition: synthvoice.h:420
void writeToMixBuffer(std::shared_ptr< AudioBuffer > oscBuffers, uint32_t samplesInBlock, double scaling)
write to final mix buffer
Definition: synthvoice.cpp:532
void loadFilterCore(uint32_t filterIndex, uint32_t index)
load a new filter core
Definition: synthvoice.cpp:1309
void loadOscCore(uint32_t oscIndex, uint32_t index)
load a new oscillator core
Definition: synthvoice.cpp:1347
std::shared_ptr< AudioBuffer > mixBuffers
buffers for mixing audio and procesisng the voice digital audio engine
Definition: synthvoice.h:461
Definition: analogegcore.cpp:4
bool stealPending
stealing is inevitible
Definition: synthvoice.h:477
std::vector< std::string > getModuleStrings(uint32_t mask, bool modKnobs)
only for dynamic string loading
Definition: synthvoice.cpp:1094
virtual bool doNoteOn(midiEvent &event)
Note-on handler for voice.
Definition: synthvoice.cpp:844
void loadEGCore(uint32_t egIndex, uint32_t index)
load a new EG core
Definition: synthvoice.cpp:1444
const uint32_t NUM_FILTER
Definition: synthconstants.h:86
void setAllCustomUpdateCodes()
one of many ways to keep track of what needs updating; this will likely be very dependent on your GUI...
Definition: synthvoice.cpp:972
voiceState getVoiceState()
Definition: synthvoice.h:414
std::shared_ptr< PCMSampleDatabase > sampleDatabase
shared PCM database
Definition: synthvoice.h:459
virtual bool processMIDIEvent(midiEvent &event)
MIDI Event handler.
Definition: synthvoice.cpp:942
bool voiceIsStealing()
trur if voice will be stolen
Definition: synthvoice.h:427
std::unique_ptr< SynthModule > oscillator[NUM_OSC]
oscillators
Definition: synthvoice.h:494
uint32_t timestamp
voice timestamp, for knowing the age of a voice
Definition: synthvoice.h:466
midiEvent voiceStealMIDIEvent
MIDI note event for the new (stolen) voice.
Definition: synthvoice.h:478
SynthVoice(std::shared_ptr< MidiInputData > _midiInputData, const std::shared_ptr< MidiOutputData > _midiOutputData, std::shared_ptr< SynthVoiceParameters > _parameters, std::shared_ptr< WavetableDatabase > _wavetableDatabase, std::shared_ptr< PCMSampleDatabase > _sampleDatabase, uint32_t _blockSize=64)
Construction:
Definition: synthvoice.cpp:27
std::unique_ptr< DCA > dca
one and only DCA
Definition: synthvoice.h:509
This structure holds all of the information needed to for the plugin framework to send MIDI informati...
Definition: synthbase.h:1316
Contains parameters for the Synth Voice component.
Definition: synthvoice.h:233
virtual bool render(SynthProcessInfo &synthProcessInfo)
Render a block of audio data for an active note event.
Definition: synthvoice.cpp:562
virtual ~SynthVoice()
empty destructor
Definition: synthvoice.h:399
void setDynamicModules(std::vector< std::shared_ptr< SynthLab::ModuleCore >> modules)
add dynamically loaded DLL modules to existing cores
Definition: synthvoice.cpp:1205
void loadLFOCore(uint32_t lfoIndex, uint32_t index)
load a new LFO core
Definition: synthvoice.cpp:1273
std::shared_ptr< MidiInputData > midiInputData
shared MIDI input data
Definition: synthvoice.h:456
std::unique_ptr< EnvelopeGenerator > ampEG
amp EG
Definition: synthvoice.h:504
bool isVoiceActive()
Definition: synthvoice.h:411
uint32_t getTimestamp()
get current timestamp, the higher the value, the older the voice has been running ...
Definition: synthvoice.h:418
bool voiceIsActive
activity flag
Definition: synthvoice.h:473
std::shared_ptr< WavetableDatabase > wavetableDatabase
shared wavetable database
Definition: synthvoice.h:458
void incrementTimestamp()
increment timestamp when a new note is triggered
Definition: synthvoice.h:419
voiceState voiceNoteState
state variable
Definition: synthvoice.h:470
unsigned int getMIDINoteNumber()
note is data byte 1, velocity is byte 2
Definition: synthvoice.h:423
std::unique_ptr< EnvelopeGenerator > auxEG
auxEG
Definition: synthvoice.h:506
virtual bool doNoteOff(midiEvent &event)
Note-off handler for voice.
Definition: synthvoice.cpp:904
Information about a MIDI event.
Definition: synthstructures.h:155
const std::shared_ptr< MidiOutputData > midiOutputData
shared MIDI output data (not used in SynthLab)
Definition: synthvoice.h:457
virtual bool update()
Update voice specific stuff.
Definition: synthvoice.cpp:411