X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fsurfaces%2Fosc%2Fosc_select_observer.cc;h=c4a5eae09cea26e1bf5f9b80c84a304c8e3eeeed;hb=c4a4857b8710654e8b91aa354f602331ed8fc859;hp=06decb7e324c54911aa7e91b9f210597c411a451;hpb=3e29a46603e0f8f7b06c531498dd3c34b896e5b3;p=ardour.git diff --git a/libs/surfaces/osc/osc_select_observer.cc b/libs/surfaces/osc/osc_select_observer.cc index 06decb7e32..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" @@ -24,211 +25,309 @@ #include "ardour/monitor_control.h" #include "ardour/dB.h" #include "ardour/meter.h" +#include "ardour/phase_control.h" +#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 "i18n.h" +#include + +#include "pbd/i18n.h" using namespace std; using namespace PBD; using namespace ARDOUR; using namespace ArdourSurface; -OSCSelectObserver::OSCSelectObserver (boost::shared_ptr s, lo_address a, uint32_t ss, uint32_t gm, std::bitset<32> fb) +OSCSelectObserver::OSCSelectObserver (boost::shared_ptr s, lo_address a, ArdourSurface::OSC::OSCSurface* su) : _strip (s) - ,ssid (ss) - ,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()); name_changed (ARDOUR::Properties::name); - _strip->mute_control()->Changed.connect (strip_connections, MISSING_INVALIDATOR, bind (&OSCSelectObserver::send_change_message, this, X_("/select/mute"), _strip->mute_control()), OSC::instance()); - send_change_message ("/select/mute", _strip->mute_control()); + _strip->mute_control()->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message, this, X_("/select/mute"), _strip->mute_control()), OSC::instance()); + change_message ("/select/mute", _strip->mute_control()); + + _strip->solo_control()->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message, this, X_("/select/solo"), _strip->solo_control()), OSC::instance()); + change_message ("/select/solo", _strip->solo_control()); - _strip->solo_control()->Changed.connect (strip_connections, MISSING_INVALIDATOR, bind (&OSCSelectObserver::send_change_message, this, X_("/select/solo"), _strip->solo_control()), OSC::instance()); - send_change_message ("/select/solo", _strip->solo_control()); + if (_strip->solo_isolate_control()) { + _strip->solo_isolate_control()->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message, this, X_("/select/solo_iso"), _strip->solo_isolate_control()), OSC::instance()); + change_message ("/select/solo_iso", _strip->solo_isolate_control()); + } + + if (_strip->solo_safe_control()) { + _strip->solo_safe_control()->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message, this, X_("/select/solo_safe"), _strip->solo_safe_control()), OSC::instance()); + change_message ("/select/solo_safe", _strip->solo_safe_control()); + } boost::shared_ptr track = boost::dynamic_pointer_cast (_strip); if (track) { - track->monitoring_control()->Changed.connect (strip_connections, MISSING_INVALIDATOR, bind (&OSCSelectObserver::send_monitor_status, this, track->monitoring_control()), OSC::instance()); - send_monitor_status (track->monitoring_control()); + track->monitoring_control()->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::monitor_status, this, track->monitoring_control()), OSC::instance()); + monitor_status (track->monitoring_control()); } boost::shared_ptr rec_controllable = _strip->rec_enable_control (); if (rec_controllable) { - rec_controllable->Changed.connect (strip_connections, MISSING_INVALIDATOR, bind (&OSCSelectObserver::send_change_message, this, X_("/select/recenable"), _strip->rec_enable_control()), OSC::instance()); - send_change_message ("/select/recenable", _strip->rec_enable_control()); + rec_controllable->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message, this, X_("/select/recenable"), _strip->rec_enable_control()), OSC::instance()); + change_message ("/select/recenable", _strip->rec_enable_control()); } + boost::shared_ptr recsafe_controllable = _strip->rec_safe_control (); - if (rec_controllable) { - recsafe_controllable->Changed.connect (strip_connections, MISSING_INVALIDATOR, bind (&OSCSelectObserver::send_change_message, this, X_("/select/record_safe"), _strip->rec_safe_control()), OSC::instance()); - send_change_message ("/select/record_safe", _strip->rec_safe_control()); + if (recsafe_controllable) { + recsafe_controllable->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message, this, X_("/select/record_safe"), _strip->rec_safe_control()), OSC::instance()); + change_message ("/select/record_safe", _strip->rec_safe_control()); } + + boost::shared_ptr phase_controllable = _strip->phase_control (); + if (phase_controllable) { + phase_controllable->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message, this, X_("/select/polarity"), _strip->phase_control()), OSC::instance()); + change_message ("/select/polarity", _strip->phase_control()); + } + } if (feedback[1]) { // level controls - if (gainmode) { - _strip->gain_control()->Changed.connect (strip_connections, MISSING_INVALIDATOR, bind (&OSCSelectObserver::send_gain_message, this, X_("/select/fader"), _strip->gain_control()), OSC::instance()); - send_gain_message ("/select/fader", _strip->gain_control()); - } else { - _strip->gain_control()->Changed.connect (strip_connections, MISSING_INVALIDATOR, bind (&OSCSelectObserver::send_gain_message, this, X_("/select/gain"), _strip->gain_control()), OSC::instance()); - send_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) { - trim_controllable->Changed.connect (strip_connections, MISSING_INVALIDATOR, bind (&OSCSelectObserver::send_trim_message, this, X_("/select/trimdB"), _strip->trim_control()), OSC::instance()); - send_trim_message ("/select/trimdB", _strip->trim_control()); + trim_controllable->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::trim_message, this, X_("/select/trimdB"), _strip->trim_control()), OSC::instance()); + trim_message ("/select/trimdB", _strip->trim_control()); } boost::shared_ptr pan_controllable = boost::dynamic_pointer_cast(_strip->pan_azimuth_control()); if (pan_controllable) { - pan_controllable->Changed.connect (strip_connections, MISSING_INVALIDATOR, bind (&OSCSelectObserver::send_change_message, this, X_("/select/pan_stereo_position"), _strip->pan_azimuth_control()), OSC::instance()); - send_change_message ("/select/pan_stereo_position", _strip->pan_azimuth_control()); + pan_controllable->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message, this, X_("/select/pan_stereo_position"), _strip->pan_azimuth_control()), OSC::instance()); + change_message ("/select/pan_stereo_position", _strip->pan_azimuth_control()); } + + boost::shared_ptr width_controllable = boost::dynamic_pointer_cast(_strip->pan_width_control()); + if (width_controllable) { + width_controllable->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message, this, X_("/select/pan_stereo_width"), _strip->pan_width_control()), OSC::instance()); + change_message ("/select/pan_stereo_width", _strip->pan_width_control()); + } + + } + 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 :) + if (_strip->pan_elevation_control ()) { + _strip->pan_elevation_control()->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message, this, X_("/select/pan_elevation_position"), _strip->pan_elevation_control()), OSC::instance()); + change_message ("/select/pan_elevation_position", _strip->pan_elevation_control()); + } + if (_strip->pan_frontback_control ()) { + _strip->pan_frontback_control()->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message, this, X_("/select/pan_frontback_position"), _strip->pan_frontback_control()), OSC::instance()); + change_message ("/select/pan_frontback_position", _strip->pan_frontback_control()); + } + if (_strip->pan_lfe_control ()) { + _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); - r->processors_changed.connect (strip_connections, MISSING_INVALIDATOR, bind (&OSCSelectObserver::send_restart, this, -1), OSC::instance()); - send_init(); + 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::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()); + change_message ("/select/comp_threshold", _strip->comp_threshold_controllable()); + } + if (_strip->comp_speed_controllable ()) { + _strip->comp_speed_controllable ()->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::change_message, this, X_("/select/comp_speed"), _strip->comp_speed_controllable()), OSC::instance()); + change_message ("/select/comp_speed", _strip->comp_speed_controllable()); + } + if (_strip->comp_mode_controllable ()) { + _strip->comp_mode_controllable ()->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCSelectObserver::comp_mode, this), OSC::instance()); + comp_mode (); + } + if (_strip->comp_makeup_controllable ()) { + _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()); + } + } + tick(); } OSCSelectObserver::~OSCSelectObserver () { - strip_connections.drop_connections (); // all strip buttons should be off and faders 0 and etc. if (feedback[0]) { // buttons are separate feedback - lo_message msg = lo_message_new (); - // name is a string do it first - string path = "/select/name"; - lo_message_add_string (msg, " "); - lo_send_message (addr, path.c_str(), msg); - lo_message_free (msg); - 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); + send_float ("/select/expand", 0); + text_message ("/select/name", " "); + text_message ("/select/comment", " "); + 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); + 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 + 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", " "); + send_float ("/select/comp_makeup", 0); } send_end(); + eq_end(); 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, bind (&OSCSelectObserver::send_gain, this, X_("/select/send_gain"), nsends, _strip->send_level_controllable(nsends)), OSC::instance()); - send_gain ("/select/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, bind (&OSCSelectObserver::send_enable, this, X_("/select/send_enable"), nsends, _strip->send_enable_controllable(nsends)), OSC::instance()); - send_enable ("/select/send_enable", nsends, _strip->send_enable_controllable(nsends)); - sends = true; - } else if (sends) { - // not used by Ardour, just mixbus so in Ardour always true - lo_message msg = lo_message_new (); - path = "/select/send_enable"; - if (feedback[2]) { - path = set_path (path, nsends + 1); - } else { - lo_message_add_int32 (msg, nsends + 1); + 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); } - lo_message_add_int32 (msg, 1); - lo_send_message (addr, path.c_str(), msg); - lo_message_free (msg); + 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()); } - - if (sends) { // if the gain control is there, this is too - send_rename ("/select/send_name", nsends, _strip->send_name(nsends)); } - // 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++) { - lo_message msg = lo_message_new (); - string path = "/select/send_gain"; - if (feedback[2]) { - path = set_path (path, i); - } else { - lo_message_add_int32 (msg, i); - } - + for (uint32_t i = 1; i <= send_size; i++) { if (gainmode) { - lo_message_add_int32 (msg, 0); + send_float_with_id ("/select/send_fader", i, 0); } else { - lo_message_add_float (msg, -193); + send_float_with_id ("/select/send_gain", i, -193); } - lo_send_message (addr, path.c_str(), msg); - lo_message_free (msg); // next enable - msg = lo_message_new (); - path = "/select/send_enable"; - if (feedback[2]) { - path = set_path (path, i); - } else { - lo_message_add_int32 (msg, i); - } - lo_message_add_int32 (msg, 0); - lo_send_message (addr, path.c_str(), msg); - lo_message_free (msg); + send_float_with_id ("/select/send_enable", i, 0); // next name - msg = lo_message_new (); - path = "/select/send_name"; - if (feedback[2]) { - path = set_path (path, i); - } else { - lo_message_add_int32 (msg, i); - } - lo_message_add_string (msg, " "); - lo_send_message (addr, path.c_str(), msg); - lo_message_free (msg); + text_with_id ("/select/send_name", i, " "); } + // need to delete or clear send_timeout + send_timeout.clear(); nsends = 0; } @@ -243,16 +342,19 @@ void OSCSelectObserver::tick () { if (feedback[7] || feedback[8] || feedback[9]) { // meters enabled - - float now_meter = _strip->peak_meter()->meter_level(0, MeterMCP); - if (now_meter < -193) now_meter = -193; + float now_meter; + if (_strip->peak_meter()) { + now_meter = _strip->peak_meter()->meter_level(0, MeterMCP); + } else { + now_meter = -193; + } + if (now_meter < -144) now_meter = -193; if (_last_meter != now_meter) { if (feedback[7] || feedback[8]) { 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); @@ -282,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]--; + } + } + } } @@ -289,42 +421,90 @@ void OSCSelectObserver::name_changed (const PBD::PropertyChange& what_changed) { if (!what_changed.contains (ARDOUR::Properties::name)) { - return; + return; } if (!_strip) { return; } + text_message ("/select/name", _strip->name()); + boost::shared_ptr route = boost::dynamic_pointer_cast (_strip); + if (route) { + //spit out the comment at the same time + text_message ("/select/comment", route->comment()); + // lets tell the surface how many inputs this strip has + send_float ("/select/n_inputs", (float) route->n_inputs().n_total()); + // lets tell the surface how many outputs this strip has + send_float ("/select/n_outputs", (float) route->n_outputs().n_total()); + } +} + +void +OSCSelectObserver::change_message (string path, boost::shared_ptr controllable) +{ lo_message msg = lo_message_new (); + float val = controllable->get_value(); + + lo_message_add_float (msg, (float) controllable->internal_to_interface (val)); + + lo_send_message (addr, path.c_str(), msg); + 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); + } + +} - // ssid is the strip on the surface this observer refers to - // not part of the internal ordering. - string path = "/select/name"; - /*if (feedback[2]) { - path = set_path (path); +void +OSCSelectObserver::change_message_with_id (string path, uint32_t id, boost::shared_ptr controllable) +{ + lo_message msg = lo_message_new (); + float val = controllable->get_value(); + if (feedback[2]) { + path = set_path (path, id); } else { - lo_message_add_int32 (msg, ssid); - }*/ - lo_message_add_string (msg, _strip->name().c_str()); + lo_message_add_int32 (msg, id); + } + + lo_message_add_float (msg, (float) controllable->internal_to_interface (val)); lo_send_message (addr, path.c_str(), msg); lo_message_free (msg); } void -OSCSelectObserver::send_change_message (string path, boost::shared_ptr controllable) +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) { lo_message msg = lo_message_new (); - lo_message_add_float (msg, (float) controllable->get_value()); + lo_message_add_string (msg, text.c_str()); lo_send_message (addr, path.c_str(), msg); lo_message_free (msg); } void -OSCSelectObserver::send_monitor_status (boost::shared_ptr controllable) +OSCSelectObserver::monitor_status (boost::shared_ptr controllable) { int disk, input; float val = controllable->get_value(); @@ -342,22 +522,12 @@ OSCSelectObserver::send_monitor_status (boost::shared_ptr controll input = 0; } - lo_message msg = lo_message_new (); - string path = "/select/monitor_input"; - lo_message_add_int32 (msg, (float) input); - lo_send_message (addr, path.c_str(), msg); - lo_message_free (msg); - - msg = lo_message_new (); - path = "/select/monitor_disk"; - lo_message_add_int32 (msg, (float) disk); - lo_send_message (addr, path.c_str(), msg); - lo_message_free (msg); - + send_float ("/select/monitor_input", (float) input); + send_float ("/select/monitor_disk", (float) disk); } void -OSCSelectObserver::send_trim_message (string path, boost::shared_ptr controllable) +OSCSelectObserver::trim_message (string path, boost::shared_ptr controllable) { lo_message msg = lo_message_new (); @@ -368,81 +538,122 @@ OSCSelectObserver::send_trim_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::send_gain (std::string path, uint32_t id, boost::shared_ptr controllable) +OSCSelectObserver::gain_automation () { - lo_message msg = lo_message_new (); - - if (feedback[2]) { - path = set_path (path, id + 1); - } else { - lo_message_add_int32 (msg, id + 1); + 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) { - 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); - } + send_float ("/select/fader/automation", output); + text_message ("/select/fader/automation_name", auto_name); } else { - if (controllable->get_value() < 1e-15) { - lo_message_add_float (msg, -200); - } else { - lo_message_add_float (msg, accurate_coefficient_to_dB (controllable->get_value())); - } + send_float ("/select/gain/automation", output); + text_message ("/select/gain/automation_name", auto_name); } - lo_send_message (addr, path.c_str(), msg); - lo_message_free (msg); + gain_message (); } void -OSCSelectObserver::send_enable (string path, uint32_t id, boost::shared_ptr controllable) +OSCSelectObserver::send_gain (uint32_t id, boost::shared_ptr controllable) { lo_message msg = lo_message_new (); - if (feedback[2]) { - path = set_path (path, id + 1); + 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"; +#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 { - lo_message_add_int32 (msg, id + 1); + path = "/select/send_gain"; + value = db; } - lo_message_add_float (msg, (float) controllable->get_value()); + if (feedback[2]) { + path = set_path (path, id); + } else { + lo_message_add_int32 (msg, id); + } + lo_message_add_float (msg, value); lo_send_message (addr, path.c_str(), msg); lo_message_free (msg); } void -OSCSelectObserver::send_rename (string path, uint32_t id, string name) +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) { lo_message msg = lo_message_new (); 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_string (msg, name.c_str()); @@ -451,21 +662,141 @@ OSCSelectObserver::send_rename (string path, uint32_t id, string name) lo_message_free (msg); } +void +OSCSelectObserver::comp_mode () +{ + change_message ("/select/comp_mode", _strip->comp_mode_controllable()); + text_message ("/select/comp_mode_name", _strip->comp_mode_name(_strip->comp_mode_controllable()->get_value())); + text_message ("/select/comp_speed_name", _strip->comp_speed_name(_strip->comp_mode_controllable()->get_value())); +} + +void +OSCSelectObserver::eq_init() +{ + // HPF and enable are special case, rest are in bands + 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::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 (); + if (!eq_bands) { + return; + } + + for (uint32_t i = 0; i < eq_bands; i++) { + if (_strip->eq_band_name(i).size()) { + 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 + 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 + 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 + 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 + 1, _strip->eq_shape_controllable(i)), OSC::instance()); + change_message_with_id ("/select/eq_shape", i + 1, _strip->eq_shape_controllable(i)); + } + } +} + +void +OSCSelectObserver::eq_end () +{ + //need to check feedback for [13] + eq_connections.drop_connections (); + 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, " "); + 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); + + + } +} + +void +OSCSelectObserver::eq_restart(int x) +{ + eq_end(); + eq_init(); +} + 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); + + lo_send_message (addr, path.c_str(), msg); + lo_message_free (msg); + +} + +void +OSCSelectObserver::send_float_with_id (string path, uint32_t id, float val) { lo_message msg = lo_message_new (); + if (feedback[2]) { + path = set_path (path, id); + } else { + lo_message_add_int32 (msg, id); + } + lo_message_add_float (msg, val); lo_send_message (addr, path.c_str(), msg);