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 "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         if (feedback[4]) {
  41                 addr = lo_address_new (lo_address_get_hostname(a) , lo_address_get_port(a));
  42                 session = &s;
  43                 _last_frame = -1;
  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                 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());
  65                 send_change_message ("/master/pan_stereo_position", strip->pan_azimuth_control());
  66
  67                 boost::shared_ptr<Controllable> gain_controllable = boost::dynamic_pointer_cast<Controllable>(strip->gain_control());
  68                 if (gainmode) {
  69                         gain_controllable->Changed.connect (strip_connections, MISSING_INVALIDATOR, bind (&OSCGlobalObserver::send_gain_message, this, X_("/master/fader"), strip->gain_control()), OSC::instance());
  70                         send_gain_message ("/master/fader", strip->gain_control());
  71                 } else {
  72                         gain_controllable->Changed.connect (strip_connections, MISSING_INVALIDATOR, bind (&OSCGlobalObserver::send_gain_message, this, X_("/master/gain"), strip->gain_control()), OSC::instance());
  73                         send_gain_message ("/master/gain", strip->gain_control());
  74                 }
  75
  76                 // monitor stuff next
  77                 /*
  78                 *       Monitor (todo)
  79                 *               Mute
  80                 *               Dim
  81                 *               Mono
  82                 *               Rude Solo
  83                 *               etc.
  84                 */
  85                 strip = session->monitor_out();
  86                 if (strip) {
  87
  88                         // Hmm, it seems the monitor mute is not at route->mute_control()
  89                         /*boost::shared_ptr<Controllable> mute_controllable2 = boost::dynamic_pointer_cast<Controllable>(strip->mute_control());
  90                         //mute_controllable = boost::dynamic_pointer_cast<Controllable>(r2->mute_control());
  91                         mute_controllable2->Changed.connect (monitor_mute_connection, MISSING_INVALIDATOR, bind (&OSCGlobalObserver::send_change_message, this, X_("/monitor/mute"), strip->mute_control()), OSC::instance());
  92                         send_change_message ("/monitor/mute", strip->mute_control());
  93                         */
  94                         gain_controllable = boost::dynamic_pointer_cast<Controllable>(strip->gain_control());
  95                         if (gainmode) {
  96                                 gain_controllable->Changed.connect (strip_connections, MISSING_INVALIDATOR, bind (&OSCGlobalObserver::send_gain_message, this, X_("/monitor/fader"), strip->gain_control()), OSC::instance());
  97                                 send_gain_message ("/monitor/fader", strip->gain_control());
  98                         } else {
  99                                 gain_controllable->Changed.connect (strip_connections, MISSING_INVALIDATOR, bind (&OSCGlobalObserver::send_gain_message, this, X_("/monitor/gain"), strip->gain_control()), OSC::instance());
 100                                 send_gain_message ("/monitor/gain", strip->gain_control());
 101                         }
 102                 }
 103
 104                 /*
 105                 *       Transport (todo)
 106                 *               punchin/out
 107                 */
 108                 //Transport feedback
 109                 session->TransportStateChange.connect(session_connections, MISSING_INVALIDATOR, boost::bind (&OSCGlobalObserver::send_transport_state_changed, this), OSC::instance());
 110                 send_transport_state_changed ();
 111                 session->TransportLooped.connect(session_connections, MISSING_INVALIDATOR, boost::bind (&OSCGlobalObserver::send_transport_state_changed, this), OSC::instance());
 112                 session->RecordStateChanged.connect(session_connections, MISSING_INVALIDATOR, boost::bind (&OSCGlobalObserver::send_record_state_changed, this), OSC::instance());
 113                 send_record_state_changed ();
 114
 115                 // session feedback
 116                 session->StateSaved.connect(session_connections, MISSING_INVALIDATOR, boost::bind (&OSCGlobalObserver::send_session_saved, this, _1), OSC::instance());
 117                 send_session_saved (session->snap_name());
 118
 119                 /*
 120                 *       Maybe (many) more
 121                 */
 122         }
 123 }
 124
 125 OSCGlobalObserver::~OSCGlobalObserver ()
 126 {
 127
 128         strip_connections.drop_connections ();
 129         session_connections.drop_connections ();
 130
 131         lo_address_free (addr);
 132 }
 133
 134 void
 135 OSCGlobalObserver::tick ()
 136 {
 137         framepos_t now_frame = session->transport_frame();
 138         if (now_frame != _last_frame) {
 139                 if (feedback[6]) { // timecode enabled
 140                         Timecode::Time timecode;
 141                         session->timecode_time (now_frame, timecode);
 142
 143                         // Timecode mode: Hours/Minutes/Seconds/Frames
 144                         ostringstream os;
 145                         os << setw(2) << setfill('0') << timecode.hours;
 146                         os << ':';
 147                         os << setw(2) << setfill('0') << timecode.minutes;
 148                         os << ':';
 149                         os << setw(2) << setfill('0') << timecode.seconds;
 150                         os << '.';
 151                         os << setw(2) << setfill('0') << timecode.frames;
 152
 153                         lo_message msg = lo_message_new ();
 154                         lo_message_add_string (msg, os.str().c_str());
 155                         lo_send_message (addr, "/timecode", msg);
 156                         lo_message_free (msg);
 157                 }
 158                 if (feedback[5]) { // Bar beat enabled
 159                         Timecode::BBT_Time bbt_time;
 160
 161                         session->bbt_time (now_frame, bbt_time);
 162
 163                         // semantics:  BBB/bb/tttt
 164                         ostringstream os;
 165
 166                         os << setw(3) << setfill('0') << bbt_time.bars;
 167                         os << '|';
 168                         os << setw(2) << setfill('0') << bbt_time.beats;
 169                         os << '|';
 170                         os << setw(4) << setfill('0') << bbt_time.ticks;
 171
 172                         lo_message msg = lo_message_new ();
 173                         lo_message_add_string (msg, os.str().c_str());
 174                         lo_send_message (addr, "/bar_beat", msg);
 175                         lo_message_free (msg);
 176                 }
 177                 _last_frame = now_frame;
 178         }
 179         if (feedback[3]) { //heart beat enabled
 180                 if (_heartbeat == 10) {
 181                         lo_message msg = lo_message_new ();
 182                         lo_message_add_float (msg, 1.0);
 183                         lo_send_message (addr, "/heartbeat", msg);
 184                         lo_message_free (msg);
 185                 }
 186                 if (!_heartbeat) {
 187                         lo_message msg = lo_message_new ();
 188                         lo_message_add_float (msg, 0.0);
 189                         lo_send_message (addr, "/heartbeat", msg);
 190                         lo_message_free (msg);
 191                 }
 192                 _heartbeat++;
 193                 if (_heartbeat > 20) _heartbeat = 0;
 194         }
 195         if (feedback[7] || feedback[8] || feedback[9]) { // meters enabled
 196                 // the only meter here is master
 197                 float now_meter = session->master_out()->peak_meter()->meter_level(0, MeterMCP);
 198                 if (now_meter < -193) now_meter = -193;
 199                 if (_last_meter != now_meter) {
 200                         if (feedback[7] || feedback[8]) {
 201                                 lo_message msg = lo_message_new ();
 202                                 if (gainmode && feedback[7]) {
 203                                         uint32_t lev1023 = (uint32_t)((now_meter + 54) * 17.05);
 204                                         lo_message_add_int32 (msg, lev1023);
 205                                         lo_send_message (addr, "/master/meter", msg);
 206                                 } else if ((!gainmode) && feedback[7]) {
 207                                         lo_message_add_float (msg, now_meter);
 208                                         lo_send_message (addr, "/master/meter", msg);
 209                                 } else if (feedback[8]) {
 210                                         uint32_t ledlvl = (uint32_t)(((now_meter + 54) / 3.75)-1);
 211                                         uint32_t ledbits = ~(0xfff<<ledlvl);
 212                                         lo_message_add_int32 (msg, ledbits);
 213                                         lo_send_message (addr, "/master/meter", msg);
 214                                 }
 215                                 lo_message_free (msg);
 216                         }
 217                         if (feedback[9]) {
 218                                 lo_message msg = lo_message_new ();
 219                                 float signal;
 220                                 if (now_meter < -40) {
 221                                         signal = 0;
 222                                 } else {
 223                                         signal = 1;
 224                                 }
 225                                 lo_message_add_float (msg, signal);
 226                                 lo_send_message (addr, "/master/signal", msg);
 227                                 lo_message_free (msg);
 228                         }
 229                 }
 230                 _last_meter = now_meter;
 231
 232         }
 233 }
 234
 235 void
 236 OSCGlobalObserver::send_change_message (string path, boost::shared_ptr<Controllable> controllable)
 237 {
 238         lo_message msg = lo_message_new ();
 239
 240         lo_message_add_float (msg, (float) controllable->get_value());
 241
 242
 243         lo_send_message (addr, path.c_str(), msg);
 244         lo_message_free (msg);
 245 }
 246
 247 void
 248 OSCGlobalObserver::send_gain_message (string path, boost::shared_ptr<Controllable> controllable)
 249 {
 250         lo_message msg = lo_message_new ();
 251
 252         if (gainmode) {
 253                 if (controllable->get_value() == 1) {
 254                         lo_message_add_int32 (msg, 800);
 255                 } else {
 256                         lo_message_add_int32 (msg, gain_to_slider_position (controllable->get_value()) * 1023);
 257                 }
 258         } else {
 259                 if (controllable->get_value() < 1e-15) {
 260                         lo_message_add_float (msg, -200);
 261                 } else {
 262                         lo_message_add_float (msg, accurate_coefficient_to_dB (controllable->get_value()));
 263                 }
 264         }
 265
 266         lo_send_message (addr, path.c_str(), msg);
 267         lo_message_free (msg);
 268 }
 269
 270 void
 271 OSCGlobalObserver::send_trim_message (string path, boost::shared_ptr<Controllable> controllable)
 272 {
 273         lo_message msg = lo_message_new ();
 274
 275         lo_message_add_float (msg, (float) accurate_coefficient_to_dB (controllable->get_value()));
 276
 277         lo_send_message (addr, path.c_str(), msg);
 278         lo_message_free (msg);
 279 }
 280
 281
 282 void
 283 OSCGlobalObserver::send_transport_state_changed()
 284 {
 285
 286         lo_message msg = lo_message_new ();
 287         lo_message_add_int32 (msg, session->get_play_loop());
 288         lo_send_message (addr, "/loop_toggle", msg);
 289         lo_message_free (msg);
 290
 291         msg = lo_message_new ();
 292         lo_message_add_int32 (msg, session->transport_speed() == 1.0);
 293         lo_send_message (addr, "/transport_play", msg);
 294         lo_message_free (msg);
 295
 296         msg = lo_message_new ();
 297         lo_message_add_int32 (msg, session->transport_stopped ());
 298         lo_send_message (addr, "/transport_stop", msg);
 299         lo_message_free (msg);
 300
 301         msg = lo_message_new ();
 302         lo_message_add_int32 (msg, session->transport_speed() < 0.0);
 303         lo_send_message (addr, "/rewind", msg);
 304         lo_message_free (msg);
 305
 306         msg = lo_message_new ();
 307         lo_message_add_int32 (msg, session->transport_speed() > 1.0);
 308         lo_send_message (addr, "/ffwd", msg);
 309         lo_message_free (msg);
 310
 311 }
 312
 313 void
 314 OSCGlobalObserver::send_record_state_changed ()
 315 {
 316         lo_message msg = lo_message_new ();
 317         lo_message_add_int32 (msg, (int)session->get_record_enabled ());
 318         lo_send_message (addr, "/rec_enable_toggle", msg);
 319         lo_message_free (msg);
 320
 321         msg = lo_message_new ();
 322         if (session->have_rec_enabled_track ()) {
 323                 lo_message_add_int32 (msg, 1);
 324         } else {
 325                 lo_message_add_int32 (msg, 0);
 326         }
 327         lo_send_message (addr, "/record_tally", msg);
 328         lo_message_free (msg);
 329
 330 }
 331
 332 void
 333 OSCGlobalObserver::send_session_saved (std::string name)
 334 {
 335         lo_message msg = lo_message_new ();
 336         lo_message_add_string (msg, name.c_str());
 337         lo_send_message (addr, "/session_name", msg);
 338         lo_message_free (msg);
 339
 340 }
 341