Guitarix
gx_paramtable.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  * parameter and midi data
21  *
22  * ----------------------------------------------------------------------------
23  */
24 
25 #ifndef NDEBUG
26 #include <iostream>
27 #endif
28 
29 #include "engine.h" // NOLINT
30 
31 namespace gx_engine {
32 
33 /****************************************************************
34  ** Global Variables
35  */
36 
37 /* Midi */
38 MidiStandardControllers midi_std_ctr; // map ctrl num -> standard name
39 
40 
41 /****************************************************************
42  ** class MidiStandardControllers
43  */
44 
45 static struct midi_std_init {
46  int ctrl;
47  const char *name;
48 } midi_std_itab[] = {
49  { 0, "Bank Select MSB"},
50  { 1, "Modulation MSB"},
51  { 2, "Breath Controller"},
52 
53  { 4, "Foot Controller MSB"},
54  { 5, "Portamento Time MSB"},
55  { 6, "Data Entry MSB"},
56  { 7, "Main Volume"},
57  { 8, "Balance"},
58 
59  {10, "Pan"},
60  {11, "Expression"},
61  {12, "Effect Control 1"},
62  {13, "Effect Control 2"},
63 
64  {22, "Midi Beat Clock"},
65  {23, "Clock start/stop"},
66  {24, "Jack Transport"},
67 
68  {32, "Bank Select LSB"},
69 
70  {64, "Sustain"},
71  {65, "Portamento"},
72  {66, "Sostenuto"},
73  {67, "Soft Pedal"},
74  {68, "Legato Footswitch"},
75  {69, "Hold 2"},
76  {70, "Sound Contr. 1"}, // default: Sound Variation
77  {71, "Sound Contr. 2"}, // default: Timbre/Harmonic Content
78  {72, "Sound Contr. 3"}, // default: Release Time
79  {73, "Sound Contr. 4"}, // default: Attack Time
80  {74, "Sound Contr. 5"}, // default: Brightness
81  {75, "Sound Contr. 6"},
82  {76, "Sound Contr. 7"},
83  {77, "Sound Contr. 8"},
84  {78, "Sound Contr. 9"},
85  {79, "Sound Contr. 10"},
86 
87  {84, "Portamento Control"},
88 
89  {91, "Eff. 1 Depth"},
90  {92, "Eff. 2 Depth"},
91  {93, "Eff. 3 Depth"},
92  {94, "Eff. 4 Depth"},
93  {95, "Eff. 5 Depth"},
94  {96, "Data Inc"},
95  {97, "Data Dec"},
96  {98, "NRPN LSB"},
97  {99, "NRPN MSB"},
98  {100, "RPN LSB"},
99  {101, "RPN MSB"},
100 
101  {120, "All Sounds Off"},
102  {121, "Controller Reset"},
103  {122, "Local Control"},
104  {123, "All Notes Off"},
105  {124, "Omni Off"},
106  {125, "Omni On"},
107  {126, "Mono On (Poly Off)"},
108  {127, "Poly On (Mono Off)"},
109 };
110 
111 string MidiStandardControllers::midi_to_note(int ctr) {
112  static const char* notes[12] = {"C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B" };
113  int octave = (ctr / 12) - 1;
114  ostringstream b;
115  b << octave;
116  string p = b.str().substr(0, 1);
117  int index = (ctr % 12);
118  string note = notes[index];
119  return note + p;
120 }
121 
122 string MidiStandardControllers::ctr_desc(int ctr) {
123  string p = midi_to_note(ctr-200);
124  return "Note On ( " + p + " )";
125  }
126 
128  for (unsigned int i = 0; i < sizeof(midi_std_itab)/sizeof(midi_std_itab[0]); i++) {
129  m.insert(pair<int, modstring>(midi_std_itab[i].ctrl, modstring(midi_std_itab[i].name)));
130  }
131  for (unsigned int i = 0; i < 127; i++) {
132  const int mm = i + 200;
133  m.insert(pair<int, modstring>(mm, modstring(ctr_desc(mm).c_str())));
134  }
135 }
136 
137 void MidiStandardControllers::replace(int ctr, const string& name) {
138  map<int, modstring>::iterator i = m.find(ctr);
139  if (name.empty()) {
140  if (i != m.end()) {
141  if (i->second.modified) {
142  if (i->second.std) {
143  i->second.name = m[ctr].std;
144  m[ctr].modified = false;
145  } else {
146  m.erase(i);
147  }
148  }
149  }
150  } else {
151  if (i == m.end()) {
152  m[ctr] = modstring(name, true, 0);
153  } else {
154  i->second.modified = true;
155  i->second.name = name;
156  }
157  }
158 }
159 
161  jw.begin_object(true);
162  for (map<int, modstring>::const_iterator i = m.begin(); i != m.end(); ++i) {
163  if (i->second.modified) {
164  ostringstream ostr;
165  ostr << i->first;
166  jw.write_kv(ostr.str().c_str(), i->second.name);
167  }
168  }
169  jw.end_object(true);
170 }
171 
174  while (jp.peek() == gx_system::JsonParser::value_key) {
175  jp.next();
176  istringstream istr(jp.current_value());
177  int ctl;
178  istr >> ctl;
179  if (istr.fail()) {
180  throw gx_system::JsonException(_("midi standard controllers: number expected"));
181  }
182  jp.next();
183  replace(ctl, jp.current_value());
184  }
186 }
187 
188 
189 /****************************************************************
190  ** class MidiController
191  */
192 
194  jw.begin_array();
195  jw.write(param->id());
196  if (param->getControlType() == Parameter::Continuous ||
197  param->getControlType() == Parameter::Enum) {
198  jw.write(_lower);
199  jw.write(_upper);
200  } else {
201  assert(param->getControlType() == Parameter::Switch);
202  jw.write(toggle);
203  jw.write(_toggle_behaviour);
204  }
205  jw.end_array();
206 }
207 
211  string id = jp.current_value();
212  if (!pmap.hasId(id)) {
213  gx_print_warning(_("Midi controller settings"),
214  _("unknown parameter: ") + id);
215  while (jp.next() != gx_system::JsonParser::end_array);
216  return 0;
217  }
218  Parameter& pm = pmap[id];
219  float lower = 0, upper = 0;
220  bool toggle = false;
221  int toggle_behaviour = 0;
222  bool bad = false;
223  bool chg = false;
229  // two numbers -> range
230  float pmin, pmax;
231  if (pm.hasRange()) {
232  pmin = pm.getLowerAsFloat();
233  pmax = pm.getUpperAsFloat();
234  } else {
235  bad = true;
236  pmin = pmax = 0;
237  }
238  lower = jp.current_value_float();
240  upper = jp.current_value_float();
241  if (lower > pmax) {
242  lower = pmax;
243  chg = true;
244  } else if (lower < pmin) {
245  lower = pmin;
246  chg = true;
247  }
248  if (upper > pmax) {
249  upper = pmax;
250  chg = true;
251  } else if (upper < pmin) {
252  upper = pmin;
253  chg = true;
254  }
255  } else {
256  // just one number -> switch (new format)
257  bad = true;
258  }
259  } else {
260  // no number -> switch (old format)
261  bad = true;
262  }
263  } else if (pm.getControlType() == Parameter::Switch) {
266  int _toggle = jp.current_value_int();
269  if (jp.current_value_int() < Parameter::toggle_type::_Count) {
270  toggle = _toggle;
272  } else {
273  // two numbers -> range
274  bad = true;
275  }
276  } else {
277  toggle = _toggle;
278  }
279  }
280  } else {
281  // bad control type
282  bad = true;
283  }
284  assert(jp.peek() == gx_system::JsonParser::end_array);
285  while (jp.next() != gx_system::JsonParser::end_array); // be tolerant (non-debug mode)
286  if (bad) {
288  _("recall MIDI state"),
289  _("invalid format, Parameter skipped: ") + id);
290  return 0;
291  }
292  if (chg) {
294  _("recall MIDI state"),
295  _("Parameter range outside bounds, changed: ") + id);
296  }
297  return new MidiController(pm, lower, upper, toggle, toggle_behaviour);
298 }
299 
300 bool MidiController::set_midi(int n, int last_value, bool update) {
301  bool ret = false;
302  if (param->get_midi_blocked()) return ret;
303  if (toggle) {
304  switch (_toggle_behaviour) {
305  case Parameter::toggle_type::OnOff: {
306  bool s_o = (2*last_value > 127);
307  bool s_n = (2*n > 127);
308  if (!s_o && s_n) {
309  if (param->on_off_value()) {
310  ret = param->midi_set(0, 127, _lower, _upper);
311  } else {
312  ret = param->midi_set(127, 127, _lower, _upper);
313  }
314  }
315  break;
316  }
317  case Parameter::toggle_type::Constant: {
318  if (n == last_value || last_value == -1) {
319  if (param->on_off_value()) {
320  if (!update) ret = param->midi_set(0, n, _lower, _upper);
321  else ret = param->midi_set(127, n, _lower, _upper);
322  } else {
323  if (!update) ret = param->midi_set(127, n, _lower, _upper);
324  else ret = param->midi_set(0, n, _lower, _upper);
325  }
326  }
327  break;
328  }
329  }
330  } else {
331  //fprintf(stderr,"continues %s \n",param->id().c_str());
332  //fprintf(stderr,"%f \n",(127.*log10f(double(n+1.)))/2.1072);
333  //fprintf(stderr,"%f \n",double(n * double(double(n+1.)/128)));
334  ret = param->midi_set(n, 127, _lower, _upper);
335  param->trigger_changed();
336  }
337  //param->trigger_changed();
338  return ret;
339 }
340 
341 bool MidiController::set_trans(int n, int last_value) {
342  bool ret = false;
343  if (param->get_blocked()) return ret;
344  if (strcmp(param->id().c_str(), "engine.mute")==0) {
345  if ( n == 0) n = 127;
346  else n = 0;
347  }
348  ret = param->midi_set(n, 127, _lower, _upper);
349  return ret;
350 }
351 
352 bool MidiController::set_bpm(int n, int last_value) {
353  bool ret = false;
354  if (param->get_blocked()) return ret;
355  if (toggle) {
356  bool s_o = (2*last_value > 360);
357  bool s_n = (2*n > 360);
358  if (!s_o && s_n) {
359  if (param->on_off_value()) {
360  ret = param->midi_set_bpm(0, 360, _lower, _upper);
361  } else {
362  ret = param->midi_set_bpm(360, 360, _lower, _upper);
363  }
364  }
365  } else {
366  ret = param->midi_set_bpm(n, 360, _lower, _upper);
367  }
368  return ret;
369 }
370 
371 /****************************************************************
372  ** class ControllerArray
373  */
374 
376  for (unsigned int n = 0; n < array_size; n++) {
377  operator[](n).clear();
378  }
380  while (jp.peek() != gx_system::JsonParser::end_array) {
382  midi_controller_list& l = operator[](jp.current_value_int());
384  while (jp.peek() != gx_system::JsonParser::end_array) {
386  if (p) {
387  l.push_back(*p);
388  delete p;
389  }
390  }
392  }
394 }
395 
397  w.begin_array(true);
398  for (unsigned int n = 0; n < array_size; n++) {
399  const midi_controller_list& cl = operator[](n);
400  if (cl.empty())
401  continue;
402  w.write(n);
403  w.begin_array();
404  for (midi_controller_list::const_iterator i = cl.begin(); i != cl.end(); ++i)
405  i->writeJSON(w);
406  w.end_array(true);
407  }
408  w.newline();
409  w.end_array(true);
410 }
411 
413  for (ControllerArray::size_type n = 0; n < size(); ++n) {
414  const midi_controller_list& cl = operator[](n);
415  for (midi_controller_list::const_iterator i = cl.begin(); i != cl.end(); ++i) {
416  if (i->hasParameter(param)) {
417  if (p) {
418  *p = &(*i);
419  }
420  return n;
421  }
422  }
423  }
424  return -1;
425 }
426 
428  for (iterator pctr = begin(); pctr != end(); ++pctr) {
429  for (midi_controller_list::iterator i = pctr->begin(); i != pctr->end(); ++i) {
430  if (i->hasParameter(p)) {
431  pctr->erase(i);
432  return true;
433  }
434  }
435  }
436  return false;
437 }
438 
439 
440 /****************************************************************
441  ** class MidiClockToBpm
442  */
443 
444 
446  : time1(0),
447  time_diff(0),
448  collect(0),
449  collect_(0),
450  bpm(0),
451  bpm_new(0),
452  ret(false) {}
453 
454 unsigned int MidiClockToBpm::rounded(float f) {
455  if (f >= 0x1.0p23) return (unsigned int) f;
456  return (unsigned int) (f + 0.49999997f);
457 }
458 
459 bool MidiClockToBpm::time_to_bpm(double time, unsigned int* bpm_) {
460  ret = false;
461  // if time drift to far, reset bpm detection.
462  if ((time-time1)> (1.05*time_diff) || (time-time1)*1.05 < (time_diff)) {
463  bpm = 0;
464  collect = 0;
465  collect_ = 0;
466  } else {
467  bpm_new = ((1000000000. / (time-time1) / 24) * 60);
468  bpm += bpm_new;
469  collect++;
470 
471  if (collect >= (bpm_new*bpm_new*0.0002)+1) {
472  bpm = (bpm/collect);
473  if (collect_>=2) {
474  (*bpm_) = rounded(min(360.,max(24.,bpm)));
475  collect_ = 0;
476  ret = true;
477  }
478  collect_++;
479  collect = 1;
480  }
481  }
482  time_diff = time-time1;
483  time1 = time;
484  return ret;
485 }
486 
487 /****************************************************************
488  ** class MidiControllerList
489  */
490 
492  : map(),
493  last_midi_control_value(),
494  last_midi_control(-2),
495  changed_midi_control_value(),
496  program_change(-1),
497  mute_change(-1),
498  bank_change(-1),
499  time0(0),
500  bpm_(9),
501  mp(),
502  pgm_chg(),
503  mute_chg(),
504  bank_chg(),
505  val_chg(),
506  changed(),
507  new_program(),
508  new_mute_state(),
509  new_bank(),
510  midi_value_changed() {
511  for (int i = 0; i < ControllerArray::array_size; ++i) {
512  last_midi_control_value[i] = -1;
513  changed_midi_control_value[i] = 0;
514  }
515  pgm_chg.connect(sigc::mem_fun(*this, &MidiControllerList::on_pgm_chg));
516  mute_chg.connect(sigc::mem_fun(*this, &MidiControllerList::on_mute_chg));
517  bank_chg.connect(sigc::mem_fun(*this, &MidiControllerList::on_bank_chg));
518  val_chg.connect(sigc::mem_fun(*this, &MidiControllerList::on_val_chg));
519  // Glib::signal_timeout().connect(
520  // sigc::mem_fun(this, &MidiControllerList::check_midi_values), 60);
521 }
522 
523 bool MidiControllerList::check_midi_values() {
524  static int saved_values[ControllerArray::array_size];
525  for (unsigned int n = 0; n < ControllerArray::array_size; ++n) {
526  if (changed_midi_control_value[n]) {
527  changed_midi_control_value[n] = 0;
528  saved_values[n] = last_midi_control_value[n];
529  midi_value_changed(n, saved_values[n]);
530  if (!get_config_mode()) {
531  midi_controller_list& ctr_list = map[n];
532  for (midi_controller_list::iterator i = ctr_list.begin(); i != ctr_list.end(); ++i) {
533  if (i->is_toggle()
534  && i->toggle_behaviour() == Parameter::toggle_type::Constant) {
535  midi_value_changed(n, i->getParameter().on_off_value() * 127);
536  }
537  i->trigger_changed();
538  }
539  }
540  }
541  }
542  return true;
543 }
544 
545 void MidiControllerList::on_val_chg() {
546  static int saved_values[ControllerArray::array_size];
547  for (unsigned int n = 0; n < ControllerArray::array_size; ++n) {
548  if (changed_midi_control_value[n]) {
549  changed_midi_control_value[n] = 0;
550  saved_values[n] = last_midi_control_value[n];
551  midi_value_changed(n, saved_values[n]);
552  if (!get_config_mode()) {
553  midi_controller_list& ctr_list = map[n];
554  for (midi_controller_list::iterator i = ctr_list.begin(); i != ctr_list.end(); ++i) {
555  if (i->is_toggle()
556  && i->toggle_behaviour() == Parameter::toggle_type::Constant) {
557  midi_value_changed(n, i->getParameter().on_off_value() * 127);
558  }
559  i->trigger_changed();
560  }
561  }
562  }
563  }
564 }
565 
568  int v = get_last_midi_control_value(ctr);
569  if (v >= 0) {
570  midi_controller_list& cl = map[ctr];
571  for (midi_controller_list::iterator i = cl.begin(); i != cl.end(); ++i) {
572  i->set_midi(v, v, true);
573  }
574  }
575 }
576 
578  for (unsigned int n = 0; n < map.size(); n++) {
580  }
581 }
582 
583 void MidiControllerList::on_pgm_chg() {
584  int pgm;
585  do {
586  pgm = gx_system::atomic_get(program_change);
587  } while (!gx_system::atomic_compare_and_exchange(&program_change, pgm, -1));
588  if (pgm>=0) new_program(pgm);
589 }
590 
591 void MidiControllerList::on_mute_chg() {
592  int mute;
593  do {
594  mute = gx_system::atomic_get(mute_change);
595  } while (!gx_system::atomic_compare_and_exchange(&mute_change, mute, -1));
596  new_mute_state(mute);
597 }
598 
599 void MidiControllerList::on_bank_chg() {
600  int bk;
601  do {
602  bk = gx_system::atomic_get(bank_change);
603  } while (!gx_system::atomic_compare_and_exchange(&bank_change, bk, -1));
604  if (bk>=0) new_bank(bk);
605 }
606 
607 void MidiControllerList::set_config_mode(bool mode, int ctl) {
608  assert(mode != get_config_mode());
609  if (mode) {
610  last_midi_control = ctl;
611  } else {
612  last_midi_control = -2;
613  }
614 }
615 
617  bool mode = get_config_mode();
618  if (!mode) {
619  set_config_mode(true); // keep rt thread away from table
620  }
621  if (map.deleteParameter(p)) {
622  changed();
623  }
624  if (!mode) {
625  set_config_mode(false);
626  }
627 }
628 
630  float lower, float upper, bool toggle, int toggle_behaviour) {
631  if (!get_config_mode()) {
632  assert(false);
633  return; // keep rt thread away from table
634  }
635  // maximal one controller for a zone allowed
636  deleteParameter(param);
637  if (last_midi_control < 0)
638  return;
639  // add zone to controller
640  map[last_midi_control].push_front(MidiController(param, lower, upper, toggle, toggle_behaviour));
641  update_from_controller(last_midi_control);
642  changed();
643 }
644 
646  for (unsigned int n = 0; n < ControllerArray::array_size; ++n) {
647  int v = last_midi_control_value[n];
648  midi_controller_list& ctr_list = map[n];
649  for (midi_controller_list::iterator i = ctr_list.begin(); i != ctr_list.end(); ++i) {
650  if (i->is_toggle()) {
651  v = i->getParameter().on_off_value() * 127;
652  }
653  midi_value_changed(n, v);
654  }
655  }
656 }
657 
658 void MidiControllerList::set_ctr_val(int ctr, int val) {
659  if (get_config_mode()) {
660  last_midi_control = ctr;
661  } else {
662  midi_controller_list& ctr_list = map[ctr];
663  for (midi_controller_list::iterator i = ctr_list.begin(); i != ctr_list.end(); ++i) {
664  i->set_midi(val, get_last_midi_control_value(ctr), false);
665  }
666  }
668 }
669 
670 void MidiControllerList::set_bpm_val(unsigned int val) {
671  if (get_config_mode()) {
672  last_midi_control = 22;
673  } else {
674  midi_controller_list& ctr_list = map[22];
675  for (midi_controller_list::iterator i = ctr_list.begin(); i != ctr_list.end(); ++i) {
676  i->set_bpm(val, get_last_midi_control_value(22));
677  }
678  }
680 }
681 
683  bool mode = get_config_mode();
684  if (!mode) {
685  set_config_mode(true); // keep rt thread away from table
686  }
687  map = m;
688  if (!mode) {
689  set_config_mode(false);
690  }
691  changed();
692 }
693 
695  const ControllerArray *new_m) {
696  std::set<Parameter*> pset;
697  for (unsigned int i = 0; i < map.size(); i++) {
698  midi_controller_list& ctr = map[i];
699  for (midi_controller_list::iterator j = ctr.begin(); j != ctr.end(); ++j) {
700  if (new_m) {
701  const midi_controller_list& ctr_new = (*new_m)[i];
702  for (midi_controller_list::const_iterator jn = ctr_new.begin();
703  jn != ctr_new.end(); ++jn) {
704  if (j->getParameter() == jn->getParameter()) {
705  pset.insert(&j->getParameter());
706  break;
707  }
708  }
709  } else {
710  pset.insert(&j->getParameter());
711  }
712  }
713  }
714  for (paramlist::iterator n = plist.begin(); n != plist.end(); ) {
715  paramlist::iterator n1 = n++;
716  if (pset.find(*n1) != pset.end()) {
717  plist.erase(n1);
718  }
719  }
720 }
721 
723  channel_select = s;
724 }
725 
726 void MidiControllerList::process_trans(int transport_state) {
727  unsigned int val = 0;
728  switch (transport_state) {
729  case JackTransportStopped:
730  val = 0;
731  break;
732  case JackTransportRolling:
733  val = 127;
734  break;
735  case JackTransportStarting:
736  val = 127;
737  break;
738  default:
739  return;
740  }
741  if (get_config_mode()) {
742  last_midi_control = 24;
743  } else {
744  midi_controller_list& ctr_list = map[24];
745  for (midi_controller_list::iterator i = ctr_list.begin(); i != ctr_list.end(); ++i) {
746  i->set_trans(val, get_last_midi_control_value(24));
747  }
748  }
750  val_chg();
751 }
752 
753 // ----- jack process callback for the midi input
754 void MidiControllerList::compute_midi_in(void* midi_input_port_buf, void *arg) {
755  jack_midi_event_t in_event;
756  jack_nframes_t event_count = jack_midi_get_event_count(midi_input_port_buf);
757  unsigned int i;
758  for (i = 0; i < event_count; i++) {
759  jack_midi_event_get(&in_event, midi_input_port_buf, i);
760  bool ch = true;
761  if (channel_select>0) {
762  if ((channel_select) != (int(in_event.buffer[0]&0x0f)+1)) {
763  ch = false;
764  }
765  }
766  if ((in_event.buffer[0] & 0xf0) == 0xc0 && ch) { // program change on any midi channel
767  gx_system::atomic_set(&program_change, in_event.buffer[1]);
768  pgm_chg();
769  } else if ((in_event.buffer[0] & 0xf0) == 0xb0 && ch) { // controller
770  if (in_event.buffer[1]== 120) { // engine mute by All Sound Off on any midi channel
771  gx_system::atomic_set(&mute_change, in_event.buffer[2]);
772  mute_chg();
773  } else if (in_event.buffer[1]== 32 && ch) { // bank change on any midi channel
774  gx_system::atomic_set(&bank_change, in_event.buffer[2]);
775  bank_chg();
776  } else {
777  set_ctr_val(in_event.buffer[1], in_event.buffer[2]);
778  val_chg();
779  }
780  } else if ((in_event.buffer[0] & 0xf0) == 0x90 && ch) { // Note On
781  set_ctr_val(in_event.buffer[1]+200, 1);
782  val_chg();
783  //fprintf(stderr,"Note On %i", (int)in_event.buffer[1]);
784  } else if ((in_event.buffer[0] ) > 0xf0) { // midi clock
785  if ((in_event.buffer[0] ) == 0xf8) { // midi beat clock
786  clock_gettime(CLOCK_MONOTONIC, &ts1);
787  gx_jack::GxJack& jack = *static_cast<gx_jack::GxJack*>(arg);
788  static unsigned int sr = jack.get_jack_sr();
789  time0 = (ts1.tv_sec*1000000000.0)+(ts1.tv_nsec)+
790  (1000000000.0/(double)(sr/(double)in_event.time));
791  if (mp.time_to_bpm(time0, &bpm_)) {
792  set_bpm_val(bpm_);
793  val_chg();
794  }
795  } else if ((in_event.buffer[0] ) == 0xfa) { // midi clock start
796  set_ctr_val(23, 127);
797  val_chg();
798  } else if ((in_event.buffer[0] ) == 0xfb) { // midi clock continue
799  // set_ctr_val(23, 127);
800  } else if ((in_event.buffer[0] ) == 0xfc) { // midi clock stop
801  set_ctr_val(23, 0);
802  val_chg();
803  } else if ((in_event.buffer[0] ) == 0xf2) { // midi clock position
804  // not implemented
805  // set_ctr_val(24,(in_event.buffer[2]<<7) | in_event.buffer[1]);
806  }
807  }
808  }
809 }
810 
811 /****************************************************************
812  ** Parameter Groups
813  */
814 
816  insert("system", N_("System"));
817  insert("ui", N_("User Interface"));
818  insert("ui.amp", N_("User Interface")); // FIXME (ui.amp.tonestack)
819  insert("engine", N_("Audio Engine"));
820 }
821 
823 #ifndef NDEBUG
824  for (map<string, bool>::iterator i = used.begin(); i != used.end(); ++i) {
825  if (!i->second) {
826  gx_print_error("Debug Check", "Group not used: " + i->first);
827  }
828  }
829 #endif
830 }
831 
832 #ifndef NDEBUG
833 void ParameterGroups::group_exists(const string& id) {
834  if (groups.find(id) == groups.end()) {
835  gx_print_error("Debug Check", "Group does not exist: " + id);
836  } else {
837  used[id] = true;
838  }
839 }
840 
841 void ParameterGroups::group_is_new(const string& id) {
842  if (groups.find(id) != groups.end()) {
843  gx_print_error("Debug Check", "Group already exists: " + id);
844  }
845 }
846 
848  for (map<string, string>::iterator i = groups.begin(); i != groups.end(); ++i) {
849  printf("PG %s: %s\n", i->first.c_str(), i->second.c_str());
850  }
851 }
852 
853 #endif
854 
856  static ParameterGroups groups;
857  return groups;
858 }
859 
860 string param_group(const string& group_id, bool nowarn) {
861  static ParameterGroups& groups = get_group_table();
862  if (nowarn) {
863  return groups.get(group_id);
864  } else {
865  return groups[group_id];
866  }
867 }
868 
869 bool ParameterGroups::group_exist(const string& id) {
870  if (groups.find(id) == groups.end()) {
871  return false;
872  } else {
873  return true;
874  }
875 }
876 
877 /****************************************************************
878  ** Parameter
879  */
880 
884  assert(jp.current_value() == key);
885  return jp;
886 }
887 
889  jw.begin_object();
890  jw.write_kv("id", _id);
891  jw.write_kv("name", _name);
892  jw.write_kv("group", _group);
893  jw.write_kv("desc", _desc);
894  jw.write_kv("v_type", v_type); //FIXME
895  jw.write_kv("c_type", c_type); //FIXME
896  jw.write_kv("d_flags", d_flags); //FIXME
897  if (!controllable) {
898  jw.write_key("non_controllable"); jw.write(false);
899  }
900  if (!save_in_preset) {
901  jw.write_key("non_preset"); jw.write(false);
902  }
903  jw.end_object();
904 }
905 
907  : boost::noncopyable(),
908  _id(),
909  _name(),
910  _group(),
911  _desc(),
912  v_type(tp_float),
913  c_type(Continuous),
914  d_flags(0),
915  save_in_preset(true),
916  controllable(true),
917  do_not_save(false),
918  blocked(false),
919  used(false) {
921  while (jp.peek() != gx_system::JsonParser::end_object) {
923  if (jp.read_kv("id", _id) ||
924  jp.read_kv("name", _name) ||
925  jp.read_kv("group", _group) ||
926  jp.read_kv("desc", _desc)) {
927  } else if (jp.current_value() == "v_type") {
929  v_type = static_cast<value_type>(jp.current_value_int());
930  } else if (jp.current_value() == "c_type") {
932  c_type = static_cast<ctrl_type>(jp.current_value_int());
933  } else if (jp.current_value() == "d_flags") {
935  d_flags = jp.current_value_int();
936  } else if (jp.current_value() == "non_controllable") {
938  controllable = false;
939  } else if (jp.current_value() == "non_preset") {
941  save_in_preset = false;
942  } else {
944  "Parameter", Glib::ustring::compose("%1: unknown key: %2", _id, jp.current_value()));
945  jp.skip_object();
946  }
947  }
949 }
950 
952 }
953 
954 bool Parameter::midi_set(float n, float high, float llimit, float ulimit) {
955  assert(false);
956  return false;
957 }
958 
959 bool Parameter::midi_set_bpm(float n, float high, float llimit, float ulimit) {
960  assert(false);
961  return false;
962 }
963 
964 void Parameter::trigger_changed() {
965  assert(false);
966 }
967 
968 static int get_upper(const value_pair *vn) {
969  for (int n = 0; ; n++) {
970  if (!vn[n].value_id) {
971  return n - 1;
972  }
973  }
974 }
975 
976 void Parameter::range_warning(float value, float lower, float upper) {
978  _("parameter load"),
979  Glib::ustring::compose(_("parameter %1: value %2 out of range [%3, %4]"),
980  _id, value, lower, upper));
981 }
982 
983 const char *Parameter::get_typename() const {
984  static const char *tpname[] = {
985  "float", "int", "bool", "bool", "filename", "string", "special"};
986  assert(0 <= v_type and v_type < sizeof(tpname)/sizeof(tpname[0]));
987  return tpname[v_type];
988 }
989 
990 bool Parameter::hasRange() const {
991  return false;
992 }
993 
995  return 1;
996 }
997 
999  return 0;
1000 }
1001 
1003  return 0;
1004 }
1005 
1007  return 0;
1008 }
1009 
1010 #ifndef NDEBUG
1011 void compare_parameter(const char *title, Parameter* p1, Parameter* p2, bool all) {
1012  if (p1->_id != p2->_id) {
1014  title, Glib::ustring::compose("Different ID's: %2 / %3",
1015  p1->_id, p2->_id));
1016  }
1017  if (p1->_name != p2->_name) {
1019  title, Glib::ustring::compose("[%1]: Different name: %2 / %3",
1020  p1->_id, p1->_name, p2->_name));
1021  }
1022  if (p1->_group != p2->_group) {
1024  title, Glib::ustring::compose("[%1]: Different group: %2 / %3",
1025  p1->_id, p1->_group, p2->_group));
1026  }
1027  if (p1->_desc != p2->_desc) {
1029  title, Glib::ustring::compose("[%1]: Different desc: %2 / %3",
1030  p1->_id, p1->_desc, p2->_desc));
1031  }
1032  if (p1->save_in_preset != p2->save_in_preset) {
1034  title, Glib::ustring::compose("[%1]: save_in_preset different: %2 / %3",
1035  p1->_id, p1->save_in_preset, p2->save_in_preset));
1036  }
1037  if (p1->controllable != p2->controllable) {
1039  title, Glib::ustring::compose("[%1]: controllable different: %2 / %3",
1040  p1->_id, p1->controllable, p2->controllable));
1041  }
1042  if (p1->used != p2->used) {
1044  title, Glib::ustring::compose("[%1]: used different: %2 / %3",
1045  p1->_id, p1->used, p2->used));
1046  }
1047  if (p1->c_type != p2->c_type) {
1049  title, Glib::ustring::compose("[%1]: c_type different: %2 / %3",
1050  p1->_id, p1->c_type, p2->c_type));
1051  }
1052  if (p1->v_type != p2->v_type) {
1054  title, Glib::ustring::compose("[%1]: v_type different: %2 / %3",
1055  p1->_id, p1->v_type, p2->v_type));
1056  return;
1057  }
1058  if (p1->isFloat()) {
1059  FloatParameter& f1 = p1->getFloat();
1060  FloatParameter& f2 = p2->getFloat();
1061  if (f1.value != f2.value) {
1063  title, Glib::ustring::compose("[%1]: value address different: %2 / %3",
1064  p1->_id, f1.value, f2.value));
1065  }
1066  if (f1.lower != f2.lower) {
1068 
1069  title, Glib::ustring::compose("[%1]: float lower different: %2 / %3",
1070  p1->_id, f1.lower, f2.lower));
1071  }
1072  if (f1.upper != f2.upper) {
1074  title, Glib::ustring::compose("[%1]: float upper different: %2 / %3",
1075  p1->_id, f1.upper, f2.upper));
1076  }
1077  if (f1.step != f2.step) {
1079  title, Glib::ustring::compose("[%1]: float step different: %2 / %3",
1080  p1->_id, f1.step, f2.step));
1081  }
1082  if (f1.std_value != f2.std_value) {
1084  title, Glib::ustring::compose("[%1]: float std value different: %2 / %3",
1085  p1->_id, f1.std_value, f2.std_value));
1086  }
1087  if (all) {
1088  if (f1.value != f2.value) {
1090  title, Glib::ustring::compose("[%1]: float value different: %2 / %3",
1091  p1->_id, *f1.value, *f2.value));
1092  }
1093  if (f1.json_value != f2.json_value) {
1095  title, Glib::ustring::compose("[%1]: float json value different: %2 / %3",
1096  p1->_id, f1.json_value, f2.json_value));
1097  }
1098  }
1099  return;
1100  }
1101  if (p1->isInt()) {
1102  assert(false);
1103  return;
1104  }
1105  if (p1->isBool()) {
1106  assert(false);
1107  return;
1108  }
1109  if (p1->isFile()) {
1110  assert(false);
1111  return;
1112  }
1113  assert(false);
1114 }
1115 #endif
1116 
1117 /* FloatParameter */
1118 
1120  jw.begin_object();
1121  jw.write_key("Parameter"); Parameter::serializeJSON(jw);
1122  jw.write_kv("lower", lower);
1123  jw.write_kv("upper", upper);
1124  jw.write_kv("step", step);
1125  jw.write_kv("value", *value);
1126  jw.write_kv("std_value", std_value);
1127  jw.end_object();
1128 }
1129 
1131  : Parameter(jp_next(jp, "Parameter")), json_value(0), value(&value_storage), std_value(0), lower(), upper(), step() {
1132  while (jp.peek() != gx_system::JsonParser::end_object) {
1134  if (jp.read_kv("lower", lower) ||
1135  jp.read_kv("upper", upper) ||
1136  jp.read_kv("step", step) ||
1137  jp.read_kv("value", *value) ||
1138  jp.read_kv("std_value", std_value)) {
1139  } else {
1141  "FloatParameter", Glib::ustring::compose("%1: unknown key: %2", _id, jp.current_value()));
1142  jp.skip_object();
1143  }
1144  }
1146 }
1147 
1149 }
1150 
1151 bool FloatParameter::set(float val) const {
1152  float v = min(max(val, lower), upper);
1153  if (v != *value) {
1154  *value = v;
1155  changed(v);
1156  return true;
1157  }
1158  return false;
1159 }
1160 
1162  return *value != 0;
1163 }
1164 
1165 float FloatParameter::idx_from_id(string v_id) {
1166  assert(false);
1167  return 0;
1168 }
1169 
1170 bool FloatParameter::midi_set(float n, float high, float llimit, float ulimit) {
1171  float v;
1172  switch (c_type) {
1173  case Continuous:
1174  assert(n >= 0 && n <= high);
1175  v = llimit + (n / high) * (ulimit - llimit);
1176  break;
1177  case Switch:
1178  v = (2*n > high ? 1.0 : 0.0);
1179  break;
1180  case Enum:
1181  v = lower + min(n, upper-lower);
1182  break;
1183  default:
1184  assert(false);
1185  return false;
1186  }
1187  if (v != *value) {
1188  *value = v;
1189  return true;
1190  }
1191  return false;
1192 }
1193 
1194 bool FloatParameter::midi_set_bpm(float n, float high, float llimit, float ulimit) {
1195  float v;
1196  switch (c_type) {
1197  case Continuous:
1198  assert(n >= 0 && n <= high);
1199  if (high <= ulimit) {
1200  v = max(llimit,min(ulimit,n));
1201  } else {
1202  v = llimit + (n / high) * (ulimit - llimit);
1203  }
1204  break;
1205  case Switch:
1206  v = (2*n > high ? 1.0 : 0.0);
1207  break;
1208  case Enum:
1209  v = lower + min(n, upper-lower);
1210  break;
1211  default:
1212  assert(false);
1213  return false;
1214  }
1215  if (v != *value) {
1216  *value = v;
1217  return true;
1218  }
1219  return false;
1220 }
1221 
1222 void FloatParameter::trigger_changed() {
1223  changed(*value);
1224 }
1225 
1227  json_value = std_value;
1228 }
1229 
1231  jw.write_kv(_id.c_str(), *value);
1232 }
1233 
1235  if (std::abs(json_value - val) < 10*FLT_EPSILON || std::abs(json_value )> std::abs(val)) {
1236  json_value = val;
1237  setJSON_value();
1238  return false;
1239  } else if (val<=std_value) {
1240  json_value = val;
1241  setJSON_value();
1242  return false;
1243  }
1244  float v = val * 0.1;
1245  json_value += v;
1246  setJSON_value();
1247  //fprintf(stderr, "set value %f of %f\n",json_value, val);
1248  return true;
1249 }
1250 
1253  json_value = std_value;
1254  Glib::signal_timeout().connect(sigc::bind<float>(
1255  sigc::mem_fun (*this, &FloatParameter::ramp_value),jp.current_value_float()), 10);
1256 }
1257 
1260  json_value = jp.current_value_float();
1261  if (json_value < lower-std::abs(5*FLT_EPSILON*lower) || json_value > upper+std::abs(5*FLT_EPSILON*upper)) {
1262  range_warning(json_value, lower, upper);
1263  json_value = std_value;
1264  }
1265 }
1266 
1268  return std::abs(json_value - *value) < 5*FLT_EPSILON;
1269 }
1270 
1272  set(json_value);
1273 }
1274 
1275 void FloatParameter::convert_from_range(float low, float up) {
1276  json_value = lower + (json_value - low) / (up - low) * (upper - lower);
1277 }
1278 
1280  return true;
1281 }
1282 
1284  return lower;
1285 }
1286 
1288  return upper;
1289 }
1290 
1292  return step;
1293 }
1294 
1295 
1296 /* FloatEnumParameter */
1297 
1298 static void serializeValueNames(gx_system::JsonWriter& jw, const value_pair *p) {
1299  jw.write_key("value_names");
1300  jw.begin_array();
1301  while (p->value_id) {
1302  jw.write(p->value_id);
1303  if (p->value_label) {
1304  jw.write(p->value_label);
1305  } else {
1306  jw.write(p->value_id);
1307  }
1308  p++;
1309  }
1310  jw.end_array();
1311 }
1312 
1314  jw.begin_object();
1315  jw.write_key("FloatParameter"); FloatParameter::serializeJSON(jw);
1316  serializeValueNames(jw, value_names);
1317  jw.end_object();
1318 }
1319 
1320 FloatEnumParameter::FloatEnumParameter(const string& id, const string& name, const value_pair* vn, bool preset,
1321  float *v, int sv, int low, bool ctrl, bool no_init):
1322  FloatParameter(id, name, Enum, preset, v, sv, low, low+get_upper(vn), 1, ctrl, no_init),
1323  value_names(vn) {}
1324 
1326  return value_names;
1327 }
1328 
1330  jw.write_key(_id.c_str());
1331  jw.write(value_names[static_cast<int>(round(*value-lower))].value_id);
1332 }
1333 
1335  int up = static_cast<int>(round(upper));
1336  int low = static_cast<int>(round(lower));
1337  int n = 0;
1338  for (; n <= up-low; n++) {
1339  if (v_id == value_names[n].value_id) {
1340  return low + n;
1341  }
1342  }
1343  return -1;
1344 }
1345 
1349  // old version compatability
1351  return;
1352  }
1354  float n = idx_from_id(jp.current_value());
1355  if (n < 0) {
1357  _("read parameter"), (boost::format(_("parameter %1%: unknown enum value: %2%"))
1358  % _id % jp.current_value()).str());
1359  n = lower;
1360  }
1361  json_value = n;
1362 }
1363 
1364 /* IntParameter */
1365 
1367  jw.begin_object();
1368  jw.write_key("Parameter"); Parameter::serializeJSON(jw);
1369  jw.write_kv("lower", lower);
1370  jw.write_kv("upper", upper);
1371  jw.write_kv("value", *value);
1372  jw.write_kv("std_value", std_value);
1373  jw.end_object();
1374 }
1375 
1377  : Parameter(jp_next(jp, "Parameter")), json_value(0), value(&value_storage), std_value(0), lower(), upper() {
1378  while (jp.peek() != gx_system::JsonParser::end_object) {
1380  if (jp.read_kv("lower", lower) ||
1381  jp.read_kv("upper", upper) ||
1382  jp.read_kv("value", *value) ||
1383  jp.read_kv("std_value", std_value)) {
1384  } else {
1386  "IntParameter", Glib::ustring::compose("%1: unknown key: %2", _id, jp.current_value()));
1387  jp.skip_object();
1388  }
1389  }
1391 }
1392 
1394 }
1395 
1396 bool IntParameter::set(int val) const {
1397  int v = min(max(val, lower), upper);
1398  if (v != *value) {
1399  *value = v;
1400  changed(v);
1401  return true;
1402  }
1403  return false;
1404 }
1405 
1406 int IntParameter::idx_from_id(string v_id) {
1407  assert(false);
1408  return 0;
1409 }
1410 
1412  return *value != 0;
1413 }
1414 
1415 bool IntParameter::midi_set(float n, float high, float llimit, float ulimit) {
1416  int v;
1417  switch (c_type) {
1418  case Continuous:
1419  assert(false); // not implemented
1420  return false;
1421  case Switch:
1422  assert(false); // not implemented
1423  return false;
1424  case Enum:
1425  v = lower + min(static_cast<int>(n), upper-lower);
1426  break;
1427  default:
1428  assert(false);
1429  return false;
1430  }
1431  if (v != *value) {
1432  *value = v;
1433  return true;
1434  }
1435  return false;
1436 }
1437 
1438 void IntParameter::trigger_changed() {
1439  changed(*value);
1440 }
1441 
1443  json_value = std_value;
1444 }
1445 
1447  jw.write_kv(_id.c_str(), *value);
1448 }
1449 
1452  json_value = jp.current_value_int();
1453  if (json_value < lower || json_value > upper) {
1454  range_warning(json_value, lower, upper);
1455  }
1456 }
1457 
1459  return json_value == *value;
1460 }
1461 
1463  set(json_value);
1464 }
1465 
1467  return true;
1468 }
1469 
1471  return lower;
1472 }
1473 
1475  return upper;
1476 }
1477 
1478 /* EnumParameter */
1479 
1481  jw.begin_object();
1482  jw.write_key("IntParameter"); IntParameter::serializeJSON(jw);
1483  serializeValueNames(jw, value_names);
1484  jw.end_object();
1485 }
1486 
1487 EnumParameter::EnumParameter(const string& id, const string& name, const value_pair* vn, bool preset,
1488  int *v, int sv, bool ctrl):
1489  IntParameter(id, name, Enum, preset, v, sv, 0, get_upper(vn), ctrl),
1490  value_names(vn) {}
1491 
1493  return value_names;
1494 }
1495 
1496 int EnumParameter::idx_from_id(string v_id) {
1497  int n = 0;
1498  for (; n <= upper; n++) {
1499  if (v_id == value_names[n].value_id) {
1500  return n;
1501  }
1502  }
1503  return -1;
1504 }
1505 
1507  jw.write_key(_id.c_str());
1508  jw.write(value_names[*value].value_id);
1509 }
1510 
1514  // old version compatability
1516  return;
1517  }
1519  int n = idx_from_id(jp.current_value());
1520  if (n < 0) {
1522  _("read parameter"), (boost::format(_("parameter %1%: unknown enum value: %2%"))
1523  % _id % jp.current_value()).str());
1524  n = 0;
1525  }
1526  json_value = n;
1527 }
1528 
1529 /* derived enum parameters */
1530 
1531 typedef std::pair<std::string,std::string> id_label;
1532 
1533 void enum_parameter_load_values(gx_system::JsonParser& jp, std::vector<id_label>& value_array, const value_pair **value_names) {
1534  while (jp.peek() != gx_system::JsonParser::end_object) {
1536  if (jp.current_value() == "value_names") {
1538  while (jp.peek() != gx_system::JsonParser::end_array) {
1540  std::string value_id = jp.current_value();
1542  std::string value_label = jp.current_value();
1543  value_array.push_back(id_label(value_id, value_label));
1544  }
1546  } else {
1548  "EnumValueNames", Glib::ustring::compose("unknown key: %1", jp.current_value()));
1549  jp.skip_object();
1550  }
1551  }
1553  value_pair* p = new value_pair[value_array.size()+1];
1554  *value_names = p;
1555  for (std::vector<id_label>::iterator i = value_array.begin(); i != value_array.end(); ++i) {
1556  p->value_id = i->first.c_str();
1557  p->value_label = i->second.c_str();
1558  p++;
1559  }
1560  p->value_id = p->value_label = 0;
1561 }
1562 
1564 private:
1565  std::vector<id_label> value_array;
1566 public:
1569 };
1570 
1572  : FloatEnumParameter(jp), value_array() {
1573  enum_parameter_load_values(jp, value_array, &value_names);
1574 }
1575 
1577  delete value_names;
1578 }
1579 
1581 private:
1582  std::vector<id_label> value_array;
1583 public:
1585  ~EnumParameterD();
1586 };
1587 
1589  : EnumParameter(jp), value_array() {
1590  enum_parameter_load_values(jp, value_array, &value_names);
1591 }
1592 
1594  delete value_names;
1595 }
1596 
1597 
1598 /* BoolParameter */
1599 
1601  jw.begin_object();
1602  jw.write_key("Parameter"); Parameter::serializeJSON(jw);
1603  jw.write_kv("value", *value);
1604  jw.write_kv("std_value", std_value);
1605  jw.end_object();
1606 }
1607 
1609  : Parameter(jp_next(jp, "Parameter")), json_value(0), value(&value_storage), std_value(0) {
1610  while (jp.peek() != gx_system::JsonParser::end_object) {
1612  if (jp.read_kv("value", *value) || jp.read_kv("std_value", std_value)) {
1613  } else {
1615  "BoolParameter", Glib::ustring::compose("%1: unknown key: %2", _id, jp.current_value()));
1616  jp.skip_object();
1617  }
1618  }
1620 }
1621 
1623 }
1624 
1625 bool BoolParameter::set(bool val) const {
1626  if (val != *value) {
1627  *value = val;
1628  changed(val);
1629  return true;
1630  }
1631  return false;
1632 }
1633 
1635  return *value;
1636 }
1637 
1638 bool BoolParameter::midi_set(float n, float high, float llimit, float ulimit) {
1639  bool v;
1640  switch (c_type) {
1641  case Switch:
1642  v = (2*n > high);
1643  break;
1644  default:
1645  assert(false);
1646  return false;
1647  }
1648  if (v != *value) {
1649  *value = v;
1650  return true;
1651  }
1652  return false;
1653 }
1654 
1655 void BoolParameter::trigger_changed() {
1656  changed(*value);
1657 }
1658 
1660  json_value = std_value;
1661 }
1662 
1664  jw.write_kv(_id.c_str(), *value);
1665 }
1666 
1669  if (jp.current_value_int() < 0 || jp.current_value_int() > 1) {
1670  range_warning(json_value, 0, 1);
1671  }
1672  json_value = jp.current_value_int();
1673 }
1674 
1676  return json_value == *value;
1677 }
1678 
1680  set(json_value);
1681 }
1682 
1683 
1684 /* FileParameter */
1685 
1687  jw.begin_object();
1688  jw.write_key("Parameter"); Parameter::serializeJSON(jw);
1689  jw.write_kv("value", value->get_path());
1690  jw.write_kv("std_value", std_value->get_path());
1691  jw.end_object();
1692 }
1693 
1695  : Parameter(jp_next(jp, "Parameter")), value(0), std_value(0), json_value(0) {
1696  while (jp.peek() != gx_system::JsonParser::end_object) {
1698  if (jp.current_value() == "value") {
1700  value = Gio::File::create_for_path(jp.current_value());
1701  } else if (jp.current_value() == "std_value") {
1703  std_value = Gio::File::create_for_path(jp.current_value());
1704  } else {
1706  "FileParameter", Glib::ustring::compose("%1: unknown key: %2", _id, jp.current_value()));
1707  jp.skip_object();
1708  }
1709  }
1711 }
1712 
1713 void FileParameter::set_path(const string& path) {
1714  Glib::RefPtr<Gio::File> v = Gio::File::create_for_path(path);
1715  if (is_equal(v)) {
1716  return;
1717  }
1718  value = v;
1719  changed();
1720 }
1721 
1722 bool FileParameter::set(const Glib::RefPtr<Gio::File>& val) {
1723  if (is_equal(val)) {
1724  return false;
1725  }
1726  value = val;
1727  changed();
1728  return true;
1729 }
1730 
1731 void FileParameter::set_standard(const string& filename) {
1732  std_value = Gio::File::create_for_path(filename);
1733  if (!value) {
1734  value = std_value->dup();
1735  changed();
1736  }
1737 }
1738 
1740  json_value = std_value->dup();
1741  changed();
1742 }
1743 
1745  return bool(value);
1746 }
1747 
1749  jw.write_kv(_id.c_str(), get_path());
1750 }
1751 
1754  json_value = Gio::File::create_for_path(jp.current_value());
1755 }
1756 
1758  return json_value->get_path() == value->get_path(); //FIXME
1759 }
1760 
1762  set(json_value);
1763 }
1764 
1765 static string get_file_id(const Glib::RefPtr<Gio::File>& f) {
1766  return f->query_info(G_FILE_ATTRIBUTE_ID_FILE)->get_attribute_string(G_FILE_ATTRIBUTE_ID_FILE);
1767 }
1768 
1769 bool FileParameter::is_equal(const Glib::RefPtr<Gio::File>& v) const {
1770  string id, id2;
1771  try {
1772  id = get_file_id(value);
1773  } catch(Gio::Error& ex) {
1774  return false; // FIXME check type of exception
1775  }
1776  try {
1777  id2 = get_file_id(v);
1778  } catch(Gio::Error& ex) {
1779  return false; // FIXME check type of exception
1780  }
1781  return id == id2;
1782 }
1783 
1784 string FileParameter::get_path() const {
1785  return value->get_path();
1786 }
1787 
1789  return value->get_parent()->get_path();
1790 }
1791 
1793  return value->get_parse_name();
1794 }
1795 
1797  return value->query_info(G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME)->get_display_name();
1798 }
1799 
1800 void FileParameter::copy(const string& destination) const {
1801  value->copy(Gio::File::create_for_path(destination));
1802 }
1803 
1804 
1805 /* StringParameter */
1806 
1808  jw.begin_object();
1809  jw.write_key("Parameter"); Parameter::serializeJSON(jw);
1810  jw.write_kv("value", *value);
1811  jw.write_kv("std_value", std_value);
1812  jw.end_object();
1813 }
1814 
1816  : Parameter(jp_next(jp, "Parameter")), json_value(""), value(&value_storage), std_value("") {
1817  while (jp.peek() != gx_system::JsonParser::end_object) {
1819  if (jp.read_kv("value", *value) || jp.read_kv("std_value", std_value)) {
1820  } else {
1822  "StringParameter", Glib::ustring::compose("%1: unknown key: %2", _id, jp.current_value()));
1823  jp.skip_object();
1824  }
1825  }
1827 }
1828 
1830 }
1831 
1832 bool StringParameter::set(const Glib::ustring& val) const {
1833  if (val != *value) {
1834  *value = val;
1835  changed(*value);
1836  return true;
1837  }
1838  return false;
1839 }
1840 
1842  return !value->empty();
1843 }
1844 
1846  json_value = std_value;
1847 }
1848 
1850  jw.write_kv(_id.c_str(), *value);
1851 }
1852 
1855  json_value = jp.current_value();
1856 }
1857 
1859  return json_value == *value;
1860 }
1861 
1863  set(json_value);
1864 }
1865 
1866 /****************************************************************
1867  ** Parameter Map
1868  */
1869 
1871  : id_map(),
1872  replace_mode(false) {
1873 }
1874 
1876  for (iterator i = id_map.begin(); i != id_map.end(); ++i) {
1877  delete i->second;
1878  }
1879 }
1880 
1882  if (p->isFloat()) {
1883  if (p->getControlType() == Parameter::Enum) {
1884  jw.write("FloatEnum");
1885  } else {
1886  jw.write("Float");
1887  }
1888  } else if (p->isInt()) {
1889  if (p->getControlType() == Parameter::Enum) {
1890  jw.write("Enum");
1891  } else {
1892  jw.write("Int");
1893  }
1894  } else if (p->isBool()) {
1895  jw.write("Bool");
1896  } else if (p->isFile()) {
1897  jw.write("File");
1898  } else if (p->isString()) {
1899  jw.write("String");
1900  } else if (dynamic_cast<JConvParameter*>(p) != 0) {
1901  jw.write("JConv");
1902  } else if (dynamic_cast<SeqParameter*>(p) != 0) {
1903  jw.write("Seq");
1904  } else {
1905 #ifndef NDEBUG
1906  cerr << "skipping " << p->id() << endl;
1907 #endif
1908  return;
1909  }
1910  p->serializeJSON(jw);
1911 }
1912 
1914  jw.begin_array();
1915  for (iterator i = id_map.begin(); i != id_map.end(); ++i) {
1916  writeJSON_one(jw, i->second);
1917  }
1918  jw.end_array();
1919 }
1920 
1923  if (jp.current_value() == "FloatEnum") {
1924  return insert(new FloatEnumParameterD(jp));
1925  } else if (jp.current_value() == "Float") {
1926  return insert(new FloatParameter(jp));
1927  } else if (jp.current_value() == "Enum") {
1928  return insert(new EnumParameterD(jp));
1929  } else if (jp.current_value() == "Int") {
1930  return insert(new IntParameter(jp));
1931  } else if (jp.current_value() == "Bool") {
1932  return insert(new BoolParameter(jp));
1933  } else if (jp.current_value() == "File") {
1934  return insert(new FileParameter(jp));
1935  } else if (jp.current_value() == "String") {
1936  return insert(new StringParameter(jp));
1937  } else if (jp.current_value() == "JConv") {
1938  return insert(new JConvParameter(jp));
1939  } else if (jp.current_value() == "Seq") {
1940  return insert(new SeqParameter(jp));
1941  } else {
1943  "ParamMap", Glib::ustring::compose("unknown parameter type: %1", jp.current_value()));
1944  jp.skip_object();
1945  return 0;
1946  }
1947 }
1948 
1951  while (jp.peek() != gx_system::JsonParser::end_array) {
1952  readJSON_one(jp);
1953  }
1955 }
1956 
1957 #ifndef NDEBUG
1958 void ParamMap::unique_id(Parameter* param) {
1959  if (id_map.find(param->id()) != id_map.end()) {
1960  gx_print_error("Debug Check", "id registered twice: " + param->id());
1961  }
1962 }
1963 
1964 void ParamMap::check_id(const string& id) {
1965  if (!hasId(id)) {
1966  cerr << "string-id not found: " << id << endl;
1967  }
1968 }
1969 
1970 void ParamMap::check_p(const char *p) {
1971  if (!hasId(p)) {
1972  cerr << "char-id not found: " << p << endl;
1973  }
1974 }
1975 
1976 void ParamMap::dump(const string& fmt) {
1977  gx_system::JsonWriter *p = 0;
1979  if (fmt == "json") {
1980  jw.set_stream(&cout);
1981  p = &jw;
1982  jw.begin_array();
1983  jw.newline();
1984  } else {
1985  printf("parameter map dump\n");
1986  }
1987  for (iterator i = id_map.begin(); i != id_map.end(); ++i) {
1988  i->second->dump(p);
1989  }
1990  if (p) {
1991  jw.end_array();
1992  jw.close();
1993  } else {
1994  printf("---------------------\n");
1995  }
1996 }
1997 
1999  if (jw) {
2000  jw->begin_array();
2001  jw->write(id());
2002  switch (c_type) {
2003  case None: jw->write("None"); break;
2004  case Continuous: jw->write("Cont"); break;
2005  case Switch: jw->write("Swth"); break;
2006  case Enum: jw->write("Enum"); break;
2007  default: assert(false);
2008  }
2009  if (save_in_preset) {
2010  jw->write("preset");
2011  }
2012  if (controllable) {
2013  jw->write("control");
2014  }
2015  jw->write(l_group());
2016  jw->write(l_name());
2017  /*
2018  switch (v_type) {
2019  case tp_float: jw->write("f"); jw->write(getFloat().get_value()); break;
2020  case tp_int: jw->write("i"); jw->write(getInt().get_value()); break;
2021  case tp_bool: jw->write("b"); jw->write(getBool().get_value()); break;
2022  case tp_switch: jw->write("s"); jw->write(getSwitch().get()); break;
2023  case tp_file: jw->write("F"); jw->write(getFile().get_parse_name()); break;
2024  case tp_string: jw->write("S"); jw->write(getString().get_value()); break;
2025  case tp_special: jw->write("G"); break;
2026  default: assert(false);
2027  }
2028  */
2029  jw->write(getLowerAsFloat());
2030  jw->write(getUpperAsFloat());
2031  jw->write(getStepAsFloat());
2032  const value_pair *vn = getValueNames();
2033  if (vn) {
2034  jw->begin_array();
2035  for (int n = 0; ; ++n) {
2036  if (!vn[n].value_id) {
2037  break;
2038  }
2039  jw->begin_array();
2040  jw->write(vn[n].value_id);
2041  jw->write(vn[n].value_label ? vn[n].value_label : vn[n].value_id);
2042  jw->end_array();
2043  }
2044  jw->end_array();
2045  }
2046  jw->end_array();
2047  jw->newline();
2048  } else {
2049  printf("P: %s vt=%d ct=%d c=%d\n", _id.c_str(), v_type, c_type, controllable);
2050  }
2051 }
2052 #endif
2053 
2054 Parameter *ParamMap::insert(Parameter* param) {
2055  if (replace_mode) {
2056  map<string, Parameter*>::iterator ii = id_map.find(param->id());
2057  if (ii != id_map.end()) {
2058  Parameter *p = ii->second;
2059  insert_remove(p,false);
2060  id_map.erase(ii);
2061  delete p;
2062  }
2063  }
2064  debug_check(unique_id, param);
2065  id_map.insert(pair<string, Parameter*>(param->id(), param));
2066  insert_remove(param,true);
2067  return param;
2068 }
2069 
2071  if (!p) {
2072  return;
2073  }
2074  insert_remove(p, false);
2075  id_map.erase(p->id());
2076  delete p;
2077 }
2078 
2079 void ParamMap::unregister(const string& id) {
2080  if (!hasId(id)) {
2081  return;
2082  }
2083  unregister(&(*this)[id]);
2084 }
2085 
2087  for (iterator i = id_map.begin(); i != id_map.end(); ++i) {
2088  i->second->stdJSON_value();
2089  i->second->setJSON_value();
2090  }
2091 }
2092 
2093 static inline bool compare_groups(const std::string& id, const char **groups) {
2094  if (!groups) {
2095  return false;
2096  }
2097  for (const char **g = groups; *g; g += 2) {
2098  const char *p = *g;
2099  if ((*p) != '.') {
2100  continue;
2101  }
2102  p++;
2103  int n = strlen(p);
2104  if (strncmp(id.c_str(), p, n) == 0 && id[n] == '.') {
2105  return true;
2106  }
2107  }
2108  return false;
2109 }
2110 
2111 bool ParamMap::unit_has_std_values(const PluginDef *pdef) const {
2112  std::string group_id(pdef->id);
2113  group_id += ".";
2114  std::string on_off = group_id + "on_off";
2115  std::string pp = group_id + "pp";
2116  std::string position = group_id + "position";
2117  for (iterator i = begin(); i != end(); ++i) {
2118  if (i->first.compare(0, group_id.size(), group_id) == 0 || compare_groups(i->first, pdef->groups)) {
2119  if (i->second->isInPreset()) {
2120  if (i->first != on_off && i->first != pp && i->first != position) {
2121  i->second->stdJSON_value();
2122  if (!i->second->compareJSON_value()) {
2123  return false;
2124  break;
2125  }
2126  }
2127  }
2128  }
2129  }
2130  return true;
2131 }
2132 
2133 // reset all parameters to default settings
2134 void ParamMap::reset_unit(const PluginDef *pdef) const {
2135  std::string group_id(pdef->id);
2136  group_id += ".";
2137  std::string on_off = group_id + "on_off";
2138  std::string pp = group_id + "pp";
2139  std::string position = group_id + "position";
2140  for (iterator i = begin(); i != end(); ++i) {
2141  if (i->first.compare(0, group_id.size(), group_id) == 0 || compare_groups(i->first, pdef->groups)) {
2142  if (i->second->isInPreset()) {
2143  if (i->first != on_off && i->first != pp && i->first != position) {
2144  i->second->stdJSON_value();
2145  i->second->setJSON_value();
2146  }
2147  }
2148  }
2149  }
2150 }
2151 
2152 } // namespace gx_gui
gx_engine::FileParameter::is_equal
bool is_equal(const Glib::RefPtr< Gio::File > &v) const
Definition: gx_paramtable.cpp:1769
gx_engine::compare_parameter
void compare_parameter(const char *title, Parameter *p1, Parameter *p2, bool all=false)
Definition: gx_paramtable.cpp:1011
gx_engine::MidiControllerList::request_midi_value_update
void request_midi_value_update()
Definition: gx_paramtable.cpp:645
gx_engine::MidiControllerList::set_last_midi_control_value
void set_last_midi_control_value(unsigned int n, int v)
Definition: gx_parameter.h:784
gx_engine::ParameterV< float >::serializeJSON
virtual void serializeJSON(gx_system::JsonWriter &jw)
Definition: gx_paramtable.cpp:1119
gx_engine::ParameterV< float >::convert_from_range
void convert_from_range(float low, float up)
Definition: gx_paramtable.cpp:1275
gx_system::JsonParser::value_key
@ value_key
Definition: gx_json.h:130
gx_engine::ParameterV< Glib::ustring >::serializeJSON
virtual void serializeJSON(gx_system::JsonWriter &jw)
Definition: gx_paramtable.cpp:1807
gx_engine::ParameterV< float >::set
bool set(float val) const
Definition: gx_paramtable.cpp:1151
gx_engine::Parameter::l_name
string l_name() const
Definition: gx_parameter.h:177
gx_engine::ParameterV< float >::setJSON_value
virtual void setJSON_value()
Definition: gx_paramtable.cpp:1271
gx_engine::Parameter::value_type
value_type
Definition: gx_parameter.h:116
gx_engine::ControllerArray::readJSON
void readJSON(gx_system::JsonParser &jp, ParamMap &param)
Definition: gx_paramtable.cpp:375
gx_engine::Parameter::get_typename
const char * get_typename() const
Definition: gx_paramtable.cpp:983
gx_engine::Parameter::range_warning
void range_warning(float value, float lower, float upper)
Definition: gx_paramtable.cpp:976
gx_system::JsonParser::begin_object
@ begin_object
Definition: gx_json.h:124
gx_engine::ParameterV< float >::~ParameterV
~ParameterV()
Definition: gx_paramtable.cpp:1148
gx_engine::ParameterV< int >::serializeJSON
virtual void serializeJSON(gx_system::JsonWriter &jw)
Definition: gx_paramtable.cpp:1366
gx_engine::FloatEnumParameter::serializeJSON
virtual void serializeJSON(gx_system::JsonWriter &jw)
Definition: gx_paramtable.cpp:1313
gx_engine::FileParameter::get_parse_name
string get_parse_name() const
Definition: gx_paramtable.cpp:1792
gx_system::JsonWriter::begin_object
void begin_object(bool nl=false)
Definition: gx_json.cpp:168
gx_engine::ParameterGroups::get
string get(const string &id)
Definition: gx_parameter.h:66
gx_engine::MidiControllerList::set_midi_channel
void set_midi_channel(int s)
Definition: gx_paramtable.cpp:722
gx_system::JsonParser::value_string
@ value_string
Definition: gx_json.h:128
gx_engine::enum_parameter_load_values
void enum_parameter_load_values(gx_system::JsonParser &jp, std::vector< id_label > &value_array, const value_pair **value_names)
Definition: gx_paramtable.cpp:1533
gx_engine::ParameterV< Glib::ustring >::compareJSON_value
virtual bool compareJSON_value()
Definition: gx_paramtable.cpp:1858
gx_engine::Parameter::_id
string _id
Definition: gx_parameter.h:118
gx_engine::Parameter::v_type
enum value_type v_type
Definition: gx_parameter.h:120
gx_engine::Parameter::jp_next
static gx_system::JsonParser & jp_next(gx_system::JsonParser &jp, const char *key)
Definition: gx_paramtable.cpp:881
gx_engine::ParamMap::writeJSON_one
void writeJSON_one(gx_system::JsonWriter &jw, Parameter *p)
Definition: gx_paramtable.cpp:1881
gx_system::atomic_set
void atomic_set(volatile int *p, int v)
Definition: gx_system.h:90
gx_engine::id_label
std::pair< std::string, std::string > id_label
Definition: gx_paramtable.cpp:1531
gx_engine::MidiControllerList::get_config_mode
bool get_config_mode()
Definition: gx_parameter.h:772
gx_engine::Parameter::getUpperAsFloat
virtual float getUpperAsFloat() const
Definition: gx_paramtable.cpp:1002
gx_engine::MidiControllerList::set_config_mode
void set_config_mode(bool mode, int ctl=-1)
Definition: gx_paramtable.cpp:607
gx_engine::ParameterV< bool >::on_off_value
virtual bool on_off_value()
Definition: gx_paramtable.cpp:1634
gx_engine::FileParameter::set
bool set(const Glib::RefPtr< Gio::File > &val)
Definition: gx_paramtable.cpp:1722
gx_engine::ParameterV< int >::hasRange
virtual bool hasRange() const
Definition: gx_paramtable.cpp:1466
value_pair
Definition: gx_plugin.h:117
gx_engine::ParameterV< float >::json_value
float json_value
Definition: gx_parameter.h:236
gx_engine::ParameterV< float >::getLowerAsFloat
virtual float getLowerAsFloat() const
Definition: gx_paramtable.cpp:1283
gx_engine::Parameter::~Parameter
virtual ~Parameter()
Definition: gx_paramtable.cpp:951
gx_engine::EnumParameter::getValueNames
virtual const value_pair * getValueNames() const
Definition: gx_paramtable.cpp:1492
gx_engine::ParameterV< int >::on_off_value
virtual bool on_off_value()
Definition: gx_paramtable.cpp:1411
gx_engine::Parameter::getControlType
ctrl_type getControlType() const
Definition: gx_parameter.h:168
gx_engine::FileParameter::serializeJSON
virtual void serializeJSON(gx_system::JsonWriter &jw)
Definition: gx_paramtable.cpp:1686
gx_engine::ParameterV< float >::getUpperAsFloat
virtual float getUpperAsFloat() const
Definition: gx_paramtable.cpp:1287
gx_engine::ParameterV< float >::rampJSON_value
virtual void rampJSON_value(gx_system::JsonParser &jp)
Definition: gx_paramtable.cpp:1251
gx_engine::Parameter::on_off_value
virtual bool on_off_value()=0
gx_engine::ParameterV< float >::hasRange
virtual bool hasRange() const
Definition: gx_paramtable.cpp:1279
gx_engine::SeqParameter
ParameterV< GxSeqSettings > SeqParameter
Definition: gx_internal_plugins.h:298
gx_engine::EnumParameter::value_names
const value_pair * value_names
Definition: gx_parameter.h:335
gx_engine::ParameterV< bool >::compareJSON_value
virtual bool compareJSON_value()
Definition: gx_paramtable.cpp:1675
gx_engine::ControllerArray::param2controller
int param2controller(Parameter &param, const MidiController **p)
Definition: gx_paramtable.cpp:412
gx_engine::ParamMap::ParamMap
ParamMap()
Definition: gx_paramtable.cpp:1870
gx_engine::ParameterV< int >::setJSON_value
virtual void setJSON_value()
Definition: gx_paramtable.cpp:1462
gx_engine::ParameterV< bool >::serializeJSON
virtual void serializeJSON(gx_system::JsonWriter &jw)
Definition: gx_paramtable.cpp:1600
gx_engine::ParameterV< GxJConvSettings >
Definition: gx_internal_plugins.h:351
gx_engine::Parameter::getValueNames
virtual const value_pair * getValueNames() const
Definition: gx_paramtable.cpp:1006
gx_engine::MidiController::lower
float lower() const
Definition: gx_parameter.h:688
gx_system::JsonParser::current_value
string current_value() const
Definition: gx_json.h:143
gx_engine::FileParameter::stdJSON_value
virtual void stdJSON_value()
Definition: gx_paramtable.cpp:1739
gx_engine::midi_controller_list
list< MidiController > midi_controller_list
Definition: gx_parameter.h:700
gx_engine::ParamMap::readJSON
void readJSON(gx_system::JsonParser &jp)
Definition: gx_paramtable.cpp:1949
gx_engine::Parameter::_name
string _name
Definition: gx_parameter.h:119
gx_engine::ParameterV< int >::set
bool set(int val) const
Definition: gx_paramtable.cpp:1396
gx_system::JsonWriter::write
void write(float v, bool nl=false)
Definition: gx_json.cpp:116
gx_engine::ParameterV< int >::stdJSON_value
virtual void stdJSON_value()
Definition: gx_paramtable.cpp:1442
gx_engine::ParameterGroups::ParameterGroups
ParameterGroups()
Definition: gx_paramtable.cpp:815
gx_engine::ParameterV< int >::upper
int upper
Definition: gx_parameter.h:303
gx_engine::ControllerArray::deleteParameter
bool deleteParameter(Parameter &p)
Definition: gx_paramtable.cpp:427
gx_engine::StringParameter
ParameterV< Glib::ustring > StringParameter
Definition: gx_parameter.h:98
gx_print_warning
void gx_print_warning(const char *, const std::string &)
Definition: gx_logging.cpp:161
gx_engine::ParameterGroups::~ParameterGroups
~ParameterGroups()
Definition: gx_paramtable.cpp:822
gx_engine::Parameter::hasRange
virtual bool hasRange() const
Definition: gx_paramtable.cpp:990
gx_engine::ParameterV< float >::lower
float lower
Definition: gx_parameter.h:239
gx_engine::Parameter::c_type
enum ctrl_type c_type
Definition: gx_parameter.h:121
gx_engine::FloatEnumParameter::idx_from_id
virtual float idx_from_id(string v_id)
Definition: gx_paramtable.cpp:1334
gx_engine::MidiControllerList::update_from_controllers
void update_from_controllers()
Definition: gx_paramtable.cpp:577
gx_engine::FloatEnumParameter::writeJSON
virtual void writeJSON(gx_system::JsonWriter &jw) const
Definition: gx_paramtable.cpp:1329
gx_engine::ParamMap::begin
iterator begin() const
Definition: gx_parameter.h:538
gx_engine::Parameter::controllable
bool controllable
Definition: gx_parameter.h:124
gx_engine::FileParameter::std_value
Glib::RefPtr< Gio::File > std_value
Definition: gx_parameter.h:389
gx_engine::Parameter::getStepAsFloat
virtual float getStepAsFloat() const
Definition: gx_paramtable.cpp:994
min
#define min(x, y)
Definition: gx_faust_support.h:6
gx_engine::FileParameter::compareJSON_value
virtual bool compareJSON_value()
Definition: gx_paramtable.cpp:1757
gx_engine::FileParameter::changed
sigc::signal< void > changed
Definition: gx_parameter.h:391
gx_engine::FloatEnumParameterD::FloatEnumParameterD
FloatEnumParameterD(gx_system::JsonParser &jp)
Definition: gx_paramtable.cpp:1571
gx_engine::Parameter::serializeJSON
virtual void serializeJSON(gx_system::JsonWriter &jw)
Definition: gx_paramtable.cpp:888
PluginDef
Definition: gx_plugin.h:183
gx_engine::Parameter::Continuous
@ Continuous
Definition: gx_parameter.h:108
gx_engine::ParameterV< Glib::ustring >::setJSON_value
virtual void setJSON_value()
Definition: gx_paramtable.cpp:1862
gx_engine::ParamMap::reset_unit
void reset_unit(const PluginDef *pdef) const
Definition: gx_paramtable.cpp:2134
gx_engine::ParameterV< GxSeqSettings >
Definition: gx_internal_plugins.h:273
gx_engine::ParameterV< int >::compareJSON_value
virtual bool compareJSON_value()
Definition: gx_paramtable.cpp:1458
gx_engine::Parameter::used
bool used
Definition: gx_parameter.h:128
gx_system::JsonException
Definition: gx_json.h:40
gx_engine::ParameterV< float >::on_off_value
virtual bool on_off_value()
Definition: gx_paramtable.cpp:1161
gx_system::JsonParser::check_expect
void check_expect(token expect)
Definition: gx_json.h:142
gx_engine::ParameterGroups::insert
void insert(const string &id, const string &group)
Definition: gx_parameter.h:71
max
#define max(x, y)
Definition: gx_faust_support.h:5
gx_engine::ParameterV< int >::idx_from_id
virtual int idx_from_id(string v_id)
gx_engine::ParamMap::unregister
void unregister(Parameter *p)
Definition: gx_paramtable.cpp:2070
gx_system::JsonWriter::end_object
void end_object(bool nl=false)
Definition: gx_json.cpp:176
gx_engine::MidiController::set_bpm
bool set_bpm(int n, int last_value)
Definition: gx_paramtable.cpp:352
gx_system::JsonWriter::close
virtual void close()
Definition: gx_json.cpp:68
gx_engine::MidiStandardControllers::MidiStandardControllers
MidiStandardControllers()
Definition: gx_paramtable.cpp:127
gx_engine::EnumParameter::serializeJSON
virtual void serializeJSON(gx_system::JsonWriter &jw)
Definition: gx_paramtable.cpp:1480
gx_engine::ParameterV< bool >::ParameterV
ParameterV(const string &id, const string &name, ctrl_type ctp, bool preset, bool *v, bool sv, bool ctrl)
Definition: gx_parameter.h:370
gx_engine::EnumParameter::idx_from_id
virtual int idx_from_id(string v_id)
Definition: gx_paramtable.cpp:1496
gx_engine::MidiControllerList::compute_midi_in
void compute_midi_in(void *midi_input_port_buf, void *arg)
Definition: gx_paramtable.cpp:754
gx_engine::FloatEnumParameter::value_names
const value_pair * value_names
Definition: gx_parameter.h:280
gx_engine::ParameterV< float >
Definition: gx_parameter.h:230
gx_engine::MidiController::upper
float upper() const
Definition: gx_parameter.h:689
N_
#define N_(String)
Definition: gx_faust_support.h:23
gx_jack::GxJack
Definition: gx_jack.h:111
PluginDef::groups
const char ** groups
Definition: gx_plugin.h:189
gx_system::JsonParser::next
token next(token expect=no_token)
Definition: gx_json.cpp:496
debug_check
#define debug_check(func,...)
Definition: gx_parameter.h:36
gx_jack::GxJack::get_jack_sr
jack_nframes_t get_jack_sr()
Definition: gx_jack.h:178
gx_engine::Parameter::get_blocked
bool get_blocked()
Definition: gx_parameter.h:184
gx_engine::MidiClockToBpm::rounded
unsigned int rounded(float f)
Definition: gx_paramtable.cpp:454
gx_engine::Parameter::isInt
bool isInt() const
Definition: gx_parameter.h:164
gx_engine::Parameter::save_in_preset
bool save_in_preset
Definition: gx_parameter.h:123
gx_engine::ParameterV< int >
Definition: gx_parameter.h:295
gx_engine::FileParameter::setJSON_value
virtual void setJSON_value()
Definition: gx_paramtable.cpp:1761
gx_engine
Definition: gx_convolver.h:33
gx_engine::Parameter::dump
void dump(gx_system::JsonWriter *jw)
Definition: gx_paramtable.cpp:1998
gx_engine::ParamMap::end
iterator end() const
Definition: gx_parameter.h:539
gx_engine::ParameterV< Glib::ustring >::on_off_value
virtual bool on_off_value()
Definition: gx_paramtable.cpp:1841
gx_system::JsonWriter::write_kv
void write_kv(const char *key, float v)
Definition: gx_json.h:81
gx_engine::Parameter::getFloat
FloatParameter & getFloat()
Definition: gx_parameter.h:455
gx_system::JsonWriter
Definition: gx_json.h:55
gx_engine::ParameterV< int >::getLowerAsFloat
virtual float getLowerAsFloat() const
Definition: gx_paramtable.cpp:1470
gx_engine::param_group
string param_group(const string &group_id, bool nowarn=false)
gx_engine::MidiControllerList::set_ctr_val
void set_ctr_val(int ctr, int val)
Definition: gx_paramtable.cpp:658
gx_engine::ParameterV< Glib::ustring >::readJSON_value
virtual void readJSON_value(gx_system::JsonParser &jp)
Definition: gx_paramtable.cpp:1853
gx_engine::MidiClockToBpm::MidiClockToBpm
MidiClockToBpm()
Definition: gx_paramtable.cpp:445
gx_engine::ParameterV< bool >::~ParameterV
~ParameterV()
Definition: gx_paramtable.cpp:1622
gx_engine::ParameterGroups::group_exist
bool group_exist(const string &id)
Definition: gx_paramtable.cpp:869
gx_system::JsonParser
Definition: gx_json.h:112
gx_engine::ParameterV< int >::~ParameterV
~ParameterV()
Definition: gx_paramtable.cpp:1393
gx_engine::EnumParameter
Definition: gx_parameter.h:333
gx_engine::MidiStandardControllers
Definition: gx_parameter.h:647
gx_engine::ParameterV< Glib::ustring >::set
bool set(const Glib::ustring &val) const
Definition: gx_paramtable.cpp:1832
gx_system::atomic_compare_and_exchange
bool atomic_compare_and_exchange(volatile int *p, int oldv, int newv)
Definition: gx_system.h:114
gx_print_error
void gx_print_error(const char *, const std::string &)
Definition: gx_logging.cpp:166
gx_system::JsonParser::begin_array
@ begin_array
Definition: gx_json.h:126
gx_engine::FileParameter::value
Glib::RefPtr< Gio::File > value
Definition: gx_parameter.h:388
gx_engine::JConvParameter
ParameterV< GxJConvSettings > JConvParameter
Definition: gx_internal_plugins.h:378
gx_engine::Parameter::value_label
static const char * value_label(const value_pair &vp)
Definition: gx_parameter.h:199
gx_engine::FloatEnumParameter
Definition: gx_parameter.h:278
gx_engine::ParameterV< float >::upper
float upper
Definition: gx_parameter.h:239
gx_engine::midi_std_ctr
MidiStandardControllers midi_std_ctr
Definition: gx_paramtable.cpp:38
gx_engine::get_group_table
ParameterGroups & get_group_table()
Definition: gx_paramtable.cpp:855
gx_engine::MidiController::toggle_behaviour
int toggle_behaviour() const
Definition: gx_parameter.h:691
gx_engine::FileParameter::on_off_value
virtual bool on_off_value()
Definition: gx_paramtable.cpp:1744
gx_system::JsonParser::read_kv
bool read_kv(const char *key, float &v)
Definition: gx_json.cpp:511
gx_engine::Parameter::l_group
string l_group() const
Definition: gx_parameter.h:175
gx_system::JsonWriter::begin_array
void begin_array(bool nl=false)
Definition: gx_json.cpp:184
gx_engine::ParamMap::unit_has_std_values
bool unit_has_std_values(const PluginDef *pdef) const
Definition: gx_paramtable.cpp:2111
gx_engine::MidiStandardControllers::readJSON
void readJSON(gx_system::JsonParser &jp)
Definition: gx_paramtable.cpp:172
gx_engine::EnumParameter::writeJSON
virtual void writeJSON(gx_system::JsonWriter &jw) const
Definition: gx_paramtable.cpp:1506
gx_engine::ParamMap::set_init_values
void set_init_values()
Definition: gx_paramtable.cpp:2086
PluginDef::id
const char * id
Definition: gx_plugin.h:187
gx_engine::ControllerArray
Definition: gx_parameter.h:726
gx_system::JsonParser::end_array
@ end_array
Definition: gx_json.h:127
gx_system::JsonWriter::set_stream
void set_stream(ostream *o)
Definition: gx_json.h:70
value_pair::value_id
const char * value_id
Definition: gx_plugin.h:118
gx_engine::MidiStandardControllers::replace
void replace(int ctr, const string &name)
Definition: gx_paramtable.cpp:137
gx_engine::MidiController::writeJSON
void writeJSON(gx_system::JsonWriter &jw) const
Definition: gx_paramtable.cpp:193
gx_engine::ParameterV< float >::ramp_value
bool ramp_value(float val)
Definition: gx_paramtable.cpp:1234
gx_engine::Parameter::get_midi_blocked
bool get_midi_blocked()
Definition: gx_parameter.h:186
gx_system::JsonParser::end_object
@ end_object
Definition: gx_json.h:125
gx_engine::MidiController::set_midi
bool set_midi(int n, int last_value, bool update)
Definition: gx_paramtable.cpp:300
gx_engine::ParameterV< bool >::set
bool set(bool val) const
Definition: gx_paramtable.cpp:1625
gx_engine::Parameter::d_flags
unsigned int d_flags
Definition: gx_parameter.h:122
gx_engine::ParameterV< Glib::ustring >::ParameterV
ParameterV(const string &id, const string &name, Glib::ustring *v, const Glib::ustring &sv, bool preset=false)
Definition: gx_parameter.h:442
gx_engine::ParameterV< float >::writeJSON
virtual void writeJSON(gx_system::JsonWriter &jw) const
Definition: gx_paramtable.cpp:1230
gx_engine::MidiControllerList::update_from_controller
void update_from_controller(int ctr)
update all controlled parameters with last received value from MIDI controller ctr.
Definition: gx_paramtable.cpp:567
gx_engine::ParameterV< float >::ParameterV
ParameterV(const string &id, const string &name, ctrl_type ctp, bool preset, float *v, float sv, float lv, float uv, float tv, bool ctrl, bool no_init)
Definition: gx_parameter.h:260
gx_engine::MidiController::MidiController
MidiController(Parameter &p, float l, float u, bool t=false, int tt=0)
Definition: gx_parameter.h:686
gx_engine::ParameterV< bool >::readJSON_value
virtual void readJSON_value(gx_system::JsonParser &jp)
Definition: gx_paramtable.cpp:1667
gx_engine::MidiControllerList::set_controller_array
void set_controller_array(const ControllerArray &m)
Definition: gx_paramtable.cpp:682
gx_engine::ParameterV< bool >::setJSON_value
virtual void setJSON_value()
Definition: gx_paramtable.cpp:1679
gx_engine::EnumParameterD::~EnumParameterD
~EnumParameterD()
Definition: gx_paramtable.cpp:1593
gx_engine::ParameterV< float >::compareJSON_value
virtual bool compareJSON_value()
Definition: gx_paramtable.cpp:1267
gx_system::JsonParser::token
token
Definition: gx_json.h:121
gx_engine::FloatEnumParameterD::~FloatEnumParameterD
~FloatEnumParameterD()
Definition: gx_paramtable.cpp:1576
gx_engine::FileParameter::set_path
void set_path(const string &path)
Definition: gx_paramtable.cpp:1713
gx_engine::MidiStandardControllers::writeJSON
void writeJSON(gx_system::JsonWriter &jw) const
Definition: gx_paramtable.cpp:160
gx_engine::ParamMap::~ParamMap
~ParamMap()
Definition: gx_paramtable.cpp:1875
gx_engine::ParameterGroups
Definition: gx_parameter.h:47
gx_engine::Parameter::Parameter
Parameter(const string &id, const string &name, value_type vtp, ctrl_type ctp, bool preset, bool ctrl)
Definition: gx_parameter.h:134
gx_engine::ParamMap
Definition: gx_parameter.h:515
gx_engine::ParameterV< int >::getUpperAsFloat
virtual float getUpperAsFloat() const
Definition: gx_paramtable.cpp:1474
gx_engine::ParamMap::readJSON_one
Parameter * readJSON_one(gx_system::JsonParser &jp)
Definition: gx_paramtable.cpp:1921
gx_engine::ParameterV< float >::idx_from_id
virtual float idx_from_id(string v_id)
gx_engine::EnumParameterD
Definition: gx_paramtable.cpp:1580
gx_system::atomic_get
int atomic_get(volatile int &p)
Definition: gx_system.h:98
gx_engine::ParamMap::writeJSON
void writeJSON(gx_system::JsonWriter &jw)
Definition: gx_paramtable.cpp:1913
gx_engine::ParameterV< int >::ParameterV
ParameterV(const string &id, const string &name, ctrl_type ctp, bool preset, int *v, int sv, int lv, int uv, bool ctrl)
Definition: gx_parameter.h:319
gx_engine::Parameter::id
const string & id() const
Definition: gx_parameter.h:173
gx_engine::Parameter::Switch
@ Switch
Definition: gx_parameter.h:108
gx_system::JsonParser::value_number
@ value_number
Definition: gx_json.h:129
gx_engine::ParameterV< Glib::ustring >::stdJSON_value
virtual void stdJSON_value()
Definition: gx_paramtable.cpp:1845
gx_engine::Parameter::isFloat
bool isFloat() const
Definition: gx_parameter.h:163
gx_engine::MidiController::set_trans
bool set_trans(int n, int last_value)
Definition: gx_paramtable.cpp:341
gx_engine::MidiControllerList::set_bpm_val
void set_bpm_val(unsigned int val)
Definition: gx_paramtable.cpp:670
gx_engine::ParameterV< float >::getStepAsFloat
virtual float getStepAsFloat() const
Definition: gx_paramtable.cpp:1291
gx_engine::FileParameter::writeJSON
virtual void writeJSON(gx_system::JsonWriter &jw) const
Definition: gx_paramtable.cpp:1748
gx_engine::ParameterV< float >::stdJSON_value
virtual void stdJSON_value()
Definition: gx_paramtable.cpp:1226
gx_engine::MidiClockToBpm::time_to_bpm
bool time_to_bpm(double time, unsigned int *bpm_)
Definition: gx_paramtable.cpp:459
gx_engine::ParamMap::dump
void dump(const string &fmt)
Definition: gx_paramtable.cpp:1976
gx_engine::Parameter::ctrl_type
ctrl_type
Definition: gx_parameter.h:108
gx_engine::FileParameter::set_standard
void set_standard(const string &filename)
Definition: gx_paramtable.cpp:1731
gx_engine::ParameterV< Glib::ustring >::~ParameterV
~ParameterV()
Definition: gx_paramtable.cpp:1829
gx_engine::FileParameter::copy
void copy(const string &destination) const
Definition: gx_paramtable.cpp:1800
gx_system::JsonParser::current_value_int
int current_value_int()
Definition: gx_json.h:144
gx_engine::FileParameter::get_path
string get_path() const
Definition: gx_paramtable.cpp:1784
gx_engine::Parameter::isFile
bool isFile() const
Definition: gx_parameter.h:166
gx_engine::paramlist
list< Parameter * > paramlist
Definition: gx_parameter.h:221
gx_engine::ParameterV< bool >::writeJSON
virtual void writeJSON(gx_system::JsonWriter &jw) const
Definition: gx_paramtable.cpp:1663
gx_system::JsonParser::current_value_float
float current_value_float()
Definition: gx_json.h:146
gx_engine::Parameter::None
@ None
Definition: gx_parameter.h:108
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::FloatParameter
ParameterV< float > FloatParameter
Definition: gx_parameter.h:93
gx_engine::MidiControllerList::deleteParameter
void deleteParameter(Parameter &param)
Definition: gx_paramtable.cpp:616
gx_engine::FloatEnumParameterD
Definition: gx_paramtable.cpp:1563
engine.h
gx_engine::FloatEnumParameter::readJSON_value
virtual void readJSON_value(gx_system::JsonParser &jp)
Definition: gx_paramtable.cpp:1346
gx_engine::ParamMap::iterator
map< string, Parameter * >::const_iterator iterator
Definition: gx_parameter.h:537
gx_system::JsonParser::skip_object
void skip_object()
Definition: gx_json.cpp:611
gx_engine::ParameterGroups::dump
void dump()
Definition: gx_paramtable.cpp:847
gx_engine::FileParameter::json_value
Glib::RefPtr< Gio::File > json_value
Definition: gx_parameter.h:390
end
CmdConnection::msg_type end
Definition: jsonrpc.cpp:258
gx_engine::MidiControllerList::MidiControllerList
MidiControllerList()
Definition: gx_paramtable.cpp:491
gx_engine::ParameterV< Glib::ustring >::writeJSON
virtual void writeJSON(gx_system::JsonWriter &jw) const
Definition: gx_paramtable.cpp:1849
gx_engine::Parameter::_desc
string _desc
Definition: gx_parameter.h:119
gx_engine::ParameterV< int >::json_value
int json_value
Definition: gx_parameter.h:300
gx_engine::ParameterV< int >::writeJSON
virtual void writeJSON(gx_system::JsonWriter &jw) const
Definition: gx_paramtable.cpp:1446
gx_engine::ControllerArray::array_size
@ array_size
Definition: gx_parameter.h:728
gx_engine::IntParameter
ParameterV< int > IntParameter
Definition: gx_parameter.h:96
gx_engine::MidiControllerList::process_trans
void process_trans(int transport_state)
Definition: gx_paramtable.cpp:726
gx_engine::FileParameter
Definition: gx_parameter.h:386
gx_system::JsonWriter::end_array
void end_array(bool nl=false)
Definition: gx_json.cpp:192
gx_engine::ParameterV< float >::readJSON_value
virtual void readJSON_value(gx_system::JsonParser &jp)
Definition: gx_paramtable.cpp:1258
gx_engine::ParamMap::hasId
bool hasId(const string &id) const
Definition: gx_parameter.h:540
gx_engine::FloatEnumParameter::getValueNames
virtual const value_pair * getValueNames() const
Definition: gx_paramtable.cpp:1325
gx_engine::EnumParameterD::EnumParameterD
EnumParameterD(gx_system::JsonParser &jp)
Definition: gx_paramtable.cpp:1588
gx_engine::ParameterV< int >::value
int * value
Definition: gx_parameter.h:301
gx_engine::EnumParameter::EnumParameter
EnumParameter(gx_system::JsonParser &jp)
Definition: gx_parameter.h:336
gx_engine::FileParameter::get_display_name
string get_display_name() const
Definition: gx_paramtable.cpp:1796
gx_engine::FileParameter::get_directory_path
string get_directory_path() const
Definition: gx_paramtable.cpp:1788
gx_engine::Parameter::_group
string _group
Definition: gx_parameter.h:119
gx_engine::FileParameter::readJSON_value
virtual void readJSON_value(gx_system::JsonParser &jp)
Definition: gx_paramtable.cpp:1752
gx_engine::ParameterV< float >::value
float * value
Definition: gx_parameter.h:237
gx_engine::MidiControllerList::remove_controlled_parameters
void remove_controlled_parameters(paramlist &plist, const ControllerArray *m)
Definition: gx_paramtable.cpp:694
gx_engine::Parameter::getLowerAsFloat
virtual float getLowerAsFloat() const
Definition: gx_paramtable.cpp:998
gx_engine::MidiController
Definition: gx_parameter.h:675
gx_engine::ParameterV< float >::step
float step
Definition: gx_parameter.h:239
gx_engine::ParameterV< float >::std_value
float std_value
Definition: gx_parameter.h:238
gx_engine::Parameter
Definition: gx_parameter.h:106
gx_engine::ParameterV< bool >::stdJSON_value
virtual void stdJSON_value()
Definition: gx_paramtable.cpp:1659
gx_engine::Parameter::isBool
bool isBool() const
Definition: gx_parameter.h:165
gx_system::JsonWriter::newline
void newline()
Definition: gx_json.h:95
gx_engine::ParameterV< int >::readJSON_value
virtual void readJSON_value(gx_system::JsonParser &jp)
Definition: gx_paramtable.cpp:1450
gx_engine::FloatEnumParameter::FloatEnumParameter
FloatEnumParameter(gx_system::JsonParser &jp)
Definition: gx_parameter.h:281
gx_engine::Parameter::Enum
@ Enum
Definition: gx_parameter.h:108
value_pair::value_label
const char * value_label
Definition: gx_plugin.h:119
gx_engine::MidiControllerList::get_last_midi_control_value
int get_last_midi_control_value(unsigned int n)
Definition: gx_parameter.h:782
gx_engine::EnumParameter::readJSON_value
virtual void readJSON_value(gx_system::JsonParser &jp)
Definition: gx_paramtable.cpp:1511
gx_engine::ControllerArray::writeJSON
void writeJSON(gx_system::JsonWriter &jw) const
Definition: gx_paramtable.cpp:396
gx_engine::BoolParameter
ParameterV< bool > BoolParameter
Definition: gx_parameter.h:97
gx_engine::FileParameter::FileParameter
FileParameter(const string &id, const string &filename, bool preset=false)
Definition: gx_parameter.h:403
gx_engine::MidiControllerList::modifyCurrent
void modifyCurrent(Parameter &param, float lower, float upper, bool toggle, int toggle_behaviour)
Definition: gx_paramtable.cpp:629
gx_engine::Parameter::isString
bool isString() const
Definition: gx_parameter.h:167
gx_engine::MidiController::readJSON
static MidiController * readJSON(gx_system::JsonParser &jp, ParamMap &param)
Definition: gx_paramtable.cpp:208