Guitarix
gx_internal_plugins.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 part of the Guitarix Audio Engine
22  *
23  *
24  *
25  * --------------------------------------------------------------------------
26  */
27 
28 #include "engine.h"
29 #include "gx_faust_support.h"
30 
31 namespace gx_engine {
32 
33 /****************************************************************
34  ** class NoiseGate
35  */
36 
37 PluginDef NoiseGate::inputdef = PluginDef();
38 float NoiseGate::fnglevel = 0;
39 float NoiseGate::ngate = 1;
40 bool NoiseGate::off = true;
41 Plugin NoiseGate::inputlevel = Plugin();
43 
45 
46  inputdef.version = PLUGINDEF_VERSION;
47  inputdef.flags = PGN_SNOOP;
48  inputdef.id = "noise_gate";
49  inputdef.name = N_("Noise Gate");
50  inputdef.mono_audio = inputlevel_compute;
51  inputdef.register_params = noisegate_register;
52 
53  inputlevel.set_pdef(&inputdef);
54 
56  outputgate.id = "noiseshut";
57  outputgate.name = "?noiseshut";
58  outputgate.mono_audio = outputgate_compute;
59  outputgate.activate_plugin = outputgate_activate;
60 
61 }
62 
63 inline float sqrf(float x) {
64  return x * x;
65 }
66 
67 void NoiseGate::inputlevel_compute(int count, float *input, float *output, PluginDef*) {
68  float sumnoise = 0;
69  for (int i = 0; i < count; i++) {
70  sumnoise += sqrf(input[i]);
71  }
72  if (sumnoise/count > sqrf(fnglevel * 0.01)) {
73  ngate = 1; // -75db 0.001 = 65db
74  } else if (ngate > 0.01) {
75  ngate *= 0.996;
76  }
77 }
78 
79 int NoiseGate::noisegate_register(const ParamReg& reg) {
80  reg.registerVar("noise_gate.threshold", N_("Threshold"), "S", "", &fnglevel,
81  0.017f, 0.01f, 0.31f, 0.001f);
82  return 0;
83 }
84 
85 void NoiseGate::outputgate_compute(int count, float *input, float *output, PluginDef*) {
86  if (off) {
87  return;
88  }
89  while (count--) {
90  *output++ = ngate * *input++;
91  }
92 }
93 
94 int NoiseGate::outputgate_activate(bool start, PluginDef *pdef) {
95  if (start) {
96  off = !inputlevel.get_on_off();
97  }
98  return 0;
99 }
100 
101 /****************************************************************
102  ** class GxSeqSettings
103  */
104 
106  : seqline() {
107 }
108 
110  seqline = seqset.seqline;
111  return *this;
112 }
113 
115  w.begin_object(true);
116  w.write_key("seq.seqline");
117  w.begin_array();
118  for (unsigned int i = 0; i < seqline.size(); i++) {
119  w.write(seqline[i]);
120  }
121  w.end_array(true);
122  w.end_object(true);
123 }
124 
125 bool GxSeqSettings::operator==(const GxSeqSettings& seqset) const {
126  if (seqline != seqset.seqline) {
127  return false;
128  }
129  return true;
130 }
131 
132 void GxSeqSettings::read_seqline(gx_system::JsonParser& jp) {
133  seqline.clear();
135  while (jp.peek() == gx_system::JsonParser::value_number) {
137  int p = jp.current_value_int();
138  seqline.push_back(p);
139  }
141 }
142 
145  do {
147  if (jp.current_value() == "seq.seqline") {
148  read_seqline(jp);
149  } else {
150  gx_print_warning("seq settings", "unknown key: " + jp.current_value());
151  jp.skip_object();
152  }
153  } while (jp.peek() == gx_system::JsonParser::value_key);
155 }
156 
157 /****************************************************************
158  ** class SeqParameter
159  */
160 
162  : Parameter(id, "", tp_special, None, true, false),
163  json_value(),
164  value(v),
165  std_value(),
166  value_storage(),
167  changed() {
168  std_value.seqline = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
169 }
170 
172  ParamMap &pmap, const string& id, GxSeqSettings *v) {
173  SeqParameter *p = new SeqParameter(id, v);
174  pmap.insert(p);
175  return p;
176 }
177 
179 }
180 
182  : Parameter(jp_next(jp, "Parameter")),
183  json_value(),
184  value(&value_storage),
185  std_value() {
186  while (jp.peek() != gx_system::JsonParser::end_object) {
188  if (jp.current_value() == "value") {
189  value->readJSON(jp);
190  } else if (jp.current_value() == "std_value") {
191  std_value.readJSON(jp);
192  } else {
194  "SeqParameter", Glib::ustring::compose("%1: unknown key: %2", _id, jp.current_value()));
195  jp.skip_object();
196  }
197  }
199 }
200 
202  jw.begin_object();
203  jw.write_key("Parameter"); Parameter::serializeJSON(jw);
204  jw.write_key("value"); value->writeJSON(jw);
205  jw.write_key("std_value"); std_value.writeJSON(jw);
206  jw.end_object();
207 }
208 
210  assert(false);
211  return false;
212 }
213 
215  json_value = std_value;
216 }
217 
219  jw.write_key(_id.c_str());
220  value->writeJSON(jw);
221 }
222 
224  json_value.readJSON(jp);
225 }
226 
228  return json_value == *value;
229 }
230 
231 bool SeqParameter::set(const GxSeqSettings& val) const {
232  if (val == *value) {
233  return false;
234  }
235  *value = val;
236  changed(value);
237  return true;
238 }
239 
241  set(json_value);
242 }
243 
244 /****************************************************************
245  ** class GxJConvSettings
246  */
247 
249  : fIRFile(),
250  fIRDir(),
251  fGain(0),
252  fOffset(0),
253  fLength(0),
254  fDelay(0),
255  gainline(),
256  fGainCor(false) {
257 }
258 
260  fIRFile = jcset.fIRFile;
261  fIRDir = jcset.fIRDir;
262  fGain = jcset.fGain;
263  fOffset = jcset.fOffset;
264  fLength = jcset.fLength;
265  fDelay = jcset.fDelay;
266  gainline = jcset.gainline;
267  fGainCor = jcset.fGainCor;
268  return *this;
269 }
270 
271 std::string GxJConvSettings::getFullIRPath() const {
272  if (fIRFile.empty()) {
273  return fIRFile;
274  } else {
275  return Glib::build_filename(fIRDir, fIRFile);
276  }
277 }
278 
280  fIRDir = Glib::path_get_dirname(name);
281  fIRFile= Glib::path_get_basename(name);
282 }
283 
285  w.begin_object(true);
286  w.write_kv("jconv.IRFile", fIRFile);
287  w.write_kv("jconv.IRDir", gx_system::get_options().get_IR_prefixmap().replace_path(fIRDir));
288  w.write_kv("jconv.Gain", fGain);
289  w.write_kv("jconv.GainCor", fGainCor);
290  w.write_kv("jconv.Offset", fOffset);
291  w.write_kv("jconv.Length", fLength);
292  w.write_kv("jconv.Delay", fDelay);
293  w.write_key("jconv.gainline");
294  w.begin_array();
295  for (unsigned int i = 0; i < gainline.size(); i++) {
296  w.begin_array();
297  w.write(gainline[i].i);
298  w.write(gainline[i].g);
299  w.end_array();
300  }
301  w.end_array(true);
302  w.end_object(true);
303 }
304 
306  if (fIRFile != jcset.fIRFile || fIRDir != jcset.fIRDir) {
307  return false;
308  }
309  if (fOffset != jcset.fOffset || fLength != jcset.fLength || fDelay != jcset.fDelay) {
310  return false;
311  }
312  if (fGainCor != jcset.fGainCor) {
313  return false;
314  }
315  if (fGainCor && std::abs(fGain - jcset.fGain) > 1e-4 * (fGain + jcset.fGain)) {
316  return false;
317  }
318  if (gainline == jcset.gainline) {
319  return false;
320  }
321  return true;
322 }
323 
324 void GxJConvSettings::read_gainline(gx_system::JsonParser& jp) {
325  gainline.clear();
327  while (jp.peek() == gx_system::JsonParser::begin_array) {
328  jp.next();
330  gain_points p;
331  p.i = jp.current_value_int();
333  p.g = jp.current_value_float();
335  gainline.push_back(p);
336  }
338 }
339 
342  do {
344  if (jp.read_kv("jconv.IRFile", fIRFile) ||
345  jp.read_kv("jconv.IRDir", fIRDir) ||
346  jp.read_kv("jconv.Gain", fGain) ||
347  jp.read_kv("jconv.GainCor", fGainCor) ||
348  jp.read_kv("jconv.Offset", fOffset) ||
349  jp.read_kv("jconv.Length", fLength) ||
350  jp.read_kv("jconv.Delay", fDelay)) {
351  } else if (jp.current_value() == "jconv.gainline") {
352  read_gainline(jp);
353  } else if (jp.current_value() == "jconv.favorits") {
354  jp.skip_object();
355  } else {
356  gx_print_warning("jconv settings", "unknown key: " + jp.current_value());
357  jp.skip_object();
358  }
359  } while (jp.peek() == gx_system::JsonParser::value_key);
361  if (!fIRFile.empty()) {
362  if (fIRDir.empty()) {
363  gx_system::get_options().get_IR_pathlist().find_dir(&fIRDir, fIRFile);
364  } else {
366  }
367  }
368 }
369 
370 
371 /****************************************************************
372  ** class JConvParameter
373  */
374 
376  : Parameter(id, "", tp_special, None, true, false),
377  json_value(),
378  value(v),
379  std_value(),
380  value_storage(),
381  changed() {
382  std_value.setFullIRPath(gx_system::get_options().get_IR_prefixmap().replace_symbol("%S/greathall.wav"));
383  std_value.fGainCor = true;
384  std_value.fGain = 0.598717;
385  const int ir_len = 112561;
386  std_value.fLength = ir_len;
387  static gain_points g[2] = {{0, 0}, {ir_len-1, 0}};
388  std_value.gainline = Gainline(g, sizeof(g) / sizeof(g[0]));
389 }
390 
392  ParamMap &pmap, const string& id, ConvolverAdapter &conv, GxJConvSettings *v) {
393  JConvParameter *p = new JConvParameter(id, conv, v);
394  pmap.insert(p);
395  return p;
396 }
397 
399 }
400 
402  : Parameter(jp_next(jp, "Parameter")),
403  searchpath(0),
404  pfx_conv(0),
405  json_value(),
406  value(&value_storage),
407  std_value() {
408  while (jp.peek() != gx_system::JsonParser::end_object) {
410  if (jp.current_value() == "value") {
411  value->readJSON(jp);
412  } else if (jp.current_value() == "std_value") {
413  std_value.readJSON(jp);
414  } else {
416  "JConvParameter", Glib::ustring::compose("%1: unknown key: %2", _id, jp.current_value()));
417  jp.skip_object();
418  }
419  }
421 }
422 
424  jw.begin_object();
425  jw.write_key("Parameter"); Parameter::serializeJSON(jw);
426  jw.write_key("value"); value->writeJSON(jw);
427  jw.write_key("std_value"); std_value.writeJSON(jw);
428  jw.end_object();
429 }
430 
432  assert(false);
433  return false;
434 }
435 
437  json_value = std_value;
438 }
439 
441  jw.write_key(_id.c_str());
442  value->writeJSON(jw);
443 }
444 
446  json_value.readJSON(jp);
447 }
448 
450  return json_value == *value;
451 }
452 
453 bool JConvParameter::set(const GxJConvSettings& val) const {
454  if (val == *value) {
455  return false;
456  }
457  *value = val;
458  changed(value);
459  return true;
460 }
461 
463  set(json_value);
464 }
465 
466 
467 /****************************************************************
468  ** class ConvolverAdapter
469  */
470 
471 #include "faust/jconv_post.cc"
472 #include "faust/jconv_post_mono.cc"
473 
475  EngineControl& engine_, sigc::slot<void> sync_, ParamMap& param_)
476  : PluginDef(),
477  conv(),
478  activate_mutex(),
479  engine(engine_),
480  sync(sync_),
481  param(param_),
482  activated(false),
483  jcset(),
484  jcp(0),
485  plugin() {
487  category = N_("Reverb");
488  //FIXME: add clear_state
489  plugin = this;
491  sigc::mem_fun(*this, &ConvolverAdapter::change_buffersize));
492 }
493 
495 }
496 
497 void ConvolverAdapter::change_buffersize(unsigned int size) {
498  boost::mutex::scoped_lock lock(activate_mutex);
499  if (activated) {
500  conv.stop_process();
501  while (conv.is_runnable()) {
502  conv.checkstate();
503  }
504  conv.set_buffersize(size);
505  if (size) {
506  conv_start();
507  }
508  } else {
509  conv.set_buffersize(size);
510  }
511 }
512 
514  if (!plugin.get_on_off()) {
515  return;
516  }
518  sync();
519  conv.stop_process();
520  while (!conv.checkstate());
521  float gain;
522  if (jcset.getGainCor()) {
523  gain = jcset.getGain();
524  } else {
525  gain = 1.0;
526  }
527  bool rc = conv.configure(
528  jcset.getFullIRPath(), gain, gain, jcset.getDelay(), jcset.getDelay(),
530  int policy, priority;
531  engine.get_sched_priority(policy, priority);
532  if (!rc || !conv.start(policy, priority)) {
533  plugin.set_on_off(false);
534  }
535 }
536 
538  if (!conv.get_buffersize() || !conv.get_samplerate()) {
539  return false;
540  }
541  string path = jcset.getFullIRPath();
542  if (path.empty()) {
543  gx_print_warning(_("convolver"), _("no impulseresponse file"));
544  plugin.set_on_off(false);
545  return false;
546  }
547  while (!conv.checkstate());
548  if (conv.is_runnable()) {
549  return true;
550  }
551  float gain;
552  if (jcset.getGainCor()) {
553  gain = jcset.getGain();
554  } else {
555  gain = 1.0;
556  }
557  if (!conv.configure(
558  path, gain, gain, jcset.getDelay(), jcset.getDelay(),
559  jcset.getOffset(), jcset.getLength(), 0, 0, jcset.getGainline())) {
560  return false;
561  }
562  int policy, priority;
563  engine.get_sched_priority(policy, priority);
564  return conv.start(policy, priority);
565 }
566 
567 
568 /****************************************************************
569  ** class ConvolverStereoAdapter
570  */
571 
573  EngineControl& engine_, sigc::slot<void> sync_, ParamMap& param_)
574  : ConvolverAdapter(engine_, sync_, param_) {
575  id = "jconv";
576  name = N_("Convolver");
577  register_params = convolver_register;
578  set_samplerate = convolver_init;
579  activate_plugin = activate;
580  stereo_audio = convolver;
581 }
582 
584 }
585 
586 void ConvolverStereoAdapter::convolver(int count, float *input0, float *input1,
587  float *output0, float *output1, PluginDef* plugin) {
588  ConvolverStereoAdapter& self = *static_cast<ConvolverStereoAdapter*>(plugin);
589  if (self.conv.is_runnable()) {
590  float conv_out0[count];
591  float conv_out1[count];
592  if (self.conv.compute(count, input0, input1, conv_out0, conv_out1)) {
593  self.jc_post.compute(count, input0, input1,
594  conv_out0, conv_out1, output0, output1);
595  return;
596  }
597  self.engine.overload(EngineControl::ov_Convolver, self.id);
598  }
599  if (input0 != output0) {
600  memcpy(output0, input0, count * sizeof(float));
601  }
602  if (input1 != output1) {
603  memcpy(output1, input1, count * sizeof(float));
604  }
605 }
606 
607 int ConvolverStereoAdapter::convolver_register(const ParamReg& reg) {
608  ConvolverStereoAdapter& self = *static_cast<ConvolverStereoAdapter*>(reg.plugin);
609  self.jcp = JConvParameter::insert_param(self.param, "jconv.convolver", self, &self.jcset);
610  self.jcp->signal_changed().connect(
611  sigc::hide(
612  sigc::mem_fun(self, &ConvolverStereoAdapter::restart)));
613  return self.jc_post.register_par(reg);
614 }
615 
616 void ConvolverStereoAdapter::convolver_init(unsigned int samplingFreq, PluginDef *p) {
617  ConvolverStereoAdapter& self = *static_cast<ConvolverStereoAdapter*>(p);
618  boost::mutex::scoped_lock lock(self.activate_mutex);
619  if (self.activated) {
620  self.conv.stop_process();
621  self.conv.set_samplerate(samplingFreq);
622  self.jc_post.init(samplingFreq);
623  while (self.conv.is_runnable()) {
624  self.conv.checkstate();
625  }
626  self.conv_start();
627  } else {
628  self.conv.set_samplerate(samplingFreq);
629  self.jc_post.init(samplingFreq);
630  }
631 }
632 
633 int ConvolverStereoAdapter::activate(bool start, PluginDef *p) {
634  ConvolverStereoAdapter& self = *static_cast<ConvolverStereoAdapter*>(p);
635  boost::mutex::scoped_lock lock(self.activate_mutex);
636  if (start) {
637  if (self.activated && self.conv.is_runnable()) {
638  return 0;
639  }
640  } else {
641  if (!self.activated) {
642  return 0;
643  }
644  }
645  self.activated = start;
646  if (start) {
647  if (self.jc_post.activate(true) != 0) {
648  gx_print_error(_("convolver"), "jconv post activate error?!");
649  return -1;
650  }
651  if (!self.conv_start()) {
652  return -1;
653  }
654  } else {
655  self.conv.stop_process();
656  self.jc_post.activate(false);
657  }
658  return 0;
659 }
660 
661 
662 /****************************************************************
663  ** class ConvolverMonoAdapter
664  */
665 
667  EngineControl& engine_, sigc::slot<void> sync_, ParamMap& param_)
668  : ConvolverAdapter(engine_, sync_, param_) {
669  id = "jconv_mono";
670  name = N_("Convolver");
671  register_params = convolver_register;
672  set_samplerate = convolver_init;
673  activate_plugin = activate;
674  mono_audio = convolver;
675 }
676 
678 }
679 
680 void ConvolverMonoAdapter::convolver(int count, float *input, float *output, PluginDef* plugin) {
681  ConvolverMonoAdapter& self = *static_cast<ConvolverMonoAdapter*>(plugin);
682  if (self.conv.is_runnable()) {
683  float conv_out[count];
684  if (self.conv.compute(count, input, conv_out)) {
685  self.jc_post_mono.compute(count, output, conv_out, output);
686  return;
687  }
688  self.engine.overload(EngineControl::ov_Convolver, self.id);
689  }
690  if (input != output) {
691  memcpy(output, input, count * sizeof(float));
692  }
693 }
694 
695 int ConvolverMonoAdapter::convolver_register(const ParamReg& reg) {
696  ConvolverMonoAdapter& self = *static_cast<ConvolverMonoAdapter*>(reg.plugin);
697  self.jcp = JConvParameter::insert_param(self.param, "jconv_mono.convolver", self, &self.jcset);
698  self.jcp->signal_changed().connect(
699  sigc::hide(
700  sigc::mem_fun(self, &ConvolverMonoAdapter::restart)));
701  return self.jc_post_mono.register_par(reg);;
702 }
703 
704 void ConvolverMonoAdapter::convolver_init(unsigned int samplingFreq, PluginDef *p) {
705  ConvolverMonoAdapter& self = *static_cast<ConvolverMonoAdapter*>(p);
706  boost::mutex::scoped_lock lock(self.activate_mutex);
707  if (self.activated) {
708  self.conv.stop_process();
709  self.conv.set_samplerate(samplingFreq);
710  while (self.conv.is_runnable()) {
711  self.conv.checkstate();
712  }
713  self.conv_start();
714  } else {
715  self.conv.set_samplerate(samplingFreq);
716  }
717 }
718 
719 int ConvolverMonoAdapter::activate(bool start, PluginDef *p) {
720  ConvolverMonoAdapter& self = *static_cast<ConvolverMonoAdapter*>(p);
721  boost::mutex::scoped_lock lock(self.activate_mutex);
722  if (start) {
723  if (self.activated && self.conv.is_runnable()) {
724  return 0;
725  }
726  } else {
727  if (!self.activated) {
728  return 0;
729  }
730  }
731  self.activated = start;
732  if (start) {
733  if (!self.conv_start()) {
734  return -1;
735  }
736  } else {
737  self.conv.stop_process();
738  }
739  return 0;
740 }
741 
742 /****************************************************************
743  ** class BaseConvolver
744  */
745 
746 
748  : PluginDef(),
749  conv(resamp),
750  activate_mutex(),
751  engine(engine_),
752  sync(sync_),
753  activated(false),
754  plugin() {
758  plugin = this;
760  sigc::mem_fun(*this, &BaseConvolver::change_buffersize));
761 }
762 
764  update_conn.disconnect();
765 }
766 
767 void BaseConvolver::change_buffersize(unsigned int bufsize) {
768  boost::mutex::scoped_lock lock(activate_mutex);
769  conv.set_buffersize(bufsize);
770  if (activated) {
771  if (!bufsize) {
772  conv.stop_process();
773  } else {
774  start(true);
775  }
776  }
777 }
778 
779 void BaseConvolver::init(unsigned int samplingFreq, PluginDef *p) {
780  BaseConvolver& self = *static_cast<BaseConvolver*>(p);
781  boost::mutex::scoped_lock lock(self.activate_mutex);
782  self.conv.set_samplerate(samplingFreq);
783  if (self.activated) {
784  self.start(true);
785  }
786 }
787 
789  if (!activated || !plugin.get_on_off()) {
790  return false;
791  }
792  check_update();
793  return true;
794 }
795 
797  BaseConvolver& self = *static_cast<BaseConvolver*>(p);
798  boost::mutex::scoped_lock lock(self.activate_mutex);
799  if (start) {
800  if (!self.conv.get_buffersize()) {
801  start = false;
802  }
803  }
804  if (start == self.activated) {
805  return 0;
806  }
807  if (start) {
808  if (!self.start()) {
809  return -1;
810  }
811  self.update_conn = Glib::signal_timeout().connect(
812  sigc::mem_fun(self, &BaseConvolver::check_update_timeout), 200);
813  } else {
814  self.conv.stop_process();
815  }
816  self.activated = start;
817  return 0;
818 }
819 
821  int policy, priority;
822  engine.get_sched_priority(policy, priority);
823  return conv.start(policy, priority);
824 }
825 
826 /****************************************************************
827  ** class FixedBaseConvolver
828  */
829 
830 
832  : PluginDef(),
833  conv(resamp),
834  activate_mutex(),
835  engine(engine_),
836  sync(sync_),
837  activated(false),
838  SamplingFreq(0),
839  buffersize(0),
840  bz(0.0),
841  plugin() {
845  plugin = this;
847  sigc::mem_fun(*this, &FixedBaseConvolver::change_buffersize));
848 }
849 
851  update_conn.disconnect();
852 }
853 
854 void FixedBaseConvolver::change_buffersize(unsigned int bufsize) {
855  boost::mutex::scoped_lock lock(activate_mutex);
856  buffersize = bufsize;
857  conv.set_buffersize(static_cast<int>(ceil((bufsize*bz))));
858  if (activated) {
859  if (!bufsize) {
860  conv.stop_process();
861  } else {
862  start(true);
863  }
864  }
865 }
866 
867 void FixedBaseConvolver::init(unsigned int samplingFreq, PluginDef *p) {
868  FixedBaseConvolver& self = *static_cast<FixedBaseConvolver*>(p);
869  boost::mutex::scoped_lock lock(self.activate_mutex);
870  self.SamplingFreq = samplingFreq;
871  self.bz = 96000/samplingFreq;
872  self.conv.set_buffersize(static_cast<int>(ceil((self.buffersize*self.bz))));
873  self.conv.set_samplerate(self.bz*self.SamplingFreq);
874  if (self.activated) {
875  self.start(true);
876  }
877 }
878 
880  if (!activated || !plugin.get_on_off()) {
881  return false;
882  }
883  check_update();
884  return true;
885 }
886 
888  FixedBaseConvolver& self = *static_cast<FixedBaseConvolver*>(p);
889  boost::mutex::scoped_lock lock(self.activate_mutex);
890  if (start) {
891  if (!self.conv.get_buffersize()) {
892  start = false;
893  }
894  }
895  if (start == self.activated) {
896  return 0;
897  }
898  if (start) {
899  if (!self.start()) {
900  return -1;
901  }
902  self.update_conn = Glib::signal_timeout().connect(
903  sigc::mem_fun(self, &FixedBaseConvolver::check_update_timeout), 200);
904  } else {
905  self.conv.stop_process();
906  }
907  self.activated = start;
908  return 0;
909 }
910 
912  int policy, priority;
913  engine.get_sched_priority(policy, priority);
914  return conv.start(policy, priority);
915 }
916 
917 /****************************************************************
918  ** class CabinetConvolver
919  */
920 
921 struct CabDesc {
922  int ir_count;
923  int ir_sr;
924  float ir_data[];
925 };
926 
927 template <int tab_size>
928 struct CabDesc_imp {
929  int ir_count;
930  int ir_sr;
931  float ir_data[tab_size];
932  operator CabDesc&() { return *(CabDesc*)this; }
933 };
934 
935 #include "gx_cabinet_data.cc"
936 
937 struct CabEntry {
938  const char *value_id;
939  const char *value_label;
941 } cab_table[] = {
942  { "4x12", N_("4x12"), &static_cast<CabDesc&>(cab_data_4x12) },
943  { "2x12", N_("2x12"), &static_cast<CabDesc&>(cab_data_2x12) },
944  { "1x12", N_("1x12"), &static_cast<CabDesc&>(cab_data_1x12) },
945  { "4x10", N_("4x10"), &static_cast<CabDesc&>(cab_data_4x10) },
946  { "2x10", N_("2x10"), &static_cast<CabDesc&>(cab_data_2x10) },
947  { "HighGain", N_("HighGain Style"), &static_cast<CabDesc&>(cab_data_HighGain) },
948  { "Twin", N_("Twin Style"), &static_cast<CabDesc&>(cab_data_Twin) },
949  { "Bassman", N_("Bassman Style"), &static_cast<CabDesc&>(cab_data_Bassman) },
950  { "Marshall", N_("Marshall Style"), &static_cast<CabDesc&>(cab_data_Marshall) },
951  { "AC-30", N_("AC-30 Style"), &static_cast<CabDesc&>(cab_data_AC30) },
952  { "Princeton", N_("Princeton Style"), &static_cast<CabDesc&>(cab_data_Princeton) },
953  { "A2", N_("A2 Style"), &static_cast<CabDesc&>(cab_data_A2) },
954  { "1x15", N_("1x15"), &static_cast<CabDesc&>(cab_data_1x15) },
955  { "Mesa Boogie", N_("Mesa Boogie Style"), &static_cast<CabDesc&>(cab_data_mesa) },
956  { "Briliant", N_("Briliant"), &static_cast<CabDesc&>(cab_data_briliant) },
957  { "Vitalize", N_("Vitalize"), &static_cast<CabDesc&>(cab_data_vitalize) },
958  { "Charisma", N_("Charisma"), &static_cast<CabDesc&>(cab_data_charisma) },
959 };
960 static const unsigned int cab_table_size = sizeof(cab_table) / sizeof(cab_table[0]);
961 
962 static CabEntry& getCabEntry(unsigned int n) {
963  if (n >= cab_table_size) {
964  n = cab_table_size - 1;
965  }
966  return cab_table[n];
967 }
968 
969 static const float no_sum = 1e10;
970 
971 #include "faust/cabinet_impulse_former.cc"
972 
973 static int cab_load_ui(const UiBuilder& builder, int format) {
974  if (format & UI_FORM_GLADE) {
975  builder.load_glade_file("cabinet_ui.glade");
976  return 0;
977  } else if (format & UI_FORM_STACK) {
978  builder.openHorizontalhideBox("");
979  builder.create_selector_no_caption("cab.select");
980  builder.closeBox();
981  builder.openVerticalBox("");
982  {
983  builder.openHorizontalBox("");
984  {
985  builder.insertSpacer();
986  builder.create_selector_no_caption("cab.select");
987  builder.create_small_rackknobr("cab.bass", "Bass");
988  builder.create_small_rackknobr("cab.treble", "Treble");
989  builder.create_mid_rackknob("cab.Level", "Level");
990  }
991  builder.closeBox();
992  }
993  builder.closeBox();
994  return 0;
995  } else {
996  return -1;
997  }
998 
999 }
1000 
1001 CabinetConvolver::CabinetConvolver(EngineControl& engine, sigc::slot<void> sync,
1003  FixedBaseConvolver(engine, sync, resamp),
1004  current_cab(-1),
1005  level(0),
1006  cabinet(0),
1007  bass(0),
1008  treble(0),
1009  sum(no_sum),
1010  cab_names(new value_pair[cab_table_size+1]),
1011  impf(),
1012  smp() {
1013  for (unsigned int i = 0; i < cab_table_size; ++i) {
1014  CabEntry& cab = getCabEntry(i);
1015  cab_names[i].value_id = cab.value_id;
1016  cab_names[i].value_label = cab.value_label;
1017  }
1018  cab_names[cab_table_size].value_id = 0;
1019  cab_names[cab_table_size].value_label = 0;
1020  id = "cab";
1021  name = N_("Cabinet");
1022  category = N_("Tone Control");
1023  load_ui = cab_load_ui;
1024  mono_audio = run_cab_conf;
1025  register_params = register_cab;
1026 }
1027 
1029  delete[] cab_names;
1030 }
1031 
1032 bool CabinetConvolver::do_update() {
1033  bool configure = cabinet_changed();
1034  if (conv.is_runnable()) {
1036  sync();
1037  conv.stop_process();
1038  }
1039  CabDesc& cab = *getCabEntry(cabinet).data;
1040  if (current_cab == -1) {
1041  unsigned int sr = getSamplingFreq();
1042  unsigned int sru = 96000;
1043  unsigned int fact = sru/sr;
1044 
1045  smp.setup(sr, fact*sr);
1046  impf.init(cab.ir_sr);
1047  }
1048  float cab_irdata_c[cab.ir_count];
1049  impf.clear_state_f();
1050  impf.compute(cab.ir_count,cab.ir_data,cab_irdata_c);
1051  while (!conv.checkstate());
1052  if (configure) {
1053  if (!conv.configure(cab.ir_count, cab_irdata_c, cab.ir_sr)) {
1054  return false;
1055  }
1056  } else {
1057  if (!conv.update(cab.ir_count, cab_irdata_c, cab.ir_sr)) {
1058  return false;
1059  }
1060  }
1061  update_cabinet();
1062  update_sum();
1063  return conv_start();
1064 }
1065 
1066 bool CabinetConvolver::start(bool force) {
1067  if (force) {
1068  current_cab = -1;
1069  }
1070  if (cabinet_changed() || sum_changed()) {
1071  return do_update();
1072  } else {
1073  while (!conv.checkstate());
1074  if (!conv.is_runnable()) {
1075  return conv_start();
1076  }
1077  return true;
1078  }
1079 }
1080 
1081 void CabinetConvolver::check_update() {
1082  if (cabinet_changed() || sum_changed()) {
1083  do_update();
1084  }
1085 }
1086 
1087 void CabinetConvolver::run_cab_conf(int count, float *input0, float *output0, PluginDef *p) {
1088  CabinetConvolver& self = *static_cast<CabinetConvolver*>(p);
1089  FAUSTFLOAT buf[self.smp.max_out_count(count)];
1090  int ReCount = self.smp.up(count, output0, buf);
1091  if (!self.conv.compute(ReCount,buf)) {
1092  self.engine.overload(EngineControl::ov_Convolver, "cab");
1093  }
1094  self.smp.down(buf, output0);
1095 }
1096 
1097 int CabinetConvolver::register_cab(const ParamReg& reg) {
1098  CabinetConvolver& cab = *static_cast<CabinetConvolver*>(reg.plugin);
1099  reg.registerIEnumVar("cab.select", "select", "B", "", cab.cab_names, &cab.cabinet, 0);
1100  reg.registerVar("cab.Level", N_("Level"), "S", N_("Level"), &cab.level, 1.0, 0.5, 5.0, 0.5);
1101  reg.registerVar("cab.bass", N_("Bass"), "S", N_("Bass"), &cab.bass, 0.0, -10.0, 10.0, 0.5);
1102  reg.registerVar("cab.treble", N_("Treble"), "S", N_("Treble"), &cab.treble, 0.0, -10.0, 10.0, 0.5);
1103  cab.impf.register_par(reg);
1104  return 0;
1105 }
1106 
1108 #include "faust/cabinet_impulse_former_st.cc"
1109 
1110 static int cab_load_stereo_ui(const UiBuilder& builder, int format) {
1111  if (format & UI_FORM_GLADE) {
1112  builder.load_glade_file("cabinet_stereo_ui.glade");
1113  return 0;
1114  } else if (format & UI_FORM_STACK) {
1115  builder.openHorizontalhideBox("");
1116  builder.create_selector_no_caption("cab_st.select");
1117  builder.closeBox();
1118  builder.openVerticalBox("");
1119  {
1120  builder.openHorizontalBox("");
1121  {
1122  builder.insertSpacer();
1123  builder.create_selector_no_caption("cab_st.select");
1124  builder.create_small_rackknobr("cab_st.bass", "Bass");
1125  builder.create_small_rackknobr("cab_st.treble", "Treble");
1126  builder.create_mid_rackknob("cab_st.Level", "Level");
1127  }
1128  builder.closeBox();
1129  }
1130  builder.closeBox();
1131  return 0;
1132  } else {
1133  return -1;
1134  }
1135 
1136 }
1137 
1140  FixedBaseConvolver(engine, sync, resamp),
1141  current_cab(-1),
1142  level(0),
1143  cabinet(0),
1144  bass(0),
1145  treble(0),
1146  sum(no_sum),
1147  cab_names(new value_pair[cab_table_size+1]),
1148  impf(),
1149  smp(),
1150  smps() {
1151  for (unsigned int i = 0; i < cab_table_size; ++i) {
1152  CabEntry& cab = getCabEntry(i);
1153  cab_names[i].value_id = cab.value_id;
1154  cab_names[i].value_label = cab.value_label;
1155  }
1156  cab_names[cab_table_size].value_id = 0;
1157  cab_names[cab_table_size].value_label = 0;
1158  id = "cab_st";
1159  name = N_("Cabinet");
1160  category = N_("Tone Control");
1161  load_ui = cab_load_stereo_ui;
1162  stereo_audio = run_cab_conf;
1163  register_params = register_cab;
1164 }
1165 
1167  delete[] cab_names;
1168 }
1169 
1170 bool CabinetStereoConvolver::do_update() {
1171  bool configure = cabinet_changed();
1172  if (conv.is_runnable()) {
1174  sync();
1175  conv.stop_process();
1176  }
1177  CabDesc& cab = *getCabEntry(cabinet).data;
1178  if (current_cab == -1) {
1179  unsigned int sr = getSamplingFreq();
1180  unsigned int sru = 96000;
1181  unsigned int fact = sru/sr;
1182 
1183  smp.setup(sr, fact*sr);
1184  smps.setup(sr, fact*sr);
1185  impf.init(cab.ir_sr);
1186  }
1187  float cab_irdata_c[cab.ir_count];
1188  impf.clear_state_f();
1189  impf.compute(cab.ir_count,cab.ir_data,cab_irdata_c);
1190  while (!conv.checkstate());
1191  if (configure) {
1192  if (!conv.configure_stereo(cab.ir_count, cab_irdata_c, cab.ir_sr)) {
1193  return false;
1194  }
1195  } else {
1196  if (!conv.update_stereo(cab.ir_count, cab_irdata_c, cab.ir_sr)) {
1197  return false;
1198  }
1199  }
1200  update_cabinet();
1201  update_sum();
1202  return conv_start();
1203 }
1204 
1205 bool CabinetStereoConvolver::start(bool force) {
1206  if (force) {
1207  current_cab = -1;
1208  }
1209  if (cabinet_changed() || sum_changed()) {
1210  return do_update();
1211  } else {
1212  while (!conv.checkstate());
1213  if (!conv.is_runnable()) {
1214  return conv_start();
1215  }
1216  return true;
1217  }
1218 }
1219 
1220 void CabinetStereoConvolver::check_update() {
1221  if (cabinet_changed() || sum_changed()) {
1222  do_update();
1223  }
1224 }
1225 
1226 void CabinetStereoConvolver::run_cab_conf(int count, float *input0, float *input1, float *output0, float *output1, PluginDef *p) {
1227  CabinetStereoConvolver& self = *static_cast<CabinetStereoConvolver*>(p);
1228  FAUSTFLOAT buf[self.smp.max_out_count(count)];
1229  FAUSTFLOAT buf1[self.smps.max_out_count(count)];
1230  int ReCount = self.smp.up(count, output0, buf);
1231  self.smps.up(count, output1, buf1);
1232  if (!self.conv.compute_stereo(ReCount,buf,buf1)) {
1233  self.engine.overload(EngineControl::ov_Convolver, "cab_st");
1234  }
1235  self.smp.down(buf, output0);
1236  self.smps.down(buf1, output1);
1237 }
1238 
1239 int CabinetStereoConvolver::register_cab(const ParamReg& reg) {
1240  CabinetStereoConvolver& cab = *static_cast<CabinetStereoConvolver*>(reg.plugin);
1241  reg.registerIEnumVar("cab_st.select", "select", "B", "", cab.cab_names, &cab.cabinet, 0);
1242  reg.registerVar("cab_st.Level", N_("Level"), "S", N_("Level"), &cab.level, 1.0, 0.5, 5.0, 0.5);
1243  reg.registerVar("cab_st.bass", N_("Bass"), "S", N_("Bass"), &cab.bass, 0.0, -10.0, 10.0, 0.5);
1244  reg.registerVar("cab_st.treble", N_("Treble"), "S", N_("Treble"), &cab.treble, 0.0, -10.0, 10.0, 0.5);
1245  cab.impf.register_par(reg);
1246  return 0;
1247 }
1248 
1249 /****************************************************************
1250  ** class PreampConvolver
1251  */
1252 
1253 struct PreDesc {
1254  int ir_count;
1255  int ir_sr;
1256  float ir_data[];
1257 };
1259 template <int tab_size>
1260 struct PreDesc_imp {
1262  int ir_sr;
1263  float ir_data[tab_size];
1264  operator PreDesc&() { return *(PreDesc*)this; }
1265 };
1266 
1267 #include "gx_preamp_data.cc"
1268 
1269 struct PreEntry {
1270  const char *value_id;
1271  const char *value_label;
1273 } pre_table[] = {
1274  { "AC30", N_("AC30 Style"), &static_cast<PreDesc&>(pre_data_ac30) },
1275  { "Bassman", N_("Bassman Style"), &static_cast<PreDesc&>(pre_data_bassman) },
1276  { "Tube", N_("Tube Style"), &static_cast<PreDesc&>(pre_data_tube) },
1277  { "Fender", N_("Fender Style"), &static_cast<PreDesc&>(pre_data_fender) },
1278  { "JCM800", N_("JCM800 Style"), &static_cast<PreDesc&>(pre_data_jcm800) },
1279  { "JTM45", N_("JTM45 Style"), &static_cast<PreDesc&>(pre_data_jtm45) },
1280  { "Mesa Boogie", N_("Mesa Boogie Style"), &static_cast<PreDesc&>(pre_data_mesaboogie) },
1281  { "Boutique", N_("Boutique Style"), &static_cast<PreDesc&>(pre_data_boutique) },
1282  { "Ampeg", N_("Ampeg Style"), &static_cast<PreDesc&>(pre_data_ampeg) },
1283  { "Rectifier", N_("Rectifier Style"), &static_cast<PreDesc&>(pre_data_rectifier) },
1284 };
1285 static const unsigned int pre_table_size = sizeof(pre_table) / sizeof(pre_table[0]);
1286 
1287 static PreEntry& getPreEntry(unsigned int n) {
1288  if (n >= pre_table_size) {
1289  n = pre_table_size - 1;
1290  }
1291  return pre_table[n];
1292 }
1293 
1294 #include "faust/preamp_impulse_former.cc"
1295 
1296 static int pre_load_ui(const UiBuilder& builder, int format) {
1297  if (format & UI_FORM_GLADE) {
1298  builder.load_glade_file("ampimpulse_ui.glade");
1299  return 0;
1300  } else if (format & UI_FORM_STACK) {
1301  builder.openHorizontalhideBox("");
1302  builder.create_selector_no_caption("pre.select");
1303  builder.closeBox();
1304  builder.openVerticalBox("");
1305  {
1306  builder.openHorizontalBox("");
1307  {
1308  builder.insertSpacer();
1309  builder.create_selector_no_caption("pre.select");
1310  builder.create_small_rackknobr("pre.bass", "Bass");
1311  builder.create_small_rackknobr("pre.treble", "Treble");
1312  builder.create_mid_rackknob("pre.Level", "Level");
1313  }
1314  builder.closeBox();
1315  }
1316  builder.closeBox();
1317  return 0;
1318  } else {
1319  return -1;
1320  }
1321 
1322 }
1323 
1324 PreampConvolver::PreampConvolver(EngineControl& engine, sigc::slot<void> sync,
1326  FixedBaseConvolver(engine, sync, resamp),
1327  current_pre(-1),
1328  level(0),
1329  preamp(0),
1330  bass(0),
1331  treble(0),
1332  sum(no_sum),
1333  pre_names(new value_pair[pre_table_size+1]),
1334  impf(),
1335  smp() {
1336  for (unsigned int i = 0; i < pre_table_size; ++i) {
1337  PreEntry& pre = getPreEntry(i);
1338  pre_names[i].value_id = pre.value_id;
1339  pre_names[i].value_label = pre.value_label;
1340  }
1341  pre_names[pre_table_size].value_id = 0;
1342  pre_names[pre_table_size].value_label = 0;
1343  id = "pre";
1344  name = N_("Amp Impulse");
1345  category = N_("Tone Control");
1346  load_ui = pre_load_ui;
1347  mono_audio = run_pre_conf;
1348  register_params = register_pre;
1349 }
1350 
1352  delete[] pre_names;
1353 }
1354 
1355 bool PreampConvolver::do_update() {
1356  bool configure = preamp_changed();
1357  if (conv.is_runnable()) {
1359  sync();
1360  conv.stop_process();
1361  }
1362  PreDesc& pre = *getPreEntry(preamp).data;
1363  if (current_pre == -1) {
1364  unsigned int sr = getSamplingFreq();
1365  unsigned int sru = 96000;
1366  unsigned int fact = sru/sr;
1367 
1368  smp.setup(sr, fact*sr);
1369  impf.init(pre.ir_sr);
1370  }
1371  float pre_irdata_c[pre.ir_count];
1372  impf.clear_state_f();
1373  impf.compute(pre.ir_count,pre.ir_data,pre_irdata_c);
1374  while (!conv.checkstate());
1375  if (configure) {
1376  if (!conv.configure(pre.ir_count, pre_irdata_c, pre.ir_sr)) {
1377  return false;
1378  }
1379  } else {
1380  if (!conv.update(pre.ir_count, pre_irdata_c, pre.ir_sr)) {
1381  return false;
1382  }
1383  }
1384  update_preamp();
1385  update_sum();
1386  return conv_start();
1387 }
1388 
1389 bool PreampConvolver::start(bool force) {
1390  if (force) {
1391  current_pre = -1;
1392  }
1393  if (preamp_changed() || sum_changed()) {
1394  return do_update();
1395  } else {
1396  while (!conv.checkstate());
1397  if (!conv.is_runnable()) {
1398  return conv_start();
1399  }
1400  return true;
1401  }
1402 }
1403 
1404 void PreampConvolver::check_update() {
1405  if (preamp_changed() || sum_changed()) {
1406  do_update();
1407  }
1408 }
1409 
1410 void PreampConvolver::run_pre_conf(int count, float *input0, float *output0, PluginDef *p) {
1411  PreampConvolver& self = *static_cast<PreampConvolver*>(p);
1412  FAUSTFLOAT buf[self.smp.max_out_count(count)];
1413  int ReCount = self.smp.up(count, output0, buf);
1414  if (!self.conv.compute(ReCount, buf)) {
1415  self.engine.overload(EngineControl::ov_Convolver, "pre");
1416  }
1417  self.smp.down(buf, output0);
1418 }
1419 
1420 int PreampConvolver::register_pre(const ParamReg& reg) {
1421  PreampConvolver& pre = *static_cast<PreampConvolver*>(reg.plugin);
1422  reg.registerIEnumVar("pre.select", "select", "B", "", pre.pre_names, &pre.preamp, 0);
1423  reg.registerVar("pre.Level", N_("Level"), "S", N_("Level"), &pre.level, 1.0, 0.1, 2.1, 0.1);
1424  reg.registerVar("pre.bass", N_("Bass"), "S", N_("Bass"), &pre.bass, 0.0, -10.0, 10.0, 0.5);
1425  reg.registerVar("pre.treble", N_("Treble"), "S", N_("Treble"), &pre.treble, 0.0, -10.0, 10.0, 0.5);
1426  pre.impf.register_par(reg);
1427  return 0;
1428 }
1429 
1431 #include "faust/preamp_impulse_former_st.cc"
1432 
1433 static int pre_load_stereo_ui(const UiBuilder& builder, int format) {
1434  if (format & UI_FORM_GLADE) {
1435  builder.load_glade_file("ampimpulse_st_ui.glade");
1436  return 0;
1437  } else if (format & UI_FORM_STACK) {
1438  builder.openHorizontalhideBox("");
1439  builder.create_selector_no_caption("pre_st.select");
1440  builder.closeBox();
1441  builder.openVerticalBox("");
1442  {
1443  builder.openHorizontalBox("");
1444  {
1445  builder.insertSpacer();
1446  builder.create_selector_no_caption("pre_st.select");
1447  builder.create_small_rackknobr("pre_st.bass", "Bass");
1448  builder.create_small_rackknobr("pre_st.treble", "Treble");
1449  builder.create_mid_rackknob("pre_st.Level", "Level");
1450  }
1451  builder.closeBox();
1452  }
1453  builder.closeBox();
1454  return 0;
1455  } else {
1456  return -1;
1457  }
1458 
1459 }
1460 
1463  FixedBaseConvolver(engine, sync, resamp),
1464  current_pre(-1),
1465  level(0),
1466  preamp(0),
1467  bass(0),
1468  treble(0),
1469  sum(no_sum),
1470  pre_names(new value_pair[pre_table_size+1]),
1471  impf(),
1472  smp(),
1473  smps() {
1474  for (unsigned int i = 0; i < pre_table_size; ++i) {
1475  PreEntry& pre = getPreEntry(i);
1476  pre_names[i].value_id = pre.value_id;
1477  pre_names[i].value_label = pre.value_label;
1478  }
1479  pre_names[pre_table_size].value_id = 0;
1480  pre_names[pre_table_size].value_label = 0;
1481  id = "pre_st";
1482  name = N_("Amp Impulse");
1483  category = N_("Tone Control");
1484  load_ui = pre_load_stereo_ui;
1485  stereo_audio = run_pre_conf;
1486  register_params = register_pre;
1487 }
1488 
1490  delete[] pre_names;
1491 }
1492 
1493 bool PreampStereoConvolver::do_update() {
1494  bool configure = preamp_changed();
1495  if (conv.is_runnable()) {
1497  sync();
1498  conv.stop_process();
1499  }
1500  PreDesc& pre = *getPreEntry(preamp).data;
1501  if (current_pre == -1) {
1502  unsigned int sr = getSamplingFreq();
1503  unsigned int sru = 96000;
1504  unsigned int fact = sru/sr;
1505 
1506  smp.setup(sr, fact*sr);
1507  smps.setup(sr, fact*sr);
1508  impf.init(pre.ir_sr);
1509  }
1510  float pre_irdata_c[pre.ir_count];
1511  impf.clear_state_f();
1512  impf.compute(pre.ir_count,pre.ir_data,pre_irdata_c);
1513  while (!conv.checkstate());
1514  if (configure) {
1515  if (!conv.configure_stereo(pre.ir_count, pre_irdata_c, pre.ir_sr)) {
1516  return false;
1517  }
1518  } else {
1519  if (!conv.update_stereo(pre.ir_count, pre_irdata_c, pre.ir_sr)) {
1520  return false;
1521  }
1522  }
1523  update_preamp();
1524  update_sum();
1525  return conv_start();
1526 }
1527 
1528 bool PreampStereoConvolver::start(bool force) {
1529  if (force) {
1530  current_pre = -1;
1531  }
1532  if (preamp_changed() || sum_changed()) {
1533  return do_update();
1534  } else {
1535  while (!conv.checkstate());
1536  if (!conv.is_runnable()) {
1537  return conv_start();
1538  }
1539  return true;
1540  }
1541 }
1542 
1543 void PreampStereoConvolver::check_update() {
1544  if (preamp_changed() || sum_changed()) {
1545  do_update();
1546  }
1547 }
1548 
1549 void PreampStereoConvolver::run_pre_conf(int count, float *input0, float *input1, float *output0, float *output1, PluginDef *p) {
1550  PreampStereoConvolver& self = *static_cast<PreampStereoConvolver*>(p);
1551  FAUSTFLOAT buf[self.smp.max_out_count(count)];
1552  FAUSTFLOAT buf1[self.smps.max_out_count(count)];
1553  int ReCount = self.smp.up(count, output0, buf);
1554  self.smps.up(count, output1, buf1);
1555  if (!self.conv.compute_stereo(ReCount,buf,buf1)) {
1556  self.engine.overload(EngineControl::ov_Convolver, "pre_st");
1557  }
1558  self.smp.down(buf, output0);
1559  self.smps.down(buf1, output1);
1560 }
1561 
1562 int PreampStereoConvolver::register_pre(const ParamReg& reg) {
1563  PreampStereoConvolver& pre = *static_cast<PreampStereoConvolver*>(reg.plugin);
1564  reg.registerIEnumVar("pre_st.select", "select", "B", "", pre.pre_names, &pre.preamp, 0);
1565  reg.registerVar("pre_st.Level", N_("Level"), "SA", N_("Level"), &pre.level, 1.0, 0.1, 2.1, 0.1);
1566  reg.registerVar("pre_st.bass", N_("Bass"), "SA", N_("Bass"), &pre.bass, 0.0, -10.0, 10.0, 0.5);
1567  reg.registerVar("pre_st.treble", N_("Treble"), "SA", N_("Treble"), &pre.treble, 0.0, -10.0, 10.0, 0.5);
1568  pre.impf.register_par(reg);
1569  return 0;
1570 }
1571 
1572 /****************************************************************
1573  ** class ContrastConvolver
1574  */
1575 
1576 #include "faust/presence_level.cc"
1577 
1580  FixedBaseConvolver(engine, sync, resamp),
1581  level(0),
1582  sum(no_sum),
1583  presl(),
1584  smp() {
1585  id = "con";
1586  name = N_("Contrast convolver");
1587  mono_audio = run_contrast;
1588  register_params = register_con;
1589 }
1590 
1592 }
1593 
1594 bool ContrastConvolver::do_update() {
1595  bool configure = (sum == no_sum);
1596  if (conv.is_runnable()) {
1598  sync();
1599  conv.stop_process();
1600  }
1601  if (configure) {
1602  unsigned int sr = getSamplingFreq();
1603  unsigned int sru = 96000;
1604  unsigned int fact = sru/sr;
1605 
1606  smp.setup(sr, fact*sr);
1607  presl.init(contrast_ir_desc.ir_sr);
1608  }
1609  float contrast_irdata_c[contrast_ir_desc.ir_count];
1610  presl.compute(contrast_ir_desc.ir_count,contrast_ir_desc.ir_data,contrast_irdata_c);
1611  while (!conv.checkstate());
1612  if (configure) {
1613  if (!conv.configure(contrast_ir_desc.ir_count, contrast_irdata_c, contrast_ir_desc.ir_sr)) {
1614  return false;
1615  }
1616  } else {
1617  if (!conv.update(contrast_ir_desc.ir_count, contrast_irdata_c, contrast_ir_desc.ir_sr)) {
1618  return false;
1619  }
1620  }
1621  update_sum();
1622  return conv_start();
1623 }
1624 
1625 bool ContrastConvolver::start(bool force) {
1626  if (force) {
1627  sum = no_sum;
1628  }
1629  if (sum_changed()) {
1630  return do_update();
1631  } else {
1632  while (!conv.checkstate());
1633  if (!conv.is_runnable()) {
1634  return conv_start();
1635  }
1636  return true;
1637  }
1638 }
1639 
1640 void ContrastConvolver::check_update() {
1641  if (sum_changed()) {
1642  do_update();
1643  }
1644 }
1645 
1646 int ContrastConvolver::register_con(const ParamReg& reg) {
1647  ContrastConvolver& self = *static_cast<ContrastConvolver*>(reg.plugin);
1648  reg.registerVar("con.Level", "", "S", "", &self.level, 1.0, 0.5, 5.0, 0.5);
1649  self.presl.register_par(reg);
1650  return 0;
1651 }
1652 
1653 void ContrastConvolver::run_contrast(int count, float *input0, float *output0, PluginDef *p) {
1654  ContrastConvolver& self = *static_cast<ContrastConvolver*>(p);
1655  FAUSTFLOAT buf[self.smp.max_out_count(count)];
1656  int ReCount = self.smp.up(count, output0, buf);
1657  if (!self.conv.compute(ReCount,buf)) {
1658  self.engine.overload(EngineControl::ov_Convolver, "contrast");
1659  }
1660  self.smp.down(buf, output0);
1661 
1662 }
1663 
1664 /****************************************************************
1665  ** class Directout
1666  */
1667 Plugin Directout::directoutput = Plugin();
1668 
1669 Directout::Directout(EngineControl& engine_, sigc::slot<void> sync_)
1670  : PluginDef(),
1671  outdata(0),
1672  engine(engine_),
1673  sync(sync_),
1674  mem_allocated(false),
1675  plugin() {
1676  directoutput.set_pdef(this);
1678  flags = 0;
1679  id = "dout";
1680  name = N_("Directoutputr");
1681  stereo_audio = compute_static;
1682  set_samplerate = init_static;
1683  activate_plugin = 0;
1684  plugin = this;
1685  engine.signal_buffersize_change().connect(
1686  sigc::mem_fun(*this, &Directout::change_buffersize));
1687 }
1688 
1690  mem_free();
1691 }
1692 
1693 inline void Directout::init(unsigned int samplingFreq)
1694 {
1695  bsize = int(engine.get_buffersize());
1696  fSamplingFreq = samplingFreq;
1697  mem_alloc();
1698 }
1699 
1700 void Directout::init_static(unsigned int samplingFreq, PluginDef *p)
1701 {
1702  static_cast<Directout*>(p)->init(samplingFreq);
1703 }
1704 
1705 void Directout::mem_alloc()
1706 {
1707  if (mem_allocated) {
1708  return;
1709  }
1710  bsize = int(engine.get_buffersize());
1711  assert(bsize>0);
1712  try {
1713  outdata = new float[bsize]();
1714  } catch(...) {
1715  gx_print_error("Directout", "cant allocate memory pool");
1716  return;
1717  }
1718  mem_allocated = true;
1719 }
1720 
1721 void Directout::mem_free()
1722 {
1723  mem_allocated = false;
1724  if (outdata) { delete outdata; outdata = 0; }
1725 }
1726 
1727 void Directout::change_buffersize(unsigned int size)
1728 {
1729  sync();
1730  if (mem_allocated) {
1731  mem_free();
1732  mem_alloc();
1733  }
1734 }
1735 
1736 void always_inline Directout::compute(int count, float *input0, float *input1, float *output0, float *output1) {
1737  if (!fdfill) {
1738  return;
1739  }
1740  for (int i=0; i<count; i++) {
1741  output0[i] = input0[i] + outdata[i];
1742  output1[i] = input1[i] + outdata[i];
1743  }
1744  memset(outdata,0,count*sizeof(float));
1745  fdfill = false;
1746 }
1747 
1748 void Directout::set_data(bool dfill) {
1749  fdfill = dfill;
1750 }
1751 
1752 void __rt_func Directout::compute_static(int count, FAUSTFLOAT *input0, FAUSTFLOAT *input1, FAUSTFLOAT *output0, FAUSTFLOAT *output1, PluginDef *p)
1753 {
1754  static_cast<Directout*>(p)->compute(count, input0, input1, output0, output1);
1755 }
1756 
1757 
1758 /****************************************************************
1759  ** class LiveLooper
1760  */
1761 
1762 #include "gx_livelooper.cc"
1763 
1764 /****************************************************************
1765  ** class SCapture
1766  */
1767 
1768 #include "gx_record.cc"
1769 
1770 /****************************************************************
1771  ** class DrumSequencer
1772  */
1773 
1774 #include "faust/drumseq.cc"
1775 
1776 
1777 float* Drumout::set = 0;
1778 float* Drumout::data = 0;
1779 bool Drumout::mb = false;
1780 Plugin Drumout::output_drum = Plugin();
1781 Plugin Drumout::input_drum = Plugin();
1783 
1785 
1787 
1789  outputdrum.id = "drumout";
1790  outputdrum.name = "?drumout";
1791  outputdrum.stereo_audio = outputdrum_compute;
1792 }
1793 
1794 void always_inline Drumout::outputdrum_compute(int count, float *input0, float *input1, float *output0, float *output1, PluginDef*) {
1795  if (!(*set) || !input_drum.get_on_off() || !mb) {
1796  return;
1797  }
1798  for (int i=0; i<count; i++) {
1799  output0[i] = input0[i] + data[i];
1800  output1[i] = input1[i] + data[i];
1801  }
1802  memset(data,0,count*sizeof(float));
1803 }
1804 
1805 void Drumout::set_data(float* mode, bool ready, float* buf) {
1806  set = mode;
1807  mb = ready;
1808  data = buf;
1809 }
1810 
1812  input_drum = p;
1813 }
1814 
1815 static const char* seq_groups[] = {
1816  "hat_closed.dsp", N_("DrumSequencer"),
1817  "kick.dsp", N_("DrumSequencer"),
1818  "snare.dsp", N_("DrumSequencer"),
1819  "tom.dsp", N_("DrumSequencer"),
1820  "sequencer", N_("DrumSequencer"),
1821  0
1822 };
1823 
1824 DrumSequencer::DrumSequencer(ParamMap& param_, EngineControl& engine_, sigc::slot<void> sync_)
1825  : PluginDef(),
1826  Vectom(0),
1827  Vectom1(0),
1828  Vectom2(0),
1829  Veckick(0),
1830  Vecsnare(0),
1831  Vechat(0),
1832  engine(engine_),
1833  mem_allocated(false),
1834  sync(sync_),
1835  ready(false),
1836  outdata(0),
1837  param(param_),
1838  tomset(),
1839  tomp(0),
1840  tomset1(),
1841  tomp1(0),
1842  tomset2(),
1843  tomp2(0),
1844  snareset(),
1845  snarep(0),
1846  hatset(),
1847  hatp(0),
1848  kickset(),
1849  kickp(0),
1850  plugin() {
1852  flags = 0;
1853  id = "seq";
1854  name = N_("DrumSequencer");
1855  groups = seq_groups;
1856  description = N_("Simple Drum Step Sequencer"); // description (tooltip)
1857  category = N_("Misc"); // category
1858  shortname = N_("Drum"); // shortname
1859  mono_audio = compute_static;
1860  stereo_audio = 0;
1861  set_samplerate = init_static;
1862  activate_plugin = 0;
1863  register_params = register_params_static;
1864  delete_instance = del_instance;
1865  plugin = this;
1866  engine.signal_buffersize_change().connect(
1867  sigc::mem_fun(*this, &DrumSequencer::change_buffersize));
1868 }
1869 
1871  mem_free();
1872 }
1873 
1874 inline void DrumSequencer::init(unsigned int samplingFreq)
1875 {
1876  bsize = int(engine.get_buffersize());
1877  fSamplingFreq = samplingFreq;
1878  counter = 0;
1879  step = 0;
1880  step_orig = 0;
1881  fSlow1 = 0.0;
1882  fSlow3 = 0.0;
1883  fSlow5 = 0.0;
1884  fSlow7 = 0.0;
1885  fSlow18 = 150.0;
1886  position = 0.0;
1887  mem_alloc();
1888  drums.init(samplingFreq);
1890 }
1891 
1892 void DrumSequencer::init_static(unsigned int samplingFreq, PluginDef *p)
1893 {
1894  static_cast<DrumSequencer*>(p)->init(samplingFreq);
1895 }
1896 
1897 void DrumSequencer::mem_alloc()
1898 {
1899  if (mem_allocated) {
1900  return;
1901  }
1902  bsize = int(engine.get_buffersize());
1903  assert(bsize>0);
1904  try {
1905  outdata = new float[bsize]();
1906  } catch(...) {
1907  gx_print_error("DrumSequencer", "cant allocate memory pool");
1908  return;
1909  }
1910  mem_allocated = true;
1911  Drumout::set_data(&fSlow22, mem_allocated, outdata);
1912 }
1913 
1914 void DrumSequencer::mem_free()
1915 {
1916  ready = false;
1917  mem_allocated = false;
1918  Drumout::set_data(0, mem_allocated, 0);
1919  if (outdata) { delete outdata; outdata = 0; }
1920 }
1921 
1922 void DrumSequencer::change_buffersize(unsigned int size)
1923 {
1924  sync();
1925  ready = false;
1926  if (mem_allocated) {
1927  mem_free();
1928  mem_alloc();
1929  }
1930 }
1931 
1932 int DrumSequencer::min_seq_size(){
1933  int i = min(min(min(Vectom.size(),Veckick.size()),min(Vechat.size(),Vecsnare.size())),min(Vectom1.size(),Vectom2.size()));
1934  return i-1;
1935 }
1936 
1937 void DrumSequencer::reset_tom() {
1938  Vectom = tomset.getseqline() ;
1939  seq_size = min_seq_size();
1940 }
1941 
1942 void DrumSequencer::reset_tom1() {
1943  Vectom1 = tomset1.getseqline() ;
1944  seq_size = min_seq_size();
1945 }
1946 
1947 void DrumSequencer::reset_tom2() {
1948  Vectom2 = tomset2.getseqline() ;
1949  seq_size = min_seq_size();
1950 }
1951 
1952 void DrumSequencer::reset_kick() {
1953  Veckick = kickset.getseqline() ;
1954  seq_size = min_seq_size();
1955 }
1956 
1957 void DrumSequencer::reset_hat() {
1958  Vechat = hatset.getseqline() ;
1959  seq_size = min_seq_size();
1960 }
1961 
1962 void DrumSequencer::reset_snare() {
1963  Vecsnare = snareset.getseqline() ;
1964  seq_size = min_seq_size();
1965 }
1966 
1967 // hat = 1600Hz
1968 // kick = 50Hz
1969 // toms = 90 - 128 - 150Hz
1970 // snare = 523 - 7040Hz
1971 // todo: add compressor
1972 
1973 void always_inline DrumSequencer::compute(int count, FAUSTFLOAT *input0, FAUSTFLOAT *output0)
1974 {
1975  double fSlow15 = (60.0/double(fsliderbpm*ftact))*fSamplingFreq;
1976  counter += count;
1977  int iSlow15 = (int)fSlow15;
1978  // beat
1979  if (counter >= iSlow15) {
1980  int istep = (int)step;
1981  fSlow1 = double(Vecsnare[istep]);
1982  // disable hat when sequencer runs to fast
1983  if (iSlow15 > 4800) {
1984  fSlow3 = double(Vechat[istep]);
1985  }
1986  fSlow5 = double(Veckick[istep]);
1987  // only one tom at time
1988  if (Vectom2[istep]) {
1989  fSlow7 = double(Vectom2[istep]);
1990  fSlow18 = 150.0;
1991  fSlow20 = fSlow16;
1992  } else if (Vectom1[istep]) {
1993  fSlow7 = double(Vectom1[istep]);
1994  fSlow18 = 128.0;
1995  fSlow20 = fSlow14;
1996  } else if(Vectom[istep]) {
1997  fSlow7 = double(Vectom[istep]);
1998  fSlow18 = 90.0;
1999  fSlow20 = fSlow12;
2000  }
2001  int m = ftact;
2002  int r = rand()%(m+1 - (-m))+ (-m);
2003  counter = 0; //int(r*fsliderhum);
2004 
2005  if (step<seq_size) step = fmin(seq_size,fmax(0,step + 1.0 + int(r*fsliderhum)));
2006  else step = 0.0;
2007  if (step_orig<seq_size) step_orig += 1.0;
2008  else step_orig = 0.0;
2009  double ph1 = 2300.0/seq_size;
2010  position = fmin(2300,fmax(0,(step*ph1)));
2011  } else {
2012  fSlow1 = 0.0;
2013  fSlow3 = 0.0;
2014  fSlow5 = 0.0;
2015  fSlow7 = 0.0;
2016  }
2017  if (int(fSlow22 && mem_allocated)) {
2018  memcpy(output0, input0, count * sizeof(float));
2019  drums.compute(count,outdata,outdata);
2020  } else {
2021  drums.compute(count,input0,output0);
2022  }
2023 }
2024 
2025 void __rt_func DrumSequencer::compute_static(int count, FAUSTFLOAT *input0, FAUSTFLOAT *output0, PluginDef *p)
2026 {
2027  static_cast<DrumSequencer*>(p)->compute(count, input0, output0);
2028 }
2029 
2030 int DrumSequencer::register_par(const ParamReg& reg)
2031 {
2032  reg.registerNonMidiFloatVar("seq.hat_closed.dsp.gate",&fSlow3, false, true, 0.0, 0.0, 1.0, 1.0);
2033  reg.registerNonMidiFloatVar("seq.kick.dsp.gate",&fSlow5, false, true, 0.0, 0.0, 1.0, 1.0);
2034  reg.registerNonMidiFloatVar("seq.snare.dsp.gate",&fSlow1, false, true, 0.0, 0.0, 1.0, 1.0);
2035  reg.registerNonMidiFloatVar("seq.tom.dsp.gate",&fSlow7, false, true, 0.0, 0.0, 1.0, 1.0);
2036  reg.registerNonMidiSharedVar("seq.tom.dsp.Gainf",&fSlow20, false, true, -2e+01, -6e+01, 4e+01, 0.1);
2037  reg.registerVar("seq.tom.dsp.Gain","","S",N_("Volume level in decibels"),&fSlow12, -2e+01, -6e+01, 4e+01, 0.1);
2038  reg.registerVar("seq.tom.dsp.Gain1","","S",N_("Volume level in decibels"),&fSlow14, -2e+01, -6e+01, 4e+01, 0.1);
2039  reg.registerVar("seq.tom.dsp.Gain2","","S",N_("Volume level in decibels"),&fSlow16, -2e+01, -6e+01, 4e+01, 0.1);
2040  reg.registerNonMidiFloatVar("seq.tom.dsp.freq",&fSlow18, false, true, 9e+01, 9e+01, 1.5e+02, 1.0);
2041  reg.registerVar("seq.bpm","","S",N_("Beats per Minute"),&fsliderbpm, 120, 24, 360, 1);
2042  static const value_pair ftact_values[] = {{"1/4"},{"2/4"},{"3/4"},{"4/4"},{0}};
2043  reg.registerEnumVar("seq.tact","","S",N_("select tact"),ftact_values,&ftact, 4.0, 1.0, 4.0, 1.0);
2044  reg.registerVar("seq.asequences","","S",N_("Number of Sequences"),&fsec, 24.0, 24.0, 240.0, 4.0);
2045  reg.registerVar("seq.hum","","B",N_("Randomize Sequence"),&fsliderhum, 0.0, 0.0, 1.0, 1.0);
2046  reg.registerVar("seq.npreset","","BO",N_("Load next unit preset"),0, 0.0, 0.0, 1.0, 1.0);
2047  reg.registerVar("seq.ppreset","","BO",N_("Load previous unit preset"),0, 0.0, 0.0, 1.0, 1.0);
2048  reg.registerNonMidiFloatVar("seq.pos",&position, false, true, 0.0, 0.0, 2300.0, 1.0);
2049  reg.registerNonMidiFloatVar("seq.step",&step, false, true, 0.0, 0.0, 240.0, 1.0);
2050  reg.registerNonMidiFloatVar("seq.step_orig",&step_orig, false, true, 0.0, 0.0, 240.0, 1.0);
2051  reg.registerVar("seq.set_step","","BO",N_("Set stepper one Beat back"),0, 0.0, 0.0, 1.0, 1.0);
2052  reg.registerVar("seq.set_fstep","","BO",N_("Set stepper one Beat forward"),0, 0.0, 0.0, 1.0, 1.0);
2053  reg.registerVar("seq.set_sync","","BO",N_("Set stepper back on Beat "),0, 0.0, 0.0, 1.0, 1.0);
2054  reg.registerVar("seq.reset_step","","BO",N_("Set stepper one Start"),0, 0.0, 0.0, 1.0, 1.0);
2055  reg.registerVar("seq.follow","","BO",N_("follow playhead"),0, 0.0, 0.0, 1.0, 1.0);
2056  reg.registerVar("seq.direct_out","","BA",N_("bypass the rack for direct output"),&fSlow22, 0.0, 0.0, 1.0, 1.0);
2057  for (int i=0; i<24; i++) Vectom.push_back(0);
2058  for (int i=0; i<24; i++) Vectom1.push_back(0);
2059  for (int i=0; i<24; i++) Vectom2.push_back(0);
2060  for (int i=0; i<24; i++) Veckick.push_back(0);
2061  for (int i=0; i<24; i++) Vechat.push_back(0);
2062  for (int i=0; i<24; i++) Vecsnare.push_back(0);
2063  seq_size = min_seq_size();
2064  tomp = SeqParameter::insert_param(param, "seq.sequencer.tom", &tomset);
2065  tomp1 = SeqParameter::insert_param(param, "seq.sequencer.tom1", &tomset1);
2066  tomp2 = SeqParameter::insert_param(param, "seq.sequencer.tom2", &tomset2);
2067  snarep = SeqParameter::insert_param(param, "seq.sequencer.snare", &snareset);
2068  hatp = SeqParameter::insert_param(param, "seq.sequencer.hat", &hatset);
2069  kickp = SeqParameter::insert_param(param, "seq.sequencer.kick", &kickset);
2070  tomp->signal_changed().connect(
2071  sigc::hide(
2072  sigc::mem_fun(this, &DrumSequencer::reset_tom)));
2073  tomp1->signal_changed().connect(
2074  sigc::hide(
2075  sigc::mem_fun(this, &DrumSequencer::reset_tom1)));
2076  tomp2->signal_changed().connect(
2077  sigc::hide(
2078  sigc::mem_fun(this, &DrumSequencer::reset_tom2)));
2079  snarep->signal_changed().connect(
2080  sigc::hide(
2081  sigc::mem_fun(this, &DrumSequencer::reset_snare)));
2082  hatp->signal_changed().connect(
2083  sigc::hide(
2084  sigc::mem_fun(this, &DrumSequencer::reset_hat)));
2085  kickp->signal_changed().connect(
2086  sigc::hide(
2087  sigc::mem_fun(this, &DrumSequencer::reset_kick)));
2088 
2089  drums.register_par(reg);
2090  return 0;
2091 }
2092 
2093 int DrumSequencer::register_params_static(const ParamReg& reg)
2094 {
2095  return static_cast<DrumSequencer*>(reg.plugin)->register_par(reg);
2096 }
2097 
2098 void DrumSequencer::del_instance(PluginDef *p)
2099 {
2100  delete static_cast<DrumSequencer*>(p);
2101 }
2102 
2103 /****************************************************************************
2104 *
2105 * NAME: smbPitchShift.cpp
2106 * VERSION: 1.2
2107 * HOME URL: http://www.dspdimension.com
2108 * KNOWN BUGS: none
2109 *
2110 *
2111 * COPYRIGHT 1999-2009 Stephan M. Bernsee <smb [AT] dspdimension [DOT] com>
2112 *
2113 * Modified for guitarix by Hermann Meyer 2014
2114 *
2115 * The Wide Open License (WOL)
2116 *
2117 * Permission to use, copy, modify, distribute and sell this software and its
2118 * documentation for any purpose is hereby granted without fee, provided that
2119 * the above copyright notice and this license appear in all source copies.
2120 * THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY OF
2121 * ANY KIND. See http://www.dspguru.com/wol.htm for more information.
2122 *
2123 *****************************************************************************/
2124 
2125 bool smbPitchShift::setParameters(int sampleRate_)
2126 {
2127  numSampsToProcess = int(engine.get_buffersize());
2128  fftFrameSize = numSampsToProcess/4;
2129  sampleRate = int(sampleRate_);
2130  assert(sampleRate>0);
2131  osamp = 8;
2132  osamp1 = 1./osamp;
2133  osamp2 = 2.*M_PI*osamp1;
2134  mpi = (1./(2.*M_PI)) * osamp;
2135  mpi1 = 1./M_PI;
2136  fpb = 0;
2137  expect = 0;
2138  hanning = 0;
2139  hanningd = 0;
2140  resampin = 0;
2141  resampout = 0;
2142  indata2 = 0;
2143  resamp.setup(sampleRate,4);
2144  gRover = inFifoLatency;
2145  return true;
2146 }
2147 
2148 smbPitchShift::smbPitchShift(ParamMap& param_, EngineControl& engine_, sigc::slot<void> sync_):
2149  PluginDef(),
2150  engine(engine_),
2151  mem_allocated(false),
2152  sync(sync_),
2153  ready(false),
2154  param(param_),
2155  ftPlanForward(0),
2156  ftPlanInverse(0),
2157  plugin() {
2158  memset(gInFIFO, 0, MAX_FRAME_LENGTH*sizeof(float));
2159  memset(gOutFIFO, 0, MAX_FRAME_LENGTH*sizeof(float));
2160  memset(gLastPhase, 0, (MAX_FRAME_LENGTH/2+1)*sizeof(float));
2161  memset(gSumPhase, 0, (MAX_FRAME_LENGTH/2+1)*sizeof(float));
2162  memset(gOutputAccum, 0, 2*MAX_FRAME_LENGTH*sizeof(float));
2163  memset(gAnaFreq, 0, MAX_FRAME_LENGTH*sizeof(float));
2164  memset(gAnaMagn, 0, MAX_FRAME_LENGTH*sizeof(float));
2166  id = "smbPitchShift";
2167  name = N_("Detune");
2168  groups = 0;
2169  description = N_("detune and pitch shift up"); // description (tooltip)
2170  category = N_("Misc"); // category
2171  mono_audio = compute_static;
2172  stereo_audio = 0;
2173  set_samplerate = init;
2174  activate_plugin = activate_static;
2175  register_params = registerparam;
2176  delete_instance = del_instance;
2177  load_ui = load_ui_f_static;
2178  plugin = this;
2179  engine.signal_buffersize_change().connect(
2180  sigc::mem_fun(*this, &smbPitchShift::change_buffersize));
2181 }
2182 
2183 void smbPitchShift::init(unsigned int samplingFreq, PluginDef *plugin) {
2184  static_cast<smbPitchShift*>(plugin)->setParameters(samplingFreq);
2185 
2186 }
2187 
2188 void smbPitchShift::clear_state()
2189 {
2190  stepSize = fftFrameSize/osamp;
2191  freqPerBin = (double)(sampleRate/4)/(double)fftFrameSize;
2192  freqPerBin1 = (1/freqPerBin)*osamp2;
2193  freqPerBin2 = freqPerBin*mpi;
2194  expct = 2.*M_PI*(double)stepSize/(double)fftFrameSize;
2195  inFifoLatency = fftFrameSize-stepSize;
2196  fftFrameSize3 = 2. * (1./ ((double)(fftFrameSize2)*osamp));
2197  fftFrameSize4 = 1./(double)fftFrameSize;
2198  ai = 0;
2199  aio = 0;
2200  ii = 0;
2201  tone =0;
2202  memset(gInFIFO, 0, MAX_FRAME_LENGTH*sizeof(float));
2203  memset(gOutFIFO, 0, MAX_FRAME_LENGTH*sizeof(float));
2204  memset(gLastPhase, 0, (MAX_FRAME_LENGTH/2+1)*sizeof(float));
2205  memset(gSumPhase, 0, (MAX_FRAME_LENGTH/2+1)*sizeof(float));
2206  memset(gOutputAccum, 0, 2*MAX_FRAME_LENGTH*sizeof(float));
2207  memset(gAnaFreq, 0, MAX_FRAME_LENGTH*sizeof(float));
2208  memset(gAnaMagn, 0, MAX_FRAME_LENGTH*sizeof(float));
2209  for (k = 0; k < fftFrameSize2;k++) {
2210  fpb[k] = (double)k*freqPerBin;
2211  }
2212  for (k = 0; k < fftFrameSize2;k++) {
2213  expect[k] = (double)k*expct;
2214  }
2215  for (k = 0; k < fftFrameSize;k++) {
2216  hanning[k] = 0.5*(1-cos(2.*M_PI*(double)k/((double)fftFrameSize)));
2217  }
2218  for (k = 0; k < fftFrameSize;k++) {
2219  hanningd[k] = 0.5*(1-cos(2.*M_PI*(double)k * fftFrameSize4)) * fftFrameSize3;
2220  }
2221  for (k = 0; k < fftFrameSize;k++) {
2222  resampin[k] = 0.0;
2223  }
2224  for (k = 0; k < fftFrameSize;k++) {
2225  resampin2[k] = 0.0;
2226  }
2227  for (k = 0; k < fftFrameSize*4;k++) {
2228  resampout[k] = 0.0;
2229  }
2230  for (k = 0; k < fftFrameSize*4;k++) {
2231  indata2[k] = 0.0;
2232  }
2233  gRover = inFifoLatency;
2234  mem_allocated = true;
2235  ready = true;
2236 }
2237 
2238 void smbPitchShift::mem_alloc()
2239 {
2240  numSampsToProcess = int(engine.get_buffersize());
2241  assert(numSampsToProcess>0);
2242  numSampsToResamp = numSampsToProcess/4;
2243  sampleRate = int(engine.get_samplerate());
2244  assert(sampleRate>0);
2245 
2246  switch(latency) {
2247  case(0):
2248  if (numSampsToProcess <= 2048) {
2249  fftFrameSize = 512 ;
2250  } else {
2251  fftFrameSize = numSampsToProcess*0.25 ;
2252  }
2253  break;
2254  case(1):
2255  fftFrameSize = numSampsToProcess;
2256  break;
2257  case(2):
2258  fftFrameSize = numSampsToProcess*0.25;
2259  break;
2260  default:
2261  if (numSampsToProcess <= 2048) {
2262  fftFrameSize = 512 ;
2263  } else {
2264  fftFrameSize = numSampsToProcess*0.25 ;
2265  }
2266  break;
2267  }
2268  fftFrameSize2 = fftFrameSize/2;
2269 
2270  try {
2271  //create FFTW plan
2272  ftPlanForward = fftwf_plan_dft_1d(fftFrameSize, fftw_in, fftw_out, FFTW_FORWARD, FFTW_ESTIMATE);
2273  ftPlanInverse = fftwf_plan_dft_1d(fftFrameSize, fftw_in, fftw_out, FFTW_BACKWARD, FFTW_ESTIMATE);
2274  // alloc buffers
2275  fpb = new float[fftFrameSize2];
2276  expect = new float[fftFrameSize2];
2277  hanning = new float[fftFrameSize];
2278  hanningd = new float[fftFrameSize];
2279  resampin = new float[fftFrameSize];
2280  resampin2 = new float[fftFrameSize];
2281  resampout = new float[fftFrameSize*4];
2282  indata2 = new float[fftFrameSize*4];
2283  } catch(...) {
2284  gx_print_error("detune", "cant allocate memory pool");
2285  return;
2286  }
2287  clear_state();
2288 }
2289 
2290 void smbPitchShift::mem_free()
2291 {
2292  ready = false;
2293  mem_allocated = false;
2294  if (fpb) { delete fpb; fpb = 0; }
2295  if (expect) { delete expect; expect = 0; }
2296  if (hanning) { delete hanning; hanning = 0; }
2297  if (hanningd) { delete hanningd; hanningd = 0; }
2298  if (resampin) { delete resampin; resampin = 0; }
2299  if (resampin2) { delete resampin2; resampin2 = 0; }
2300  if (resampout) { delete resampout; resampout = 0; }
2301  if (indata2) { delete indata2; indata2 = 0; }
2302  if (ftPlanForward)
2303  {fftwf_destroy_plan(ftPlanForward);ftPlanForward = 0; }
2304  if (ftPlanInverse)
2305  { fftwf_destroy_plan(ftPlanInverse);ftPlanInverse = 0; }
2306 }
2307 
2308 int smbPitchShift::activate(bool start)
2309 {
2310  if (start) {
2311  if (!mem_allocated) {
2312  mem_alloc();
2313  }
2314  } else if (mem_allocated) {
2315  mem_free();
2316  }
2317  return 0;
2318 }
2319 
2320 void smbPitchShift::change_buffersize(unsigned int size)
2321 {
2322  sync();
2323  ready = false;
2324  if (mem_allocated) {
2325  mem_free();
2326  mem_alloc();
2327  }
2328 }
2329 
2330 void smbPitchShift::change_latency()
2331 {
2332  sync();
2333  ready = false;
2334  if (mem_allocated) {
2335  mem_free();
2336  mem_alloc();
2337  }
2338 }
2339 
2341 {
2342  if (mem_allocated) {
2343  mem_free();
2344  }
2345 }
2346 
2347 // -----------------------------------------------------------------------------------------------------------------
2348 void __rt_func smbPitchShift::compute_static(int count, float *input0, float *output0, PluginDef *p)
2349 {
2350  static_cast<smbPitchShift*>(p)->PitchShift(count, input0, output0);
2351 }
2352 
2353 
2354 void always_inline smbPitchShift::PitchShift(int count, float *indata, float *outdata)
2355 {
2356 
2357  if (!ready || count != numSampsToProcess) {
2358  if (indata != outdata)
2359  {
2360  memcpy(outdata,indata,count*sizeof(float));
2361  }
2362  return;
2363  }
2364 
2365  resamp.down(numSampsToResamp,indata,resampin);
2366  double fSlow0 = (0.01 * wet);
2367  double fSlow1 = (0.01 * dry);
2368 
2369  // collect data for latency compensation
2370  for (i = 0; i < count; i++){
2371  indata2[ii] = indata[i];
2372  ii++;
2373  }
2374  // collect data for fft
2375  for (i = 0; i < numSampsToResamp; i++){
2376  resampin2[ai] = resampin[i];
2377  ai++;
2378  }
2379  // now we have enough data
2380  if (ai>=fftFrameSize) {
2381  ai = 0;
2382  ii = 0;
2383  switch(octave) {
2384  case(0):
2385  tone =0;
2386  break;
2387  case(1):
2388  tone =12;
2389  break;
2390  case(2):
2391  tone =-12;
2392  break;
2393  default:
2394  tone =0;
2395  break;
2396  }
2397  float pitchShift = pow(2., (semitones+tone)*0.0833333333);
2398  /* main processing loop */
2399  for (i = 0; i < fftFrameSize; i++){
2400 
2401  /* As long as we have not yet collected enough data just read in */
2402  float fTemp = resampin2[i];
2403  gInFIFO[gRover] = fTemp;
2404  resampin2[i] = gOutFIFO[gRover-inFifoLatency];
2405  gRover++;
2406 
2407  /* now we have enough data for processing */
2408  if (gRover >= fftFrameSize) {
2409  gRover = inFifoLatency;
2410 
2411  /* do windowing and re,im interleave */
2412  for (k = 0; k < fftFrameSize;k++) {
2413  fftw_in[k][0] = gInFIFO[k] * hanning[k];
2414  fftw_in[k][1] = 0.0;
2415  }
2416 
2417 
2418  /* ***************** ANALYSIS ******************* */
2419  /* do transform */
2420  fftwf_execute(ftPlanForward);
2421 
2422  /* this is the analysis step */
2423  for (k = 0; k < fftFrameSize2; k++) {
2424 
2425  /* de-interlace FFT buffer */
2426  real = fftw_out[k][0];
2427  imag = fftw_out[k][1];
2428 
2429  /* compute magnitude and phase */
2430  magn = 2.*sqrt(real*real + imag*imag);
2431  phase = atan2(imag,real);
2432 
2433  /* compute phase difference */
2434  tmp = phase - gLastPhase[k];
2435  gLastPhase[k] = phase;
2436 
2437  /* subtract expected phase difference */
2438  tmp -= expect[k];
2439 
2440  /* map delta phase into +/- Pi interval */
2441  qpd = tmp*mpi1;
2442  if (qpd >= 0) qpd += qpd&1;
2443  else qpd -= qpd&1;
2444  tmp -= M_PI*(double)qpd;
2445 
2446  /* get deviation from bin frequency from the +/- Pi interval */
2447  /* compute the k-th partials' true frequency */
2448  tmp = fpb[k] + tmp*freqPerBin2;
2449 
2450  /* store magnitude and true frequency in analysis arrays */
2451  gAnaMagn[k] = magn;
2452  gAnaFreq[k] = tmp;
2453 
2454  }
2455 
2456  /* ***************** PROCESSING ******************* */
2457  /* this does the actual pitch shifting */
2458  memset(gSynMagn, 0, fftFrameSize*sizeof(float));
2459  memset(gSynFreq, 0, fftFrameSize*sizeof(float));
2460  for (k = 1; k < fftFrameSize2-2; k++) {
2461  index = k*pitchShift;
2462  if (index < fftFrameSize2) {
2463  if (index < fftFrameSize2*0.20)
2464  gSynMagn[index] += gAnaMagn[k]*a;
2465  else if (index < fftFrameSize2*0.45)
2466  gSynMagn[index] += gAnaMagn[k]*b;
2467  else if (index < fftFrameSize2*0.667)
2468  gSynMagn[index] += gAnaMagn[k]*c;
2469  else
2470  gSynMagn[index] += gAnaMagn[k]*d;
2471  gSynFreq[index] = gAnaFreq[k] * pitchShift;
2472  }
2473  }
2474 
2475  /* ***************** SYNTHESIS ******************* */
2476  /* this is the synthesis step */
2477  for (k = 0; k < fftFrameSize2; k++) {
2478 
2479  /* get magnitude and true frequency from synthesis arrays */
2480  magn = gSynMagn[k];
2481  //tmp = gSynFreq[k];
2482 
2483  /* subtract bin mid frequency */
2484  /* get bin deviation from freq deviation */
2485  /* take osamp into account */
2486  /* add the overlap phase advance back in */
2487  tmp = ((gSynFreq[k] - fpb[k]) * freqPerBin1) + expect[k];
2488 
2489  /* accumulate delta phase to get bin phase */
2490  gSumPhase[k] += tmp;
2491  phase = gSumPhase[k];
2492  if (magn == 0.0) continue;
2493 
2494  /* get real and imag part and re-interleave */
2495  fftw_in[k][0] = magn * cos (phase);
2496  fftw_in[k][1] = magn * sin (phase);
2497  }
2498 
2499  /* do inverse transform */
2500  fftwf_execute(ftPlanInverse);
2501  /* do windowing and add to output accumulator */
2502  for(k=0; k < fftFrameSize; k++) {
2503  gOutputAccum[k] += hanningd[k] * fftw_out[ k][0] ;
2504  }
2505  for (k = 0; k < stepSize; k++) gOutFIFO[k] = gOutputAccum[k];
2506 
2507  /* shift accumulator */
2508  memmove(gOutputAccum, gOutputAccum+stepSize, fftFrameSize*sizeof(float));
2509 
2510  /* move input FIFO */
2511  for (k = 0; k < inFifoLatency; k++) gInFIFO[k] = gInFIFO[k+stepSize];
2512  }
2513  }
2514  resamp.up(fftFrameSize,resampin2,resampout);
2515  aio = 0;
2516  }
2517  if(l) {
2518  for (i = 0; i < count; i++){
2519  outdata[i] = ((fSlow0 * resampout[aio]) + (fSlow1 *indata2[aio]));
2520  aio++;
2521  }
2522  } else {
2523  for (i = 0; i < count; i++){
2524  outdata[i] = ((fSlow0 * resampout[aio]) + (fSlow1 *indata[i]));
2525  aio++;
2526  }
2527  }
2528 }
2529 
2530 int smbPitchShift::register_par(const ParamReg& reg)
2531 {
2532  reg.registerVar("smbPitchShift.semitone", N_("Detune"), "S", "", &semitones, 0.0, -12., 12., 0.1);
2533  static const value_pair octave_values[] = {{"unison"},{"octave up"},{"octave down"},{0}};
2534  reg.registerIEnumVar("smbPitchShift.octave",N_("add harmonics"),"B",N_("add harmonics"),octave_values,&octave, 0);
2535  static const value_pair latency_values[] = {{"latency "},{"compensate"},{0}};
2536  reg.registerEnumVar("smbPitchShift.l",N_("compensate latency"),"S",N_("compensate latency"),latency_values,&l, 0.0f, 0.0f, 1.0f, 1.0f);
2537  static const value_pair latency_set[] = {{"high quality"},{"low quality"},{"realtime"},{0}};
2538  reg.registerIEnumVar("smbPitchShift.latency",N_("latency settings"),"B",N_("latency settings"),latency_set,&latency, 0);
2539  reg.registerVar("smbPitchShift.wet", N_("Wet"), "S", N_("Wet amount"), &wet, 50.0, 0.0, 100.0, 1);
2540  reg.registerVar("smbPitchShift.dry", N_("Dry"), "S", N_("Dry amount"), &dry, 50.0, 0.0, 100.0, 1);
2541  reg.registerVar("smbPitchShift.a", N_("low"), "S", N_("Sub"), &a, 1.0, 0.0, 2.0, 0.01);
2542  reg.registerVar("smbPitchShift.b", N_("middle low"), "S", N_("Low"), &b, 1.0, 0.0, 2.0, 0.01);
2543  reg.registerVar("smbPitchShift.c", N_("middle treble"), "S", N_("Mid"), &c, 1.0, 0.0, 2.0, 0.01);
2544  reg.registerVar("smbPitchShift.d", N_("treble"), "S", N_("Hi"), &d, 1.0, 0.0, 2.0, 0.01);
2545  param["smbPitchShift.latency"].signal_changed_int().connect(
2546  sigc::hide(sigc::mem_fun(this, &smbPitchShift::change_latency)));
2547  return 0;
2548 }
2549 
2550 int smbPitchShift::registerparam(const ParamReg& reg)
2551 {
2552  return static_cast<smbPitchShift*>(reg.plugin)->register_par(reg);
2553 }
2554 
2555 int smbPitchShift::load_ui_f(const UiBuilder& b, int form)
2556 {
2557  if (form & UI_FORM_GLADE) {
2558  b.load_glade_file("gx_detune_ui.glade");
2559  return 0;
2560  }
2561  if (form & UI_FORM_STACK) {
2562  b.openHorizontalhideBox("");
2563  {
2564  b.create_master_slider("smbPitchShift.semitone",N_("Detune"));
2565  }
2566  b.closeBox();
2567  b.openVerticalBox("");
2568  {
2569  b.openHorizontalBox("");
2570  {
2571  b.openVerticalBox("");
2572  {
2573  b.insertSpacer();
2574  b.create_selector_no_caption("smbPitchShift.octave");
2575  b.create_selector_no_caption("smbPitchShift.l");
2576  b.create_selector_no_caption("smbPitchShift.latency");
2577  b.insertSpacer();
2578  }
2579  b.closeBox();
2580  b.create_mid_rackknob("smbPitchShift.semitone",N_("Detune"));
2581  b.create_small_rackknobr("smbPitchShift.dry",N_("Dry"));
2582  b.create_small_rackknobr("smbPitchShift.wet",N_("Wet"));
2583  }
2584  b.closeBox();
2585  b.insertSpacer();
2586  b.openHorizontalBox("");
2587  {
2589  b.create_small_rackknobr("smbPitchShift.a",N_("Lo"));
2591  b.create_small_rackknobr("smbPitchShift.b",N_("LoMid"));
2593  b.create_small_rackknobr("smbPitchShift.c",N_("HiMid"));
2595  b.create_small_rackknobr("smbPitchShift.d",N_("Hi"));
2596  }
2597  b.closeBox();
2598  }
2599  b.closeBox();
2600  return 0;
2601  }
2602  return -1;
2603 }
2604 
2605 int smbPitchShift::activate_static(bool start, PluginDef *p)
2606 {
2607  return static_cast<smbPitchShift*>(p)->activate(start);
2608 }
2609 
2610 int smbPitchShift::load_ui_f_static(const UiBuilder& b, int form)
2611 {
2612  return static_cast<smbPitchShift*>(b.plugin)->load_ui_f(b, form);
2613 }
2614 
2615 void smbPitchShift::del_instance(PluginDef *p)
2616 {
2617  delete static_cast<smbPitchShift*>(p);
2618 }
2619 
2620 
2621 } // namespace gx_engine
gx_system::JsonParser::value_key
@ value_key
Definition: gx_json.h:130
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::CabinetStereoConvolver::~CabinetStereoConvolver
~CabinetStereoConvolver()
Definition: gx_internal_plugins.cpp:1166
gx_engine::CabDesc_imp::ir_count
int ir_count
Definition: gx_internal_plugins.cpp:929
gx_system::BasicOptions::get_IR_pathlist
const PathList & get_IR_pathlist() const
Definition: gx_system.h:377
gx_engine::CabDesc
Definition: gx_internal_plugins.cpp:921
always_inline
#define always_inline
Definition: gx_faust_support.h:29
gx_system::JsonParser::begin_object
@ begin_object
Definition: gx_json.h:124
gx_engine::CabEntry::data
CabDesc * data
Definition: gx_internal_plugins.cpp:940
gx_engine::FixedBaseConvolver::activate
static int activate(bool start, PluginDef *pdef)
Definition: gx_internal_plugins.cpp:887
PluginDef::set_samplerate
inifunc set_samplerate
Definition: gx_plugin.h:200
gx_system::JsonWriter::begin_object
void begin_object(bool nl=false)
Definition: gx_json.cpp:168
gx_engine::GxJConvSettings::setFullIRPath
void setFullIRPath(string name)
Definition: gx_internal_plugins.cpp:279
gx_engine::smbPitchShift
Definition: gx_internal_plugins.h:1195
gx_engine::GxSimpleConvolver::configure
bool configure(int count, float *impresp, unsigned int imprate)
Definition: gx_convolver.cpp:566
gx_engine::BaseConvolver::init
static void init(unsigned int samplingFreq, PluginDef *p)
Definition: gx_internal_plugins.cpp:779
PluginDef::mono_audio
process_mono_audio mono_audio
Definition: gx_plugin.h:197
gx_engine::DrumSequencer::plugin
Plugin plugin
Definition: gx_internal_plugins.h:1164
gx_engine::PreDesc_imp::ir_sr
int ir_sr
Definition: gx_internal_plugins.cpp:1262
gx_engine::FixedBaseConvolver::SamplingFreq
unsigned int SamplingFreq
Definition: gx_internal_plugins.h:496
gx_engine::CabEntry::value_id
const char * value_id
Definition: gx_internal_plugins.cpp:938
PGN_SNOOP
@ PGN_SNOOP
Definition: gx_plugin.h:170
gx_engine::PreDesc
Definition: gx_internal_plugins.cpp:1253
gx_engine::GxConvolverBase::get_buffersize
unsigned int get_buffersize()
Definition: gx_convolver.h:111
UiBuilder::openVerticalBox
void(* openVerticalBox)(const char *label)
Definition: gx_plugin.h:68
gx_engine::cab_table
struct gx_engine::CabEntry cab_table[]
gx_cabinet_data.cc
UiBuilder::create_mid_rackknob
void(* create_mid_rackknob)(const char *id, const char *label)
Definition: gx_plugin.h:103
gx_engine::CabDesc::ir_count
int ir_count
Definition: gx_internal_plugins.cpp:924
gx_engine::FixedBaseConvolver::engine
EngineControl & engine
Definition: gx_internal_plugins.h:493
value_pair
Definition: gx_plugin.h:117
gx_engine::GxJConvSettings::getGainCor
bool getGainCor() const
Definition: gx_internal_plugins.h:333
PluginDef::category
const char * category
Definition: gx_plugin.h:192
M_PI
#define M_PI
Definition: gx_internal_plugins.h:1192
gx_engine::ParameterV< GxJConvSettings >::set
bool set(const GxJConvSettings &val) const
Definition: gx_internal_plugins.cpp:453
PluginDef::register_params
registerfunc register_params
Definition: gx_plugin.h:202
PluginDef::shortname
const char * shortname
Definition: gx_plugin.h:193
PluginDef::version
int version
Definition: gx_plugin.h:184
gx_engine::ParameterV< GxJConvSettings >::stdJSON_value
virtual void stdJSON_value()
Definition: gx_internal_plugins.cpp:436
gx_engine::PreampConvolver::~PreampConvolver
~PreampConvolver()
Definition: gx_internal_plugins.cpp:1351
gx_engine::SeqParameter
ParameterV< GxSeqSettings > SeqParameter
Definition: gx_internal_plugins.h:298
gx_engine::ConvolverAdapter::activated
bool activated
Definition: gx_internal_plugins.h:394
gx_engine::PreDesc::ir_data
float ir_data[]
Definition: gx_internal_plugins.cpp:1258
ParamReg::registerNonMidiSharedVar
float *(* registerNonMidiSharedVar)(const char *id, float *var, bool preset, bool nosave, float val, float low, float up, float step)
Definition: gx_plugin.h:140
gx_engine::GxSimpleConvolver::update_stereo
bool update_stereo(int count, float *impresp, unsigned int imprate)
Definition: gx_convolver.cpp:699
FAUSTFLOAT
#define FAUSTFLOAT
Definition: gx_faust_support.h:21
gx_system::JsonParser::current_value
string current_value() const
Definition: gx_json.h:143
ParamReg::plugin
PluginDef * plugin
Definition: gx_plugin.h:123
gx_engine::EngineControl::ov_Convolver
@ ov_Convolver
Definition: gx_modulesequencer.h:258
gx_engine::GxSeqSettings::readJSON
void readJSON(gx_system::JsonParser &jp)
Definition: gx_internal_plugins.cpp:143
PluginDef::load_ui
uiloader load_ui
Definition: gx_plugin.h:203
gx_engine::GxConvolver::configure
bool configure(string fname, float gain, float lgain, unsigned int delay, unsigned int ldelay, unsigned int offset, unsigned int length, unsigned int size, unsigned int bufsize, const Gainline &gainline)
gx_system::JsonWriter::write
void write(float v, bool nl=false)
Definition: gx_json.cpp:116
gx_engine::BaseConvolver::conv_start
int conv_start()
Definition: gx_internal_plugins.cpp:820
gx_system::PathList::find_dir
bool find_dir(std::string *d, const std::string &filename) const
Definition: gx_system.cpp:264
gx_engine::BaseConvolver::~BaseConvolver
virtual ~BaseConvolver()
Definition: gx_internal_plugins.cpp:763
gx_engine::ParameterV< GxJConvSettings >::setJSON_value
virtual void setJSON_value()
Definition: gx_internal_plugins.cpp:462
gx_engine::pre_table
struct gx_engine::PreEntry pre_table[]
PluginDef::stereo_audio
process_stereo_audio stereo_audio
Definition: gx_plugin.h:198
gx_engine::GxJConvSettings::getLength
guint getLength() const
Definition: gx_internal_plugins.h:331
gx_engine::ConvolverAdapter::restart
void restart()
Definition: gx_internal_plugins.cpp:513
gx_print_warning
void gx_print_warning(const char *, const std::string &)
Definition: gx_logging.cpp:161
gx_engine::Directout::set_data
void set_data(bool dfill)
Definition: gx_internal_plugins.cpp:1748
gx_engine::FixedBaseConvolver::activated
bool activated
Definition: gx_internal_plugins.h:495
ParamReg::registerVar
float *(* registerVar)(const char *id, const char *name, const char *tp, const char *tooltip, float *var, float val, float low, float up, float step)
Definition: gx_plugin.h:124
gx_engine::PreDesc_imp
Definition: gx_internal_plugins.cpp:1260
gx_engine::BaseConvolver::activate
static int activate(bool start, PluginDef *pdef)
Definition: gx_internal_plugins.cpp:796
PluginDef::name
const char * name
Definition: gx_plugin.h:188
gx_engine::GxConvolverBase::start
bool start(int policy, int priority)
Definition: gx_convolver.cpp:220
gx_engine::Plugin::set_pdef
void set_pdef(PluginDef *p)
Definition: gx_pluginloader.h:56
gx_engine::FixedBaseConvolver::getSamplingFreq
unsigned int getSamplingFreq()
Definition: gx_internal_plugins.h:501
gx_engine::GxSeqSettings
Definition: gx_internal_plugins.h:251
gx_engine::PreDesc::ir_sr
int ir_sr
Definition: gx_internal_plugins.cpp:1257
PluginDef::delete_instance
deletefunc delete_instance
Definition: gx_plugin.h:206
gx_engine::ParameterV< GxSeqSettings >::setJSON_value
virtual void setJSON_value()
Definition: gx_internal_plugins.cpp:240
gx_engine::ParameterV< GxJConvSettings >::~ParameterV
~ParameterV()
Definition: gx_internal_plugins.cpp:398
gx_engine::ConvolverAdapter::change_buffersize
void change_buffersize(unsigned int size)
Definition: gx_internal_plugins.cpp:497
gx_engine::PreEntry
Definition: gx_internal_plugins.cpp:1269
ParamReg::registerEnumVar
void(* registerEnumVar)(const char *id, const char *name, const char *tp, const char *tooltip, const value_pair *values, float *var, float val, float low, float up, float step)
Definition: gx_plugin.h:132
gx_engine::DrumSequencer::DrumSequencer
DrumSequencer(ParamMap &param_, EngineControl &engine, sigc::slot< void > sync)
Definition: gx_internal_plugins.cpp:1824
gx_system::get_options
BasicOptions & get_options()
Definition: gx_system.h:515
min
#define min(x, y)
Definition: gx_faust_support.h:6
gx_engine::ConvolverAdapter::plugin
Plugin plugin
Definition: gx_internal_plugins.h:400
gx_engine::Directout::~Directout
~Directout()
Definition: gx_internal_plugins.cpp:1689
gx_engine::Parameter::serializeJSON
virtual void serializeJSON(gx_system::JsonWriter &jw)
Definition: gx_paramtable.cpp:888
PluginDef
Definition: gx_plugin.h:183
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_resample::SimpleResampler::setup
void setup(int sampleRate, unsigned int fact)
Definition: gx_resampler.cpp:55
gx_engine::ParameterV< GxSeqSettings >
Definition: gx_internal_plugins.h:273
gx_engine::ParameterV< GxSeqSettings >::signal_changed
sigc::signal< void, const GxSeqSettings * > & signal_changed()
Definition: gx_internal_plugins.h:285
gx_engine::FixedBaseConvolver::activate_mutex
boost::mutex activate_mutex
Definition: gx_internal_plugins.h:492
gx_engine::ParameterV< GxJConvSettings >::compareJSON_value
virtual bool compareJSON_value()
Definition: gx_internal_plugins.cpp:449
gx_engine::ContrastConvolver::ContrastConvolver
ContrastConvolver(EngineControl &engine, sigc::slot< void > sync, gx_resample::BufferResampler &resamp)
Definition: gx_internal_plugins.cpp:1578
gx_system::JsonWriter::end_object
void end_object(bool nl=false)
Definition: gx_json.cpp:176
gx_engine::GxSeqSettings::writeJSON
void writeJSON(gx_system::JsonWriter &w) const
Definition: gx_internal_plugins.cpp:114
gx_engine::ConvolverStereoAdapter
Definition: gx_internal_plugins.h:421
gx_engine::ConvolverStereoAdapter::~ConvolverStereoAdapter
~ConvolverStereoAdapter()
Definition: gx_internal_plugins.cpp:583
UiBuilder::load_glade_file
void(* load_glade_file)(const char *fname)
Definition: gx_plugin.h:66
gx_resample::BufferResampler
Definition: gx_resampler.h:45
gx_engine::ConvolverMonoAdapter::~ConvolverMonoAdapter
~ConvolverMonoAdapter()
Definition: gx_internal_plugins.cpp:677
gx_engine::GxSimpleConvolver::compute_stereo
bool compute_stereo(int count, float *input, float *input1, float *output, float *output1)
Definition: gx_convolver.cpp:718
gx_engine::FixedBaseConvolver::check_update
virtual void check_update()=0
gx_engine::CabDesc_imp::ir_sr
int ir_sr
Definition: gx_internal_plugins.cpp:930
gx_engine::ParameterV< GxSeqSettings >::serializeJSON
virtual void serializeJSON(gx_system::JsonWriter &jw)
Definition: gx_internal_plugins.cpp:201
gx_engine::ContrastConvolver::~ContrastConvolver
~ContrastConvolver()
Definition: gx_internal_plugins.cpp:1591
gx_engine::FixedBaseConvolver::conv_start
int conv_start()
Definition: gx_internal_plugins.cpp:911
gx_engine::Drumout::set_data
static void set_data(float *mode, bool ready, float *buf)
Definition: gx_internal_plugins.cpp:1805
N_
#define N_(String)
Definition: gx_faust_support.h:23
gx_engine::Drumout::output_drum
static Plugin output_drum
Definition: gx_internal_plugins.h:1088
gx_engine::FixedBaseConvolver::~FixedBaseConvolver
virtual ~FixedBaseConvolver()
Definition: gx_internal_plugins.cpp:850
gx_engine::GxJConvSettings::operator=
GxJConvSettings & operator=(GxJConvSettings const &jcset)
Definition: gx_internal_plugins.cpp:259
PluginDef::groups
const char ** groups
Definition: gx_plugin.h:189
gx_engine::FixedBaseConvolver::init
static void init(unsigned int samplingFreq, PluginDef *p)
Definition: gx_internal_plugins.cpp:867
gx_engine::BaseConvolver::change_buffersize
void change_buffersize(unsigned int)
Definition: gx_internal_plugins.cpp:767
gx_engine::FixedBaseConvolver::change_buffersize
void change_buffersize(unsigned int)
Definition: gx_internal_plugins.cpp:854
gx_system::JsonParser::next
token next(token expect=no_token)
Definition: gx_json.cpp:496
gx_engine::ConvolverAdapter::conv_start
bool conv_start()
Definition: gx_internal_plugins.cpp:537
gx_engine::GxJConvSettings::getOffset
guint getOffset() const
Definition: gx_internal_plugins.h:330
gx_engine::FixedBaseConvolver::update_conn
sigc::connection update_conn
Definition: gx_internal_plugins.h:499
gx_engine::smbPitchShift::smbPitchShift
smbPitchShift(ParamMap &param_, EngineControl &engine, sigc::slot< void > sync)
Definition: gx_internal_plugins.cpp:2148
gx_engine::GxSimpleConvolver::compute
bool compute(int count, float *input, float *output)
Definition: gx_convolver.cpp:613
gx_engine::PreEntry::value_id
const char * value_id
Definition: gx_internal_plugins.cpp:1270
gx_engine::BaseConvolver::engine
EngineControl & engine
Definition: gx_internal_plugins.h:465
gx_engine::ParameterV< GxSeqSettings >::compareJSON_value
virtual bool compareJSON_value()
Definition: gx_internal_plugins.cpp:227
gx_engine::BaseConvolver::check_update_timeout
bool check_update_timeout()
Definition: gx_internal_plugins.cpp:788
gx_engine::Directout::mem_allocated
bool mem_allocated
Definition: gx_internal_plugins.h:810
UiBuilder::create_small_rackknobr
void(* create_small_rackknobr)(const char *id, const char *label)
Definition: gx_plugin.h:98
gx_engine::GxJConvSettings::getGainline
const Gainline & getGainline() const
Definition: gx_internal_plugins.h:334
gx_engine::PreEntry::value_label
const char * value_label
Definition: gx_internal_plugins.cpp:1271
gx_engine::sqrf
float sqrf(float x)
Definition: gx_engine_midi.cpp:83
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
UiBuilder::create_selector_no_caption
void(* create_selector_no_caption)(const char *id)
Definition: gx_plugin.h:88
gx_system::JsonWriter::write_kv
void write_kv(const char *key, float v)
Definition: gx_json.h:81
gx_engine::GxConvolverBase::is_runnable
bool is_runnable()
Definition: gx_convolver.h:117
gx_engine::GxJConvSettings::writeJSON
void writeJSON(gx_system::JsonWriter &w) const
Definition: gx_internal_plugins.cpp:284
UiBuilder::plugin
PluginDef * plugin
Definition: gx_plugin.h:64
gx_system::JsonWriter
Definition: gx_json.h:55
gx_engine::ParameterV< GxSeqSettings >::on_off_value
virtual bool on_off_value()
Definition: gx_internal_plugins.cpp:209
gx_engine::ParameterV< GxSeqSettings >::writeJSON
virtual void writeJSON(gx_system::JsonWriter &jw) const
Definition: gx_internal_plugins.cpp:218
UI_FORM_GLADE
#define UI_FORM_GLADE
Definition: gx_plugin.h:61
gx_engine::Drumout::outputdrum
static PluginDef outputdrum
Definition: gx_internal_plugins.h:1089
gx_engine::CabinetConvolver::~CabinetConvolver
~CabinetConvolver()
Definition: gx_internal_plugins.cpp:1028
gx_engine::BaseConvolver::update_conn
sigc::connection update_conn
Definition: gx_internal_plugins.h:468
gx_engine::FixedBaseConvolver::plugin
Plugin plugin
Definition: gx_internal_plugins.h:509
gx_engine::BaseConvolver::activate_mutex
boost::mutex activate_mutex
Definition: gx_internal_plugins.h:464
gx_engine::BaseConvolver::start
virtual bool start(bool force=false)=0
gx_system::JsonParser
Definition: gx_json.h:112
gx_faust_support.h
gx_engine::NoiseGate::outputgate
static PluginDef outputgate
Definition: gx_internal_plugins.h:218
gx_engine::PreDesc::ir_count
int ir_count
Definition: gx_internal_plugins.cpp:1256
gx_engine::CabinetConvolver::CabinetConvolver
CabinetConvolver(EngineControl &engine, sigc::slot< void > sync, gx_resample::BufferResampler &resamp)
Definition: gx_internal_plugins.cpp:1001
gx_engine::GxJConvSettings::getGain
float getGain() const
Definition: gx_internal_plugins.h:329
gx_engine::ParameterV< GxJConvSettings >::ParameterV
ParameterV(const string &id, ConvolverAdapter &conv, GxJConvSettings *v)
gx_print_error
void gx_print_error(const char *, const std::string &)
Definition: gx_logging.cpp:166
UI_FORM_STACK
#define UI_FORM_STACK
Definition: gx_plugin.h:60
gx_engine::Plugin::get_on_off
bool get_on_off() const
Definition: gx_pluginloader.h:63
gx_system::JsonParser::begin_array
@ begin_array
Definition: gx_json.h:126
gx_engine::JConvParameter
ParameterV< GxJConvSettings > JConvParameter
Definition: gx_internal_plugins.h:378
gx_engine::ParameterV< GxSeqSettings >::insert_param
static ParameterV< GxSeqSettings > * insert_param(ParamMap &pmap, const string &id, GxSeqSettings *v)
gx_engine::BaseConvolver::conv
GxSimpleConvolver conv
Definition: gx_internal_plugins.h:463
PluginDef::description
const char * description
Definition: gx_plugin.h:191
gx_engine::GxSimpleConvolver::configure_stereo
bool configure_stereo(int count, float *impresp, unsigned int imprate)
Definition: gx_convolver.cpp:657
gx_engine::EngineControl::get_samplerate
unsigned int get_samplerate()
Definition: gx_modulesequencer.h:272
gx_engine::BaseConvolver
Definition: gx_internal_plugins.h:459
gx_engine::CabDesc_imp::ir_data
float ir_data[tab_size]
Definition: gx_internal_plugins.cpp:931
gx_engine::GxSeqSettings::operator=
GxSeqSettings & operator=(GxSeqSettings const &seqset)
Definition: gx_internal_plugins.cpp:109
gx_engine::GxJConvSettings::getDelay
guint getDelay() const
Definition: gx_internal_plugins.h:332
UiBuilder::closeBox
void(* closeBox)()
Definition: gx_plugin.h:77
gx_system::JsonParser::read_kv
bool read_kv(const char *key, float &v)
Definition: gx_json.cpp:511
gx_engine::ParameterV< GxJConvSettings >::on_off_value
virtual bool on_off_value()
Definition: gx_internal_plugins.cpp:431
gx_engine::ConvolverAdapter::activate_mutex
boost::mutex activate_mutex
Definition: gx_internal_plugins.h:390
gx_engine::PreampConvolver::PreampConvolver
PreampConvolver(EngineControl &engine, sigc::slot< void > sync, gx_resample::BufferResampler &resamp)
Definition: gx_internal_plugins.cpp:1324
gx_system::JsonWriter::begin_array
void begin_array(bool nl=false)
Definition: gx_json.cpp:184
gx_engine::ConvolverAdapter::sync
sigc::slot< void > sync
Definition: gx_internal_plugins.h:392
gx_engine::GxConvolverBase::set_buffersize
void set_buffersize(unsigned int sz)
Definition: gx_convolver.h:110
gx_engine::BaseConvolver::plugin
Plugin plugin
Definition: gx_internal_plugins.h:477
PluginDef::id
const char * id
Definition: gx_plugin.h:187
gx_engine::BaseConvolver::check_update
virtual void check_update()=0
gx_engine::ConvolverAdapter::conv
GxConvolver conv
Definition: gx_internal_plugins.h:389
gx_system::JsonParser::end_array
@ end_array
Definition: gx_json.h:127
value_pair::value_id
const char * value_id
Definition: gx_plugin.h:118
gx_engine::ConvolverAdapter::ConvolverAdapter
ConvolverAdapter(EngineControl &engine, sigc::slot< void > sync, ParamMap &param)
Definition: gx_internal_plugins.cpp:474
gx_engine::GxSimpleConvolver::update
bool update(int count, float *impresp, unsigned int imprate)
Definition: gx_convolver.cpp:597
gx_system::JsonParser::end_object
@ end_object
Definition: gx_json.h:125
gx_system::BasicOptions::get_IR_prefixmap
const PrefixConverter & get_IR_prefixmap() const
Definition: gx_system.h:378
gx_engine::EngineControl
Definition: gx_modulesequencer.h:238
gx_engine::FixedBaseConvolver::bz
unsigned int bz
Definition: gx_internal_plugins.h:498
gx_engine::ConvolverMonoAdapter
Definition: gx_internal_plugins.h:440
gx_engine::Directout::directoutput
static Plugin directoutput
Definition: gx_internal_plugins.h:814
gx_engine::ParameterV< GxJConvSettings >::serializeJSON
virtual void serializeJSON(gx_system::JsonWriter &jw)
Definition: gx_internal_plugins.cpp:423
gx_record.cc
gx_engine::BaseConvolver::BaseConvolver
BaseConvolver(EngineControl &engine, sigc::slot< void > sync, gx_resample::BufferResampler &resamp)
Definition: gx_internal_plugins.cpp:747
gx_engine::ConvolverMonoAdapter::ConvolverMonoAdapter
ConvolverMonoAdapter(EngineControl &engine, sigc::slot< void > sync, ParamMap &param)
Definition: gx_internal_plugins.cpp:666
gx_engine::PreDesc_imp::ir_data
float ir_data[tab_size]
Definition: gx_internal_plugins.cpp:1263
gx_engine::Directout::plugin
Plugin plugin
Definition: gx_internal_plugins.h:813
gx_engine::ConvolverAdapter::param
ParamMap & param
Definition: gx_internal_plugins.h:393
PluginDef::flags
int flags
Definition: gx_plugin.h:185
gx_engine::ParamMap
Definition: gx_parameter.h:515
gx_engine::ConvolverAdapter::jcset
GxJConvSettings jcset
Definition: gx_internal_plugins.h:397
gx_livelooper.cc
gx_engine::PreampStereoConvolver::PreampStereoConvolver
PreampStereoConvolver(EngineControl &engine, sigc::slot< void > sync, gx_resample::BufferResampler &resamp)
Definition: gx_internal_plugins.cpp:1461
gx_engine::ParameterV< GxJConvSettings >::writeJSON
virtual void writeJSON(gx_system::JsonWriter &jw) const
Definition: gx_internal_plugins.cpp:440
gx_engine::Directout::outdata
float * outdata
Definition: gx_internal_plugins.h:794
gx_engine::FixedBaseConvolver::sync
sigc::slot< void > sync
Definition: gx_internal_plugins.h:494
ParamReg
Definition: gx_plugin.h:122
gx_engine::FixedBaseConvolver
Definition: gx_internal_plugins.h:487
gx_engine::ParameterV< GxSeqSettings >::~ParameterV
~ParameterV()
Definition: gx_internal_plugins.cpp:178
gx_system::JsonParser::value_number
@ value_number
Definition: gx_json.h:129
gx_engine::PreDesc_imp::ir_count
int ir_count
Definition: gx_internal_plugins.cpp:1261
gx_resample::SimpleResampler::down
void down(int count, float *input, float *output)
Definition: gx_resampler.cpp:89
gx_engine::PreampStereoConvolver::~PreampStereoConvolver
~PreampStereoConvolver()
Definition: gx_internal_plugins.cpp:1489
UiBuilder
Definition: gx_plugin.h:63
gx_engine::CabEntry::value_label
const char * value_label
Definition: gx_internal_plugins.cpp:939
gx_system::JsonParser::current_value_int
int current_value_int()
Definition: gx_json.h:144
gx_engine::PreEntry::data
PreDesc * data
Definition: gx_internal_plugins.cpp:1272
gx_engine::ParameterV< GxSeqSettings >::ParameterV
ParameterV(const string &id, GxSeqSettings *v)
Definition: gx_internal_plugins.cpp:161
gx_engine::ConvolverAdapter::engine
EngineControl & engine
Definition: gx_internal_plugins.h:391
gx_engine::GxConvolver::compute
bool compute(int count, float *input1, float *input2, float *output1, float *output2)
Definition: gx_convolver.cpp:440
gx_engine::EngineControl::get_buffersize
unsigned int get_buffersize()
Definition: gx_modulesequencer.h:274
gx_engine::GxSeqSettings::GxSeqSettings
GxSeqSettings()
Definition: gx_internal_plugins.cpp:105
gx_engine::GxConvolverBase::set_not_runnable
void set_not_runnable()
Definition: gx_convolver.h:116
gx_system::JsonParser::current_value_float
float current_value_float()
Definition: gx_json.h:146
gx_engine::GxJConvSettings::operator==
bool operator==(const GxJConvSettings &jcset) const
Definition: gx_internal_plugins.cpp:305
PluginDef::activate_plugin
activatefunc activate_plugin
Definition: gx_plugin.h:201
gx_engine::FixedBaseConvolver::FixedBaseConvolver
FixedBaseConvolver(EngineControl &engine, sigc::slot< void > sync, gx_resample::BufferResampler &resamp)
Definition: gx_internal_plugins.cpp:831
start
CmdConnection::msg_type start
Definition: jsonrpc.cpp:257
gx_engine::DrumSequencer::~DrumSequencer
~DrumSequencer()
Definition: gx_internal_plugins.cpp:1870
gx_engine::FixedBaseConvolver::conv
GxSimpleConvolver conv
Definition: gx_internal_plugins.h:491
ParamReg::registerNonMidiFloatVar
void(* registerNonMidiFloatVar)(const char *id, float *var, bool preset, bool nosave, float val, float low, float up, float step)
Definition: gx_plugin.h:130
PLUGINDEF_VERSION
#define PLUGINDEF_VERSION
Definition: gx_plugin.h:181
gx_engine::FixedBaseConvolver::check_update_timeout
bool check_update_timeout()
Definition: gx_internal_plugins.cpp:879
gx_engine::GxConvolverBase::get_samplerate
unsigned int get_samplerate()
Definition: gx_convolver.h:113
gx_system::JsonParser::peek
token peek()
Definition: gx_json.h:139
gx_system::JsonWriter::write_key
void write_key(const char *p, bool nl=false)
Definition: gx_json.cpp:200
gx_engine::Directout
Definition: gx_internal_plugins.h:790
gx_engine::ConvolverAdapter::~ConvolverAdapter
~ConvolverAdapter()
Definition: gx_internal_plugins.cpp:494
gx_engine::BaseConvolver::activated
bool activated
Definition: gx_internal_plugins.h:467
engine.h
UiBuilder::set_next_flags
void(* set_next_flags)(int flags)
Definition: gx_plugin.h:79
gx_engine::NoiseGate::inputlevel
static Plugin inputlevel
Definition: gx_internal_plugins.h:217
__rt_func
#define __rt_func
Definition: gx_compiler.h:7
UiBuilder::create_master_slider
void(* create_master_slider)(const char *id, const char *label)
Definition: gx_plugin.h:84
gx_system::JsonParser::skip_object
void skip_object()
Definition: gx_json.cpp:611
UiBuilder::openHorizontalBox
void(* openHorizontalBox)(const char *label)
Definition: gx_plugin.h:71
gx_engine::GxSeqSettings::operator==
bool operator==(const GxSeqSettings &seqset) const
Definition: gx_internal_plugins.cpp:125
UiBuilder::openHorizontalhideBox
void(* openHorizontalhideBox)(const char *label)
Definition: gx_plugin.h:72
gx_engine::ParameterV< GxJConvSettings >::insert_param
static ParameterV< GxJConvSettings > * insert_param(ParamMap &pmap, const string &id, ConvolverAdapter &conv, GxJConvSettings *v)
gx_engine::ParameterV< GxSeqSettings >::readJSON_value
virtual void readJSON_value(gx_system::JsonParser &jp)
Definition: gx_internal_plugins.cpp:223
gx_engine::ParameterV< GxSeqSettings >::stdJSON_value
virtual void stdJSON_value()
Definition: gx_internal_plugins.cpp:214
gx_engine::ConvolverStereoAdapter::ConvolverStereoAdapter
ConvolverStereoAdapter(EngineControl &engine, sigc::slot< void > sync, ParamMap &param)
Definition: gx_internal_plugins.cpp:572
gx_engine::Plugin
Definition: gx_pluginloader.h:45
gx_engine::CabDesc::ir_data
float ir_data[]
Definition: gx_internal_plugins.cpp:926
gx_system::JsonWriter::end_array
void end_array(bool nl=false)
Definition: gx_json.cpp:192
gx_engine::GxJConvSettings::getFullIRPath
std::string getFullIRPath() const
Definition: gx_internal_plugins.cpp:271
gx_engine::GxConvolverBase::checkstate
bool checkstate()
Definition: gx_convolver.cpp:230
gx_engine::CabEntry
Definition: gx_internal_plugins.cpp:937
gx_engine::GxJConvSettings::GxJConvSettings
GxJConvSettings()
Definition: gx_internal_plugins.cpp:248
gx_engine::Directout::Directout
Directout(EngineControl &engine, sigc::slot< void > sync)
Definition: gx_internal_plugins.cpp:1669
gx_resample::FixedRateResampler::setup
int setup(int _inputRate, int _outputRate)
Definition: gx_resampler.cpp:190
gx_engine::ParameterV< GxSeqSettings >::set
bool set(const GxSeqSettings &val) const
Definition: gx_internal_plugins.cpp:231
gx_engine::GxJConvSettings
Definition: gx_internal_plugins.h:304
gx_engine::GxSeqSettings::getseqline
const std::vector< int > & getseqline() const
Definition: gx_internal_plugins.h:265
gx_engine::FixedBaseConvolver::start
virtual bool start(bool force=false)=0
gx_engine::ParameterV< GxJConvSettings >::readJSON_value
virtual void readJSON_value(gx_system::JsonParser &jp)
Definition: gx_internal_plugins.cpp:445
gx_engine::ConvolverAdapter
Definition: gx_internal_plugins.h:385
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:2340
gx_preamp_data.cc
gx_engine::CabDesc::ir_sr
int ir_sr
Definition: gx_internal_plugins.cpp:925
UI_LABEL_INVERSE
#define UI_LABEL_INVERSE
Definition: gx_plugin.h:45
gx_system::PrefixConverter::replace_symbol
std::string replace_symbol(const std::string &dir) const
Definition: gx_system.cpp:287
gx_engine::EngineControl::signal_buffersize_change
sigc::signal< void, unsigned int > & signal_buffersize_change()
Definition: gx_modulesequencer.h:278
gx_engine::ParameterV
Definition: gx_parameter.h:93
gx_resample::SimpleResampler::up
void up(int count, float *input, float *output)
Definition: gx_resampler.cpp:78
gx_engine::Parameter
Definition: gx_parameter.h:106
gx_engine::GxJConvSettings::readJSON
void readJSON(gx_system::JsonParser &jp)
Definition: gx_internal_plugins.cpp:340
gx_engine::CabDesc_imp
Definition: gx_internal_plugins.cpp:928
gx_engine::smbPitchShift::plugin
Plugin plugin
Definition: gx_internal_plugins.h:1261
value_pair::value_label
const char * value_label
Definition: gx_plugin.h:119
gx_engine::Drumout::set_plugin
static void set_plugin(Plugin p)
Definition: gx_internal_plugins.cpp:1811
gx_engine::FixedBaseConvolver::buffersize
unsigned int buffersize
Definition: gx_internal_plugins.h:497
UiBuilder::insertSpacer
void(* insertSpacer)()
Definition: gx_plugin.h:78
gx_engine::NoiseGate::NoiseGate
NoiseGate()
Definition: gx_internal_plugins.cpp:44
MAX_FRAME_LENGTH
#define MAX_FRAME_LENGTH
Definition: gx_internal_plugins.h:1193
gx_engine::Drumout::Drumout
Drumout()
Definition: gx_internal_plugins.cpp:1784