Guitarix
gx_internal_plugins.h
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 Engine namespace ------- */
22 
23 #pragma once
24 
25 
26 namespace gx_jack { class GxJack; }
27 
28 namespace gx_engine {
29 
30 /****************************************************************
31  ** MonoMute, StereoMute, MaxLevel, MidiAudioBuffer
32  */
33 
34 class MonoMute: public PluginDef {
35 private:
36  static void process(int count, float *input, float *output, PluginDef*);
37 public:
38  MonoMute();
39 };
40 
41 class StereoMute: public PluginDef {
42 private:
43  static void process(int count, float *input0, float *input1,
44  float *output0, float *output1, PluginDef*);
45 public:
46  StereoMute();
47 };
48 
49 class MaxLevel: public PluginDef {
50 public:
51  static const unsigned int channelcount = 2;
52 private:
53  static float maxlevel[channelcount];
54  static void process(int count, float *input0, float *input1,
55  float *output0, float *output1, PluginDef*);
56  static int activate(bool start, PluginDef *plugin);
57 public:
58  static float get(unsigned int channel) {
59  assert(channel < channelcount);
60  float v = maxlevel[channel];
61  maxlevel[channel] = 0;
62  return v;
63  }
64  MaxLevel();
65 };
66 
67 
68 /****************************************************************
69  ** class TunerAdapter
70  */
71 
72 class TunerAdapter: public ModuleSelector, private PluginDef, public sigc::trackable {
73 private:
74  static void feed_tuner(int count, float *input, float *output, PluginDef*);
75  static int regparam(const ParamReg& reg);
76  static int activate(bool start, PluginDef *plugin);
77  static void init(unsigned int samplingFreq, PluginDef *plugin);
78  PitchTracker pitch_tracker;
79  int state;
80  ModuleSequencer& engine;
81  enum { tuner_use = 0x01, switcher_use = 0x02, midi_use = 0x04 };
82  void set_and_check(int use, bool on);
83  Plugin* dep_plugin;
84 public:
85  Plugin plugin;
87  void used_for_switching(bool on) { set_and_check(switcher_use, on); }
88  void used_for_display(bool on) { set_and_check(tuner_use, on); }
89  bool used_for_display() { return state & tuner_use; }
90  void used_by_midi(bool on) { set_and_check(midi_use, on); }
91  void set_dep_module(Plugin* dep) { dep_plugin = dep; }
92  void set_module();
93  Glib::Dispatcher& signal_freq_changed() { return pitch_tracker.new_freq; }
94  float get_freq() { return pitch_tracker.get_estimated_freq(); }
95  float get_note() { return pitch_tracker.get_estimated_note(); }
96 };
97 
98 
99 /****************************************************************
100  ** class MidiAudioBuffer
101  */
102 
103 class MidiVariables {
104 private:
105  float fslider45;
106  float fslider38;
107  float fslider31;
108  float fslider27;
109  float fslider29;
110  float fslider30;
111  float fslider26;
112  float fslider33;
113  float fslider34;
114  float fslider35;
115  float fslider36;
116  float fslider42;
117  float fslider43;
118  float fslider40;
119  float fslider41;
120  float fslider44;
121  float fslider37;
122  float fslider39;
123  float fslider46;
124  float fslider47;
125  float fslider48;
126  float fConstlog;
127  float fConstlog2;
128  float beat0;
129  float midi_gain;
130  float fConstun0;
131  float fslider32;
132  float BeatFilter1;
133  float BeatFilter2;
134  float BeatFilterk;
135  bool fautogain;
136  bool fpitch;
137  bool fautogain1;
138  bool fpitch1;
139  bool fpitch2;
140  bool fautogain2;
141  bool midistat;
142  bool midistat1;
143  bool midistat2;
144  bool midistat3;
145 
146  int weg;
147  int program;
148  int program2;
149  int volume2;
150  int Beat_is;
151  int send;
152  int volume;
153  int noten;
154  int program1;
155  int send1;
156  int noten1;
157  int volume1;
158  int send2;
159  int noten2;
160 
161  bool fcheckbox10;
162  bool fcheckbox11;
163 
164  unsigned char* midi_send;
165  unsigned char* midi_send1;
166  unsigned char* midi_send2;
167 
168 public:
169  void register_parameter(const ParamReg& reg);
170  void init(int samplingFreq);
171  void process_midi(int len, float *audiodata, void *midi_port_buf, float jcpu_load,
172  float fConsta4, float fConsta1t);
173  bool get_midistat() { return midistat; }
174 };
175 
176 
177 class MidiAudioBuffer: PluginDef {
178 public:
179  enum Load { load_off = -1, load_low = 0, load_high = 1, load_over = 2 };
180 private:
181  MidiVariables midi;
183  gx_jack::GxJack* jack;
184  Load jack_overload;
185  Glib::Dispatcher overload_change;
186  static void fill_buffer(int count, float *input0, float *output0, PluginDef*);
187  static int regparam(const ParamReg& reg);
188  static void init(unsigned int samplingFreq, PluginDef *plugin);
189  static int activate(bool start, PluginDef *plugin);
190 public:
193  void set_jack(gx_jack::GxJack* jack_) { jack = jack_; }
194  bool get_midistat() { return midi.get_midistat(); }
195  Load jack_load_status() { return jack_overload; }
196  Glib::Dispatcher& signal_jack_load_change() { return overload_change; }
197 };
198 
199 
200 /****************************************************************
201  ** class NoiseGate
202  */
203 
204 class NoiseGate {
205 private:
206  static PluginDef inputdef;
207  static float fnglevel;
208  static float ngate;
209  static bool off;
210  static int noisegate_register(const ParamReg& reg);
211  static void inputlevel_compute(int count, float *input0, float *output0, PluginDef*);
212  static void outputgate_compute(int count, float *input, float *output, PluginDef*);
213  static int outputgate_activate(bool start, PluginDef *pdef);
214 public:
215  static Plugin inputlevel;
216  static PluginDef outputgate;
217  NoiseGate();
218 };
219 
220 
221 /****************************************************************
222  ** class OscilloscopeAdapter
223  */
224 
226 private:
227  static float* buffer;
228  static unsigned int size;
229  static void fill_buffer(int count, float *input0, float *output0, PluginDef*);
230  static int osc_register(const ParamReg& reg);
231  static int activate(bool start, PluginDef *p);
232  void change_buffersize(unsigned int);
233  int mul_buffer;
234 public:
236  sigc::signal<int, bool> activation;
237  sigc::signal<void, unsigned int> size_change;
238  void clear_buffer();
239  unsigned int get_size() { return size; }
240  inline float *get_buffer() { return buffer; }
241  int get_mul_buffer() { return mul_buffer; }
242  void set_mul_buffer(int a, unsigned int b) { mul_buffer = a; change_buffersize(b); }
243  OscilloscopeAdapter(ModuleSequencer& engine);
244 };
245 
246 
247 /****************************************************************
248  ** class GxSeqSettings
249  */
250 
252  private:
253 
254  std::vector<int> seqline;
255  void read_seqline(gx_system::JsonParser& jp);
256  friend class SequencerAdapter;
257  friend class ParameterV<GxSeqSettings>;
258  public:
259  GxSeqSettings();
261  bool operator==(const GxSeqSettings& seqset) const;
262  // getters and setters
263  inline const std::vector<int>& getseqline() const { return seqline; }
264 
265  inline void setseqline(const std::vector<int>& seq) { seqline = seq; }
266 
267  public:
269  void writeJSON(gx_system::JsonWriter& w) const;
270 };
271 
272 template<>
273 class ParameterV<GxSeqSettings>: public Parameter {
274 private:
275  GxSeqSettings json_value;
276  GxSeqSettings *value;
277  GxSeqSettings std_value;
278  GxSeqSettings value_storage;
279  sigc::signal<void, const GxSeqSettings*> changed;
280 public:
281  ParameterV(const string& id, GxSeqSettings *v);
284  virtual void serializeJSON(gx_system::JsonWriter& jw);
285  sigc::signal<void, const GxSeqSettings*>& signal_changed() { return changed; }
286  static ParameterV<GxSeqSettings> *insert_param(
287  ParamMap &pmap, const string& id, GxSeqSettings *v);
288  bool set(const GxSeqSettings& val) const;
289  const GxSeqSettings& get_value() const { return *value; }
290  virtual void stdJSON_value();
291  virtual bool on_off_value();
292  virtual void writeJSON(gx_system::JsonWriter& jw) const;
293  virtual bool compareJSON_value();
294  virtual void setJSON_value();
295  virtual void readJSON_value(gx_system::JsonParser& jp);
296 };
297 
299 
300 /****************************************************************
301  ** class GxJConvSettings
302  */
303 
304 class GxJConvSettings {
305  private:
306  // main jconv setting
307  std::string fIRFile;
308  std::string fIRDir;
309 
310  float fGain; // jconv gain
311  guint fOffset; // offset in IR where to start comvolution
312  guint fLength; // length of the IR to use for convolution
313  guint fDelay; // delay when to apply reverb
314  Gainline gainline;
315  bool fGainCor;
316  void read_gainline(gx_system::JsonParser& jp);
317  inline void setIRDir(string name) { fIRDir = name; }
318  friend class ConvolverAdapter;
320  public:
323  bool operator==(const GxJConvSettings& jcset) const;
324  // getters and setters
325  inline const std::string& getIRFile() const { return fIRFile; }
326  std::string getFullIRPath() const;
327  inline float getGain() const { return fGain; }
328  inline guint getOffset() const { return fOffset; }
329  inline guint getLength() const { return fLength; }
330  inline guint getDelay() const { return fDelay; }
331  inline bool getGainCor() const { return fGainCor; }
332  inline const Gainline& getGainline() const { return gainline; }
333  const std::string& getIRDir() const { return fIRDir; }
334  void setFullIRPath(string name);
335  inline void setIRFile(string name) { fIRFile = name; }
336  inline void setGain(float gain) { fGain = gain; }
337  inline void setGainCor(bool gain) { fGainCor = gain; }
338  inline void setOffset(guint offs) { fOffset = offs; }
339  inline void setLength(guint leng) { fLength = leng; }
340  inline void setDelay(guint del) { fDelay = del; }
341  inline void setGainline(const Gainline& gain) { gainline = gain; }
342 
343  public:
345  void writeJSON(gx_system::JsonWriter& w) const;
346 };
347 
348 class ConvolverAdapter;
349 
350 template<>
351 class ParameterV<GxJConvSettings>: public Parameter {
352 private:
353  const gx_system::PathList *searchpath;
354  const gx_system::PrefixConverter* pfx_conv;
355  GxJConvSettings json_value;
356  GxJConvSettings *value;
357  GxJConvSettings std_value;
358  GxJConvSettings value_storage;
359  sigc::signal<void, const GxJConvSettings*> changed;
360 public:
361  ParameterV(const string& id, ConvolverAdapter &conv, GxJConvSettings *v);
363  ~ParameterV();
364  virtual void serializeJSON(gx_system::JsonWriter& jw);
365  sigc::signal<void, const GxJConvSettings*>& signal_changed() { return changed; }
366  static ParameterV<GxJConvSettings> *insert_param(
367  ParamMap &pmap, const string& id, ConvolverAdapter &conv, GxJConvSettings *v);
368  bool set(const GxJConvSettings& val) const;
369  const GxJConvSettings& get_value() const { return *value; }
370  virtual void stdJSON_value();
371  virtual bool on_off_value();
372  virtual void writeJSON(gx_system::JsonWriter& jw) const;
373  virtual bool compareJSON_value();
374  virtual void setJSON_value();
375  virtual void readJSON_value(gx_system::JsonParser& jp);
376 };
377 
379 
380 
381 /****************************************************************
382  ** class ConvolverAdapter
383  */
384 
385 class ConvolverAdapter: protected PluginDef, public sigc::trackable {
386 protected:
388  boost::mutex activate_mutex;
390  sigc::slot<void> sync;
392  bool activated;
393  // wrapper for the rack order function pointers
394  void change_buffersize(unsigned int size);
397 public:
399 public:
402  void restart();
403  bool conv_start();
404  inline const std::string& getIRFile() const { return jcset.getIRFile(); }
405  inline void set_sync(bool val) { conv.set_sync(val); }
406  inline std::string getFullIRPath() const { return jcset.getFullIRPath(); }
407  inline const std::string& getIRDir() const { return jcset.getIRDir(); }
408  bool set(const GxJConvSettings& jcset) const { return jcp->set(jcset); }
409  const GxJConvSettings& get_jcset() const { return jcset; }
410  ParamMap& get_parameter_map() const { return param; }
411 };
412 
413 
414 /****************************************************************
415  ** class ConvolverStereoAdapter
416  */
417 
418 #include "faust/jconv_post.h"
419 #include "faust/jconv_post_mono.h"
420 
422 private:
423  jconv_post::Dsp jc_post;
424  // wrapper for the rack order function pointers
425  static void convolver_init(unsigned int samplingFreq, PluginDef *pdef);
426  static int activate(bool start, PluginDef *pdef);
427  static void convolver(int count, float *input0, float *input1,
428  float *output0, float *output1, PluginDef*);
429  static int convolver_register(const ParamReg& reg);
430 public:
433 };
434 
435 
436 /****************************************************************
437  ** class ConvolverMonoAdapter
438  */
439 
441 private:
442  jconv_post_mono::Dsp jc_post_mono;
443  // wrapper for the rack order function pointers
444  static void convolver_init(unsigned int samplingFreq, PluginDef *pdef);
445  static int activate(bool start, PluginDef *pdef);
446  static void convolver(int count, float *input, float *output, PluginDef*);
447  static int convolver_register(const ParamReg& reg);
448 public:
451 };
452 
453 
454 /****************************************************************
455  ** class BaseConvolver
456  */
457 
458 
459 class BaseConvolver: protected PluginDef {
460 protected:
462  boost::mutex activate_mutex;
464  sigc::slot<void> sync;
465  bool activated;
466  sigc::connection update_conn;
467  static void init(unsigned int samplingFreq, PluginDef *p);
468  static int activate(bool start, PluginDef *pdef);
469  void change_buffersize(unsigned int);
470  int conv_start();
471  bool check_update_timeout();
472  virtual void check_update() = 0;
473  virtual bool start(bool force = false) = 0;
474 public:
476 public:
478  virtual ~BaseConvolver();
479  inline void set_sync(bool val) { conv.set_sync(val); }
480 };
481 
482 /****************************************************************
483  ** class FixedBaseConvolver
484  */
485 
486 
487 class FixedBaseConvolver: protected PluginDef {
488 protected:
490  boost::mutex activate_mutex;
492  sigc::slot<void> sync;
493  bool activated;
494  unsigned int SamplingFreq;
495  unsigned int buffersize;
496  unsigned int bz;
497  sigc::connection update_conn;
498  static void init(unsigned int samplingFreq, PluginDef *p);
499  unsigned int getSamplingFreq() { return SamplingFreq;};
500  static int activate(bool start, PluginDef *pdef);
501  void change_buffersize(unsigned int);
502  int conv_start();
503  bool check_update_timeout();
504  virtual void check_update() = 0;
505  virtual bool start(bool force = false) = 0;
506 public:
508 public:
510  virtual ~FixedBaseConvolver();
511  inline void set_sync(bool val) { conv.set_sync(val); }
512 };
513 
514 /****************************************************************
515  ** class CabinetConvolver
516  */
517 
518 #include "faust/cabinet_impulse_former.h"
519 
520 class CabinetConvolver: public FixedBaseConvolver {
521 private:
522  int current_cab;
523  float level;
524  int cabinet;
525  float bass;
526  float treble;
527  float sum;
528  value_pair *cab_names;
529  cabinet_impulse_former::Dsp impf;
531  static void run_cab_conf(int count, float *input, float *output, PluginDef*);
532  static int register_cab(const ParamReg& reg);
533  bool do_update();
534  virtual void check_update();
535  virtual bool start(bool force = false);
536  bool cabinet_changed() { return current_cab != cabinet; }
537  void update_cabinet() { current_cab = cabinet; }
538  bool sum_changed() { return std::abs(sum - (level + bass + treble)) > 0.01; }
539  void update_sum() { sum = level + bass + treble; }
540 public:
541  CabinetConvolver(EngineControl& engine, sigc::slot<void> sync,
544 };
545 
546 #include "faust/cabinet_impulse_former_st.h"
547 
548 class CabinetStereoConvolver: public FixedBaseConvolver {
549 private:
550  int current_cab;
551  float level;
552  int cabinet;
553  float bass;
554  float treble;
555  float sum;
556  value_pair *cab_names;
557  cabinet_impulse_former_st::Dsp impf;
560  static void run_cab_conf(int count, float *input, float *input1, float *output, float *output1, PluginDef*);
561  static int register_cab(const ParamReg& reg);
562  bool do_update();
563  virtual void check_update();
564  virtual bool start(bool force = false);
565  bool cabinet_changed() { return current_cab != cabinet; }
566  void update_cabinet() { current_cab = cabinet; }
567  bool sum_changed() { return fabs(sum - (level + bass + treble)) > 0.01; }
568  void update_sum() { sum = level + bass + treble; }
569 public:
570  CabinetStereoConvolver(EngineControl& engine, sigc::slot<void> sync,
573 };
574 
575 
576 /****************************************************************
577  ** class PreampConvolver
578  */
579 
580 #include "faust/preamp_impulse_former.h"
581 
582 class PreampConvolver: public FixedBaseConvolver {
583 private:
584  int current_pre;
585  float level;
586  int preamp;
587  float bass;
588  float treble;
589  float sum;
590  value_pair *pre_names;
591  preamp_impulse_former::Dsp impf;
593  static void run_pre_conf(int count, float *input, float *output, PluginDef*);
594  static int register_pre(const ParamReg& reg);
595  bool do_update();
596  virtual void check_update();
597  virtual bool start(bool force = false);
598  bool preamp_changed() { return current_pre != preamp; }
599  void update_preamp() { current_pre = preamp; }
600  bool sum_changed() { return std::abs(sum - (level + bass + treble)) > 0.01; }
601  void update_sum() { sum = level + bass + treble; }
602 public:
603  PreampConvolver(EngineControl& engine, sigc::slot<void> sync,
606 };
607 
608 #include "faust/preamp_impulse_former_st.h"
609 
610 class PreampStereoConvolver: public FixedBaseConvolver {
611 private:
612  int current_pre;
613  float level;
614  int preamp;
615  float bass;
616  float treble;
617  float sum;
618  value_pair *pre_names;
619  preamp_impulse_former_st::Dsp impf;
622  static void run_pre_conf(int count, float *input, float *input1, float *output, float *output1, PluginDef*);
623  static int register_pre(const ParamReg& reg);
624  bool do_update();
625  virtual void check_update();
626  virtual bool start(bool force = false);
627  bool preamp_changed() { return current_pre != preamp; }
628  void update_preamp() { current_pre = preamp; }
629  bool sum_changed() { return fabs(sum - (level + bass + treble)) > 0.01; }
630  void update_sum() { sum = level + bass + treble; }
631 public:
632  PreampStereoConvolver(EngineControl& engine, sigc::slot<void> sync,
635 };
636 
637 /****************************************************************
638  ** class ContrastConvolver
639  */
640 
641 #include "faust/presence_level.h"
642 
643 class ContrastConvolver: public FixedBaseConvolver {
644 private:
645  float level;
646  float sum;
647  presence_level::Dsp presl;
649  static void run_contrast(int count, float *input, float *output, PluginDef*);
650  static int register_con(const ParamReg& reg);
651  inline void update_sum() { sum = level; }
652  virtual void check_update();
653  bool do_update();
654  inline bool sum_changed() { return std::abs(sum - level) > 0.01; }
655  virtual bool start(bool force = false);
656 public:
657  ContrastConvolver(EngineControl& engine, sigc::slot<void> sync,
660 };
661 
662 /****************************************************************
663  ** class LV2Features
664  */
665 
666 class LV2Features {
667 private:
668 
669  static LV2_Options_Option gx_options[2];
670  static LV2_Feature gx_options_feature;
671 
672  static LV2_URID lv2_urid_map(LV2_URID_Map_Handle, const char* const uri_);
673  static LV2_Feature gx_urid_map_feature;
674 
675  static uint32_t lv2_uri_to_id(LV2_URI_Map_Callback_Data handle, const char*, const char* uri);
676  static LV2_URI_Map_Feature gx_uri_map;
677  static LV2_Feature gx_uri_map_feature;
678 
679  static const char* lv2_urid_unmap(LV2_URID_Unmap_Handle, const LV2_URID urid);
680  static LV2_Feature gx_urid_unmap_feature;
681  LV2Features() {};
682 
683 public:
684  static LV2Features& getInstance()
685  {
686  static LV2Features instance;
687  return instance;
688  }
689  static LV2_Feature* gx_features[];
690  static LV2_URID_Map gx_urid_map;
691  static LV2_URID_Unmap gx_urid_unmap;
692 
693  LV2Features(LV2Features const&) = delete;
694  void operator=(LV2Features const&) = delete;
695 
696 };
697 
698 /****************************************************************
699  ** class LadspaLoader
700  */
701 
703 
704 struct paradesc: boost::noncopyable {
705  int index;
706  std::string name;
707  float dflt;
708  float low;
709  float up;
710  float step;
712  bool newrow;
715  paradesc(): index(), name(), dflt(), low(), up(), step(), tp(), newrow(), has_caption(true), values() {}
717  void set_valuelist(const std::vector<std::string>& v);
720 };
721 
722 enum quirkflag { need_activate = 1, no_cleanup = 2, is_lv2 = 4 };
723 
724 class plugdesc {
725 public:
726  std::string path;
727  unsigned int index;
728  unsigned long UniqueID;
729  Glib::ustring Label;
730  Glib::ustring shortname;
731  Glib::ustring category;
732  int quirks; // quirkflag bits
734  int stereo_to_mono;
735  int master_idx;
736  Glib::ustring master_label;
737  std::vector<paradesc*> names;
738  std::string id_str;
739 private:
740  plugdesc() {}
741  ~plugdesc();
742  friend class LadspaLoader;
743 public:
746 };
747 
748 class LadspaLoader {
749 public:
750  typedef std::vector<plugdesc*> pluginarray;
751 private:
753  pluginarray plugins;
754  LilvWorld* world;
755  ParamMap& param;
756  const LilvPlugins* lv2_plugins;
757  LilvNode* lv2_AudioPort;
758  LilvNode* lv2_ControlPort;
759  LilvNode* lv2_InputPort;
760  LilvNode* lv2_OutputPort;
761 private:
762  void read_module_config(const std::string& filename, plugdesc *p);
763  void read_module_list(pluginarray& p);
764 public:
766  ~LadspaLoader();
767  bool load(pluginarray& p);
768  unsigned int size() { return plugins.size(); }
769  PluginDef *create(unsigned int idx) { return create(plugins[idx]); }
770  PluginDef *create(const plugdesc *p);
771  pluginarray::iterator begin() { return plugins.begin(); }
772  pluginarray::iterator end() { return plugins.end(); }
773  pluginarray::iterator find(plugdesc* desc);
774  void set_plugins(pluginarray& new_plugins);
775  void change_plugins(pluginarray& new_plugins);
776  void update_instance(PluginDef *pdef, plugdesc *pdesc);
777  static std::string get_ladspa_filename(unsigned long uid)
778  { return "ladspa"+gx_system::to_string(uid)+".js"; }
779  static std::string get_ladspa_filename(std::string uid_key)
780  { return "ladspa"+uid_key.substr(9)+".js"; }
781  ParamMap& get_parameter_map() const { return param; }
782  friend class Lv2Dsp;
783 };
784 
785 
786 /****************************************************************
787  ** class Directout
788  */
789 
790 class Directout: public PluginDef {
791 public:
792  float* outdata;
793 private:
794  int fSamplingFreq;
795  int bsize;
796  bool fdfill;
797  EngineControl& engine;
798  sigc::slot<void> sync;
799  void mem_alloc();
800  void mem_free();
801  void init(unsigned int samplingFreq);
802  void compute(int count, float *input0, float *input1, float *output0, float *output1);
803  void change_buffersize(unsigned int size);
804 
805  static void init_static(unsigned int samplingFreq, PluginDef*);
806  static void compute_static(int count, float *input0, float *input1, float *output0, float *output1, PluginDef*);
807 public:
808  bool mem_allocated;
809  float* get_buffer() {return outdata;};
810  void set_data(bool dfill);
811  Plugin plugin;
812  static Plugin directoutput;
813  Directout( EngineControl& engine, sigc::slot<void> sync);
814  ~Directout();
815 };
816 
817 
818 /****************************************************************
819  ** class LiveLooper
820  */
821 
822 class LiveLooper: public PluginDef {
823 
824 
825 class FileResampler {
826 private:
827  Resampler r_file;
828  int inputRate, outputRate;
829  int last_in_count;
830 public:
831  int setup(int _inputRate, int _outputRate);
832  int run(int count, float *input, float *output);
833  int max_out_count(int in_count) {
834  return static_cast<int>(ceil((in_count*static_cast<double>(outputRate))/inputRate)); }
835 };
836 
837 private:
838  int fSamplingFreq;
839  float gain;
840  float fRec0[2];
841  float gain_out;
842  float fclip1;
843  float fclip2;
844  float fclip3;
845  float fclip4;
846  float fclips1;
847  float fclips2;
848  float fclips3;
849  float fclips4;
850  float fspeed1;
851  float fspeed2;
852  float fspeed3;
853  float fspeed4;
854  float rplay1;
855  float rplay2;
856  float rplay3;
857  float rplay4;
858  float load1;
859  float load2;
860  float load3;
861  float load4;
862  float od1;
863  float od2;
864  float od3;
865  float od4;
866  float fod1;
867  float fod2;
868  float fod3;
869  float fod4;
870  float record1;
871  int iVec0[2];
872  int IOTA1;
873  int IOTA2;
874  int IOTA3;
875  int IOTA4;
876  float IOTAR1;
877  float IOTAR2;
878  float IOTAR3;
879  float IOTAR4;
880  float *tape1;
881  int tape1_size;
882  float fConst0;
883  float fConst1;
884  float fConst2;
885  float reset1;
886  int RecSize1[2];
887  float rectime0;
888  float fRec1[2];
889  float fRec2[2];
890  int iRec3[2];
891  int iRec4[2];
892  float play1;
893  float playh1;
894  float gain1;
895  float record2;
896  int iVec2[2];
897  float *tape2;
898  int tape2_size;
899  float reset2;
900  int RecSize2[2];
901  float rectime1;
902  float fRec6[2];
903  float fRec7[2];
904  int iRec8[2];
905  int iRec9[2];
906  float play2;
907  float playh2;
908  float gain2;
909  float record3;
910  int iVec4[2];
911  float *tape3;
912  int tape3_size;
913  float reset3;
914  int RecSize3[2];
915  float rectime2;
916  float fRec11[2];
917  float fRec12[2];
918  int iRec13[2];
919  int iRec14[2];
920  float play3;
921  float playh3;
922  float gain3;
923  float record4;
924  int iVec6[2];
925  float *tape4;
926  int tape4_size;
927  float reset4;
928  int RecSize4[2];
929  float rectime3;
930  float fRec16[2];
931  float fRec17[2];
932  int iRec18[2];
933  int iRec19[2];
934  float play4;
935  float playh4;
936  float gain4;
937  float play_all;
938  float dout;
939  float* outbuffer;
940  bool save1;
941  bool save2;
942  bool save3;
943  bool save4;
944  bool first1;
945  bool first2;
946  bool first3;
947  bool first4;
948  bool RP1;
949  bool RP2;
950  bool RP3;
951  bool RP4;
952  Glib::ustring preset_name;
953  Glib::ustring load_file1;
954  Glib::ustring load_file2;
955  Glib::ustring load_file3;
956  Glib::ustring load_file4;
957  Glib::ustring cur_name;
958  Glib::ustring loop_dir;
959  bool save_p;
960  ParamMap& param;
961  bool mem_allocated;
962  sigc::slot<void> sync;
963  volatile int ready;
964  FileResampler smp;
965  Directout* d;
966 
967  int do_resample(int inrate, int insize, float *input, int maxsize);
968  int do_mono(int c, int f, float *oIn, float *tape, int n);
969  void play_all_tapes();
970  void mem_alloc();
971  void mem_free();
972  void clear_state_f();
973  int activate(bool start);
974  int load_ui_f(const UiBuilder& b, int form);
975  void init(unsigned int samplingFreq);
976  void compute(int count, float *input0, float *output0);
977  int register_par(const ParamReg& reg);
978  void save_array(std::string name);
979  void load_array(std::string name);
980  void save_to_wave(std::string fname, float *tape, float fSize, int tape_size);
981  int load_from_wave(std::string fname, float **tape, int tape_size);
982  void set_p_state();
983  void load_tape1();
984  void load_tape2();
985  void load_tape3();
986  void load_tape4();
987 
988  static void clear_state_f_static(PluginDef*);
989  static int activate_static(bool start, PluginDef*);
990  static int load_ui_f_static(const UiBuilder& b, int form);
991  static void init_static(unsigned int samplingFreq, PluginDef*);
992  static void compute_static(int count, float *input0, float *output0, PluginDef*);
993  static int register_params_static(const ParamReg& reg);
994  static void del_instance(PluginDef *p);
995 public:
996  Plugin plugin;
997  LiveLooper(ParamMap& param_, sigc::slot<void> sync, const string& loop_dir_);
998  ~LiveLooper();
999 };
1000 
1001 
1002 /****************************************************************
1003  ** class SCapture
1004  */
1005 
1006 
1007 class SCapture: public PluginDef {
1008 private:
1009  SNDFILE * recfile;
1010  EngineControl& engine;
1011  int fSamplingFreq;
1012  int channel;
1013  float fcheckbox0;
1014  float fcheckbox1;
1015  float fslider0;
1016  float fbargraph0;
1017  float fRecC0[2];
1018  float fformat;
1019  int IOTA;
1020  int iA;
1021  int savesize;
1022  int filesize;
1023  float *fRec0;
1024  float *fRec1;
1025  float *tape;
1026  sem_t m_trig;
1027  pthread_t m_pthr;
1028  volatile bool keep_stream;
1029  bool mem_allocated;
1030  bool is_wav;
1031  bool err;
1032  float fConst0;
1033  float fRecb0[2];
1034  int iRecb1[2];
1035  float fRecb2[2];
1036  void mem_alloc();
1037  void mem_free();
1038  void clear_state_f();
1039  int activate(bool start);
1040  int load_ui_f(const UiBuilder& b, int form);
1041  void init(unsigned int samplingFreq);
1042  void compute(int count, float *input0, float *output0);
1043  void compute_st(int count, float *input0, float *input1, float *output0, float *output1);
1044  int register_par(const ParamReg& reg);
1045  void save_to_wave(SNDFILE * sf, float *tape, int lSize);
1046  SNDFILE *open_stream(std::string fname);
1047  void close_stream(SNDFILE **sf);
1048  void stop_thread();
1049  void start_thread();
1050  void disc_stream();
1051  inline std::string get_ffilename();
1052 
1053  static void *run_thread(void* p);
1054  static void clear_state_f_static(PluginDef*);
1055  static int activate_static(bool start, PluginDef*);
1056  static const char *glade_def;
1057  static const char *glade_def_st;
1058  static int load_ui_f_static(const UiBuilder& b, int form);
1059  static void init_static(unsigned int samplingFreq, PluginDef*);
1060  static void compute_static(int count, float *input0, float *output0, PluginDef*);
1061  static void compute_static_st(int count, float *input0, float *input1, float *output0, float *output1, PluginDef*);
1062  static int register_params_static(const ParamReg& reg);
1063  static void del_instance(PluginDef *p);
1064 public:
1065  Plugin plugin;
1066  SCapture(EngineControl& engine, int channel_);
1068 };
1069 
1070 /****************************************************************
1071  ** class DrumSequencer
1072  */
1073 
1074 #include "faust/drumseq.h"
1075 
1076 class Drumout {
1077 private:
1078  static float* set;
1079  static bool mb;
1080  static float* data;
1081  static Plugin input_drum;
1082  static void outputdrum_compute(int count, float *input0, float *input1, float *output0, float *output1, PluginDef*);
1083 public:
1084  static void set_plugin(Plugin p);
1085  static void set_data(float* mode, bool ready, float* buf);
1086  static Plugin output_drum;
1087  static PluginDef outputdrum;
1088  Drumout();
1089 };
1090 
1091 
1092 class DrumSequencer: public PluginDef {
1093 private:
1094  int fSamplingFreq;
1095  FAUSTFLOAT position;
1096  FAUSTFLOAT ftact;
1097  FAUSTFLOAT fsec;
1098  FAUSTFLOAT fslidergain;
1099  FAUSTFLOAT fsliderbpm;
1100  FAUSTFLOAT fsliderhum;
1101  drumseq::Dsp drums;
1102 
1103  int counter;
1104  int seq_size;
1105  int bsize;
1106  FAUSTFLOAT step;
1107  FAUSTFLOAT step_orig;
1108  FAUSTFLOAT fSlow1;
1109  FAUSTFLOAT fSlow3;
1110  FAUSTFLOAT fSlow5;
1111  FAUSTFLOAT fSlow7;
1112  FAUSTFLOAT fSlow12;
1113  FAUSTFLOAT fSlow14;
1114  FAUSTFLOAT fSlow16;
1115  FAUSTFLOAT fSlow18;
1116  FAUSTFLOAT fSlow20;
1117  FAUSTFLOAT fSlow22;
1118  std::vector<int> Vectom;
1119  std::vector<int> Vectom1;
1120  std::vector<int> Vectom2;
1121  std::vector<int> Veckick;
1122  std::vector<int> Vecsnare;
1123  std::vector<int> Vechat;
1124 
1125  EngineControl& engine;
1126  bool mem_allocated;
1127  sigc::slot<void> sync;
1128  volatile bool ready;
1129  float *outdata;
1130  ParamMap& param;
1131  GxSeqSettings tomset;
1132  SeqParameter *tomp;
1133  GxSeqSettings tomset1;
1134  SeqParameter *tomp1;
1135  GxSeqSettings tomset2;
1136  SeqParameter *tomp2;
1137  GxSeqSettings snareset;
1138  SeqParameter *snarep;
1139  GxSeqSettings hatset;
1140  SeqParameter *hatp;
1141  GxSeqSettings kickset;
1142  SeqParameter *kickp;
1144  void mem_alloc();
1145  void mem_free();
1146  void init(unsigned int samplingFreq);
1147  void compute(int count, FAUSTFLOAT *input0, FAUSTFLOAT *output0);
1148  void change_buffersize(unsigned int size);
1149  int register_par(const ParamReg& reg);
1150 
1151  int min_seq_size();
1152  void reset_tom();
1153  void reset_tom1();
1154  void reset_tom2();
1155  void reset_kick();
1156  void reset_hat();
1157  void reset_snare();
1158 
1159  static void init_static(unsigned int samplingFreq, PluginDef*);
1160  static void compute_static(int count, FAUSTFLOAT *input0, FAUSTFLOAT *output0, PluginDef*);
1161  static int register_params_static(const ParamReg& reg);
1162  static void del_instance(PluginDef *p);
1163 public:
1164  Plugin plugin;
1165  DrumSequencer(ParamMap& param_, EngineControl& engine, sigc::slot<void> sync);
1166  ~DrumSequencer();
1167 };
1168 
1169 /****************************************************************************
1171 * NAME: smbPitchShift.cpp
1172 * VERSION: 1.2
1173 * HOME URL: http://www.dspdimension.com
1174 * KNOWN BUGS: none
1175 *
1176 *
1177 * COPYRIGHT 1999-2009 Stephan M. Bernsee <smb [AT] dspdimension [DOT] com>
1178 *
1179 * Modified for guitarix by Hermann Meyer 2014
1180 *
1181 * The Wide Open License (WOL)
1182 *
1183 * Permission to use, copy, modify, distribute and sell this software and its
1184 * documentation for any purpose is hereby granted without fee, provided that
1185 * the above copyright notice and this license appear in all source copies.
1186 * THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY OF
1187 * ANY KIND. See http://www.dspguru.com/wol.htm for more information.
1188 *
1189 *****************************************************************************/
1190 
1191 
1192 #define M_PI 3.14159265358979323846
1193 #define MAX_FRAME_LENGTH 8096
1194 
1195 class smbPitchShift : public PluginDef {
1196 private:
1198  EngineControl& engine;
1199  bool mem_allocated;
1200  sigc::slot<void> sync;
1201  volatile bool ready;
1202  ParamMap& param;
1203  float gInFIFO[MAX_FRAME_LENGTH];
1204  float gOutFIFO[MAX_FRAME_LENGTH];
1205  float *fpb;
1206  float *expect;
1207  float *hanning;
1208  float *hanningd;
1209  float *resampin;
1210  float *resampin2;
1211  float *resampout;
1212  float *indata2;
1213  float gLastPhase[MAX_FRAME_LENGTH/2+1];
1214  float gSumPhase[MAX_FRAME_LENGTH/2+1];
1215  float gOutputAccum[2*MAX_FRAME_LENGTH];
1216  float gAnaFreq[MAX_FRAME_LENGTH];
1217  float gAnaMagn[MAX_FRAME_LENGTH];
1218  float gSynFreq[MAX_FRAME_LENGTH];
1219  float gSynMagn[MAX_FRAME_LENGTH];
1220  float semitones;
1221  float a,b,c,d,l;
1222  float wet;
1223  float dry;
1224  float mpi, mpi1;
1225  float tone;
1226  int octave, osamp, numSampsToResamp, numSampsToProcess, fftFrameSize, sampleRate ;
1227  int latency;
1228  int ai;
1229  int aio;
1230  int ii;
1231  long gRover , gInit ;
1232  double magn, phase, tmp, window, real, imag;
1233  double freqPerBin, freqPerBin1, freqPerBin2, expct;
1234  double fftFrameSize3;
1235  double fftFrameSize4;
1236  double osamp1,osamp2;
1237  long i,k, qpd, index, inFifoLatency, stepSize, fftFrameSize2;
1238 
1239  fftwf_complex fftw_in[MAX_FRAME_LENGTH], fftw_out[MAX_FRAME_LENGTH];
1240  fftwf_plan ftPlanForward, ftPlanInverse;
1241 
1242  inline int load_ui_f(const UiBuilder& b, int form);
1243  int register_par(const ParamReg& reg);
1244  void change_latency();
1245 
1246  void mem_alloc();
1247  void mem_free();
1248  void clear_state();
1249  int activate(bool start);
1250  bool setParameters( int sampleRate);
1251  void PitchShift(int count, float *indata, float *outdata);
1252  void change_buffersize(unsigned int size);
1253  static int activate_static(bool start, PluginDef*);
1254  static void del_instance(PluginDef *p);
1255  static int registerparam(const ParamReg& reg);
1256  static int load_ui_f_static(const UiBuilder& b, int form);
1257  static void init(unsigned int sampleRate, PluginDef *plugin);
1258  static void compute_static(int count, float *input0, float *output0, PluginDef *p);
1259 
1260 public:
1261  Plugin plugin;
1262  smbPitchShift(ParamMap& param_, EngineControl& engine, sigc::slot<void> sync);
1263  ~smbPitchShift();
1264 };
1265 
1266 
1267 } // namespace gx_engine
gx_engine::paradesc::set_valuelist
void set_valuelist(const std::vector< std::string > &v)
Definition: ladspaplugin.cpp:1444
gx_engine::BaseConvolver::set_sync
void set_sync(bool val)
Definition: gx_internal_plugins.h:469
gx_engine::MidiAudioBuffer::jack_load_status
Load jack_load_status()
Definition: gx_internal_plugins.h:192
gx_engine::tp_enabled
Definition: gx_internal_plugins.h:686
gx_engine::CabinetStereoConvolver::~CabinetStereoConvolver
~CabinetStereoConvolver()
Definition: gx_internal_plugins.cpp:1166
gx_engine::TunerAdapter::signal_freq_changed
Glib::Dispatcher & signal_freq_changed()
Definition: gx_internal_plugins.h:92
gx_engine::ConvolverAdapter::getFullIRPath
std::string getFullIRPath() const
Definition: gx_internal_plugins.h:399
gx_engine::GxConvolverBase::set_sync
void set_sync(bool val)
Definition: gx_convolver.h:120
cabinet_impulse_former::init
void init(int samplingFreq)
Definition: cabinet_impulse_former.cc:37
gx_engine::FixedBaseConvolver::activate
static int activate(bool start, PluginDef *pdef)
Definition: gx_internal_plugins.cpp:877
gx_engine::PitchTracker::get_estimated_note
float get_estimated_note()
Definition: gx_pitch_tracker.cpp:396
gx_engine::GxJConvSettings::setGain
void setGain(float gain)
Definition: gx_internal_plugins.h:330
gx_engine::GxJConvSettings::setFullIRPath
void setFullIRPath(string name)
Definition: gx_internal_plugins.cpp:275
gx_engine::LadspaLoader::size
unsigned int size()
Definition: gx_internal_plugins.h:751
gx_engine::smbPitchShift
Definition: gx_internal_plugins.h:1173
gx_engine::MidiVariables::process_midi
void process_midi(int len, float *audiodata, void *midi_port_buf, float jcpu_load, float fConsta4, float fConsta1t)
Definition: gx_engine_midi.cpp:88
gx_engine::BaseConvolver::init
static void init(unsigned int samplingFreq, PluginDef *p)
Definition: gx_internal_plugins.cpp:770
gx_engine::LV2Features::gx_features
static LV2_Feature * gx_features[]
Definition: gx_internal_plugins.h:674
gx_engine::GxJConvSettings::setLength
void setLength(guint leng)
Definition: gx_internal_plugins.h:333
gx_engine::DrumSequencer::plugin
Plugin plugin
Definition: gx_internal_plugins.h:1143
gx_engine::MidiAudioBuffer::load_off
Definition: gx_internal_plugins.h:176
gx_engine::plugdesc::master_label
Glib::ustring master_label
Definition: gx_internal_plugins.h:719
gx_engine::FixedBaseConvolver::SamplingFreq
unsigned int SamplingFreq
Definition: gx_internal_plugins.h:483
gx_engine::TunerAdapter::plugin
Plugin plugin
Definition: gx_internal_plugins.h:84
gx_engine::MidiAudioBuffer::load_high
Definition: gx_internal_plugins.h:176
gx_engine::TunerAdapter::used_by_midi
void used_by_midi(bool on)
Definition: gx_internal_plugins.h:89
gx_engine::LV2Features
Definition: gx_internal_plugins.h:650
gx_engine::LadspaLoader::update_instance
void update_instance(PluginDef *pdef, plugdesc *pdesc)
Definition: ladspaplugin.cpp:1429
gx_engine::PitchTracker::get_estimated_freq
float get_estimated_freq()
Definition: gx_pitch_tracker.h:39
gx_engine::OscilloscopeAdapter::OscilloscopeAdapter
OscilloscopeAdapter(ModuleSequencer &engine)
Definition: gx_internal_ui_plugins.cpp:171
gx_engine::ConvolverAdapter::getIRDir
const std::string & getIRDir() const
Definition: gx_internal_plugins.h:400
gx_engine::plugdesc::category
Glib::ustring category
Definition: gx_internal_plugins.h:714
gx_engine::ConvolverAdapter::set
bool set(const GxJConvSettings &jcset) const
Definition: gx_internal_plugins.h:401
gx_engine::FixedBaseConvolver::engine
EngineControl & engine
Definition: gx_internal_plugins.h:480
gx_resample::FixedRateResampler
Definition: gx_resampler.h:61
value_pair
Definition: gx_plugin.h:117
gx_engine::GxJConvSettings::getGainCor
bool getGainCor() const
Definition: gx_internal_plugins.h:325
gx_engine::LV2Features::gx_urid_unmap
static LV2_URID_Unmap gx_urid_unmap
Definition: gx_internal_plugins.h:676
gx_engine::OscilloscopeAdapter::get_buffer
float * get_buffer()
Definition: gx_internal_plugins.h:236
gx_engine::MaxLevel::channelcount
static const unsigned int channelcount
Definition: gx_internal_plugins.h:50
gx_engine::ParameterV< GxJConvSettings >::set
bool set(const GxJConvSettings &val) const
Definition: gx_internal_plugins.cpp:448
gx_engine::TunerAdapter::get_note
float get_note()
Definition: gx_internal_plugins.h:94
gx_engine::FixedBaseConvolver::set_sync
void set_sync(bool val)
Definition: gx_internal_plugins.h:500
gx_engine::plugdesc
Definition: gx_internal_plugins.h:707
gx_engine::SCapture
Definition: gx_internal_plugins.h:987
gx_engine::MidiAudioBuffer::load_over
Definition: gx_internal_plugins.h:176
gx_engine::MaxLevel::MaxLevel
MaxLevel()
Definition: gx_internal_ui_plugins.cpp:61
gx_engine::NoiseGate
Definition: gx_internal_plugins.h:200
gx_engine::PreampConvolver::~PreampConvolver
~PreampConvolver()
Definition: gx_internal_plugins.cpp:1351
gx_engine::Parameter::on_off_value
virtual bool on_off_value()=0
gx_engine::SeqParameter
ParameterV< GxSeqSettings > SeqParameter
Definition: gx_internal_plugins.h:292
gx_engine::StereoMute::StereoMute
StereoMute()
Definition: gx_internal_ui_plugins.cpp:47
gx_engine::ConvolverAdapter::activated
bool activated
Definition: gx_internal_plugins.h:385
gx_engine::ParameterV< GxJConvSettings >
Definition: gx_internal_plugins.h:344
gx_engine::MidiAudioBuffer::set_jack
void set_jack(gx_jack::GxJack *jack_)
Definition: gx_internal_plugins.h:190
gx_engine::plugdesc::names
std::vector< paradesc * > names
Definition: gx_internal_plugins.h:720
FAUSTFLOAT
#define FAUSTFLOAT
Definition: gx_faust_support.h:21
gx_engine::MidiAudioBuffer::Load
Load
Definition: gx_internal_plugins.h:176
gx_engine::plugdesc::UniqueID
unsigned long UniqueID
Definition: gx_internal_plugins.h:711
gx_jack
Definition: gx_engine.h:28
gx_engine::GxSeqSettings::readJSON
void readJSON(gx_system::JsonParser &jp)
Definition: gx_internal_plugins.cpp:141
gx_engine::TunerAdapter::TunerAdapter
TunerAdapter(ModuleSequencer &engine)
Definition: gx_internal_ui_plugins.cpp:101
gx_engine::no_cleanup
Definition: gx_internal_plugins.h:705
gx_engine::GxSeqSettings::setseqline
void setseqline(const std::vector< int > &seq)
Definition: gx_internal_plugins.h:260
gx_engine::plugdesc::writeJSON
void writeJSON(gx_system::JsonWriter &jw)
Definition: ladspaplugin.cpp:267
gx_engine::paradesc::newrow
bool newrow
Definition: gx_internal_plugins.h:695
gx_engine::BaseConvolver::conv_start
int conv_start()
Definition: gx_internal_plugins.cpp:811
gx_engine::LV2Features::gx_urid_map
static LV2_URID_Map gx_urid_map
Definition: gx_internal_plugins.h:675
gx_engine::BaseConvolver::~BaseConvolver
virtual ~BaseConvolver()
Definition: gx_internal_plugins.cpp:754
gx_engine::GxJConvSettings::getLength
guint getLength() const
Definition: gx_internal_plugins.h:323
gx_engine::ConvolverAdapter::set_sync
void set_sync(bool val)
Definition: gx_internal_plugins.h:398
gx_engine::ConvolverAdapter::restart
void restart()
Definition: gx_internal_plugins.cpp:507
gx_engine::ConvolverAdapter::get_jcset
const GxJConvSettings & get_jcset() const
Definition: gx_internal_plugins.h:402
gx_engine::tp_display_toggle
Definition: gx_internal_plugins.h:686
gx_engine::PitchTracker::new_freq
Glib::Dispatcher new_freq
Definition: gx_pitch_tracker.h:44
gx_engine::Directout::set_data
void set_data(bool dfill)
Definition: gx_internal_plugins.cpp:1746
gx_engine::FixedBaseConvolver::activated
bool activated
Definition: gx_internal_plugins.h:482
gx_engine::OscilloscopeAdapter::plugin
Plugin plugin
Definition: gx_internal_plugins.h:231
gx_engine::BaseConvolver::activate
static int activate(bool start, PluginDef *pdef)
Definition: gx_internal_plugins.cpp:787
PluginDef::name
const char * name
Definition: gx_plugin.h:188
gx_engine::LadspaLoader::begin
pluginarray::iterator begin()
Definition: gx_internal_plugins.h:754
gx_engine::FixedBaseConvolver::getSamplingFreq
unsigned int getSamplingFreq()
Definition: gx_internal_plugins.h:488
gx_engine::GxSeqSettings
Definition: gx_internal_plugins.h:245
gx_engine::plugdesc::add_wet_dry
int add_wet_dry
Definition: gx_internal_plugins.h:716
gx_engine::LadspaLoader::change_plugins
void change_plugins(pluginarray &new_plugins)
Definition: ladspaplugin.cpp:1400
gx_engine::paradesc
Definition: gx_internal_plugins.h:687
gx_engine::ConvolverAdapter::change_buffersize
void change_buffersize(unsigned int size)
Definition: gx_internal_plugins.cpp:491
gx_engine::DrumSequencer::DrumSequencer
DrumSequencer(ParamMap &param_, EngineControl &engine, sigc::slot< void > sync)
Definition: gx_internal_plugins.cpp:1823
gx_engine::plugdesc::Label
Glib::ustring Label
Definition: gx_internal_plugins.h:712
gx_engine::MaxLevel
Definition: gx_internal_plugins.h:48
gx_engine::ConvolverAdapter::plugin
Plugin plugin
Definition: gx_internal_plugins.h:391
gx_engine::plugdesc::shortname
Glib::ustring shortname
Definition: gx_internal_plugins.h:713
gx_engine::LadspaLoader
Definition: gx_internal_plugins.h:731
gx_engine::Directout::~Directout
~Directout()
Definition: gx_internal_plugins.cpp:1687
gx_engine::MonoMute
Definition: gx_internal_plugins.h:33
gx_engine::Parameter::serializeJSON
virtual void serializeJSON(gx_system::JsonWriter &jw)
Definition: gx_paramtable.cpp:880
gx_engine::MidiVariables
Definition: gx_internal_plugins.h:100
gx_engine::widget_type
widget_type
Definition: gx_internal_plugins.h:685
PluginDef
Definition: gx_plugin.h:183
gx_engine::ParameterV< GxSeqSettings >
Definition: gx_internal_plugins.h:267
gx_engine::FixedBaseConvolver::activate_mutex
boost::mutex activate_mutex
Definition: gx_internal_plugins.h:479
gx_engine::ContrastConvolver::ContrastConvolver
ContrastConvolver(EngineControl &engine, sigc::slot< void > sync, gx_resample::BufferResampler &resamp)
Definition: gx_internal_plugins.cpp:1577
gx_system::to_string
std::string to_string(const T &t)
Definition: gx_system.h:524
gx_engine::OscilloscopeAdapter::activation
sigc::signal< int, bool > activation
Definition: gx_internal_plugins.h:232
gx_engine::GxJConvSettings::setGainline
void setGainline(const Gainline &gain)
Definition: gx_internal_plugins.h:335
gx_engine::MidiVariables::get_midistat
bool get_midistat()
Definition: gx_internal_plugins.h:171
gx_engine::MidiAudioBuffer::load_low
Definition: gx_internal_plugins.h:176
gx_engine::GxSeqSettings::writeJSON
void writeJSON(gx_system::JsonWriter &w) const
Definition: gx_internal_plugins.cpp:112
gx_engine::ConvolverStereoAdapter
Definition: gx_internal_plugins.h:412
gx_engine::ConvolverStereoAdapter::~ConvolverStereoAdapter
~ConvolverStereoAdapter()
Definition: gx_internal_plugins.cpp:576
gx_resample::BufferResampler
Definition: gx_resampler.h:45
gx_engine::ConvolverMonoAdapter::~ConvolverMonoAdapter
~ConvolverMonoAdapter()
Definition: gx_internal_plugins.cpp:669
gx_engine::SCapture::plugin
Plugin plugin
Definition: gx_internal_plugins.h:1046
gx_engine::ConvolverAdapter::getIRFile
const std::string & getIRFile() const
Definition: gx_internal_plugins.h:397
gx_engine::FixedBaseConvolver::check_update
virtual void check_update()=0
gx_engine::ContrastConvolver::~ContrastConvolver
~ContrastConvolver()
Definition: gx_internal_plugins.cpp:1590
gx_engine::GxJConvSettings::setIRFile
void setIRFile(string name)
Definition: gx_internal_plugins.h:329
gx_engine::ConvolverAdapter::jcp
JConvParameter * jcp
Definition: gx_internal_plugins.h:389
gx_engine::FixedBaseConvolver::conv_start
int conv_start()
Definition: gx_internal_plugins.cpp:901
gx_engine::Drumout::set_data
static void set_data(float *mode, bool ready, float *buf)
Definition: gx_internal_plugins.cpp:1804
gx_jack::GxJack
Definition: gx_jack.h:109
gx_engine::Drumout::output_drum
static Plugin output_drum
Definition: gx_internal_plugins.h:1066
gx_engine::FixedBaseConvolver::~FixedBaseConvolver
virtual ~FixedBaseConvolver()
Definition: gx_internal_plugins.cpp:840
gx_engine::GxJConvSettings::operator=
GxJConvSettings & operator=(GxJConvSettings const &jcset)
Definition: gx_internal_plugins.cpp:255
gx_engine::FixedBaseConvolver::init
static void init(unsigned int samplingFreq, PluginDef *p)
Definition: gx_internal_plugins.cpp:857
gx_engine::BaseConvolver::sync
sigc::slot< void > sync
Definition: gx_internal_plugins.h:454
gx_engine::plugdesc::index
unsigned int index
Definition: gx_internal_plugins.h:710
gx_engine::BaseConvolver::change_buffersize
void change_buffersize(unsigned int)
Definition: gx_internal_plugins.cpp:758
gx_engine::FixedBaseConvolver::change_buffersize
void change_buffersize(unsigned int)
Definition: gx_internal_plugins.cpp:844
gx_engine::ConvolverAdapter::conv_start
bool conv_start()
Definition: gx_internal_plugins.cpp:531
gx_engine::GxJConvSettings::getOffset
guint getOffset() const
Definition: gx_internal_plugins.h:322
gx_engine::FixedBaseConvolver::update_conn
sigc::connection update_conn
Definition: gx_internal_plugins.h:486
gx_engine::MidiAudioBuffer::MidiAudioBuffer
MidiAudioBuffer(TunerAdapter &t)
Definition: gx_midi_plugin.cpp:43
gx_engine::smbPitchShift::smbPitchShift
smbPitchShift(ParamMap &param_, EngineControl &engine, sigc::slot< void > sync)
Definition: gx_internal_plugins.cpp:2146
gx_engine::BaseConvolver::engine
EngineControl & engine
Definition: gx_internal_plugins.h:453
gx_engine::paradesc::values
value_pair * values
Definition: gx_internal_plugins.h:697
gx_engine::LadspaLoader::get_ladspa_filename
static std::string get_ladspa_filename(unsigned long uid)
Definition: gx_internal_plugins.h:760
gx_engine::LiveLooper::plugin
Plugin plugin
Definition: gx_internal_plugins.h:978
gx_engine::BaseConvolver::check_update_timeout
bool check_update_timeout()
Definition: gx_internal_plugins.cpp:779
gx_engine::Directout::mem_allocated
bool mem_allocated
Definition: gx_internal_plugins.h:791
gx_engine::GxJConvSettings::getGainline
const Gainline & getGainline() const
Definition: gx_internal_plugins.h:326
gx_engine
Definition: gx_convolver.h:33
gx_engine::LV2Features::operator=
void operator=(LV2Features const &)=delete
gx_engine::GxJConvSettings::setGainCor
void setGainCor(bool gain)
Definition: gx_internal_plugins.h:331
gx_engine::GxJConvSettings::writeJSON
void writeJSON(gx_system::JsonWriter &w) const
Definition: gx_internal_plugins.cpp:280
gx_system::JsonWriter
Definition: gx_json.h:54
gx_engine::SCapture::SCapture
SCapture(EngineControl &engine, int channel_)
Definition: gx_record.cc:32
gx_engine::Drumout::outputdrum
static PluginDef outputdrum
Definition: gx_internal_plugins.h:1067
gx_engine::CabinetConvolver::~CabinetConvolver
~CabinetConvolver()
Definition: gx_internal_plugins.cpp:1028
gx_engine::MidiAudioBuffer
Definition: gx_internal_plugins.h:174
gx_engine::BaseConvolver::update_conn
sigc::connection update_conn
Definition: gx_internal_plugins.h:456
gx_resample::SimpleResampler
Definition: gx_resampler.h:34
gx_engine::GxSeqSettings::SequencerAdapter
friend class SequencerAdapter
Definition: gx_internal_plugins.h:251
gx_engine::FixedBaseConvolver::plugin
Plugin plugin
Definition: gx_internal_plugins.h:496
gx_engine::BaseConvolver::activate_mutex
boost::mutex activate_mutex
Definition: gx_internal_plugins.h:452
gx_engine::ModuleSelector
Definition: gx_modulesequencer.h:28
gx_engine::paradesc::index
int index
Definition: gx_internal_plugins.h:688
gx_system::PathList
Definition: gx_system.h:287
gx_engine::BaseConvolver::start
virtual bool start(bool force=false)=0
gx_system::JsonParser
Definition: gx_json.h:111
gx_engine::paradesc::step
float step
Definition: gx_internal_plugins.h:693
gx_engine::NoiseGate::outputgate
static PluginDef outputgate
Definition: gx_internal_plugins.h:213
gx_engine::paradesc::has_caption
bool has_caption
Definition: gx_internal_plugins.h:696
gx_engine::CabinetConvolver::CabinetConvolver
CabinetConvolver(EngineControl &engine, sigc::slot< void > sync, gx_resample::BufferResampler &resamp)
Definition: gx_internal_plugins.cpp:1001
gx_engine::paradesc::~paradesc
~paradesc()
Definition: ladspaplugin.cpp:1437
gx_engine::LV2Features::getInstance
static LV2Features & getInstance()
Definition: gx_internal_plugins.h:669
gx_engine::GxJConvSettings::getGain
float getGain() const
Definition: gx_internal_plugins.h:321
gx_engine::Parameter::setJSON_value
virtual void setJSON_value()=0
gx_engine::JConvParameter
ParameterV< GxJConvSettings > JConvParameter
Definition: gx_internal_plugins.h:371
gx_engine::StereoMute
Definition: gx_internal_plugins.h:40
gx_engine::BaseConvolver::conv
GxSimpleConvolver conv
Definition: gx_internal_plugins.h:451
gx_engine::LadspaLoader::end
pluginarray::iterator end()
Definition: gx_internal_plugins.h:755
gx_engine::BaseConvolver
Definition: gx_internal_plugins.h:448
gx_engine::TunerAdapter::set_module
void set_module()
Definition: gx_internal_ui_plugins.cpp:161
gx_engine::GxSeqSettings::operator=
GxSeqSettings & operator=(GxSeqSettings const &seqset)
Definition: gx_internal_plugins.cpp:107
gx_engine::LadspaLoader::~LadspaLoader
~LadspaLoader()
Definition: ladspaplugin.cpp:1379
gx_engine::GxJConvSettings::getDelay
guint getDelay() const
Definition: gx_internal_plugins.h:324
gx_engine::TunerAdapter::used_for_display
bool used_for_display()
Definition: gx_internal_plugins.h:88
gx_engine::MidiAudioBuffer::get_midistat
bool get_midistat()
Definition: gx_internal_plugins.h:191
gx_engine::tp_enum
Definition: gx_internal_plugins.h:686
gx_engine::ConvolverAdapter::activate_mutex
boost::mutex activate_mutex
Definition: gx_internal_plugins.h:381
gx_engine::PreampConvolver::PreampConvolver
PreampConvolver(EngineControl &engine, sigc::slot< void > sync, gx_resample::BufferResampler &resamp)
Definition: gx_internal_plugins.cpp:1324
gx_engine::ConvolverAdapter::sync
sigc::slot< void > sync
Definition: gx_internal_plugins.h:383
gx_engine::GxJConvSettings::getIRFile
const std::string & getIRFile() const
Definition: gx_internal_plugins.h:319
gx_engine::BaseConvolver::plugin
Plugin plugin
Definition: gx_internal_plugins.h:465
gx_engine::paradesc::readJSON
void readJSON(gx_system::JsonParser &jp)
Definition: ladspaplugin.cpp:182
gx_engine::BaseConvolver::check_update
virtual void check_update()=0
gx_engine::ConvolverAdapter::conv
GxConvolver conv
Definition: gx_internal_plugins.h:380
gx_engine::is_lv2
Definition: gx_internal_plugins.h:705
gx_engine::tp_scale
Definition: gx_internal_plugins.h:686
gx_engine::ConvolverAdapter::ConvolverAdapter
ConvolverAdapter(EngineControl &engine, sigc::slot< void > sync, ParamMap &param)
Definition: gx_internal_plugins.cpp:468
gx_engine::paradesc::tp
widget_type tp
Definition: gx_internal_plugins.h:694
gx_engine::Parameter::readJSON_value
virtual void readJSON_value(gx_system::JsonParser &jp)=0
gx_engine::EngineControl
Definition: gx_modulesequencer.h:233
gx_engine::FixedBaseConvolver::bz
unsigned int bz
Definition: gx_internal_plugins.h:485
gx_engine::ConvolverMonoAdapter
Definition: gx_internal_plugins.h:430
gx_engine::Directout::directoutput
static Plugin directoutput
Definition: gx_internal_plugins.h:795
gx_engine::plugdesc::master_idx
int master_idx
Definition: gx_internal_plugins.h:718
gx_engine::OscilloscopeAdapter::size_change
sigc::signal< void, unsigned int > size_change
Definition: gx_internal_plugins.h:233
gx_engine::BaseConvolver::BaseConvolver
BaseConvolver(EngineControl &engine, sigc::slot< void > sync, gx_resample::BufferResampler &resamp)
Definition: gx_internal_plugins.cpp:738
gx_engine::ConvolverMonoAdapter::ConvolverMonoAdapter
ConvolverMonoAdapter(EngineControl &engine, sigc::slot< void > sync, ParamMap &param)
Definition: gx_internal_plugins.cpp:658
gx_engine::Directout::plugin
Plugin plugin
Definition: gx_internal_plugins.h:794
gx_system::PrefixConverter
Definition: gx_system.h:306
gx_engine::ConvolverAdapter::get_parameter_map
ParamMap & get_parameter_map() const
Definition: gx_internal_plugins.h:403
gx_engine::GxJConvSettings::getIRDir
const std::string & getIRDir() const
Definition: gx_internal_plugins.h:327
gx_engine::ConvolverAdapter::param
ParamMap & param
Definition: gx_internal_plugins.h:384
gx_engine::tp_scale_log
Definition: gx_internal_plugins.h:686
gx_engine::quirkflag
quirkflag
Definition: gx_internal_plugins.h:705
gx_engine::ParamMap
Definition: gx_parameter.h:512
gx_engine::paradesc::paradesc
paradesc()
Definition: gx_internal_plugins.h:698
gx_engine::Parameter::writeJSON
virtual void writeJSON(gx_system::JsonWriter &jw) const =0
gx_engine::ConvolverAdapter::jcset
GxJConvSettings jcset
Definition: gx_internal_plugins.h:388
gx_engine::PreampStereoConvolver::PreampStereoConvolver
PreampStereoConvolver(EngineControl &engine, sigc::slot< void > sync, gx_resample::BufferResampler &resamp)
Definition: gx_internal_plugins.cpp:1461
gx_engine::Directout::outdata
float * outdata
Definition: gx_internal_plugins.h:775
gx_engine::FixedBaseConvolver::sync
sigc::slot< void > sync
Definition: gx_internal_plugins.h:481
gx_engine::LiveLooper::LiveLooper
LiveLooper(ParamMap &param_, sigc::slot< void > sync, const string &loop_dir_)
Definition: gx_livelooper.cc:70
gx_engine::Drumout
Definition: gx_internal_plugins.h:1055
ParamReg
Definition: gx_plugin.h:122
gx_system::CmdlineOptions
Definition: gx_system.h:377
gx_engine::FixedBaseConvolver
Definition: gx_internal_plugins.h:475
gx_engine::DrumSequencer
Definition: gx_internal_plugins.h:1071
gx_engine::OscilloscopeAdapter::get_mul_buffer
int get_mul_buffer()
Definition: gx_internal_plugins.h:237
gx_engine::tp_none
Definition: gx_internal_plugins.h:686
gx_engine::LadspaLoader::Lv2Dsp
friend class Lv2Dsp
Definition: gx_internal_plugins.h:765
gx_engine::PreampStereoConvolver::~PreampStereoConvolver
~PreampStereoConvolver()
Definition: gx_internal_plugins.cpp:1489
gx_engine::Directout::get_buffer
float * get_buffer()
Definition: gx_internal_plugins.h:792
gx_engine::LadspaLoader::LadspaLoader
LadspaLoader(const gx_system::CmdlineOptions &options, ParamMap &param)
Definition: ladspaplugin.cpp:1364
gx_engine::LadspaLoader::find
pluginarray::iterator find(plugdesc *desc)
Definition: ladspaplugin.cpp:1414
gx_engine::PitchTracker
Definition: gx_pitch_tracker.h:33
gx_engine::paradesc::dflt
float dflt
Definition: gx_internal_plugins.h:690
gx_engine::LiveLooper::~LiveLooper
~LiveLooper()
Definition: gx_livelooper.cc:120
UiBuilder
Definition: gx_plugin.h:63
gx_engine::MidiAudioBuffer::signal_jack_load_change
Glib::Dispatcher & signal_jack_load_change()
Definition: gx_internal_plugins.h:193
gx_engine::ModuleSequencer
Definition: gx_modulesequencer.h:290
gx_engine::ConvolverAdapter::engine
EngineControl & engine
Definition: gx_internal_plugins.h:382
gx_engine::Parameter::compareJSON_value
virtual bool compareJSON_value()=0
gx_engine::GxSeqSettings::GxSeqSettings
GxSeqSettings()
Definition: gx_internal_plugins.cpp:103
gx_engine::GxJConvSettings::operator==
bool operator==(const GxJConvSettings &jcset) const
Definition: gx_internal_plugins.cpp:301
gx_engine::FixedBaseConvolver::FixedBaseConvolver
FixedBaseConvolver(EngineControl &engine, sigc::slot< void > sync, gx_resample::BufferResampler &resamp)
Definition: gx_internal_plugins.cpp:821
start
CmdConnection::msg_type start
Definition: jsonrpc.cpp:255
gx_engine::DrumSequencer::~DrumSequencer
~DrumSequencer()
Definition: gx_internal_plugins.cpp:1869
gx_engine::LadspaLoader::create
PluginDef * create(unsigned int idx)
Definition: gx_internal_plugins.h:752
gx_engine::FixedBaseConvolver::conv
GxSimpleConvolver conv
Definition: gx_internal_plugins.h:478
gx_engine::FixedBaseConvolver::check_update_timeout
bool check_update_timeout()
Definition: gx_internal_plugins.cpp:869
gx_engine::LadspaLoader::set_plugins
void set_plugins(pluginarray &new_plugins)
Definition: ladspaplugin.cpp:1407
gx_engine::plugdesc::quirks
int quirks
Definition: gx_internal_plugins.h:715
gx_engine::TunerAdapter::set_dep_module
void set_dep_module(Plugin *dep)
Definition: gx_internal_plugins.h:90
gx_engine::plugdesc::stereo_to_mono
int stereo_to_mono
Definition: gx_internal_plugins.h:717
gx_engine::TunerAdapter::get_freq
float get_freq()
Definition: gx_internal_plugins.h:93
gx_engine::ConvolverAdapter::~ConvolverAdapter
~ConvolverAdapter()
Definition: gx_internal_plugins.cpp:488
gx_engine::BaseConvolver::activated
bool activated
Definition: gx_internal_plugins.h:455
gx_engine::NoiseGate::inputlevel
static Plugin inputlevel
Definition: gx_internal_plugins.h:212
gx_engine::LadspaLoader::load
bool load(pluginarray &p)
Definition: ladspaplugin.cpp:1390
gx_engine::paradesc::up
float up
Definition: gx_internal_plugins.h:692
gx_engine::GxSeqSettings::operator==
bool operator==(const GxSeqSettings &seqset) const
Definition: gx_internal_plugins.cpp:123
gx_engine::MaxLevel::get
static float get(unsigned int channel)
Definition: gx_internal_plugins.h:57
gx_engine::GxConvolver
Definition: gx_convolver.h:123
gx_engine::OscilloscopeAdapter::get_size
unsigned int get_size()
Definition: gx_internal_plugins.h:235
gx_engine::TunerAdapter::used_for_switching
void used_for_switching(bool on)
Definition: gx_internal_plugins.h:86
gx_engine::LadspaLoader::pluginarray
std::vector< plugdesc * > pluginarray
Definition: gx_internal_plugins.h:733
gx_engine::plugdesc::readJSON
void readJSON(gx_system::JsonParser &jp)
Definition: ladspaplugin.cpp:236
gx_engine::ConvolverStereoAdapter::ConvolverStereoAdapter
ConvolverStereoAdapter(EngineControl &engine, sigc::slot< void > sync, ParamMap &param)
Definition: gx_internal_plugins.cpp:565
gx_engine::Plugin
Definition: gx_pluginloader.h:44
gx_engine::MidiVariables::init
void init(int samplingFreq)
Definition: gx_engine_midi.cpp:73
gx_engine::GxJConvSettings::getFullIRPath
std::string getFullIRPath() const
Definition: gx_internal_plugins.cpp:267
gx_engine::tp_toggle
Definition: gx_internal_plugins.h:686
gx_engine::GxJConvSettings::setOffset
void setOffset(guint offs)
Definition: gx_internal_plugins.h:332
gx_engine::TunerAdapter
Definition: gx_internal_plugins.h:70
gx_engine::GxJConvSettings::GxJConvSettings
GxJConvSettings()
Definition: gx_internal_plugins.cpp:244
gx_engine::Directout::Directout
Directout(EngineControl &engine, sigc::slot< void > sync)
Definition: gx_internal_plugins.cpp:1667
gx_engine::GxJConvSettings
Definition: gx_internal_plugins.h:297
gx_engine::GxSeqSettings::getseqline
const std::vector< int > & getseqline() const
Definition: gx_internal_plugins.h:258
gx_engine::FixedBaseConvolver::start
virtual bool start(bool force=false)=0
gx_engine::ConvolverAdapter
Definition: gx_internal_plugins.h:377
gx_engine::Parameter::stdJSON_value
virtual void stdJSON_value()=0
gx_engine::SCapture::~SCapture
~SCapture()
Definition: gx_record.cc:76
gx_engine::CabinetStereoConvolver::CabinetStereoConvolver
CabinetStereoConvolver(EngineControl &engine, sigc::slot< void > sync, gx_resample::BufferResampler &resamp)
Definition: gx_internal_plugins.cpp:1138
gx_engine::smbPitchShift::~smbPitchShift
~smbPitchShift()
Definition: gx_internal_plugins.cpp:2338
gx_engine::paradesc::low
float low
Definition: gx_internal_plugins.h:691
gx_engine::need_activate
Definition: gx_internal_plugins.h:705
gx_engine::paradesc::name
std::string name
Definition: gx_internal_plugins.h:689
gx_engine::OscilloscopeAdapter::set_mul_buffer
void set_mul_buffer(int a, unsigned int b)
Definition: gx_internal_plugins.h:238
gx_engine::paradesc::writeJSON
void writeJSON(gx_system::JsonWriter &jw)
Definition: ladspaplugin.cpp:211
gx_engine::GxSimpleConvolver
Definition: gx_convolver.h:153
gx_engine::MidiVariables::register_parameter
void register_parameter(const ParamReg &reg)
Definition: gx_engine_midi.cpp:31
gx_engine::LadspaLoader::get_parameter_map
ParamMap & get_parameter_map() const
Definition: gx_internal_plugins.h:764
gx_engine::tp_display
Definition: gx_internal_plugins.h:686
gx_engine::ParameterV
Definition: gx_parameter.h:91
gx_engine::Parameter
Definition: gx_parameter.h:104
gx_engine::GxJConvSettings::setDelay
void setDelay(guint del)
Definition: gx_internal_plugins.h:334
gx_engine::GxJConvSettings::readJSON
void readJSON(gx_system::JsonParser &jp)
Definition: gx_internal_plugins.cpp:336
gx_engine::plugdesc::id_str
std::string id_str
Definition: gx_internal_plugins.h:721
gx_engine::smbPitchShift::plugin
Plugin plugin
Definition: gx_internal_plugins.h:1239
gx_engine::Drumout::set_plugin
static void set_plugin(Plugin p)
Definition: gx_internal_plugins.cpp:1810
gx_engine::plugdesc::path
std::string path
Definition: gx_internal_plugins.h:709
gx_engine::FixedBaseConvolver::buffersize
unsigned int buffersize
Definition: gx_internal_plugins.h:484
gx_engine::MidiAudioBuffer::plugin
Plugin plugin
Definition: gx_internal_plugins.h:188
gx_engine::tp_int
Definition: gx_internal_plugins.h:686
gx_engine::OscilloscopeAdapter::clear_buffer
void clear_buffer()
Definition: gx_internal_ui_plugins.cpp:228
gx_engine::NoiseGate::NoiseGate
NoiseGate()
Definition: gx_internal_plugins.cpp:43
MAX_FRAME_LENGTH
#define MAX_FRAME_LENGTH
Definition: gx_internal_plugins.h:1171
gx_engine::OscilloscopeAdapter
Definition: gx_internal_plugins.h:220
gx_engine::MonoMute::MonoMute
MonoMute()
Definition: gx_internal_ui_plugins.cpp:35
gx_engine::Drumout::Drumout
Drumout()
Definition: gx_internal_plugins.cpp:1783