libs/surfaces/osc/osc_route_observer.cc

   1 /*
   2     Copyright (C) 2009 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include "boost/lambda/lambda.hpp"
  21
  22 #include "pbd/control_math.h"
  23 #include <glibmm.h>
  24
  25
  26 #include "ardour/session.h"
  27 #include "ardour/track.h"
  28 #include "ardour/monitor_control.h"
  29 #include "ardour/dB.h"
  30 #include "ardour/meter.h"
  31 #include "ardour/solo_isolate_control.h"
  32
  33 #include "osc.h"
  34 #include "osc_route_observer.h"
  35
  36 #include "pbd/i18n.h"
  37
  38 using namespace std;
  39 using namespace PBD;
  40 using namespace ARDOUR;
  41 using namespace ArdourSurface;
  42
  43 OSCRouteObserver::OSCRouteObserver (OSC& o, uint32_t ss, ArdourSurface::OSC::OSCSurface* su)
  44         : _osc (o)
  45         ,ssid (ss)
  46         ,sur (su)
  47         ,_last_gain (-1.0)
  48         ,_last_trim (-1.0)
  49         ,_init (true)
  50         ,_expand (2048)
  51 {
  52         addr = lo_address_new_from_url (sur->remote_url.c_str());
  53         gainmode = sur->gainmode;
  54         feedback = sur->feedback;
  55         in_line = feedback[2];
  56         uint32_t sid = sur->bank + ssid - 2;
  57         uint32_t not_ready = 0;
  58         if (sur->linkset) {
  59                 not_ready = _osc.link_sets[sur->linkset].not_ready;
  60         }
  61         if (not_ready) {
  62                 set_link_ready (not_ready);
  63         } else if (sid >= sur->strips.size ()) {
  64                 // this _should_ only occure if the number of strips is less than banksize
  65                 _strip = boost::shared_ptr<ARDOUR::Stripable>();
  66                 clear_strip ();
  67         } else {
  68                 _strip = sur->strips[sid];
  69                 refresh_strip (_strip, true);
  70         }
  71         if (sur->expand_enable) {
  72                 set_expand (sur->expand);
  73         } else {
  74                 set_expand (0);
  75         }
  76 }
  77
  78 OSCRouteObserver::~OSCRouteObserver ()
  79 {
  80         _init = true;
  81         strip_connections.drop_connections ();
  82
  83         lo_address_free (addr);
  84 }
  85
  86 void
  87 OSCRouteObserver::no_strip ()
  88 {
  89         // This gets called on drop references
  90         _init = true;
  91
  92         strip_connections.drop_connections ();
  93         /*
  94          * The strip will sit idle at this point doing nothing until
  95          * the surface has recalculated it's strip list and then calls
  96          * refresh_strip. Otherwise refresh strip will get a strip address
  97          * that does not exist... Crash
  98          */
  99  }
 100
 101 void
 102 OSCRouteObserver::refresh_strip (boost::shared_ptr<ARDOUR::Stripable> new_strip, bool force)
 103 {
 104         _init = true;
 105         if (_tick_busy) {
 106                 Glib::usleep(100); // let tick finish
 107         }
 108         _last_gain =-1.0;
 109         _last_trim =-1.0;
 110
 111         send_select_status (ARDOUR::Properties::selected);
 112
 113         if ((new_strip == _strip) && !force) {
 114                 // no change don't send feedback
 115                 _init = false;
 116                 return;
 117         }
 118         strip_connections.drop_connections ();
 119         _strip = new_strip;
 120         if (!_strip) {
 121                 // this strip is blank and should be cleared
 122                 clear_strip ();
 123                 return;
 124         }
 125         _strip->DropReferences.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCRouteObserver::no_strip, this), OSC::instance());
 126         as = ARDOUR::Off;
 127
 128         if (feedback[0]) { // buttons are separate feedback
 129                 _strip->PropertyChanged.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCRouteObserver::name_changed, this, boost::lambda::_1), OSC::instance());
 130                 name_changed (ARDOUR::Properties::name);
 131
 132                 _strip->mute_control()->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCRouteObserver::send_change_message, this, X_("/strip/mute"), _strip->mute_control()), OSC::instance());
 133                 send_change_message ("/strip/mute", _strip->mute_control());
 134
 135                 _strip->solo_control()->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCRouteObserver::send_change_message, this, X_("/strip/solo"), _strip->solo_control()), OSC::instance());
 136                 send_change_message ("/strip/solo", _strip->solo_control());
 137
 138                 if (_strip->solo_isolate_control()) {
 139                         _strip->solo_isolate_control()->Changed.connect (strip_connections, MISSING_INVALIDATOR, bind (&OSCRouteObserver::send_change_message, this, X_("/strip/solo_iso"), _strip->solo_isolate_control()), OSC::instance());
 140                         send_change_message ("/strip/solo_iso", _strip->solo_isolate_control());
 141                 }
 142
 143                 if (_strip->solo_safe_control()) {
 144                         _strip->solo_safe_control()->Changed.connect (strip_connections, MISSING_INVALIDATOR, bind (&OSCRouteObserver::send_change_message, this, X_("/strip/solo_safe"), _strip->solo_safe_control()), OSC::instance());
 145                         send_change_message ("/strip/solo_safe", _strip->solo_safe_control());
 146                 }
 147
 148                 boost::shared_ptr<Track> track = boost::dynamic_pointer_cast<Track> (_strip);
 149                 if (track) {
 150                         track->monitoring_control()->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCRouteObserver::send_monitor_status, this, track->monitoring_control()), OSC::instance());
 151                         send_monitor_status (track->monitoring_control());
 152                 }
 153
 154                 boost::shared_ptr<AutomationControl> rec_controllable = _strip->rec_enable_control ();
 155                 if (rec_controllable) {
 156                         rec_controllable->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCRouteObserver::send_change_message, this, X_("/strip/recenable"), _strip->rec_enable_control()), OSC::instance());
 157                         send_change_message ("/strip/recenable", _strip->rec_enable_control());
 158                 }
 159                 boost::shared_ptr<AutomationControl> recsafe_controllable = _strip->rec_safe_control ();
 160                 if (rec_controllable) {
 161                         recsafe_controllable->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCRouteObserver::send_change_message, this, X_("/strip/record_safe"), _strip->rec_safe_control()), OSC::instance());
 162                         send_change_message ("/strip/record_safe", _strip->rec_safe_control());
 163                 }
 164                 _strip->presentation_info().PropertyChanged.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCRouteObserver::send_select_status, this, _1), OSC::instance());
 165                 send_select_status (ARDOUR::Properties::selected);
 166         }
 167
 168         if (feedback[1]) { // level controls
 169                 boost::shared_ptr<GainControl> gain_cont = _strip->gain_control();
 170                 gain_cont->alist()->automation_state_changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCRouteObserver::gain_automation, this), OSC::instance());
 171                 gain_cont->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCRouteObserver::send_gain_message, this), OSC::instance());
 172                 gain_automation ();
 173
 174                 boost::shared_ptr<Controllable> trim_controllable = boost::dynamic_pointer_cast<Controllable>(_strip->trim_control());
 175                 if (trim_controllable) {
 176                         trim_controllable->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCRouteObserver::send_trim_message, this), OSC::instance());
 177                         send_trim_message ();
 178                 }
 179
 180                 boost::shared_ptr<Controllable> pan_controllable = boost::dynamic_pointer_cast<Controllable>(_strip->pan_azimuth_control());
 181                 if (pan_controllable) {
 182                         pan_controllable->Changed.connect (strip_connections, MISSING_INVALIDATOR, boost::bind (&OSCRouteObserver::send_change_message, this, X_("/strip/pan_stereo_position"), _strip->pan_azimuth_control()), OSC::instance());
 183                         send_change_message ("/strip/pan_stereo_position", _strip->pan_azimuth_control());
 184                 }
 185         }
 186         _init = false;
 187         tick();
 188
 189 }
 190
 191 void
 192 OSCRouteObserver::set_expand (uint32_t expand)
 193 {
 194         if (expand != _expand) {
 195                 _expand = expand;
 196                 if (expand == ssid) {
 197                         _osc.float_message_with_id ("/strip/expand", ssid, 1.0, in_line, addr);
 198                 } else {
 199                         _osc.float_message_with_id ("/strip/expand", ssid, 0.0, in_line, addr);
 200                 }
 201         }
 202 }
 203
 204 void
 205 OSCRouteObserver::set_link_ready (uint32_t not_ready)
 206 {
 207         if (not_ready) {
 208                 clear_strip ();
 209                 switch (ssid) {
 210                         case 1:
 211                                 _osc.text_message_with_id ("/strip/name", ssid, "Device", in_line, addr);
 212                                 break;
 213                         case 2:
 214                                 _osc.text_message_with_id ("/strip/name", ssid, string_compose ("%1", not_ready), in_line, addr);
 215                                 break;
 216                         case 3:
 217                                 _osc.text_message_with_id ("/strip/name", ssid, "Missing", in_line, addr);
 218                                 break;
 219                         case 4:
 220                                 _osc.text_message_with_id ("/strip/name", ssid, "from", in_line, addr);
 221                                 break;
 222                         case 5:
 223                                 _osc.text_message_with_id ("/strip/name", ssid, "Linkset", in_line, addr);
 224                                 break;
 225                         default:
 226                                 break;
 227                 }
 228         } else {
 229                 refresh_strip (_strip, true);
 230         }
 231 }
 232
 233 void
 234 OSCRouteObserver::clear_strip ()
 235 {
 236         _init = true;
 237
 238         strip_connections.drop_connections ();
 239
 240         // all strip buttons should be off and faders 0 and etc.
 241         _osc.float_message_with_id ("/strip/expand", ssid, 0, in_line, addr);
 242         if (feedback[0]) { // buttons are separate feedback
 243                 _osc.text_message_with_id ("/strip/name", ssid, " ", in_line, addr);
 244                 _osc.float_message_with_id ("/strip/mute", ssid, 0, in_line, addr);
 245                 _osc.float_message_with_id ("/strip/solo", ssid, 0, in_line, addr);
 246                 _osc.float_message_with_id ("/strip/recenable", ssid, 0, in_line, addr);
 247                 _osc.float_message_with_id ("/strip/record_safe", ssid, 0, in_line, addr);
 248                 _osc.float_message_with_id ("/strip/monitor_input", ssid, 0, in_line, addr);
 249                 _osc.float_message_with_id ("/strip/monitor_disk", ssid, 0, in_line, addr);
 250                 _osc.float_message_with_id ("/strip/gui_select", ssid, 0, in_line, addr);
 251                 _osc.float_message_with_id ("/strip/select", ssid, 0, in_line, addr);
 252         }
 253         if (feedback[1]) { // level controls
 254                 if (gainmode) {
 255                         _osc.float_message_with_id ("/strip/fader", ssid, 0, in_line, addr);
 256                 } else {
 257                         _osc.float_message_with_id ("/strip/gain", ssid, -193, in_line, addr);
 258                 }
 259                 _osc.float_message_with_id ("/strip/trimdB", ssid, 0, in_line, addr);
 260                 _osc.float_message_with_id ("/strip/pan_stereo_position", ssid, 0.5, in_line, addr);
 261         }
 262         if (feedback[9]) {
 263                 _osc.float_message_with_id ("/strip/signal", ssid, 0, in_line, addr);
 264         }
 265         if (feedback[7]) {
 266                 if (gainmode) {
 267                         _osc.float_message_with_id ("/strip/meter", ssid, 0, in_line, addr);
 268                 } else {
 269                         _osc.float_message_with_id ("/strip/meter", ssid, -193, in_line, addr);
 270                 }
 271         }else if (feedback[8]) {
 272                 _osc.float_message_with_id ("/strip/meter", ssid, 0, in_line, addr);
 273         }
 274 }
 275
 276
 277 void
 278 OSCRouteObserver::tick ()
 279 {
 280         if (_init) {
 281                 return;
 282         }
 283         _tick_busy = true;
 284         if (feedback[7] || feedback[8] || feedback[9]) { // meters enabled
 285                 // the only meter here is master
 286                 float now_meter;
 287                 if (_strip->peak_meter()) {
 288                         now_meter = _strip->peak_meter()->meter_level(0, MeterMCP);
 289                 } else {
 290                         now_meter = -193;
 291                 }
 292                 if (now_meter < -120) now_meter = -193;
 293                 if (_last_meter != now_meter) {
 294                         if (feedback[7] || feedback[8]) {
 295                                 if (gainmode && feedback[7]) {
 296                                         _osc.float_message_with_id ("/strip/meter", ssid, ((now_meter + 94) / 100), in_line, addr);
 297                                 } else if ((!gainmode) && feedback[7]) {
 298                                         _osc.float_message_with_id ("/strip/meter", ssid, now_meter, in_line, addr);
 299                                 } else if (feedback[8]) {
 300                                         uint32_t ledlvl = (uint32_t)(((now_meter + 54) / 3.75)-1);
 301                                         uint16_t ledbits = ~(0xfff<<ledlvl);
 302                                         _osc.int_message_with_id ("/strip/meter", ssid, ledbits, in_line, addr);
 303                                 }
 304                         }
 305                         if (feedback[9]) {
 306                                 float signal;
 307                                 if (now_meter < -40) {
 308                                         signal = 0;
 309                                 } else {
 310                                         signal = 1;
 311                                 }
 312                                 _osc.float_message_with_id ("/strip/signal", ssid, signal, in_line, addr);
 313                         }
 314                 }
 315                 _last_meter = now_meter;
 316
 317         }
 318         if (feedback[1]) {
 319                 if (gain_timeout) {
 320                         if (gain_timeout == 1) {
 321                                 _osc.text_message_with_id ("/strip/name", ssid, _strip->name(), in_line, addr);
 322                         }
 323                         gain_timeout--;
 324                 }
 325                 if (trim_timeout) {
 326                         if (trim_timeout == 1) {
 327                                 _osc.text_message_with_id ("/strip/name", ssid, _strip->name(), in_line, addr);
 328                         }
 329                         trim_timeout--;
 330                 }
 331                 if (as == ARDOUR::Play ||  as == ARDOUR::Touch) {
 332                         if(_last_gain != _strip->gain_control()->get_value()) {
 333                                 _last_gain = _strip->gain_control()->get_value();
 334                                 send_gain_message ();
 335                         }
 336                 }
 337         }
 338         _tick_busy = false;
 339 }
 340
 341 void
 342 OSCRouteObserver::name_changed (const PBD::PropertyChange& what_changed)
 343 {
 344         if (!what_changed.contains (ARDOUR::Properties::name)) {
 345             return;
 346         }
 347
 348         if (_strip) {
 349                 _osc.text_message_with_id ("/strip/name", ssid, _strip->name(), in_line, addr);
 350         }
 351 }
 352
 353 void
 354 OSCRouteObserver::send_change_message (string path, boost::shared_ptr<Controllable> controllable)
 355 {
 356         float val = controllable->get_value();
 357         _osc.float_message_with_id (path, ssid, (float) controllable->internal_to_interface (val), in_line, addr);
 358 }
 359
 360 void
 361 OSCRouteObserver::send_monitor_status (boost::shared_ptr<Controllable> controllable)
 362 {
 363         int disk, input;
 364         float val = controllable->get_value();
 365         switch ((int) val) {
 366                 case 1:
 367                         disk = 0;
 368                         input = 1;
 369                         break;
 370                 case 2:
 371                         disk = 1;
 372                         input = 0;
 373                         break;
 374                 case 3:
 375                         disk = 1;
 376                         input = 1;
 377                         break;
 378                 default:
 379                         disk = 0;
 380                         input = 0;
 381         }
 382         _osc.int_message_with_id ("/strip/monitor_input", ssid, input, in_line, addr);
 383         _osc.int_message_with_id ("/strip/monitor_disk", ssid, disk, in_line, addr);
 384
 385 }
 386
 387 void
 388 OSCRouteObserver::send_trim_message ()
 389 {
 390         if (_last_trim != _strip->trim_control()->get_value()) {
 391                 _last_trim = _strip->trim_control()->get_value();
 392         } else {
 393                 return;
 394         }
 395         if (gainmode) {
 396                 _osc.text_message_with_id ("/strip/name", ssid, string_compose ("%1%2%3", std::fixed, std::setprecision(2), accurate_coefficient_to_dB (_last_trim)), in_line, addr);
 397                 trim_timeout = 8;
 398         }
 399
 400         _osc.float_message_with_id ("/strip/trimdB", ssid, (float) accurate_coefficient_to_dB (_last_trim), in_line, addr);
 401 }
 402
 403 void
 404 OSCRouteObserver::send_gain_message ()
 405 {
 406         boost::shared_ptr<Controllable> controllable = _strip->gain_control();
 407         if (_last_gain != controllable->get_value()) {
 408                 _last_gain = controllable->get_value();
 409         } else {
 410                 return;
 411         }
 412
 413         if (gainmode) {
 414                 _osc.float_message_with_id ("/strip/fader", ssid, controllable->internal_to_interface (_last_gain), in_line, addr);
 415                 _osc.text_message_with_id ("/strip/name", ssid, string_compose ("%1%2%3", std::fixed, std::setprecision(2), accurate_coefficient_to_dB (controllable->get_value())), in_line, addr);
 416                 gain_timeout = 8;
 417         } else {
 418                 if (controllable->get_value() < 1e-15) {
 419                         _osc.float_message_with_id ("/strip/gain", ssid, -200, in_line, addr);
 420                 } else {
 421                         _osc.float_message_with_id ("/strip/gain", ssid, accurate_coefficient_to_dB (_last_gain), in_line, addr);
 422                 }
 423         }
 424 }
 425
 426 void
 427 OSCRouteObserver::gain_automation ()
 428 {
 429         string path = "/strip/gain";
 430         if (gainmode) {
 431                 path = "/strip/fader";
 432         }
 433         send_gain_message ();
 434         as = _strip->gain_control()->alist()->automation_state();
 435         string auto_name;
 436         float output = 0;
 437         switch (as) {
 438                 case ARDOUR::Off:
 439                         output = 0;
 440                         auto_name = "Manual";
 441                         break;
 442                 case ARDOUR::Play:
 443                         output = 1;
 444                         auto_name = "Play";
 445                         break;
 446                 case ARDOUR::Write:
 447                         output = 2;
 448                         auto_name = "Write";
 449                         break;
 450                 case ARDOUR::Touch:
 451                         output = 3;
 452                         auto_name = "Touch";
 453                         break;
 454                 case ARDOUR::Latch:
 455                         output = 4;
 456                         auto_name = "Latch";
 457                         break;
 458                 default:
 459                         break;
 460         }
 461         _osc.float_message_with_id (string_compose ("%1/automation", path), ssid, output, in_line, addr);
 462         _osc.text_message_with_id (string_compose ("%1/automation_name", path), ssid, auto_name, in_line, addr);
 463 }
 464
 465 void
 466 OSCRouteObserver::send_select_status (const PropertyChange& what)
 467 {
 468         if (what == PropertyChange(ARDOUR::Properties::selected)) {
 469                 if (_strip) {
 470                         _osc.float_message_with_id ("/strip/select", ssid, _strip->is_selected(), in_line, addr);
 471                 }
 472         }
 473 }