X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fsurfaces%2Fosc%2Fosc_select_observer.cc;h=c4a5eae09cea26e1bf5f9b80c84a304c8e3eeeed;hb=c4a4857b8710654e8b91aa354f602331ed8fc859;hp=bd726123ea091ffe12d3d25b0bc2843570b179bd;hpb=b502d689e29183595505c1b1180298d2f11158dc;p=ardour.git diff --git a/libs/surfaces/osc/osc_select_observer.cc b/libs/surfaces/osc/osc_select_observer.cc index bd726123ea..c4a5eae09c 100644 --- a/libs/surfaces/osc/osc_select_observer.cc +++ b/libs/surfaces/osc/osc_select_observer.cc @@ -17,6 +17,7 @@ */ +#include #include "boost/lambda/lambda.hpp" #include "ardour/session.h" @@ -28,10 +29,15 @@ #include "ardour/solo_isolate_control.h" #include "ardour/solo_safe_control.h" #include "ardour/route.h" +#include "ardour/send.h" +#include "ardour/processor.h" +#include "ardour/readonly_control.h" #include "osc.h" #include "osc_select_observer.h" +#include + #include "pbd/i18n.h" using namespace std; @@ -39,13 +45,17 @@ using namespace PBD; using namespace ARDOUR; using namespace ArdourSurface; -OSCSelectObserver::OSCSelectObserver (boost::shared_ptr s, lo_address a, uint32_t gm, std::bitset<32> fb) +OSCSelectObserver::OSCSelectObserver (boost::shared_ptr s, lo_address a, ArdourSurface::OSC::OSCSurface* su) : _strip (s) - ,gainmode (gm) - ,feedback (fb) + ,sur (su) ,nsends (0) + ,_last_gain (0.0) { addr = lo_address_new (lo_address_get_hostname(a) , lo_address_get_port(a)); + gainmode = sur->gainmode; + feedback = sur->feedback; + as = ARDOUR::Off; + send_size = 0; if (feedback[0]) { // buttons are separate feedback _strip->PropertyChanged.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::name_changed, this, boost::lambda::_1), OSC::instance()); @@ -94,13 +104,9 @@ OSCSelectObserver::OSCSelectObserver (boost::shared_ptr s, lo_address } if (feedback[1]) { // level controls - if (gainmode) { - _strip->gain_control()->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::gain_message, this, X_("/select/fader"), _strip->gain_control()), OSC::instance()); - gain_message ("/select/fader", _strip->gain_control()); - } else { - _strip->gain_control()->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::gain_message, this, X_("/select/gain"), _strip->gain_control()), OSC::instance()); - gain_message ("/select/gain", _strip->gain_control()); - } + _strip->gain_control()->alist()->automation_state_changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::gain_automation, this), OSC::instance()); + _strip->gain_control()->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::gain_message, this), OSC::instance()); + gain_automation (); boost::shared_ptr trim_controllable = boost::dynamic_pointer_cast(_strip->trim_control()); if (trim_controllable) { @@ -120,14 +126,6 @@ OSCSelectObserver::OSCSelectObserver (boost::shared_ptr s, lo_address change_message ("/select/pan_stereo_width", _strip->pan_width_control()); } - // detecting processor changes requires cast to route - boost::shared_ptr r = boost::dynamic_pointer_cast(_strip); - if (r) { - r->processors_changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::send_restart, this, -1), OSC::instance()); - send_init(); - eq_init(); - } - } if (feedback[13]) { // Well known controls // Rest of possible pan controls... Untested because I can't find a way to get them in the GUI :) @@ -143,10 +141,20 @@ OSCSelectObserver::OSCSelectObserver (boost::shared_ptr s, lo_address _strip->pan_lfe_control()->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message, this, X_("/select/pan_lfe_control"), _strip->pan_lfe_control()), OSC::instance()); change_message ("/select/pan_lfe_control", _strip->pan_lfe_control()); } + + // sends and eq + // detecting processor changes requires cast to route + boost::shared_ptr r = boost::dynamic_pointer_cast(_strip); + if (r) { + r->processors_changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::send_restart, this, -1), OSC::instance()); + send_init(); + eq_init(); + } + // Compressor if (_strip->comp_enable_controllable ()) { - _strip->comp_enable_controllable ()->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message, this, X_("/select/comp_enable"), _strip->comp_enable_controllable()), OSC::instance()); - change_message ("/select/comp_enable", _strip->comp_enable_controllable()); + _strip->comp_enable_controllable ()->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::enable_message, this, X_("/select/comp_enable"), _strip->comp_enable_controllable()), OSC::instance()); + enable_message ("/select/comp_enable", _strip->comp_enable_controllable()); } if (_strip->comp_threshold_controllable ()) { _strip->comp_threshold_controllable ()->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message, this, X_("/select/comp_threshold"), _strip->comp_threshold_controllable()), OSC::instance()); @@ -164,10 +172,6 @@ OSCSelectObserver::OSCSelectObserver (boost::shared_ptr s, lo_address _strip->comp_makeup_controllable ()->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message, this, X_("/select/comp_makeup"), _strip->comp_makeup_controllable()), OSC::instance()); change_message ("/select/comp_makeup", _strip->comp_makeup_controllable()); } - if (_strip->comp_redux_controllable ()) { - _strip->comp_redux_controllable ()->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message, this, X_("/select/comp_redux"), _strip->comp_redux_controllable()), OSC::instance()); - change_message ("/select/comp_redux", _strip->comp_redux_controllable()); - } } @@ -176,57 +180,55 @@ OSCSelectObserver::OSCSelectObserver (boost::shared_ptr s, lo_address OSCSelectObserver::~OSCSelectObserver () { - strip_connections.drop_connections (); // all strip buttons should be off and faders 0 and etc. - clear_strip ("/select/expand", 0); if (feedback[0]) { // buttons are separate feedback + send_float ("/select/expand", 0); text_message ("/select/name", " "); text_message ("/select/comment", " "); - clear_strip ("/select/mute", 0); - clear_strip ("/select/solo", 0); - clear_strip ("/select/recenable", 0); - clear_strip ("/select/record_safe", 0); - clear_strip ("/select/monitor_input", 0); - clear_strip ("/select/monitor_disk", 0); - clear_strip ("/select/polarity", 0); - clear_strip ("/select/n_inputs", 0); - clear_strip ("/select/n_outputs", 0); + send_float ("/select/mute", 0); + send_float ("/select/solo", 0); + send_float ("/select/recenable", 0); + send_float ("/select/record_safe", 0); + send_float ("/select/monitor_input", 0); + send_float ("/select/monitor_disk", 0); + send_float ("/select/polarity", 0); + send_float ("/select/n_inputs", 0); + send_float ("/select/n_outputs", 0); } if (feedback[1]) { // level controls if (gainmode) { - clear_strip ("/select/fader", 0); + send_float ("/select/fader", 0); } else { - clear_strip ("/select/gain", -193); + send_float ("/select/gain", -193); } - clear_strip ("/select/trimdB", 0); - clear_strip ("/select/pan_stereo_position", 0.5); - clear_strip ("/select/pan_stereo_width", 1); + send_float ("/select/trimdB", 0); + send_float ("/select/pan_stereo_position", 0.5); + send_float ("/select/pan_stereo_width", 1); } if (feedback[9]) { - clear_strip ("/select/signal", 0); + send_float ("/select/signal", 0); } if (feedback[7]) { if (gainmode) { - clear_strip ("/select/meter", 0); + send_float ("/select/meter", 0); } else { - clear_strip ("/select/meter", -193); + send_float ("/select/meter", -193); } }else if (feedback[8]) { - clear_strip ("/select/meter", 0); + send_float ("/select/meter", 0); } if (feedback[13]) { // Well known controls - clear_strip ("/select/pan_elevation_position", .5); - clear_strip ("/select/pan_frontback_position", .5); - clear_strip ("/select/pan_lfe_control", 0); - clear_strip ("/select/comp_enable", 0); - clear_strip ("/select/comp_threshold", 0); - clear_strip ("/select/comp_speed", 0); - clear_strip ("/select/comp_mode", 0); + send_float ("/select/pan_elevation_position", 0); + send_float ("/select/pan_frontback_position", .5); + send_float ("/select/pan_lfe_control", 0); + send_float ("/select/comp_enable", 0); + send_float ("/select/comp_threshold", 0); + send_float ("/select/comp_speed", 0); + send_float ("/select/comp_mode", 0); text_message ("/select/comp_mode_name", " "); text_message ("/select/comp_speed_name", " "); - clear_strip ("/select/comp_makeup", 0); - clear_strip ("/select/comp_redux", 0); + send_float ("/select/comp_makeup", 0); } send_end(); eq_end(); @@ -234,53 +236,98 @@ OSCSelectObserver::~OSCSelectObserver () lo_address_free (addr); } +void +OSCSelectObserver::renew_sends () { + send_end(); + send_init(); +} + +void +OSCSelectObserver::renew_plugin () { + // to be written :) +} + void OSCSelectObserver::send_init() { // we don't know how many there are, so find out. bool sends; + nsends = 0; do { sends = false; if (_strip->send_level_controllable (nsends)) { - _strip->send_level_controllable(nsends)->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::send_gain, this, nsends, _strip->send_level_controllable(nsends)), OSC::instance()); - send_gain (nsends, _strip->send_level_controllable(nsends)); sends = true; + nsends++; } + } while (sends); + if (!nsends) { + return; + } - if (_strip->send_enable_controllable (nsends)) { - _strip->send_enable_controllable(nsends)->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message_with_id, this, X_("/select/send_enable"), nsends + 1, _strip->send_enable_controllable(nsends)), OSC::instance()); - change_message_with_id ("/select/send_enable", nsends + 1, _strip->send_enable_controllable(nsends)); - sends = true; - } else if (sends) { - // not used by Ardour, just mixbus so in Ardour always true - clear_strip_with_id ("/select/send_enable", nsends + 1, 1); - } - // this should get signalled by the route the send goes to, (TODO) - if (sends) { // if the gain control is there, this is too - text_with_id ("/select/send_name", nsends + 1, _strip->send_name(nsends)); + send_size = nsends; + if (sur->send_page_size) { + send_size = sur->send_page_size; + } + // check limits + uint32_t max_page = (uint32_t)(nsends / send_size) + 1; + if (sur->send_page < 1) { + sur->send_page = 1; + } else if ((uint32_t)sur->send_page > max_page) { + sur->send_page = max_page; + } + uint32_t page_start = ((sur->send_page - 1) * send_size); + uint32_t last_send = sur->send_page * send_size; + uint32_t c = 1; + + for (uint32_t s = page_start; s < last_send; ++s, ++c) { + + bool send_valid = false; + if (_strip->send_level_controllable (s)) { + _strip->send_level_controllable(s)->Changed.connect (send_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::send_gain, this, c, _strip->send_level_controllable(s)), OSC::instance()); + send_timeout.push_back (0); + send_gain (c, _strip->send_level_controllable(s)); + send_valid = true; + } + + if (_strip->send_enable_controllable (s)) { + _strip->send_enable_controllable(s)->Changed.connect (send_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::enable_message_with_id, this, X_("/select/send_enable"), c, _strip->send_enable_controllable(s)), OSC::instance()); + enable_message_with_id ("/select/send_enable", c, _strip->send_enable_controllable(s)); + } else if (send_valid) { + boost::shared_ptr r = boost::dynamic_pointer_cast (_strip); + if (!r) { + // should never get here + send_float_with_id ("/select/send_enable", c, 0); + } + boost::shared_ptr snd = boost::dynamic_pointer_cast (r->nth_send(s)); + if (snd) { + boost::shared_ptr proc = boost::dynamic_pointer_cast (snd); + proc->ActiveChanged.connect (send_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::send_enable, this, X_("/select/send_enable"), c, proc), OSC::instance()); + send_float_with_id ("/select/send_enable", c, proc->enabled()); + } } - // Send numbers are 0 based, OSC is 1 based so this gets incremented at the end - if (sends) { - nsends++; + if (!gainmode && send_valid) { + text_with_id ("/select/send_name", c, _strip->send_name(s)); } - } while (sends); + } } void OSCSelectObserver::send_end () { send_connections.drop_connections (); - for (uint32_t i = 1; i <= nsends; i++) { + for (uint32_t i = 1; i <= send_size; i++) { if (gainmode) { - clear_strip_with_id ("/select/send_fader", i, 0); + send_float_with_id ("/select/send_fader", i, 0); } else { - clear_strip_with_id ("/select/send_gain", i, -193); + send_float_with_id ("/select/send_gain", i, -193); } // next enable - clear_strip_with_id ("/select/send_enable", i, 0); + send_float_with_id ("/select/send_enable", i, 0); // next name text_with_id ("/select/send_name", i, " "); } + // need to delete or clear send_timeout + send_timeout.clear(); nsends = 0; } @@ -307,8 +354,7 @@ OSCSelectObserver::tick () string path = "/select/meter"; lo_message msg = lo_message_new (); if (gainmode && feedback[7]) { - uint32_t lev1023 = (uint32_t)((now_meter + 54) * 17.05); - lo_message_add_int32 (msg, lev1023); + lo_message_add_float (msg, ((now_meter + 94) / 100)); lo_send_message (addr, path.c_str(), msg); } else if ((!gainmode) && feedback[7]) { lo_message_add_float (msg, now_meter); @@ -338,6 +384,36 @@ OSCSelectObserver::tick () _last_meter = now_meter; } + if (feedback[1]) { + if (gain_timeout) { + if (gain_timeout == 1) { + text_message ("/select/name", _strip->name()); + } + gain_timeout--; + } + + if (as == ARDOUR::Play || as == ARDOUR::Touch) { + if(_last_gain != _strip->gain_control()->get_value()) { + _last_gain = _strip->gain_control()->get_value(); + gain_message (); + } + } + } + if (feedback[13]) { + if (_strip->comp_redux_controllable()) { + if (_strip->comp_redux_controllable()->get_parameter()) { + send_float ("/select/comp_redux", (float) _strip->comp_redux_controllable()->get_parameter ()); + } + } + for (uint32_t i = 0; i < send_timeout.size(); i++) { + if (send_timeout[i]) { + if (send_timeout[i] == 1) { + text_with_id ("/select/send_name", i + 1, _strip->send_name(i)); + } + send_timeout[i]--; + } + } + } } @@ -358,9 +434,9 @@ OSCSelectObserver::name_changed (const PBD::PropertyChange& what_changed) //spit out the comment at the same time text_message ("/select/comment", route->comment()); // lets tell the surface how many inputs this strip has - clear_strip ("/select/n_inputs", (float) route->n_inputs().n_total()); + send_float ("/select/n_inputs", (float) route->n_inputs().n_total()); // lets tell the surface how many outputs this strip has - clear_strip ("/select/n_outputs", (float) route->n_outputs().n_total()); + send_float ("/select/n_outputs", (float) route->n_outputs().n_total()); } } @@ -376,6 +452,18 @@ OSCSelectObserver::change_message (string path, boost::shared_ptr lo_message_free (msg); } +void +OSCSelectObserver::enable_message (string path, boost::shared_ptr controllable) +{ + float val = controllable->get_value(); + if (val) { + send_float (path, 1); + } else { + send_float (path, 0); + } + +} + void OSCSelectObserver::change_message_with_id (string path, uint32_t id, boost::shared_ptr controllable) { @@ -393,6 +481,17 @@ OSCSelectObserver::change_message_with_id (string path, uint32_t id, boost::shar lo_message_free (msg); } +void +OSCSelectObserver::enable_message_with_id (string path, uint32_t id, boost::shared_ptr controllable) +{ + float val = controllable->get_value(); + if (val) { + send_float_with_id (path, id, 1); + } else { + send_float_with_id (path, id, 0); + } +} + void OSCSelectObserver::text_message (string path, std::string text) { @@ -423,8 +522,8 @@ OSCSelectObserver::monitor_status (boost::shared_ptr controllable) input = 0; } - clear_strip ("/select/monitor_input", (float) input); - clear_strip ("/select/monitor_disk", (float) disk); + send_float ("/select/monitor_input", (float) input); + send_float ("/select/monitor_disk", (float) disk); } void @@ -439,26 +538,59 @@ OSCSelectObserver::trim_message (string path, boost::shared_ptr co } void -OSCSelectObserver::gain_message (string path, boost::shared_ptr controllable) +OSCSelectObserver::gain_message () { - lo_message msg = lo_message_new (); + float value = _strip->gain_control()->get_value(); if (gainmode) { - if (controllable->get_value() == 1) { - lo_message_add_int32 (msg, 800); - } else { - lo_message_add_int32 (msg, gain_to_slider_position (controllable->get_value()) * 1023); - } + text_message ("/select/name", string_compose ("%1%2%3", std::fixed, std::setprecision(2), accurate_coefficient_to_dB (value))); + gain_timeout = 8; + send_float ("/select/fader", gain_to_slider_position (value)); } else { - if (controllable->get_value() < 1e-15) { - lo_message_add_float (msg, -200); + if (value < 1e-15) { + send_float ("/select/gain", -200); } else { - lo_message_add_float (msg, accurate_coefficient_to_dB (controllable->get_value())); + send_float ("/select/gain", accurate_coefficient_to_dB (value)); } } +} - lo_send_message (addr, path.c_str(), msg); - lo_message_free (msg); +void +OSCSelectObserver::gain_automation () +{ + float output; + as = _strip->gain_control()->alist()->automation_state(); + string auto_name; + switch (as) { + case ARDOUR::Off: + output = 0; + auto_name = "Manual"; + break; + case ARDOUR::Play: + output = 1; + auto_name = "Play"; + break; + case ARDOUR::Write: + output = 2; + auto_name = "Write"; + break; + case ARDOUR::Touch: + output = 3; + auto_name = "Touch"; + break; + default: + break; + } + + if (gainmode) { + send_float ("/select/fader/automation", output); + text_message ("/select/fader/automation_name", auto_name); + } else { + send_float ("/select/gain/automation", output); + text_message ("/select/gain/automation_name", auto_name); + } + + gain_message (); } void @@ -467,27 +599,37 @@ OSCSelectObserver::send_gain (uint32_t id, boost::shared_ptr lo_message msg = lo_message_new (); string path; float value; + float db; +#ifdef MIXBUS + db = controllable->get_value(); +#else + if (controllable->get_value() < 1e-15) { + db = -193; + } else { + db = accurate_coefficient_to_dB (controllable->get_value()); + } +#endif if (gainmode) { path = "/select/send_fader"; - if (controllable->get_value() == 1) { - value = 800; - } else { - value = gain_to_slider_position (controllable->get_value()); - } +#ifdef MIXBUS + value = controllable->internal_to_interface (controllable->get_value()); +#else + value = gain_to_slider_position (controllable->get_value()); +#endif + text_with_id ("/select/send_name" , id, string_compose ("%1%2%3", std::fixed, std::setprecision(2), db)); + if (send_timeout.size() > id) { + send_timeout[id] = 8; + } } else { path = "/select/send_gain"; - if (controllable->get_value() < 1e-15) { - value = -193; - } else { - value = accurate_coefficient_to_dB (controllable->get_value()); - } + value = db; } if (feedback[2]) { - path = set_path (path, id + 1); + path = set_path (path, id); } else { - lo_message_add_int32 (msg, id + 1); + lo_message_add_int32 (msg, id); } lo_message_add_float (msg, value); @@ -495,6 +637,15 @@ OSCSelectObserver::send_gain (uint32_t id, boost::shared_ptr lo_message_free (msg); } +void +OSCSelectObserver::send_enable (string path, uint32_t id, boost::shared_ptr proc) +{ + // with no delay value is wrong + Glib::usleep(10); + + send_float_with_id ("/select/send_enable", id, proc->enabled()); +} + void OSCSelectObserver::text_with_id (string path, uint32_t id, string name) { @@ -523,13 +674,39 @@ void OSCSelectObserver::eq_init() { // HPF and enable are special case, rest are in bands - if (_strip->eq_hpf_controllable ()) { - _strip->eq_hpf_controllable ()->Changed.connect (eq_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message, this, X_("/select/eq_hpf"), _strip->eq_hpf_controllable()), OSC::instance()); - change_message ("/select/eq_hpf", _strip->eq_hpf_controllable()); + if (_strip->filter_enable_controllable (true)) { + _strip->filter_enable_controllable (true)->Changed.connect (eq_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message, this, X_("/select/eq_hpf/enable"), _strip->filter_enable_controllable (true)), OSC::instance()); + change_message ("/select/eq_hpf/enable", _strip->filter_enable_controllable(true)); + } + + if (_strip->filter_enable_controllable (false)) { + _strip->filter_enable_controllable (false)->Changed.connect (eq_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message, this, X_("/select/eq_lpf/enable"), _strip->filter_enable_controllable (false)), OSC::instance()); + change_message ("/select/eq_lpf/enable", _strip->filter_enable_controllable(false)); + } + + if (_strip->filter_freq_controllable (true)) { + _strip->filter_freq_controllable (true)->Changed.connect (eq_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message, this, X_("/select/eq_hpf/freq"), _strip->filter_freq_controllable (true)), OSC::instance()); + change_message ("/select/eq_hpf/freq", _strip->filter_freq_controllable(true)); + } + + if (_strip->filter_freq_controllable (false)) { + _strip->filter_freq_controllable (false)->Changed.connect (eq_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message, this, X_("/select/eq_lpf/freq"), _strip->filter_freq_controllable (false)), OSC::instance()); + change_message ("/select/eq_lpf/freq", _strip->filter_freq_controllable(false)); } + + if (_strip->filter_slope_controllable (true)) { + _strip->filter_slope_controllable (true)->Changed.connect (eq_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message, this, X_("/select/eq_hpf/slope"), _strip->filter_slope_controllable (true)), OSC::instance()); + change_message ("/select/eq_hpf/slope", _strip->filter_slope_controllable(true)); + } + + if (_strip->filter_slope_controllable (false)) { + _strip->filter_slope_controllable (false)->Changed.connect (eq_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message, this, X_("/select/eq_lpf/slope"), _strip->filter_slope_controllable (false)), OSC::instance()); + change_message ("/select/eq_lpf/slope", _strip->filter_slope_controllable(false)); + } + if (_strip->eq_enable_controllable ()) { - _strip->eq_enable_controllable ()->Changed.connect (eq_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message, this, X_("/select/eq_enable"), _strip->eq_enable_controllable()), OSC::instance()); - change_message ("/select/eq_enable", _strip->eq_enable_controllable()); + _strip->eq_enable_controllable ()->Changed.connect (eq_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::enable_message, this, X_("/select/eq_enable"), _strip->eq_enable_controllable()), OSC::instance()); + enable_message ("/select/eq_enable", _strip->eq_enable_controllable()); } uint32_t eq_bands = _strip->eq_band_cnt (); @@ -542,19 +719,19 @@ OSCSelectObserver::eq_init() text_with_id ("/select/eq_band_name", i + 1, _strip->eq_band_name (i)); } if (_strip->eq_gain_controllable (i)) { - _strip->eq_gain_controllable(i)->Changed.connect (eq_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message_with_id, this, X_("/select/eq_gain"), i, _strip->eq_gain_controllable(i)), OSC::instance()); + _strip->eq_gain_controllable(i)->Changed.connect (eq_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message_with_id, this, X_("/select/eq_gain"), i + 1, _strip->eq_gain_controllable(i)), OSC::instance()); change_message_with_id ("/select/eq_gain", i + 1, _strip->eq_gain_controllable(i)); } if (_strip->eq_freq_controllable (i)) { - _strip->eq_freq_controllable(i)->Changed.connect (eq_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message_with_id, this, X_("/select/eq_freq"), i, _strip->eq_freq_controllable(i)), OSC::instance()); + _strip->eq_freq_controllable(i)->Changed.connect (eq_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message_with_id, this, X_("/select/eq_freq"), i + 1, _strip->eq_freq_controllable(i)), OSC::instance()); change_message_with_id ("/select/eq_freq", i + 1, _strip->eq_freq_controllable(i)); } if (_strip->eq_q_controllable (i)) { - _strip->eq_q_controllable(i)->Changed.connect (eq_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message_with_id, this, X_("/select/eq_q"), i, _strip->eq_q_controllable(i)), OSC::instance()); + _strip->eq_q_controllable(i)->Changed.connect (eq_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message_with_id, this, X_("/select/eq_q"), i + 1, _strip->eq_q_controllable(i)), OSC::instance()); change_message_with_id ("/select/eq_q", i + 1, _strip->eq_q_controllable(i)); } if (_strip->eq_shape_controllable (i)) { - _strip->eq_shape_controllable(i)->Changed.connect (eq_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message_with_id, this, X_("/select/eq_shape"), i, _strip->eq_shape_controllable(i)), OSC::instance()); + _strip->eq_shape_controllable(i)->Changed.connect (eq_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message_with_id, this, X_("/select/eq_shape"), i + 1, _strip->eq_shape_controllable(i)), OSC::instance()); change_message_with_id ("/select/eq_shape", i + 1, _strip->eq_shape_controllable(i)); } } @@ -565,15 +742,19 @@ OSCSelectObserver::eq_end () { //need to check feedback for [13] eq_connections.drop_connections (); - clear_strip ("/select/eq_hpf", 0); - clear_strip ("/select/eq_enable", 0); + if (_strip->filter_freq_controllable (true)) { + send_float ("/select/eq_hpf", 0); + } + if (_strip->eq_enable_controllable ()) { + send_float ("/select/eq_enable", 0); + } for (uint32_t i = 1; i <= _strip->eq_band_cnt (); i++) { text_with_id ("/select/eq_band_name", i, " "); - clear_strip_with_id ("/select/eq_gain", i, 0); - clear_strip_with_id ("/select/eq_freq", i, 0); - clear_strip_with_id ("/select/eq_q", i, 0); - clear_strip_with_id ("/select/eq_shape", i, 0); + send_float_with_id ("/select/eq_gain", i, 0); + send_float_with_id ("/select/eq_freq", i, 0); + send_float_with_id ("/select/eq_q", i, 0); + send_float_with_id ("/select/eq_shape", i, 0); } @@ -590,15 +771,13 @@ string OSCSelectObserver::set_path (string path, uint32_t id) { if (feedback[2]) { - ostringstream os; - os << path << "/" << id; - path = os.str(); + path = string_compose ("%1/%2", path, id); } return path; } void -OSCSelectObserver::clear_strip (string path, float val) +OSCSelectObserver::send_float (string path, float val) { lo_message msg = lo_message_new (); lo_message_add_float (msg, val); @@ -609,7 +788,7 @@ OSCSelectObserver::clear_strip (string path, float val) } void -OSCSelectObserver::clear_strip_with_id (string path, uint32_t id, float val) +OSCSelectObserver::send_float_with_id (string path, uint32_t id, float val) { lo_message msg = lo_message_new (); if (feedback[2]) {