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