Guitarix
gx_engine_audio.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2009, 2010 Hermann Meyer, James Warden, Andreas Degert
3  * Copyright (C) 2011 Pete Shorthose
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18  * --------------------------------------------------------------------------
19  *
20  *
21  * This is the Guitarix Audio Engine
22  *
23  *
24  * --------------------------------------------------------------------------
25  */
26 
27 #include "engine.h" // NOLINT
28 
29 namespace gx_engine {
30 
31 /****************************************************************
32  ** class ProcessingChainBase
33  */
34 
36  sync_sem(),
37  to_release(),
38  ramp_value(0),
39  ramp_mode(ramp_mode_down_dead),
40  stopped(true),
41  steps_up(),
42  steps_up_dead(),
43  steps_down(),
44  modules(),
45  next_commit_needs_ramp() {
46  sem_init(&sync_sem, 0, 0);
47  set_samplerate(96000);
48 
49 }
50 
52  steps_down = 4 * (256 * samplerate) / 48000;
54  //steps_down = (64 * samplerate) / 48000;
55  //steps_up = 4 * steps_down;
56  steps_up_dead = 0;
57 }
58 
60  stopped = v;
61  if (v) {
62  post_rt_finished(); // in case someone is already waiting
63  }
64 }
65 
67  if (stopped) {
68  return true;
69  }
70 
71 #ifdef __APPLE__
72  // no timedewait here
73  while (sem_wait(&sync_sem) == -1) {
74 #else
75  timespec ts;
76  clock_gettime(CLOCK_REALTIME, &ts);
77  const long ns_in_sec = 1000000000;
78  ts.tv_nsec += ns_in_sec / 10;
79  if (ts.tv_nsec >= ns_in_sec) {
80  ts.tv_nsec -= ns_in_sec;
81  ts.tv_sec += 1;
82  }
83  while (sem_timedwait(&sync_sem, &ts) == -1) {
84 #endif
85 
86  if (errno == EINTR) {
87  continue;
88  }
89  if (errno == ETIMEDOUT) {
90  gx_print_warning("sem_timedwait", "timeout");
91  return false;
92  }
93  gx_print_error("sem_timedwait", "unknown error");
94  break;
95  }
96  return true;
97 }
98 
100  int val;
101  sem_getvalue(&sync_sem, &val);
102  if (val > 0) {
103  sem_wait(&sync_sem);
104  }
105  assert(sem_getvalue(&sync_sem, &val) == 0 && val == 0);
106 }
107 
109  if (stopped) {
110  return;
111  }
112  while (ramp_mode == ramp_mode_down) {
113  if (!wait_rt_finished()) {
114  break;
115  }
116  }
117 }
118 
120  RampMode rm = get_ramp_mode();
121  if (!stopped) {
122  if (rm != ramp_mode_down_dead && rm != ramp_mode_down) {
123  return;
124  }
125  set_ramp_value(0);
127  }
128 }
129 
131  RampMode rm = get_ramp_mode();
132  if (rm == ramp_mode_down_dead || rm == ramp_mode_down) {
133  return;
134  }
135  int rv = min(steps_down,get_ramp_value());
136  if (rv == 0) {
138  } else {
139  set_ramp_value(rv);
141  }
142 }
143 
144 void __rt_func ProcessingChainBase::try_set_ramp_mode(RampMode oldmode, RampMode newmode, int oldrv, int newrv) {
145  if (oldmode != newmode) {
146  if (!gx_system::atomic_compare_and_exchange(&ramp_mode, oldmode, newmode)) {
147  return;
148  }
149  }
150  if (oldrv != newrv) {
151  if (!gx_system::atomic_compare_and_exchange(&ramp_value, oldrv, newrv)) {
152  return;
153  }
154  }
155 }
156 
157 bool lists_equal(const list<Plugin*>& p1, const list<Plugin*>& p2, bool *need_ramp)
158 {
159  list<Plugin*>::const_iterator i1 = p1.begin();
160  list<Plugin*>::const_iterator i2 = p2.begin();
161  bool ret = true;
162  bool nr = false;
163  while (true) {
164  if (i1 == p1.end()) {
165  if (i2 != p2.end()) {
166  ret = false;
167  nr = true;
168  }
169  break;
170  }
171  if (i2 == p2.end()) {
172  ret = false;
173  nr = true;
174  break;
175  }
176  if (*i1 != *i2) {
177  ret = false;
178  while ((*i1)->get_pdef()->flags & PGN_SNOOP) {
179  ++i1;
180  if (i1 == p1.end()) {
181  break;
182  }
183  }
184  while ((*i2)->get_pdef()->flags & PGN_SNOOP) {
185  ++i2;
186  if (i2 == p2.end()) {
187  break;
188  }
189  }
190  if (*i1 != *i2) {
191  nr = true;
192  break;
193  }
194  }
195  ++i1;
196  ++i2;
197  }
198  if (ret) {
199  nr = false;
200  }
201  *need_ramp = nr;
202  return ret;
203 }
204 
205 bool ProcessingChainBase::set_plugin_list(const list<Plugin*> &p) {
207  return false;
208  }
209  wait_latch();
210  if (check_release()) {
211  release();
212  }
213  typedef set<const char*, stringcomp> pchar_set;
214  pchar_set new_ids;
215  for (list<Plugin*>::const_iterator i = p.begin(); i != p.end(); ++i) {
216  new_ids.insert((*i)->get_pdef()->id);
217  }
218  for (list<Plugin*>::const_iterator i = modules.begin(); i != modules.end(); ++i) {
219  if (!(*i)->get_pdef()->activate_plugin) {
220  continue;
221  }
222  pchar_set::iterator r = new_ids.find((*i)->get_pdef()->id);
223  if (r == new_ids.end()) {
224  to_release.push_back(*i);
225  }
226  }
227  modules = p;
228  return true;
229 }
230 
232  for (list<Plugin*>::const_iterator p = modules.begin(); p != modules.end(); ++p) {
233  PluginDef* pd = (*p)->get_pdef();
234  if (pd->activate_plugin) {
235  pd->activate_plugin(true, pd);
236  } else if (pd->clear_state) {
237  pd->clear_state(pd);
238  }
239  }
240 }
241 
243  wait_latch();
244  for (list<Plugin*>::const_iterator p = to_release.begin(); p != to_release.end(); ++p) {
245  (*p)->get_pdef()->activate_plugin(false, (*p)->get_pdef());
246  }
247  to_release.clear();
248 }
249 
250 #ifndef NDEBUG
251 void ProcessingChainBase::print_chain_state(const char *title) {
252  int val;
253  sem_getvalue(&sync_sem, &val);
254  printf("%s sync_sem = %d, stopped = %d, ramp_mode = %d\n",
255  title, val, stopped, ramp_mode);
256 }
257 #endif
258 
259 
260 /****************************************************************
261  ** MonoModuleChain, StereoModuleChain
262  */
263 
264 void __rt_func MonoModuleChain::process(int count, float *input, float *output) {
265  RampMode rm = get_ramp_mode();
266  if (rm == ramp_mode_down_dead) {
267  memset(output, 0, count*sizeof(float));
268  return;
269  }
270  memcpy(output, input, count*sizeof(float));
271  for (monochain_data *p = get_rt_chain(); p->func; ++p) {
272  p->func(count, output, output, p->plugin);
273  }
274  if (rm == ramp_mode_off) {
275  return;
276  }
277  int rv = get_ramp_value();
278  int rv1 = rv;
279  RampMode rm1 = get_ramp_mode();
280  if (rm != rm1) {
281  // ramp_mode has changed while processing
282  if (rm1 != ramp_mode_up && rm1 != ramp_mode_down) {
283  return;
284  }
285  rv1 = rv = get_ramp_value();
286  // assume ramp_mode doesn't change too fast
287  rm = rm1;
288  }
289  int i = 0;
290  if (rm1 == ramp_mode_up_dead) {
291  for ( ; i < count; ++i) {
292  if (++rv1 > steps_up_dead) {
293  rm1 = ramp_mode_up;
294  rv1 = 0;
295  break;
296  }
297  output[i] = 0.0;
298  }
299  }
300  if (rm1 == ramp_mode_up) {
301  for ( ; i < count; ++i) {
302  if (++rv1 >= steps_up) {
303  rm1 = ramp_mode_off;
304  break;
305  }
306  output[i] = (output[i] * rv1) / steps_up;
307  }
308  }
309  else if (rm1 == ramp_mode_down) {
310  for (i = 0; i < count; ++i) {
311  if (--rv1 == 0) {
312  rm1 = ramp_mode_down_dead;
313  break;
314  }
315  output[i] = (output[i] * rv1) / steps_down;
316  }
317  for ( ; i < count; ++i) {
318  output[i] = 0.0;
319  }
320  }
321  try_set_ramp_mode(rm, rm1, rv, rv1);
322 }
323 
324 void __rt_func StereoModuleChain::process(int count, float *input1, float *input2, float *output1, float *output2) {
325  // run stereo rack
326  RampMode rm = get_ramp_mode();
327  if (rm == ramp_mode_down_dead) {
328  memset(output1, 0, count*sizeof(float));
329  memset(output2, 0, count*sizeof(float));
330  return;
331  }
332  memcpy(output1, input1, count*sizeof(float));
333  memcpy(output2, input2, count*sizeof(float));
334  for (stereochain_data *p = get_rt_chain(); p->func; ++p) {
335  (p->func)(count, output1, output2, output1, output2, p->plugin);
336  }
337  if (rm == ramp_mode_off) {
338  return;
339  }
340  int rv = get_ramp_value();
341  int rv1 = rv;
342  RampMode rm1 = get_ramp_mode();
343  if (rm != rm1) {
344  // ramp_mode has changed while processing
345  if (rm1 != ramp_mode_up && rm1 != ramp_mode_down) {
346  return;
347  }
348  rv1 = rv = get_ramp_value();
349  // assume ramp_mode doesn't change too fast
350  rm = rm1;
351  }
352  int i = 0;
353  if (rm1 == ramp_mode_up_dead) {
354  for ( ; i < count; ++i) {
355  if (++rv1 > steps_up_dead) {
356  rm1 = ramp_mode_up;
357  rv1 = 0;
358  break;
359  }
360  output1[i] = 0.0;
361  output2[i] = 0.0;
362  }
363  }
364  if (rm1 == ramp_mode_up) {
365  for ( ; i < count; ++i) {
366  if (++rv1 >= steps_up) {
367  rm1 = ramp_mode_off;
368  break;
369  }
370  output1[i] = (output1[i] * rv1) / steps_up;
371  output2[i] = (output2[i] * rv1) / steps_up;
372  }
373  }
374  else if (rm1 == ramp_mode_down) {
375  for (i = 0; i < count; ++i) {
376  if (--rv1 == 0) {
377  rm1 = ramp_mode_down_dead;
378  break;
379  }
380  output1[i] = (output1[i] * rv1) / steps_down;
381  output2[i] = (output2[i] * rv1) / steps_down;
382  }
383  for ( ; i < count; ++i) {
384  output1[i] = 0.0;
385  output2[i] = 0.0;
386  }
387  }
388  try_set_ramp_mode(rm, rm1, rv, rv1);
389 }
390 
391 
392 /****************************************************************
393  ** ModuleSelectorFromList
394  */
395 
397  EngineControl& seq_, const char* id_, const char* name_,
398  const char* category_, plugindef_creator plugins[], const char* select_id_,
399  const char* select_name_, uiloader loader, const char** groups_, int flags_)
400  : ModuleSelector(seq_),
401  PluginDef(),
402  selector(0),
403  select_id(select_id_),
404  select_name(select_name_),
405  current_plugin(0),
406  modules(),
407  size(),
408  plugin() {
410  register_params = static_register;
411  plugindef_creator *p = plugins;
412  for (size = 0; *p; ++p, ++size);
413  modules = new PluginDef*[size];
414  for (unsigned int i = 0; i < size; ++i) {
415  modules[i] = plugins[i]();
416  }
417  id = id_;
418  name = name_;
419  category = category_;
420  groups = groups_;
421  flags = flags_;
422  load_ui = loader;
423  plugin = this;
424 }
425 
427  delete[] modules;
428 }
429 
430 int ModuleSelectorFromList::register_parameter(const ParamReg &param) {
431  value_pair *p = new value_pair[size+1];
432  for (unsigned int i = 0; i < size; ++i) {
433  p[i].value_id = modules[i]->id;
434  p[i].value_label = modules[i]->name;
435  }
436  p[size].value_id = 0;
437  p[size].value_label = 0;
438  param.registerIEnumVar(select_id, select_name, "S", "", p, &selector, 0);
439  seq.get_param()[select_id].signal_changed_int().connect(
440  sigc::hide(sigc::mem_fun(seq, &EngineControl::set_rack_changed)));
441  return 0;
442 }
443 
444 int ModuleSelectorFromList::static_register(const ParamReg &param) {
445  return static_cast<ModuleSelectorFromList*>(param.plugin)
446  ->register_parameter(param);
447 }
448 
450  if (plugin.get_on_off()) {
451  Plugin *old = current_plugin;
452  current_plugin = seq.pluginlist.lookup_plugin(modules[selector]->id);
453  if (old && old != current_plugin) {
454  old->set_on_off(false);
455  }
456  current_plugin->set_on_off(true);
457  current_plugin->copy_position(plugin);
458  } else if (current_plugin) {
459  current_plugin->set_on_off(false);
460  current_plugin = 0;
461  }
462 }
463 
464 
465 /****************************************************************
466  ** class EngineControl
467  */
468 
470  : selectors(),
471  rack_changed(),
472  pmap(),
473  policy(),
474  priority(),
475  buffersize_change(),
476  samplerate_change(),
477  buffersize(0),
478  samplerate(0),
479  pluginlist(*this) {
480 }
481 
483 }
484 
486  selectors.push_back(&sel);
487 }
488 
490 {
492 }
493 
494 void EngineControl::get_sched_priority(int &policy_, int &priority_, int prio_dim) {
495  policy_ = policy;
496  priority_ = priority;
497  if (!prio_dim) {
498  return;
499  }
500  int min, max;
501  min = sched_get_priority_min(policy);
502  max = sched_get_priority_max(policy);
503  priority_ = priority - prio_dim;
504  if (priority_ > max) {
505  priority_ = max;
506  }
507  if (priority_ < min) {
508  priority_ = min;
509  }
510 }
511 
512 void EngineControl::set_samplerate(unsigned int samplerate_) {
513  if (samplerate == samplerate_) {
514  return;
515  }
516  samplerate = samplerate_;
519 }
520 
521 void EngineControl::set_buffersize(unsigned int buffersize_) {
522  if (buffersize == buffersize_) {
523  return;
524  }
525  buffersize = buffersize_;
527 }
528 
529 void EngineControl::init(unsigned int samplerate_, unsigned int buffersize_,
530  int policy_, int priority_) {
531  if (policy_ != policy || priority_ != priority) {
532  policy = policy_;
533  priority = priority_;
534  set_buffersize(buffersize_);
535  set_samplerate(samplerate_);
536  return;
537  }
538  if (buffersize_ != buffersize) {
539  set_buffersize(buffersize_);
540  }
541  if (samplerate_ != samplerate) {
542  set_samplerate(samplerate_);
543  }
544 }
545 
547  rack_changed.disconnect();
548 }
549 
551  return rack_changed.connected();
552 }
553 
554 
555 /****************************************************************
556  ** ModuleSequencer
557  */
558 
560  : EngineControl(),
561  audio_mode(PGN_MODE_NORMAL),
562  stateflags_mutex(),
563  stateflags(SF_INITIALIZING),
564  state_change(),
565  overload_detected(),
566  overload_reason(),
567  ov_disabled(0),
568  mono_chain(),
569  stereo_chain() {
570  overload_detected.connect(
571  sigc::mem_fun(this, &ModuleSequencer::check_overload));
572 }
573 
575  start_ramp_down();
578 }
579 
583 }
584 
588 }
589 
593 }
594 
596  if (!get_buffersize() || !get_samplerate()) {
597  return false;
598  }
599  if (prepare_module_lists()) {
601  if (stateflags & SF_OVERLOAD) {
602  // hack: jackd need some time for new load statistic
603  Glib::signal_timeout().connect_once(
604  sigc::bind(
605  sigc::mem_fun(this,&ModuleSequencer::clear_stateflag),
606  SF_OVERLOAD), 1000);
607  }
608  return true;
609  }
610  return false;
611 }
612 
613 void ModuleSequencer::set_samplerate(unsigned int samplerate) {
617 }
618 
620  if (mono_chain.check_release()) {
622  }
623  if (stereo_chain.check_release()) {
625  }
626  if (get_rack_changed()) {
629  }
630  return false;
631 }
632 
634  if (rack_changed.connected()) {
635  return;
636  }
637  rack_changed = Glib::signal_idle().connect(
638  sigc::mem_fun(this, &ModuleSequencer::check_module_lists));
639 }
640 
642  for (list<ModuleSelector*>::iterator i = selectors.begin(); i != selectors.end(); ++i) {
643  (*i)->set_module();
644  }
645  list<Plugin*> modules;
647  bool ret_mono = mono_chain.set_plugin_list(modules);
649  bool ret_stereo = stereo_chain.set_plugin_list(modules);
650  if (ret_mono || ret_stereo) {
651  mono_chain.print();
653  }
654  return ret_mono || ret_stereo;
655 }
656 
659  bool monoramp = mono_chain.next_commit_needs_ramp && !already_down;
660  if (monoramp) {
663  }
666  bool stereoramp = stereo_chain.next_commit_needs_ramp && !already_down;
667  if (stereoramp) {
670  }
672  if (monoramp) {
675  }
676  if (stereoramp) {
679  }
680 }
681 
683 
684 void __rt_func ModuleSequencer::overload(OverloadType tp, const char *reason) {
685  if (!(audio_mode & PGN_MODE_NORMAL)) {
686  return; // no overload message in mute/bypass modes
687  }
688  if ((tp & ov_disabled) == ov_XRun) {
689  return; // the xrun should show up in the log anyhow
690  }
691  bool ignore = false;
692  if ((tp & ov_disabled) == ov_Convolver) {
693  ignore = true;
694  }
695  if (sporadic_interval > 0 && !ignore && (tp & (ov_Convolver|ov_XRun))) {
696  static float last = -sporadic_interval;
697  timespec ts;
698  clock_gettime(CLOCK_MONOTONIC, &ts);
699  float now = ts.tv_sec + ts.tv_nsec * 1e-9;
700  if (now - last < sporadic_interval) { // max. 1 event every sporadic_interval seconds
701  last = now;
702  ignore = true;
703  }
704  }
705  if (!ignore) {
707  }
710 }
711 
713  if (stateflags & flag) {
714  return;
715  }
716  boost::mutex::scoped_lock lock(stateflags_mutex);
717  mono_chain.set_stopped(true);
719  if (!stateflags) {
720  set_down_dead();
721  }
722  stateflags |= flag;
723 }
724 
726  if (!(stateflags & flag)) {
727  return;
728  }
729  boost::mutex::scoped_lock lock(stateflags_mutex);
730  stateflags &= ~flag;
731  if (!stateflags) {
732  mono_chain.set_stopped(false);
733  stereo_chain.set_stopped(false);
734  start_ramp_up();
735  }
736 }
737 
739  if (stateflags & SF_OVERLOAD) {
743  "watchdog",
744  boost::format(_("Overload (%s)")) % gx_system::atomic_get(overload_reason));
745  } else {
747  "watchdog",
748  boost::format(_("Overload ignored (%s)")) % gx_system::atomic_get(overload_reason));
749  }
750 }
751 
753  int newmode = PGN_MODE_MUTE;
754  switch( state ) {
755  case kEngineOn: newmode = PGN_MODE_NORMAL; break;
756  case kEngineBypass: newmode = PGN_MODE_BYPASS; break;
757  case kEngineOff: newmode = PGN_MODE_MUTE; break;
758  }
759  if (audio_mode == newmode) {
760  return;
761  }
762  audio_mode = newmode;
764  state_change(state);
765 }
766 
767 #ifndef NDEBUG
769  printf("stateflags = %d, audio_mode = %d\n", stateflags, audio_mode);
770  mono_chain.print_chain_state("mono :");
771  stereo_chain.print_chain_state("stereo:");
772 }
773 #endif
774 
776  if (audio_mode & PGN_MODE_NORMAL) {
777  return kEngineOn;
778  } else if (audio_mode & PGN_MODE_BYPASS) {
779  return kEngineBypass;
780  } else if (audio_mode & PGN_MODE_MUTE) {
781  return kEngineOff;
782  } else {
783  assert(false);
784  return kEngineOff;
785  }
786 }
787 
788 } // end namespace gx_engine
gx_engine::PluginList::registerAllPlugins
void registerAllPlugins(ParamMap &param, ParameterGroups &groups)
Definition: gx_pluginloader.cpp:693
gx_engine::stereochain_data::func
stereochainorder func
Definition: gx_modulesequencer.h:140
gx_engine::EngineControl::get_sched_priority
void get_sched_priority(int &policy, int &priority, int prio_dim=0)
Definition: gx_engine_audio.cpp:494
gx_engine::ModuleSequencer::overload
virtual void overload(OverloadType tp, const char *reason)
Definition: gx_engine_audio.cpp:684
gx_engine::ProcessingChainBase::wait_latch
void wait_latch()
Definition: gx_modulesequencer.h:84
gx_engine::ProcessingChainBase::ramp_mode_off
@ ramp_mode_off
Definition: gx_modulesequencer.h:53
gx_engine::StereoModuleChain::print
void print()
Definition: gx_modulesequencer.h:230
gx_engine::plugindef_creator
PluginDef *(* plugindef_creator)()
Definition: gx_pluginloader.h:133
gx_engine::EngineControl::OverloadType
OverloadType
Definition: gx_modulesequencer.h:256
gx_engine::ModuleSequencer::set_down_dead
void set_down_dead()
Definition: gx_modulesequencer.h:332
PGN_SNOOP
@ PGN_SNOOP
Definition: gx_plugin.h:170
gx_engine::ProcessingChainBase::set_plugin_list
bool set_plugin_list(const list< Plugin * > &p)
Definition: gx_engine_audio.cpp:205
gx_engine::ModuleSelectorFromList::~ModuleSelectorFromList
~ModuleSelectorFromList()
Definition: gx_engine_audio.cpp:426
gx_engine::ProcessingChainBase::steps_up_dead
int steps_up_dead
Definition: gx_modulesequencer.h:59
gx_system::atomic_set
void atomic_set(volatile int *p, int v)
Definition: gx_system.h:90
gx_engine::EngineControl::set_buffersize
void set_buffersize(unsigned int buffersize_)
Definition: gx_engine_audio.cpp:521
gx_engine::ModuleSequencer::stateflags
int stateflags
Definition: gx_modulesequencer.h:300
gx_engine::ModuleSequencer::overload_detected
Glib::Dispatcher overload_detected
Definition: gx_modulesequencer.h:302
gx_engine::EngineControl::~EngineControl
~EngineControl()
Definition: gx_engine_audio.cpp:482
value_pair
Definition: gx_plugin.h:117
gx_engine::ProcessingChainBase::start_ramp_down
void start_ramp_down()
Definition: gx_engine_audio.cpp:130
PluginDef::category
const char * category
Definition: gx_plugin.h:192
gx_engine::ProcessingChainBase::RampMode
RampMode
Definition: gx_modulesequencer.h:50
gx_engine::ModuleSequencer::~ModuleSequencer
~ModuleSequencer()
Definition: gx_engine_audio.cpp:574
PluginDef::register_params
registerfunc register_params
Definition: gx_plugin.h:202
gx_engine::ModuleSequencer::clear_stateflag
void clear_stateflag(StateFlag flag)
Definition: gx_engine_audio.cpp:725
PluginDef::version
int version
Definition: gx_plugin.h:184
gx_engine::ModuleSequencer::print_engine_state
void print_engine_state()
Definition: gx_engine_audio.cpp:768
gx_engine::ProcessingChainBase::next_commit_needs_ramp
bool next_commit_needs_ramp
Definition: gx_modulesequencer.h:66
gx_engine::ModuleSequencer::start_ramp_down
virtual void start_ramp_down()
Definition: gx_engine_audio.cpp:585
gx_engine::EngineControl::registerParameter
void registerParameter(ParameterGroups &groups)
Definition: gx_engine_audio.cpp:489
gx_engine::ProcessingChainBase::get_ramp_mode
RampMode get_ramp_mode()
Definition: gx_modulesequencer.h:68
ParamReg::plugin
PluginDef * plugin
Definition: gx_plugin.h:123
gx_engine::monochain_data::func
monochainorder func
Definition: gx_modulesequencer.h:133
gx_engine::EngineControl::ov_Convolver
@ ov_Convolver
Definition: gx_modulesequencer.h:258
PluginDef::load_ui
uiloader load_ui
Definition: gx_plugin.h:203
gx_engine::ProcessingChainBase::clear_module_states
void clear_module_states()
Definition: gx_engine_audio.cpp:231
gx_engine::ProcessingChainBase::try_set_ramp_mode
void try_set_ramp_mode(RampMode oldmode, RampMode newmode, int oldrv, int newrv)
Definition: gx_engine_audio.cpp:144
gx_engine::ProcessingChainBase::ramp_mode_up
@ ramp_mode_up
Definition: gx_modulesequencer.h:53
gx_engine::MonoModuleChain::print
void print()
Definition: gx_modulesequencer.h:225
gx_engine::ModuleSequencer::overload_reason
const char * overload_reason
Definition: gx_modulesequencer.h:303
gx_engine::ModuleSequencer::stateflags_mutex
boost::mutex stateflags_mutex
Definition: gx_modulesequencer.h:299
gx_engine::ModuleSequencer::StateFlag
StateFlag
Definition: gx_modulesequencer.h:311
gx_engine::EngineControl::init
void init(unsigned int samplerate, unsigned int buffersize, int policy, int priority)
Definition: gx_engine_audio.cpp:529
gx_engine::ModuleSequencer::set_stateflag
void set_stateflag(StateFlag flag)
Definition: gx_engine_audio.cpp:712
gx_print_warning
void gx_print_warning(const char *, const std::string &)
Definition: gx_logging.cpp:161
gx_engine::ProcessingChainBase::ramp_mode_down_dead
@ ramp_mode_down_dead
Definition: gx_modulesequencer.h:53
ladspa::flag
int flag
Definition: ladspaback.cpp:56
gx_engine::ProcessingChainBase::wait_ramp_down_finished
void wait_ramp_down_finished()
Definition: gx_engine_audio.cpp:108
gx_engine::ModuleSequencer::get_state
GxEngineState get_state()
Definition: gx_engine_audio.cpp:775
PluginDef::name
const char * name
Definition: gx_plugin.h:188
gx_engine::ProcessingChainBase::ProcessingChainBase
ProcessingChainBase()
Definition: gx_engine_audio.cpp:35
gx_engine::GxEngineState
GxEngineState
Definition: gx_modulesequencer.h:289
gx_engine::EngineControl::selectors
list< ModuleSelector * > selectors
Definition: gx_modulesequencer.h:242
gx_engine::ModuleSelectorFromList::ModuleSelectorFromList
ModuleSelectorFromList(EngineControl &seq, const char *id, const char *name, const char *category, plugindef_creator module_ids[], const char *select_id, const char *select_name, uiloader loader, const char **groups=0, int flags=0)
Definition: gx_engine_audio.cpp:396
gx_engine::stereochain_data
Definition: gx_modulesequencer.h:139
min
#define min(x, y)
Definition: gx_faust_support.h:6
gx_engine::ThreadSafeChainPointer::commit
void commit(bool clear, ParamMap &pmap)
Definition: gx_modulesequencer.h:191
uiloader
int(* uiloader)(const UiBuilder &builder, int format)
Definition: gx_plugin.h:158
PluginDef
Definition: gx_plugin.h:183
gx_engine::ModuleSelector::seq
EngineControl & seq
Definition: gx_modulesequencer.h:33
ParamReg::registerIEnumVar
void(* registerIEnumVar)(const char *id, const char *name, const char *tp, const char *tooltip, const value_pair *values, int *var, int val)
Definition: gx_plugin.h:138
gx_engine::EngineControl::samplerate_change
sigc::signal< void, unsigned int > samplerate_change
Definition: gx_modulesequencer.h:252
max
#define max(x, y)
Definition: gx_faust_support.h:5
gx_engine::ModuleSequencer::SF_OVERLOAD
@ SF_OVERLOAD
Definition: gx_modulesequencer.h:315
gx_engine::ProcessingChainBase::print_chain_state
void print_chain_state(const char *title)
Definition: gx_engine_audio.cpp:251
gx_engine::ProcessingChainBase::wait_rt_finished
bool wait_rt_finished()
Definition: gx_engine_audio.cpp:66
gx_engine::ModuleSequencer::sporadic_interval
static int sporadic_interval
Definition: gx_modulesequencer.h:305
gx_engine::EngineControl::ov_XRun
@ ov_XRun
Definition: gx_modulesequencer.h:259
gx_engine::kEngineOff
@ kEngineOff
Definition: gx_modulesequencer.h:292
gx_engine::EngineControl::buffersize
unsigned int buffersize
Definition: gx_modulesequencer.h:253
gx_engine::EngineControl::buffersize_change
sigc::signal< void, unsigned int > buffersize_change
Definition: gx_modulesequencer.h:251
gx_engine::EngineControl::pmap
ParamMap pmap
Definition: gx_modulesequencer.h:245
gx_engine::ProcessingChainBase::set_samplerate
void set_samplerate(int samplerate)
Definition: gx_engine_audio.cpp:51
gx_engine::ModuleSequencer::audio_mode
int audio_mode
Definition: gx_modulesequencer.h:298
gx_engine::EngineControl::add_selector
void add_selector(ModuleSelector &sel)
Definition: gx_engine_audio.cpp:485
gx_engine::ProcessingChainBase::set_ramp_value
void set_ramp_value(int n)
Definition: gx_modulesequencer.h:62
gx_engine::ProcessingChainBase::post_rt_finished
void post_rt_finished()
Definition: gx_modulesequencer.h:75
gx_engine::EngineControl::get_rack_changed
bool get_rack_changed()
Definition: gx_engine_audio.cpp:550
PluginDef::groups
const char ** groups
Definition: gx_plugin.h:189
PGN_MODE_BYPASS
@ PGN_MODE_BYPASS
Definition: gx_plugin.h:172
gx_engine::ModuleSequencer::prepare_module_lists
bool prepare_module_lists()
Definition: gx_engine_audio.cpp:641
gx_engine::EngineControl::get_param
ParamMap & get_param()
Definition: gx_modulesequencer.h:283
gx_engine::ProcessingChainBase::release
void release()
Definition: gx_engine_audio.cpp:242
gx_engine::ModuleSequencer::mono_chain
MonoModuleChain mono_chain
Definition: gx_modulesequencer.h:309
gx_engine::EngineControl::priority
int priority
Definition: gx_modulesequencer.h:247
gx_engine::Plugin::copy_position
void copy_position(const Plugin &plugin)
Definition: gx_pluginloader.cpp:351
gx_engine
Definition: gx_convolver.h:33
gx_engine::Plugin::set_on_off
void set_on_off(bool v) const
Definition: gx_pluginloader.h:68
PluginDef::clear_state
clearstatefunc clear_state
Definition: gx_plugin.h:204
gx_engine::ProcessingChainBase::start_ramp_up
void start_ramp_up()
Definition: gx_engine_audio.cpp:119
gx_engine::ModuleSelectorFromList::set_module
void set_module()
Definition: gx_engine_audio.cpp:449
gx_engine::ModuleSequencer::SF_INITIALIZING
@ SF_INITIALIZING
Definition: gx_modulesequencer.h:314
gx_engine::EngineControl::pluginlist
PluginList pluginlist
Definition: gx_modulesequencer.h:261
gx_engine::ModuleSelector
Definition: gx_modulesequencer.h:29
PGN_MODE_NORMAL
@ PGN_MODE_NORMAL
Definition: gx_plugin.h:171
gx_engine::MonoModuleChain::process
void process(int count, float *input, float *output)
Definition: gx_engine_audio.cpp:264
gx_engine::ModuleSequencer::stereo_chain
StereoModuleChain stereo_chain
Definition: gx_modulesequencer.h:310
gx_engine::EngineControl::clear_rack_changed
void clear_rack_changed()
Definition: gx_engine_audio.cpp:546
gx_engine::PluginList::set_samplerate
void set_samplerate(int samplerate)
Definition: gx_pluginloader.cpp:777
gx_system::atomic_compare_and_exchange
bool atomic_compare_and_exchange(volatile int *p, int oldv, int newv)
Definition: gx_system.h:114
gx_print_error
void gx_print_error(const char *, const std::string &)
Definition: gx_logging.cpp:166
gx_engine::ModuleSequencer::check_overload
void check_overload()
Definition: gx_engine_audio.cpp:738
gx_engine::Plugin::get_on_off
bool get_on_off() const
Definition: gx_pluginloader.h:63
gx_engine::StereoModuleChain::process
void process(int count, float *input1, float *input2, float *output1, float *output2)
Definition: gx_engine_audio.cpp:324
gx_engine::ProcessingChainBase::set_ramp_mode
void set_ramp_mode(RampMode n)
Definition: gx_modulesequencer.h:63
gx_engine::lists_equal
bool lists_equal(const list< Plugin * > &p1, const list< Plugin * > &p2, bool *need_ramp)
Definition: gx_engine_audio.cpp:157
gx_engine::EngineControl::get_samplerate
unsigned int get_samplerate()
Definition: gx_modulesequencer.h:272
gx_engine::kEngineOn
@ kEngineOn
Definition: gx_modulesequencer.h:293
gx_engine::kEngineBypass
@ kEngineBypass
Definition: gx_modulesequencer.h:294
gx_engine::ModuleSequencer::ov_disabled
int ov_disabled
Definition: gx_modulesequencer.h:304
PluginDef::id
const char * id
Definition: gx_plugin.h:187
value_pair::value_id
const char * value_id
Definition: gx_plugin.h:118
gx_engine::ProcessingChainBase::set_stopped
void set_stopped(bool v)
Definition: gx_engine_audio.cpp:59
gx_engine::EngineControl
Definition: gx_modulesequencer.h:238
gx_engine::monochain_data
Definition: gx_modulesequencer.h:132
gx_engine::ModuleSequencer::commit_module_lists
void commit_module_lists()
Definition: gx_engine_audio.cpp:657
gx_engine::ParameterGroups
Definition: gx_parameter.h:47
PluginDef::flags
int flags
Definition: gx_plugin.h:185
gx_engine::ProcessingChainBase::steps_down
int steps_down
Definition: gx_modulesequencer.h:60
gx_engine::EngineControl::set_samplerate
void set_samplerate(unsigned int samplerate_)
Definition: gx_engine_audio.cpp:512
gx_system::atomic_get
int atomic_get(volatile int &p)
Definition: gx_system.h:98
ParamReg
Definition: gx_plugin.h:122
gx_engine::ModuleSequencer::update_module_lists
virtual bool update_module_lists()
Definition: gx_engine_audio.cpp:595
gx_engine::EngineControl::rack_changed
sigc::connection rack_changed
Definition: gx_modulesequencer.h:244
gx_engine::ModuleSequencer::state_change
sigc::signal< void, GxEngineState > state_change
Definition: gx_modulesequencer.h:301
gx_engine::EngineControl::samplerate
unsigned int samplerate
Definition: gx_modulesequencer.h:254
gx_engine::EngineControl::policy
int policy
Definition: gx_modulesequencer.h:246
PGN_MODE_MUTE
@ PGN_MODE_MUTE
Definition: gx_plugin.h:173
gx_engine::ModuleSequencer::ModuleSequencer
ModuleSequencer()
Definition: gx_engine_audio.cpp:559
gx_engine::EngineControl::get_buffersize
unsigned int get_buffersize()
Definition: gx_modulesequencer.h:274
gx_engine::ProcessingChainBase::get_ramp_value
int get_ramp_value()
Definition: gx_modulesequencer.h:71
PluginDef::activate_plugin
activatefunc activate_plugin
Definition: gx_plugin.h:201
PLUGINDEF_VERSION
#define PLUGINDEF_VERSION
Definition: gx_plugin.h:181
gx_engine::ModuleSequencer::wait_ramp_down_finished
virtual void wait_ramp_down_finished()
Definition: gx_engine_audio.cpp:590
gx_engine::ProcessingChainBase::set_latch
void set_latch()
Definition: gx_engine_audio.cpp:99
engine.h
__rt_func
#define __rt_func
Definition: gx_compiler.h:7
gx_engine::EngineControl::set_rack_changed
virtual void set_rack_changed()=0
gx_engine::Plugin
Definition: gx_pluginloader.h:45
gx_engine::ModuleSequencer::check_module_lists
bool check_module_lists()
Definition: gx_engine_audio.cpp:619
gx_engine::PluginList::ordered_stereo_list
void ordered_stereo_list(list< Plugin * > &stereo, int mode)
Definition: gx_pluginloader.cpp:731
gx_engine::ProcessingChainBase::modules
list< Plugin * > modules
Definition: gx_modulesequencer.h:61
gx_engine::ModuleSelectorFromList::plugin
Plugin plugin
Definition: gx_engine.h:51
gx_engine::ProcessingChainBase::steps_up
int steps_up
Definition: gx_modulesequencer.h:58
gx_engine::ModuleSequencer::set_rack_changed
virtual void set_rack_changed()
Definition: gx_engine_audio.cpp:633
gx_engine::PluginList::ordered_mono_list
void ordered_mono_list(list< Plugin * > &mono, int mode)
Definition: gx_pluginloader.cpp:713
gx_engine::ProcessingChainBase::ramp_mode_up_dead
@ ramp_mode_up_dead
Definition: gx_modulesequencer.h:53
gx_engine::EngineControl::EngineControl
EngineControl()
Definition: gx_engine_audio.cpp:469
gx_engine::ModuleSequencer::set_state
void set_state(GxEngineState state)
Definition: gx_engine_audio.cpp:752
gx_engine::ModuleSequencer::start_ramp_up
virtual void start_ramp_up()
Definition: gx_engine_audio.cpp:580
gx_engine::ProcessingChainBase::ramp_mode_down
@ ramp_mode_down
Definition: gx_modulesequencer.h:53
gx_engine::ProcessingChainBase::check_release
bool check_release()
Definition: gx_modulesequencer.h:86
gx_engine::PluginListBase::lookup_plugin
Plugin * lookup_plugin(const std::string &id) const
Definition: gx_pluginloader.cpp:399
value_pair::value_label
const char * value_label
Definition: gx_plugin.h:119
gx_engine::ModuleSequencer::set_samplerate
virtual void set_samplerate(unsigned int samplerate)
Definition: gx_engine_audio.cpp:613