libs/surfaces/osc/osc_global_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 "ardour/session.h"
  23 #include "ardour/dB.h"
  24 #include "ardour/meter.h"
  25
  26 #include "osc.h"
  27 #include "osc_global_observer.h"
  28
  29 #include "pbd/i18n.h"
  30
  31 using namespace std;
  32 using namespace PBD;
  33 using namespace ARDOUR;
  34 using namespace ArdourSurface;
  35
  36 OSCGlobalObserver::OSCGlobalObserver (Session& s, lo_address a, uint32_t gm, std::bitset<32> fb)
  37         : gainmode (gm)
  38         ,feedback (fb)
  39 {
  40         addr = lo_address_new (lo_address_get_hostname(a) , lo_address_get_port(a));
  41         session = &s;
  42         _last_frame = -1;
  43         if (feedback[4]) {
  44
  45                 // connect to all the things we want to send feed back from
  46
  47                 /*
  48                 *       Master (todo)
  49                 *               Pan width
  50                 */
  51
  52                 // Master channel first
  53                 boost::shared_ptr<Stripable> strip = session->master_out();
  54
  55                 boost::shared_ptr<Controllable> mute_controllable = boost::dynamic_pointer_cast<Controllable>(strip->mute_control());
  56                 mute_controllable->Changed.connect (strip_connections, MISSING_INVALIDATOR, bind (&OSCGlobalObserver::send_change_message, this, X_("/master/mute"), strip->mute_control()), OSC::instance());
  57                 send_change_message ("/master/mute", strip->mute_control());
  58
  59                 boost::shared_ptr<Controllable> trim_controllable = boost::dynamic_pointer_cast<Controllable>(strip->trim_control());
  60                 trim_controllable->Changed.connect (strip_connections, MISSING_INVALIDATOR, bind (&OSCGlobalObserver::send_trim_message, this, X_("/master/trimdB"), strip->trim_control()), OSC::instance());
  61                 send_trim_message ("/master/trimdB", strip->trim_control());
  62
  63                 boost::shared_ptr<Controllable> pan_controllable = boost::dynamic_pointer_cast<Controllable>(strip->pan_azimuth_control());
  64                 if (pan_controllable) {
  65                         pan_controllable->Changed.connect (strip_connections, MISSING_INVALIDATOR, bind (&OSCGlobalObserver::send_change_message, this, X_("/master/pan_stereo_position"), strip->pan_azimuth_control()), OSC::instance());
  66                         send_change_message ("/master/pan_stereo_position", strip->pan_azimuth_control());
  67                 }
  68
  69                 boost::shared_ptr<Controllable> gain_controllable = boost::dynamic_pointer_cast<Controllable>(strip->gain_control());
  70                 if (gainmode) {
  71                         gain_controllable->Changed.connect (strip_connections, MISSING_INVALIDATOR, bind (&OSCGlobalObserver::send_gain_message, this, X_("/master/fader"), strip->gain_control()), OSC::instance());
  72                         send_gain_message ("/master/fader", strip->gain_control());
  73                 } else {
  74                         gain_controllable->Changed.connect (strip_connections, MISSING_INVALIDATOR, bind (&OSCGlobalObserver::send_gain_message, this, X_("/master/gain"), strip->gain_control()), OSC::instance());
  75                         send_gain_message ("/master/gain", strip->gain_control());
  76                 }
  77
  78                 // monitor stuff next
  79                 /*
  80                 *       Monitor (todo)
  81                 *               Mute
  82                 *               Dim
  83                 *               Mono
  84                 *               Rude Solo
  85                 *               etc.
  86                 */
  87                 strip = session->monitor_out();
  88                 if (strip) {
  89
  90                         // Hmm, it seems the monitor mute is not at route->mute_control()
  91                         /*boost::shared_ptr<Controllable> mute_controllable2 = boost::dynamic_pointer_cast<Controllable>(strip->mute_control());
  92                         //mute_controllable = boost::dynamic_pointer_cast<Controllable>(r2->mute_control());
  93                         mute_controllable2->Changed.connect (monitor_mute_connection, MISSING_INVALIDATOR, bind (&OSCGlobalObserver::send_change_message, this, X_("/monitor/mute"), strip->mute_control()), OSC::instance());
  94                         send_change_message ("/monitor/mute", strip->mute_control());
  95                         */
  96                         gain_controllable = boost::dynamic_pointer_cast<Controllable>(strip->gain_control());
  97                         if (gainmode) {
  98                                 gain_controllable->Changed.connect (strip_connections, MISSING_INVALIDATOR, bind (&OSCGlobalObserver::send_gain_message, this, X_("/monitor/fader"), strip->gain_control()), OSC::instance());
  99                                 send_gain_message ("/monitor/fader", strip->gain_control());
 100                         } else {
 101                                 gain_controllable->Changed.connect (strip_connections, MISSING_INVALIDATOR, bind (&OSCGlobalObserver::send_gain_message, this, X_("/monitor/gain"), strip->gain_control()), OSC::instance());
 102                                 send_gain_message ("/monitor/gain", strip->gain_control());
 103                         }
 104                 }
 105
 106                 /*
 107                 *       Transport (todo)
 108                 *               punchin/out
 109                 */
 110                 //Transport feedback
 111                 session->TransportStateChange.connect(session_connections, MISSING_INVALIDATOR, boost::bind (&OSCGlobalObserver::send_transport_state_changed, this), OSC::instance());
 112                 send_transport_state_changed ();
 113                 session->TransportLooped.connect(session_connections, MISSING_INVALIDATOR, boost::bind (&OSCGlobalObserver::send_transport_state_changed, this), OSC::instance());
 114                 session->RecordStateChanged.connect(session_connections, MISSING_INVALIDATOR, boost::bind (&OSCGlobalObserver::send_record_state_changed, this), OSC::instance());
 115                 send_record_state_changed ();
 116
 117                 // session feedback
 118                 session->StateSaved.connect(session_connections, MISSING_INVALIDATOR, boost::bind (&OSCGlobalObserver::text_message, this, X_("/session_name"), _1), OSC::instance());
 119                 text_message (X_("/session_name"), session->snap_name());
 120                 session->SoloActive.connect(session_connections, MISSING_INVALIDATOR, boost::bind (&OSCGlobalObserver::solo_active, this, _1), OSC::instance());
 121                 solo_active (session->soloing() || session->listening());
 122
 123                 /*
 124                 *       Maybe (many) more
 125                 */
 126         }
 127 }
 128
 129 OSCGlobalObserver::~OSCGlobalObserver ()
 130 {
 131
 132         strip_connections.drop_connections ();
 133         session_connections.drop_connections ();
 134
 135         lo_address_free (addr);
 136 }
 137
 138 void
 139 OSCGlobalObserver::tick ()
 140 {
 141         framepos_t now_frame = session->transport_frame();
 142         if (now_frame != _last_frame) {
 143                 if (feedback[6]) { // timecode enabled
 144                         Timecode::Time timecode;
 145                         session->timecode_time (now_frame, timecode);
 146
 147                         // Timecode mode: Hours/Minutes/Seconds/Frames
 148                         ostringstream os;
 149                         os << setw(2) << setfill('0') << timecode.hours;
 150                         os << ':';
 151                         os << setw(2) << setfill('0') << timecode.minutes;
 152                         os << ':';
 153                         os << setw(2) << setfill('0') << timecode.seconds;
 154                         os << ':';
 155                         os << setw(2) << setfill('0') << timecode.frames;
 156
 157                         text_message ("/position/smpte", os.str());
 158                 }
 159                 if (feedback[5]) { // Bar beat enabled
 160                         Timecode::BBT_Time bbt_time;
 161
 162                         session->bbt_time (now_frame, bbt_time);
 163
 164                         // semantics:  BBB/bb/tttt
 165                         ostringstream os;
 166
 167                         os << setw(3) << setfill('0') << bbt_time.bars;
 168                         os << '|';
 169                         os << setw(2) << setfill('0') << bbt_time.beats;
 170                         os << '|';
 171                         os << setw(4) << setfill('0') << bbt_time.ticks;
 172
 173                         text_message ("/position/bbt", os.str());
 174                 }
 175                 if (feedback[11]) { // minutes/seconds enabled
 176                         framepos_t left = now_frame;
 177                         int hrs = (int) floor (left / (session->frame_rate() * 60.0f * 60.0f));
 178                         left -= (framecnt_t) floor (hrs * session->frame_rate() * 60.0f * 60.0f);
 179                         int mins = (int) floor (left / (session->frame_rate() * 60.0f));
 180                         left -= (framecnt_t) floor (mins * session->frame_rate() * 60.0f);
 181                         int secs = (int) floor (left / (float) session->frame_rate());
 182                         left -= (framecnt_t) floor ((double)(secs * session->frame_rate()));
 183                         int millisecs = floor (left * 1000.0 / (float) session->frame_rate());
 184
 185                         // Min/sec mode: Hours/Minutes/Seconds/msec
 186                         ostringstream os;
 187                         os << setw(2) << setfill('0') << hrs;
 188                         os << ':';
 189                         os << setw(2) << setfill('0') << mins;
 190                         os << ':';
 191                         os << setw(2) << setfill('0') << secs;
 192                         os << '.';
 193                         os << setw(3) << setfill('0') << millisecs;
 194
 195                         text_message ("/position/time", os.str());
 196                 }
 197                 if (feedback[10]) { // samples
 198                         ostringstream os;
 199                         os << now_frame;
 200                         text_message ("/position/samples", os.str());
 201                 }
 202                 _last_frame = now_frame;
 203         }
 204         if (feedback[3]) { //heart beat enabled
 205                 if (_heartbeat == 10) {
 206                         lo_message msg = lo_message_new ();
 207                         lo_message_add_float (msg, 1.0);
 208                         lo_send_message (addr, "/heartbeat", msg);
 209                         lo_message_free (msg);
 210                 }
 211                 if (!_heartbeat) {
 212                         lo_message msg = lo_message_new ();
 213                         lo_message_add_float (msg, 0.0);
 214                         lo_send_message (addr, "/heartbeat", msg);
 215                         lo_message_free (msg);
 216                 }
 217                 _heartbeat++;
 218                 if (_heartbeat > 20) _heartbeat = 0;
 219         }
 220         if (feedback[7] || feedback[8] || feedback[9]) { // meters enabled
 221                 // the only meter here is master
 222                 float now_meter = session->master_out()->peak_meter()->meter_level(0, MeterMCP);
 223                 if (now_meter < -94) now_meter = -193;
 224                 if (_last_meter != now_meter) {
 225                         if (feedback[7] || feedback[8]) {
 226                                 lo_message msg = lo_message_new ();
 227                                 if (gainmode && feedback[7]) {
 228                                         // change from db to 0-1
 229                                         lo_message_add_float (msg, ((now_meter + 94) / 100));
 230                                         lo_send_message (addr, "/master/meter", msg);
 231                                 } else if ((!gainmode) && feedback[7]) {
 232                                         lo_message_add_float (msg, now_meter);
 233                                         lo_send_message (addr, "/master/meter", msg);
 234                                 } else if (feedback[8]) {
 235                                         uint32_t ledlvl = (uint32_t)(((now_meter + 54) / 3.75)-1);
 236                                         uint32_t ledbits = ~(0xfff<<ledlvl);
 237                                         lo_message_add_int32 (msg, ledbits);
 238                                         lo_send_message (addr, "/master/meter", msg);
 239                                 }
 240                                 lo_message_free (msg);
 241                         }
 242                         if (feedback[9]) {
 243                                 lo_message msg = lo_message_new ();
 244                                 float signal;
 245                                 if (now_meter < -40) {
 246                                         signal = 0;
 247                                 } else {
 248                                         signal = 1;
 249                                 }
 250                                 lo_message_add_float (msg, signal);
 251                                 lo_send_message (addr, "/master/signal", msg);
 252                                 lo_message_free (msg);
 253                         }
 254                 }
 255                 _last_meter = now_meter;
 256
 257         }
 258 }
 259
 260 void
 261 OSCGlobalObserver::send_change_message (string path, boost::shared_ptr<Controllable> controllable)
 262 {
 263         lo_message msg = lo_message_new ();
 264
 265         lo_message_add_float (msg, (float) controllable->get_value());
 266
 267
 268         lo_send_message (addr, path.c_str(), msg);
 269         lo_message_free (msg);
 270 }
 271
 272 void
 273 OSCGlobalObserver::send_gain_message (string path, boost::shared_ptr<Controllable> controllable)
 274 {
 275         lo_message msg = lo_message_new ();
 276
 277         if (gainmode) {
 278                 lo_message_add_float (msg, gain_to_slider_position (controllable->get_value()));
 279         } else {
 280                 if (controllable->get_value() < 1e-15) {
 281                         lo_message_add_float (msg, -200);
 282                 } else {
 283                         lo_message_add_float (msg, accurate_coefficient_to_dB (controllable->get_value()));
 284                 }
 285         }
 286
 287         lo_send_message (addr, path.c_str(), msg);
 288         lo_message_free (msg);
 289 }
 290
 291 void
 292 OSCGlobalObserver::send_trim_message (string path, boost::shared_ptr<Controllable> controllable)
 293 {
 294         lo_message msg = lo_message_new ();
 295
 296         lo_message_add_float (msg, (float) accurate_coefficient_to_dB (controllable->get_value()));
 297
 298         lo_send_message (addr, path.c_str(), msg);
 299         lo_message_free (msg);
 300 }
 301
 302
 303 void
 304 OSCGlobalObserver::send_transport_state_changed()
 305 {
 306
 307         lo_message msg = lo_message_new ();
 308         lo_message_add_int32 (msg, session->get_play_loop());
 309         lo_send_message (addr, "/loop_toggle", msg);
 310         lo_message_free (msg);
 311
 312         msg = lo_message_new ();
 313         lo_message_add_int32 (msg, session->transport_speed() == 1.0);
 314         lo_send_message (addr, "/transport_play", msg);
 315         lo_message_free (msg);
 316
 317         msg = lo_message_new ();
 318         lo_message_add_int32 (msg, session->transport_stopped ());
 319         lo_send_message (addr, "/transport_stop", msg);
 320         lo_message_free (msg);
 321
 322         msg = lo_message_new ();
 323         lo_message_add_int32 (msg, session->transport_speed() < 0.0);
 324         lo_send_message (addr, "/rewind", msg);
 325         lo_message_free (msg);
 326
 327         msg = lo_message_new ();
 328         lo_message_add_int32 (msg, (session->transport_speed() != 1.0 && session->transport_speed() > 0.0));
 329         lo_send_message (addr, "/ffwd", msg);
 330         lo_message_free (msg);
 331
 332 }
 333
 334 void
 335 OSCGlobalObserver::send_record_state_changed ()
 336 {
 337         lo_message msg = lo_message_new ();
 338         lo_message_add_int32 (msg, (int)session->get_record_enabled ());
 339         lo_send_message (addr, "/rec_enable_toggle", msg);
 340         lo_message_free (msg);
 341
 342         msg = lo_message_new ();
 343         if (session->have_rec_enabled_track ()) {
 344                 lo_message_add_int32 (msg, 1);
 345         } else {
 346                 lo_message_add_int32 (msg, 0);
 347         }
 348         lo_send_message (addr, "/record_tally", msg);
 349         lo_message_free (msg);
 350
 351 }
 352
 353 void
 354 OSCGlobalObserver::solo_active (bool active)
 355 {
 356         lo_message msg = lo_message_new ();
 357         lo_message_add_float (msg, (float) active);
 358         lo_send_message (addr, "/cancel_all_solos", msg);
 359         lo_message_free (msg);
 360 }
 361
 362 void
 363 OSCGlobalObserver::text_message (string path, std::string text)
 364 {
 365         lo_message msg = lo_message_new ();
 366
 367         lo_message_add_string (msg, text.c_str());
 368
 369         lo_send_message (addr, path.c_str(), msg);
 370         lo_message_free (msg);
 371 }