libs/surfaces/osc/osc.cc

   1 /*
   2  * Copyright (C) 2006 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17  *
  18  */
  19
  20 #include <cstdio>
  21 #include <cstdlib>
  22 #include <cerrno>
  23 #include <algorithm>
  24
  25 #include <unistd.h>
  26 #include <fcntl.h>
  27
  28 #include "pbd/gstdio_compat.h"
  29 #include <glibmm/miscutils.h>
  30
  31 #include <pbd/convert.h>
  32 #include <pbd/pthread_utils.h>
  33 #include <pbd/file_utils.h>
  34 #include <pbd/failed_constructor.h>
  35
  36 #include "ardour/amp.h"
  37 #include "ardour/session.h"
  38 #include "ardour/route.h"
  39 #include "ardour/audio_track.h"
  40 #include "ardour/midi_track.h"
  41 #include "ardour/monitor_control.h"
  42 #include "ardour/dB.h"
  43 #include "ardour/filesystem_paths.h"
  44 #include "ardour/panner.h"
  45 #include "ardour/plugin.h"
  46 #include "ardour/plugin_insert.h"
  47 #include "ardour/presentation_info.h"
  48 #include "ardour/send.h"
  49
  50 #include "osc_select_observer.h"
  51 #include "osc.h"
  52 #include "osc_controllable.h"
  53 #include "osc_route_observer.h"
  54 #include "osc_global_observer.h"
  55 #include "i18n.h"
  56
  57 using namespace ARDOUR;
  58 using namespace std;
  59 using namespace Glib;
  60 using namespace ArdourSurface;
  61
  62 #include "pbd/abstract_ui.cc" // instantiate template
  63
  64 OSC* OSC::_instance = 0;
  65
  66 #ifdef DEBUG
  67 static void error_callback(int num, const char *m, const char *path)
  68 {
  69         fprintf(stderr, "liblo server error %d in path %s: %s\n", num, path, m);
  70 }
  71 #else
  72 static void error_callback(int, const char *, const char *)
  73 {
  74
  75 }
  76 #endif
  77
  78 OSC::OSC (Session& s, uint32_t port)
  79         : ControlProtocol (s, X_("Open Sound Control (OSC)"))
  80         , AbstractUI<OSCUIRequest> (name())
  81         , local_server (0)
  82         , remote_server (0)
  83         , _port(port)
  84         , _ok (true)
  85         , _shutdown (false)
  86         , _osc_server (0)
  87         , _osc_unix_server (0)
  88         , _send_route_changes (true)
  89         , _debugmode (Off)
  90         , gui (0)
  91 {
  92         _instance = this;
  93
  94         session->Exported.connect (*this, MISSING_INVALIDATOR, boost::bind (&OSC::session_exported, this, _1, _2), this);
  95 }
  96
  97 OSC::~OSC()
  98 {
  99         stop ();
 100         _instance = 0;
 101 }
 102
 103 void*
 104 OSC::request_factory (uint32_t num_requests)
 105 {
 106         /* AbstractUI<T>::request_buffer_factory() is a template method only
 107            instantiated in this source module. To provide something visible for
 108            use in the interface/descriptor, we have this static method that is
 109            template-free.
 110         */
 111         return request_buffer_factory (num_requests);
 112 }
 113
 114 void
 115 OSC::do_request (OSCUIRequest* req)
 116 {
 117         if (req->type == CallSlot) {
 118
 119                 call_slot (MISSING_INVALIDATOR, req->the_slot);
 120
 121         } else if (req->type == Quit) {
 122
 123                 stop ();
 124         }
 125 }
 126
 127 int
 128 OSC::set_active (bool yn)
 129 {
 130         if (yn != active()) {
 131
 132                 if (yn) {
 133                         if (start ()) {
 134                                 return -1;
 135                         }
 136                 } else {
 137                         if (stop ()) {
 138                                 return -1;
 139                         }
 140                 }
 141
 142         }
 143
 144         return ControlProtocol::set_active (yn);
 145 }
 146
 147 bool
 148 OSC::get_active () const
 149 {
 150         return _osc_server != 0;
 151 }
 152
 153 int
 154 OSC::set_feedback (bool yn)
 155 {
 156         _send_route_changes = yn;
 157         return 0;
 158 }
 159
 160 bool
 161 OSC::get_feedback () const
 162 {
 163         return _send_route_changes;
 164 }
 165
 166 int
 167 OSC::start ()
 168 {
 169         char tmpstr[255];
 170
 171         if (_osc_server) {
 172                 /* already started */
 173                 return 0;
 174         }
 175
 176         for (int j=0; j < 20; ++j) {
 177                 snprintf(tmpstr, sizeof(tmpstr), "%d", _port);
 178
 179                 //if ((_osc_server = lo_server_new_with_proto (tmpstr, LO_TCP, error_callback))) {
 180                 //      break;
 181                 //}
 182
 183                 if ((_osc_server = lo_server_new (tmpstr, error_callback))) {
 184                         break;
 185                 }
 186
 187 #ifdef DEBUG
 188                 cerr << "can't get osc at port: " << _port << endl;
 189 #endif
 190                 _port++;
 191                 continue;
 192         }
 193
 194         if (!_osc_server) {
 195                 return 1;
 196         }
 197
 198 #ifdef ARDOUR_OSC_UNIX_SERVER
 199
 200         // APPEARS sluggish for now
 201
 202         // attempt to create unix socket server too
 203
 204         snprintf(tmpstr, sizeof(tmpstr), "/tmp/sooperlooper_XXXXXX");
 205         int fd = mkstemp(tmpstr);
 206
 207         if (fd >= 0 ) {
 208                 ::g_unlink (tmpstr);
 209                 close (fd);
 210
 211                 _osc_unix_server = lo_server_new (tmpstr, error_callback);
 212
 213                 if (_osc_unix_server) {
 214                         _osc_unix_socket_path = tmpstr;
 215                 }
 216         }
 217 #endif
 218
 219         PBD::info << "OSC @ " << get_server_url () << endmsg;
 220
 221         std::string url_file;
 222
 223         if (find_file (ardour_config_search_path(), "osc_url", url_file)) {
 224                 _osc_url_file = url_file;
 225                 if (g_file_set_contents (_osc_url_file.c_str(), get_server_url().c_str(), -1, NULL)) {
 226                         cerr << "Couldn't write '" <<  _osc_url_file << "'" <<endl;
 227                 }
 228         }
 229
 230         register_callbacks();
 231
 232         session_loaded (*session);
 233
 234         // lo_server_thread_add_method(_sthread, NULL, NULL, OSC::_dummy_handler, this);
 235
 236         /* startup the event loop thread */
 237
 238         BaseUI::run ();
 239
 240         // start timers for metering, timecode and heartbeat.
 241         // timecode and metering run at 100
 242         Glib::RefPtr<Glib::TimeoutSource> periodic_timeout = Glib::TimeoutSource::create (100); // milliseconds
 243         periodic_connection = periodic_timeout->connect (sigc::mem_fun (*this, &OSC::periodic));
 244         periodic_timeout->attach (main_loop()->get_context());
 245
 246         StripableSelectionChanged.connect (session_connections, MISSING_INVALIDATOR, boost::bind (&OSC::gui_selection_changed, this, _1), this);
 247
 248         return 0;
 249 }
 250
 251 void
 252 OSC::thread_init ()
 253 {
 254         pthread_set_name (event_loop_name().c_str());
 255
 256         if (_osc_unix_server) {
 257                 Glib::RefPtr<IOSource> src = IOSource::create (lo_server_get_socket_fd (_osc_unix_server), IO_IN|IO_HUP|IO_ERR);
 258                 src->connect (sigc::bind (sigc::mem_fun (*this, &OSC::osc_input_handler), _osc_unix_server));
 259                 src->attach (_main_loop->get_context());
 260                 local_server = src->gobj();
 261                 g_source_ref (local_server);
 262         }
 263
 264         if (_osc_server) {
 265 #ifdef PLATFORM_WINDOWS
 266                 Glib::RefPtr<IOChannel> chan = Glib::IOChannel::create_from_win32_socket (lo_server_get_socket_fd (_osc_server));
 267                 Glib::RefPtr<IOSource> src  = IOSource::create (chan, IO_IN|IO_HUP|IO_ERR);
 268 #else
 269                 Glib::RefPtr<IOSource> src  = IOSource::create (lo_server_get_socket_fd (_osc_server), IO_IN|IO_HUP|IO_ERR);
 270 #endif
 271                 src->connect (sigc::bind (sigc::mem_fun (*this, &OSC::osc_input_handler), _osc_server));
 272                 src->attach (_main_loop->get_context());
 273                 remote_server = src->gobj();
 274                 g_source_ref (remote_server);
 275         }
 276
 277         PBD::notify_event_loops_about_thread_creation (pthread_self(), event_loop_name(), 2048);
 278         SessionEvent::create_per_thread_pool (event_loop_name(), 128);
 279 }
 280
 281 int
 282 OSC::stop ()
 283 {
 284         /* stop main loop */
 285
 286         if (local_server) {
 287                 g_source_destroy (local_server);
 288                 g_source_unref (local_server);
 289                 local_server = 0;
 290         }
 291
 292         if (remote_server) {
 293                 g_source_destroy (remote_server);
 294                 g_source_unref (remote_server);
 295                 remote_server = 0;
 296         }
 297
 298         BaseUI::quit ();
 299
 300         if (_osc_server) {
 301                 lo_server_free (_osc_server);
 302                 _osc_server = 0;
 303         }
 304
 305         if (_osc_unix_server) {
 306                 lo_server_free (_osc_unix_server);
 307                 _osc_unix_server = 0;
 308         }
 309
 310         if (!_osc_unix_socket_path.empty()) {
 311                 ::g_unlink (_osc_unix_socket_path.c_str());
 312         }
 313
 314         if (!_osc_url_file.empty() ) {
 315                 ::g_unlink (_osc_url_file.c_str() );
 316         }
 317
 318         periodic_connection.disconnect ();
 319         session_connections.drop_connections ();
 320         // Delete any active route observers
 321         for (RouteObservers::iterator x = route_observers.begin(); x != route_observers.end();) {
 322
 323                 OSCRouteObserver* rc;
 324
 325                 if ((rc = dynamic_cast<OSCRouteObserver*>(*x)) != 0) {
 326                         delete *x;
 327                         x = route_observers.erase (x);
 328                 } else {
 329                         ++x;
 330                 }
 331         }
 332 // Should maybe do global_observers too
 333         for (GlobalObservers::iterator x = global_observers.begin(); x != global_observers.end();) {
 334
 335                 OSCGlobalObserver* gc;
 336
 337                 if ((gc = dynamic_cast<OSCGlobalObserver*>(*x)) != 0) {
 338                         delete *x;
 339                         x = global_observers.erase (x);
 340                 } else {
 341                         ++x;
 342                 }
 343         }
 344 // delete select observers
 345         for (uint32_t it = 0; it < _surface.size(); ++it) {
 346                 OSCSurface* sur = &_surface[it];
 347                 OSCSelectObserver* so;
 348                 if ((so = dynamic_cast<OSCSelectObserver*>(sur->sel_obs)) != 0) {
 349                         delete so;
 350                 }
 351         }
 352
 353         return 0;
 354 }
 355
 356 void
 357 OSC::register_callbacks()
 358 {
 359         lo_server srvs[2];
 360         lo_server serv;
 361
 362         srvs[0] = _osc_server;
 363         srvs[1] = _osc_unix_server;
 364
 365         for (size_t i = 0; i < 2; ++i) {
 366
 367                 if (!srvs[i]) {
 368                         continue;
 369                 }
 370
 371                 serv = srvs[i];
 372
 373
 374 #define REGISTER_CALLBACK(serv,path,types, function) lo_server_add_method (serv, path, types, OSC::_ ## function, this)
 375
 376                 // Some controls have optional "f" for feedback or touchosc
 377                 // http://hexler.net/docs/touchosc-controls-reference
 378
 379                 REGISTER_CALLBACK (serv, "/set_surface", "iiii", set_surface);
 380                 REGISTER_CALLBACK (serv, "/set_surface/feedback", "i", set_surface_feedback);
 381                 REGISTER_CALLBACK (serv, "/set_surface/bank_size", "i", set_surface_bank_size);
 382                 REGISTER_CALLBACK (serv, "/set_surface/gainmode", "i", set_surface_gainmode);
 383                 REGISTER_CALLBACK (serv, "/set_surface/strip_types", "i", set_surface_strip_types);
 384                 REGISTER_CALLBACK (serv, "/strip/list", "", routes_list);
 385                 REGISTER_CALLBACK (serv, "/add_marker", "", add_marker);
 386                 REGISTER_CALLBACK (serv, "/add_marker", "f", add_marker);
 387                 REGISTER_CALLBACK (serv, "/access_action", "s", access_action);
 388                 REGISTER_CALLBACK (serv, "/loop_toggle", "", loop_toggle);
 389                 REGISTER_CALLBACK (serv, "/loop_toggle", "f", loop_toggle);
 390                 REGISTER_CALLBACK (serv, "/loop_location", "ii", loop_location);
 391                 REGISTER_CALLBACK (serv, "/goto_start", "", goto_start);
 392                 REGISTER_CALLBACK (serv, "/goto_start", "f", goto_start);
 393                 REGISTER_CALLBACK (serv, "/goto_end", "", goto_end);
 394                 REGISTER_CALLBACK (serv, "/goto_end", "f", goto_end);
 395                 REGISTER_CALLBACK (serv, "/rewind", "", rewind);
 396                 REGISTER_CALLBACK (serv, "/rewind", "f", rewind);
 397                 REGISTER_CALLBACK (serv, "/ffwd", "", ffwd);
 398                 REGISTER_CALLBACK (serv, "/ffwd", "f", ffwd);
 399                 REGISTER_CALLBACK (serv, "/transport_stop", "", transport_stop);
 400                 REGISTER_CALLBACK (serv, "/transport_stop", "f", transport_stop);
 401                 REGISTER_CALLBACK (serv, "/transport_play", "", transport_play);
 402                 REGISTER_CALLBACK (serv, "/transport_play", "f", transport_play);
 403                 REGISTER_CALLBACK (serv, "/transport_frame", "", transport_frame);
 404                 REGISTER_CALLBACK (serv, "/transport_speed", "", transport_speed);
 405                 REGISTER_CALLBACK (serv, "/record_enabled", "", record_enabled);
 406                 REGISTER_CALLBACK (serv, "/set_transport_speed", "f", set_transport_speed);
 407                 // locate ii is position and bool roll
 408                 REGISTER_CALLBACK (serv, "/locate", "ii", locate);
 409                 REGISTER_CALLBACK (serv, "/save_state", "", save_state);
 410                 REGISTER_CALLBACK (serv, "/save_state", "f", save_state);
 411                 REGISTER_CALLBACK (serv, "/prev_marker", "", prev_marker);
 412                 REGISTER_CALLBACK (serv, "/prev_marker", "f", prev_marker);
 413                 REGISTER_CALLBACK (serv, "/next_marker", "", next_marker);
 414                 REGISTER_CALLBACK (serv, "/next_marker", "f", next_marker);
 415                 REGISTER_CALLBACK (serv, "/undo", "", undo);
 416                 REGISTER_CALLBACK (serv, "/undo", "f", undo);
 417                 REGISTER_CALLBACK (serv, "/redo", "", redo);
 418                 REGISTER_CALLBACK (serv, "/redo", "f", redo);
 419                 REGISTER_CALLBACK (serv, "/toggle_punch_in", "", toggle_punch_in);
 420                 REGISTER_CALLBACK (serv, "/toggle_punch_in", "f", toggle_punch_in);
 421                 REGISTER_CALLBACK (serv, "/toggle_punch_out", "", toggle_punch_out);
 422                 REGISTER_CALLBACK (serv, "/toggle_punch_out", "f", toggle_punch_out);
 423                 REGISTER_CALLBACK (serv, "/rec_enable_toggle", "", rec_enable_toggle);
 424                 REGISTER_CALLBACK (serv, "/rec_enable_toggle", "f", rec_enable_toggle);
 425                 REGISTER_CALLBACK (serv, "/toggle_all_rec_enables", "", toggle_all_rec_enables);
 426                 REGISTER_CALLBACK (serv, "/toggle_all_rec_enables", "f", toggle_all_rec_enables);
 427                 REGISTER_CALLBACK (serv, "/all_tracks_rec_in", "f", all_tracks_rec_in);
 428                 REGISTER_CALLBACK (serv, "/all_tracks_rec_out", "f", all_tracks_rec_out);
 429                 REGISTER_CALLBACK (serv, "/remove_marker", "", remove_marker_at_playhead);
 430                 REGISTER_CALLBACK (serv, "/remove_marker", "f", remove_marker_at_playhead);
 431                 REGISTER_CALLBACK (serv, "/jump_bars", "f", jump_by_bars);
 432                 REGISTER_CALLBACK (serv, "/jump_seconds", "f", jump_by_seconds);
 433                 REGISTER_CALLBACK (serv, "/mark_in", "", mark_in);
 434                 REGISTER_CALLBACK (serv, "/mark_in", "f", mark_in);
 435                 REGISTER_CALLBACK (serv, "/mark_out", "", mark_out);
 436                 REGISTER_CALLBACK (serv, "/mark_out", "f", mark_out);
 437                 REGISTER_CALLBACK (serv, "/toggle_click", "", toggle_click);
 438                 REGISTER_CALLBACK (serv, "/toggle_click", "f", toggle_click);
 439                 REGISTER_CALLBACK (serv, "/midi_panic", "", midi_panic);
 440                 REGISTER_CALLBACK (serv, "/midi_panic", "f", midi_panic);
 441                 REGISTER_CALLBACK (serv, "/toggle_roll", "", toggle_roll);
 442                 REGISTER_CALLBACK (serv, "/toggle_roll", "f", toggle_roll);
 443                 REGISTER_CALLBACK (serv, "/stop_forget", "", stop_forget);
 444                 REGISTER_CALLBACK (serv, "/stop_forget", "f", stop_forget);
 445                 REGISTER_CALLBACK (serv, "/set_punch_range", "", set_punch_range);
 446                 REGISTER_CALLBACK (serv, "/set_punch_range", "f", set_punch_range);
 447                 REGISTER_CALLBACK (serv, "/set_loop_range", "", set_loop_range);
 448                 REGISTER_CALLBACK (serv, "/set_loop_range", "f", set_loop_range);
 449                 REGISTER_CALLBACK (serv, "/set_session_range", "", set_session_range);
 450                 REGISTER_CALLBACK (serv, "/set_session_range", "f", set_session_range);
 451                 // /toggle_monitor_* not working (comented out)
 452                 REGISTER_CALLBACK (serv, "/toggle_monitor_mute", "", toggle_monitor_mute);
 453                 REGISTER_CALLBACK (serv, "/toggle_monitor_mute", "f", toggle_monitor_mute);
 454                 REGISTER_CALLBACK (serv, "/toggle_monitor_dim", "", toggle_monitor_dim);
 455                 REGISTER_CALLBACK (serv, "/toggle_monitor_dim", "f", toggle_monitor_dim);
 456                 REGISTER_CALLBACK (serv, "/toggle_monitor_mono", "", toggle_monitor_mono);
 457                 REGISTER_CALLBACK (serv, "/toggle_monitor_mono", "f", toggle_monitor_mono);
 458                 REGISTER_CALLBACK (serv, "/quick_snapshot_switch", "", quick_snapshot_switch);
 459                 REGISTER_CALLBACK (serv, "/quick_snapshot_switch", "f", quick_snapshot_switch);
 460                 REGISTER_CALLBACK (serv, "/quick_snapshot_stay", "", quick_snapshot_stay);
 461                 REGISTER_CALLBACK (serv, "/quick_snapshot_stay", "f", quick_snapshot_stay);
 462                 REGISTER_CALLBACK (serv, "/fit_1_track", "", fit_1_track);
 463                 REGISTER_CALLBACK (serv, "/fit_1_track", "f", fit_1_track);
 464                 REGISTER_CALLBACK (serv, "/fit_2_tracks", "", fit_2_tracks);
 465                 REGISTER_CALLBACK (serv, "/fit_2_tracks", "f", fit_2_tracks);
 466                 REGISTER_CALLBACK (serv, "/fit_4_tracks", "", fit_4_tracks);
 467                 REGISTER_CALLBACK (serv, "/fit_4_tracks", "f", fit_4_tracks);
 468                 REGISTER_CALLBACK (serv, "/fit_8_tracks", "", fit_8_tracks);
 469                 REGISTER_CALLBACK (serv, "/fit_8_tracks", "f", fit_8_tracks);
 470                 REGISTER_CALLBACK (serv, "/fit_16_tracks", "", fit_16_tracks);
 471                 REGISTER_CALLBACK (serv, "/fit_16_tracks", "f", fit_16_tracks);
 472                 REGISTER_CALLBACK (serv, "/fit_32_tracks", "", fit_32_tracks);
 473                 REGISTER_CALLBACK (serv, "/fit_32_tracks", "f", fit_32_tracks);
 474                 REGISTER_CALLBACK (serv, "/fit_all_tracks", "", fit_all_tracks);
 475                 REGISTER_CALLBACK (serv, "/fit_all_tracks", "f", fit_all_tracks);
 476                 REGISTER_CALLBACK (serv, "/zoom_100_ms", "", zoom_100_ms);
 477                 REGISTER_CALLBACK (serv, "/zoom_100_ms", "f", zoom_100_ms);
 478                 REGISTER_CALLBACK (serv, "/zoom_1_sec", "", zoom_1_sec);
 479                 REGISTER_CALLBACK (serv, "/zoom_1_sec", "f", zoom_1_sec);
 480                 REGISTER_CALLBACK (serv, "/zoom_10_sec", "", zoom_10_sec);
 481                 REGISTER_CALLBACK (serv, "/zoom_10_sec", "f", zoom_10_sec);
 482                 REGISTER_CALLBACK (serv, "/zoom_1_min", "", zoom_1_min);
 483                 REGISTER_CALLBACK (serv, "/zoom_1_min", "f", zoom_1_min);
 484                 REGISTER_CALLBACK (serv, "/zoom_5_min", "", zoom_5_min);
 485                 REGISTER_CALLBACK (serv, "/zoom_5_min", "f", zoom_5_min);
 486                 REGISTER_CALLBACK (serv, "/zoom_10_min", "", zoom_10_min);
 487                 REGISTER_CALLBACK (serv, "/zoom_10_min", "f", zoom_10_min);
 488                 REGISTER_CALLBACK (serv, "/zoom_to_session", "", zoom_to_session);
 489                 REGISTER_CALLBACK (serv, "/zoom_to_session", "f", zoom_to_session);
 490                 REGISTER_CALLBACK (serv, "/temporal_zoom_in", "f", temporal_zoom_in);
 491                 REGISTER_CALLBACK (serv, "/temporal_zoom_in", "", temporal_zoom_in);
 492                 REGISTER_CALLBACK (serv, "/temporal_zoom_out", "", temporal_zoom_out);
 493                 REGISTER_CALLBACK (serv, "/temporal_zoom_out", "f", temporal_zoom_out);
 494                 REGISTER_CALLBACK (serv, "/scroll_up_1_track", "f", scroll_up_1_track);
 495                 REGISTER_CALLBACK (serv, "/scroll_up_1_track", "", scroll_up_1_track);
 496                 REGISTER_CALLBACK (serv, "/scroll_dn_1_track", "f", scroll_dn_1_track);
 497                 REGISTER_CALLBACK (serv, "/scroll_dn_1_track", "", scroll_dn_1_track);
 498                 REGISTER_CALLBACK (serv, "/scroll_up_1_page", "f", scroll_up_1_page);
 499                 REGISTER_CALLBACK (serv, "/scroll_up_1_page", "", scroll_up_1_page);
 500                 REGISTER_CALLBACK (serv, "/scroll_dn_1_page", "f", scroll_dn_1_page);
 501                 REGISTER_CALLBACK (serv, "/scroll_dn_1_page", "", scroll_dn_1_page);
 502                 REGISTER_CALLBACK (serv, "/bank_up", "", bank_up);
 503                 REGISTER_CALLBACK (serv, "/bank_up", "f", bank_up);
 504                 REGISTER_CALLBACK (serv, "/bank_down", "", bank_down);
 505                 REGISTER_CALLBACK (serv, "/bank_down", "f", bank_down);
 506
 507                 // controls for "special" strips
 508                 REGISTER_CALLBACK (serv, "/master/gain", "f", master_set_gain);
 509                 REGISTER_CALLBACK (serv, "/master/fader", "i", master_set_fader);
 510                 REGISTER_CALLBACK (serv, "/master/mute", "i", master_set_mute);
 511                 REGISTER_CALLBACK (serv, "/master/trimdB", "f", master_set_trim);
 512                 REGISTER_CALLBACK (serv, "/master/pan_stereo_position", "f", master_set_pan_stereo_position);
 513                 REGISTER_CALLBACK (serv, "/monitor/gain", "f", monitor_set_gain);
 514                 REGISTER_CALLBACK (serv, "/monitor/fader", "i", monitor_set_fader);
 515
 516                 // Controls for the Selected strip
 517                 REGISTER_CALLBACK (serv, "/select/recenable", "i", sel_recenable);
 518                 REGISTER_CALLBACK (serv, "/select/record_safe", "i", sel_recsafe);
 519                 REGISTER_CALLBACK (serv, "/select/mute", "i", sel_mute);
 520                 REGISTER_CALLBACK (serv, "/select/solo", "i", sel_solo);
 521                 REGISTER_CALLBACK (serv, "/select/monitor_input", "i", sel_monitor_input);
 522                 REGISTER_CALLBACK (serv, "/select/monitor_disk", "i", sel_monitor_disk);
 523                 REGISTER_CALLBACK (serv, "/select/gain", "f", sel_gain);
 524                 REGISTER_CALLBACK (serv, "/select/fader", "f", sel_fader);
 525
 526                 /* These commands require the route index in addition to the arg; TouchOSC (et al) can't use these  */
 527                 REGISTER_CALLBACK (serv, "/strip/mute", "ii", route_mute);
 528                 REGISTER_CALLBACK (serv, "/strip/solo", "ii", route_solo);
 529                 REGISTER_CALLBACK (serv, "/strip/recenable", "ii", route_recenable);
 530                 REGISTER_CALLBACK (serv, "/strip/record_safe", "ii", route_recsafe);
 531                 REGISTER_CALLBACK (serv, "/strip/monitor_input", "ii", route_monitor_input);
 532                 REGISTER_CALLBACK (serv, "/strip/monitor_disk", "ii", route_monitor_disk);
 533                 REGISTER_CALLBACK (serv, "/strip/select", "ii", strip_select);
 534                 REGISTER_CALLBACK (serv, "/strip/gui_select", "ii", strip_gui_select);
 535                 REGISTER_CALLBACK (serv, "/strip/gain", "if", route_set_gain_dB);
 536                 REGISTER_CALLBACK (serv, "/strip/fader", "if", route_set_gain_fader);
 537                 REGISTER_CALLBACK (serv, "/strip/trimabs", "if", route_set_trim_abs);
 538                 REGISTER_CALLBACK (serv, "/strip/trimdB", "if", route_set_trim_dB);
 539                 REGISTER_CALLBACK (serv, "/strip/pan_stereo_position", "if", route_set_pan_stereo_position);
 540                 REGISTER_CALLBACK (serv, "/strip/pan_stereo_width", "if", route_set_pan_stereo_width);
 541                 REGISTER_CALLBACK (serv, "/strip/plugin/parameter", "iiif", route_plugin_parameter);
 542                 // prints to cerr only
 543                 REGISTER_CALLBACK (serv, "/strip/plugin/parameter/print", "iii", route_plugin_parameter_print);
 544                 REGISTER_CALLBACK (serv, "/strip/send/gainabs", "iif", route_set_send_gain_abs);
 545                 REGISTER_CALLBACK (serv, "/strip/send/gaindB", "iif", route_set_send_gain_dB);
 546
 547                 /* still not-really-standardized query interface */
 548                 //REGISTER_CALLBACK (serv, "/ardour/*/#current_value", "", current_value);
 549                 //REGISTER_CALLBACK (serv, "/ardour/set", "", set);
 550
 551                 // un/register_update args= s:ctrl s:returl s:retpath
 552                 //lo_server_add_method(serv, "/register_update", "sss", OSC::global_register_update_handler, this);
 553                 //lo_server_add_method(serv, "/unregister_update", "sss", OSC::global_unregister_update_handler, this);
 554                 //lo_server_add_method(serv, "/register_auto_update", "siss", OSC::global_register_auto_update_handler, this);
 555                 //lo_server_add_method(serv, "/unregister_auto_update", "sss", OSC::_global_unregister_auto_update_handler, this);
 556
 557                 /* this is a special catchall handler,
 558                  * register at the end so this is only called if no
 559                  * other handler matches (used for debug) */
 560                 lo_server_add_method (serv, 0, 0, _catchall, this);
 561         }
 562 }
 563
 564 bool
 565 OSC::osc_input_handler (IOCondition ioc, lo_server srv)
 566 {
 567         if (ioc & ~IO_IN) {
 568                 return false;
 569         }
 570
 571         if (ioc & IO_IN) {
 572                 lo_server_recv (srv);
 573         }
 574
 575         return true;
 576 }
 577
 578 std::string
 579 OSC::get_server_url()
 580 {
 581         string url;
 582         char * urlstr;
 583
 584         if (_osc_server) {
 585                 urlstr = lo_server_get_url (_osc_server);
 586                 url = urlstr;
 587                 free (urlstr);
 588         }
 589
 590         return url;
 591 }
 592
 593 std::string
 594 OSC::get_unix_server_url()
 595 {
 596         string url;
 597         char * urlstr;
 598
 599         if (_osc_unix_server) {
 600                 urlstr = lo_server_get_url (_osc_unix_server);
 601                 url = urlstr;
 602                 free (urlstr);
 603         }
 604
 605         return url;
 606 }
 607
 608 void
 609 OSC::listen_to_route (boost::shared_ptr<Stripable> strip, lo_address addr)
 610 {
 611         /* avoid duplicate listens */
 612
 613         for (RouteObservers::iterator x = route_observers.begin(); x != route_observers.end(); ++x) {
 614
 615                 OSCRouteObserver* ro;
 616
 617                 if ((ro = dynamic_cast<OSCRouteObserver*>(*x)) != 0) {
 618
 619                         int res = strcmp(lo_address_get_url(ro->address()), lo_address_get_url(addr));
 620
 621                         if (ro->strip() == strip && res == 0) {
 622                                 return;
 623                         }
 624                 }
 625         }
 626
 627         OSCSurface *s = get_surface(addr);
 628         uint32_t sid = get_sid (strip->presentation_info().order() + 1, addr);
 629         // above is zero based add 1
 630         OSCRouteObserver* o = new OSCRouteObserver (strip, addr, sid, s->gainmode, s->feedback);
 631         route_observers.push_back (o);
 632
 633         strip->DropReferences.connect (*this, MISSING_INVALIDATOR, boost::bind (&OSC::drop_route, this, boost::weak_ptr<Stripable> (strip)), this);
 634 }
 635
 636 void
 637 OSC::drop_route (boost::weak_ptr<Stripable> wr)
 638 {
 639         boost::shared_ptr<Stripable> r = wr.lock ();
 640
 641         if (!r) {
 642                 return;
 643         }
 644
 645         for (RouteObservers::iterator x = route_observers.begin(); x != route_observers.end();) {
 646
 647                 OSCRouteObserver* rc;
 648
 649                 if ((rc = dynamic_cast<OSCRouteObserver*>(*x)) != 0) {
 650
 651                         if (rc->strip() == r) {
 652                                 delete *x;
 653                                 x = route_observers.erase (x);
 654                         } else {
 655                                 ++x;
 656                         }
 657                 } else {
 658                         ++x;
 659                 }
 660         }
 661 }
 662
 663 void
 664 OSC::end_listen (boost::shared_ptr<Stripable> r, lo_address addr)
 665 {
 666         RouteObservers::iterator x;
 667
 668         // Remove the route observers
 669         for (x = route_observers.begin(); x != route_observers.end();) {
 670
 671                 OSCRouteObserver* ro;
 672
 673                 if ((ro = dynamic_cast<OSCRouteObserver*>(*x)) != 0) {
 674
 675                         int res = strcmp(lo_address_get_url(ro->address()), lo_address_get_url(addr));
 676
 677                         if (ro->strip() == r && res == 0) {
 678                                 delete *x;
 679                                 x = route_observers.erase (x);
 680                         }
 681                         else {
 682                                 ++x;
 683                         }
 684                 }
 685                 else {
 686                         ++x;
 687                 }
 688         }
 689 }
 690
 691 void
 692 OSC::current_value_query (const char* path, size_t len, lo_arg **argv, int argc, lo_message msg)
 693 {
 694         char* subpath;
 695
 696         subpath = (char*) malloc (len-15+1);
 697         memcpy (subpath, path, len-15);
 698         subpath[len-15] = '\0';
 699
 700         send_current_value (subpath, argv, argc, msg);
 701
 702         free (subpath);
 703 }
 704
 705 void
 706 OSC::send_current_value (const char* path, lo_arg** argv, int argc, lo_message msg)
 707 {
 708         if (!session) {
 709                 return;
 710         }
 711
 712         lo_message reply = lo_message_new ();
 713         boost::shared_ptr<Route> r;
 714         int id;
 715
 716         lo_message_add_string (reply, path);
 717
 718         if (argc == 0) {
 719                 lo_message_add_string (reply, "bad syntax");
 720         } else {
 721                 id = argv[0]->i;
 722                 r = session->get_remote_nth_route (id);
 723
 724                 if (!r) {
 725                         lo_message_add_string (reply, "not found");
 726                 } else {
 727
 728                         if (strcmp (path, "/strip/state") == 0) {
 729
 730                                 if (boost::dynamic_pointer_cast<AudioTrack>(r)) {
 731                                         lo_message_add_string (reply, "AT");
 732                                 } else if (boost::dynamic_pointer_cast<MidiTrack>(r)) {
 733                                         lo_message_add_string (reply, "MT");
 734                                 } else {
 735                                         lo_message_add_string (reply, "B");
 736                                 }
 737
 738                                 lo_message_add_string (reply, r->name().c_str());
 739                                 lo_message_add_int32 (reply, r->n_inputs().n_audio());
 740                                 lo_message_add_int32 (reply, r->n_outputs().n_audio());
 741                                 lo_message_add_int32 (reply, r->muted());
 742                                 lo_message_add_int32 (reply, r->soloed());
 743
 744                         } else if (strcmp (path, "/strip/mute") == 0) {
 745
 746                                 lo_message_add_int32 (reply, (float) r->muted());
 747
 748                         } else if (strcmp (path, "/strip/solo") == 0) {
 749
 750                                 lo_message_add_int32 (reply, r->soloed());
 751                         }
 752                 }
 753         }
 754
 755         lo_send_message (lo_message_get_source (msg), "#reply", reply);
 756         lo_message_free (reply);
 757 }
 758
 759 int
 760 OSC::_catchall (const char *path, const char *types, lo_arg **argv, int argc, void *data, void *user_data)
 761 {
 762         return ((OSC*)user_data)->catchall (path, types, argv, argc, data);
 763 }
 764
 765 int
 766 OSC::catchall (const char *path, const char* types, lo_arg **argv, int argc, lo_message msg)
 767 {
 768         size_t len;
 769         int ret = 1; /* unhandled */
 770
 771         //cerr << "Received a message, path = " << path << " types = \""
 772         //     << (types ? types : "NULL") << '"' << endl;
 773
 774         /* 15 for /#current_value plus 2 for /<path> */
 775
 776         len = strlen (path);
 777
 778         if (len >= 17 && !strcmp (&path[len-15], "/#current_value")) {
 779                 current_value_query (path, len, argv, argc, msg);
 780                 ret = 0;
 781
 782         } else if (strcmp (path, "/strip/listen") == 0) {
 783
 784                 cerr << "set up listener\n";
 785
 786                 lo_message reply = lo_message_new ();
 787
 788                 if (argc <= 0) {
 789                         lo_message_add_string (reply, "syntax error");
 790                 } else {
 791                         for (int n = 0; n < argc; ++n) {
 792
 793                                 boost::shared_ptr<Route> r = session->get_remote_nth_route (argv[n]->i);
 794
 795                                 if (!r) {
 796                                         lo_message_add_string (reply, "not found");
 797                                         cerr << "no such route\n";
 798                                         break;
 799                                 } else {
 800                                         cerr << "add listener\n";
 801                                         listen_to_route (r, lo_message_get_source (msg));
 802                                         lo_message_add_int32 (reply, argv[n]->i);
 803                                 }
 804                         }
 805                 }
 806
 807                 lo_send_message (lo_message_get_source (msg), "#reply", reply);
 808                 lo_message_free (reply);
 809
 810                 ret = 0;
 811
 812         } else if (strcmp (path, "/strip/ignore") == 0) {
 813
 814                 for (int n = 0; n < argc; ++n) {
 815
 816                         boost::shared_ptr<Route> r = session->get_remote_nth_route (argv[n]->i);
 817
 818                         if (r) {
 819                                 end_listen (r, lo_message_get_source (msg));
 820                         }
 821                 }
 822
 823                 ret = 0;
 824         } else if (argc == 1 && types[0] == 'f') { // single float -- probably TouchOSC
 825                 if (!strncmp (path, "/strip/gain/", 12) && strlen (path) > 12) {
 826                         // in dB
 827                         int ssid = atoi (&path[12]);
 828                         route_set_gain_dB (ssid, argv[0]->f, msg);
 829                         ret = 0;
 830                 }
 831                 else if (!strncmp (path, "/strip/fader/", 13) && strlen (path) > 13) {
 832                         // in fader position
 833                         int ssid = atoi (&path[13]);
 834                         route_set_gain_fader (ssid, argv[0]->f, msg);
 835                         ret = 0;
 836                 }
 837                 else if (!strncmp (path, "/strip/trimdB/", 14) && strlen (path) > 14) {
 838                         int ssid = atoi (&path[14]);
 839                         route_set_trim_dB (ssid, argv[0]->f, msg);
 840                         ret = 0;
 841                 }
 842                 else if (!strncmp (path, "/strip/mute/", 12) && strlen (path) > 12) {
 843                         int ssid = atoi (&path[12]);
 844                         route_mute (ssid, argv[0]->f == 1.0, msg);
 845                         ret = 0;
 846                 }
 847                 else if (!strncmp (path, "/strip/solo/", 12) && strlen (path) > 12) {
 848                         int ssid = atoi (&path[12]);
 849                         route_solo (ssid, argv[0]->f == 1.0, msg);
 850                         ret = 0;
 851                 }
 852                 else if (!strncmp (path, "/strip/monitor_input/", 21) && strlen (path) > 21) {
 853                         int ssid = atoi (&path[21]);
 854                         route_monitor_input (ssid, argv[0]->f == 1.0, msg);
 855                         ret = 0;
 856                 }
 857                 else if (!strncmp (path, "/strip/monitor_disk/", 20) && strlen (path) > 20) {
 858                         int ssid = atoi (&path[20]);
 859                         route_monitor_disk (ssid, argv[0]->f == 1.0, msg);
 860                         ret = 0;
 861                 }
 862                 else if (!strncmp (path, "/strip/recenable/", 17) && strlen (path) > 17) {
 863                         int ssid = atoi (&path[17]);
 864                         route_recenable (ssid, argv[0]->f == 1.0, msg);
 865                         ret = 0;
 866                 }
 867                 else if (!strncmp (path, "/strip/record_safe/", 19) && strlen (path) > 19) {
 868                         int ssid = atoi (&path[19]);
 869                         route_recsafe (ssid, argv[0]->f == 1.0, msg);
 870                         ret = 0;
 871                 }
 872                 else if (!strncmp (path, "/strip/select/", 14) && strlen (path) > 14) {
 873                         int ssid = atoi (&path[14]);
 874                         strip_select (ssid, argv[0]->f == 1.0, msg);
 875                         ret = 0;
 876                 }
 877                 else if (!strncmp (path, "/strip/gui_select/", 18) && strlen (path) > 18) {
 878                         int ssid = atoi (&path[18]);
 879                         strip_gui_select (ssid, argv[0]->f == 1.0, msg);
 880                         ret = 0;
 881                 }
 882         }
 883
 884         if ((ret && _debugmode == Unhandled)) {
 885                 debugmsg (_("Unhandled OSC message"), path, types, argv, argc);
 886         }
 887
 888         return ret;
 889 }
 890
 891 void
 892 OSC::debugmsg (const char *prefix, const char *path, const char* types, lo_arg **argv, int argc)
 893 {
 894         std::stringstream ss;
 895         for (int i = 0; i < argc; ++i) {
 896                 lo_type type = (lo_type)types[i];
 897                         ss << " ";
 898                 switch (type) {
 899                         case LO_INT32:
 900                                 ss << "i:" << argv[i]->i;
 901                                 break;
 902                         case LO_FLOAT:
 903                                 ss << "f:" << argv[i]->f;
 904                                 break;
 905                         case LO_DOUBLE:
 906                                 ss << "d:" << argv[i]->d;
 907                                 break;
 908                         case LO_STRING:
 909                                 ss << "s:" << &argv[i]->s;
 910                                 break;
 911                         case LO_INT64:
 912                                 ss << "h:" << argv[i]->h;
 913                                 break;
 914                         case LO_CHAR:
 915                                 ss << "c:" << argv[i]->s;
 916                                 break;
 917                         case LO_TIMETAG:
 918                                 ss << "<Timetag>";
 919                                 break;
 920                         case LO_BLOB:
 921                                 ss << "<BLOB>";
 922                                 break;
 923                         case LO_TRUE:
 924                                 ss << "#T";
 925                                 break;
 926                         case LO_FALSE:
 927                                 ss << "#F";
 928                                 break;
 929                         case LO_NIL:
 930                                 ss << "NIL";
 931                                 break;
 932                         case LO_INFINITUM:
 933                                 ss << "#inf";
 934                                 break;
 935                         case LO_MIDI:
 936                                 ss << "<MIDI>";
 937                                 break;
 938                         case LO_SYMBOL:
 939                                 ss << "<SYMBOL>";
 940                                 break;
 941                         default:
 942                                 ss << "< ?? >";
 943                                 break;
 944                 }
 945         }
 946         PBD::info << prefix << ": " << path << ss.str() << endmsg;
 947 }
 948
 949 void
 950 OSC::update_clock ()
 951 {
 952
 953 }
 954
 955 // "Application Hook" Handlers //
 956 void
 957 OSC::session_loaded (Session& s)
 958 {
 959 //      lo_address listener = lo_address_new (NULL, "7770");
 960 //      lo_send (listener, "/session/loaded", "ss", s.path().c_str(), s.name().c_str());
 961 }
 962
 963 void
 964 OSC::session_exported (std::string path, std::string name)
 965 {
 966         lo_address listener = lo_address_new (NULL, "7770");
 967         lo_send (listener, "/session/exported", "ss", path.c_str(), name.c_str());
 968         lo_address_free (listener);
 969 }
 970
 971 // end "Application Hook" Handlers //
 972
 973 /* path callbacks */
 974
 975 int
 976 OSC::current_value (const char */*path*/, const char */*types*/, lo_arg **/*argv*/, int /*argc*/, void */*data*/, void* /*user_data*/)
 977 {
 978 #if 0
 979         const char* returl;
 980
 981         if (argc < 3 || types == 0 || strlen (types) < 3 || types[0] != 's' || types[1] != 's' || types[2] != s) {
 982                 return 1;
 983         }
 984
 985         const char *returl = argv[1]->s;
 986         lo_address addr = find_or_cache_addr (returl);
 987
 988         const char *retpath = argv[2]->s;
 989
 990
 991         if (strcmp (argv[0]->s, "transport_frame") == 0) {
 992
 993                 if (session) {
 994                         lo_send (addr, retpath, "i", session->transport_frame());
 995                 }
 996
 997         } else if (strcmp (argv[0]->s, "transport_speed") == 0) {
 998
 999                 if (session) {
1000                         lo_send (addr, retpath, "i", session->transport_frame());
1001                 }
1002
1003         } else if (strcmp (argv[0]->s, "transport_locked") == 0) {
1004
1005                 if (session) {
1006                         lo_send (addr, retpath, "i", session->transport_frame());
1007                 }
1008
1009         } else if (strcmp (argv[0]->s, "punch_in") == 0) {
1010
1011                 if (session) {
1012                         lo_send (addr, retpath, "i", session->transport_frame());
1013                 }
1014
1015         } else if (strcmp (argv[0]->s, "punch_out") == 0) {
1016
1017                 if (session) {
1018                         lo_send (addr, retpath, "i", session->transport_frame());
1019                 }
1020
1021         } else if (strcmp (argv[0]->s, "rec_enable") == 0) {
1022
1023                 if (session) {
1024                         lo_send (addr, retpath, "i", session->transport_frame());
1025                 }
1026
1027         } else {
1028
1029                 /* error */
1030         }
1031 #endif
1032         return 0;
1033 }
1034
1035 void
1036 OSC::routes_list (lo_message msg)
1037 {
1038         if (!session) {
1039                 return;
1040         }
1041         for (int n = 0; n < (int) session->nroutes(); ++n) {
1042
1043                 boost::shared_ptr<Route> r = session->get_remote_nth_route (n);
1044
1045                 if (r) {
1046
1047                         lo_message reply = lo_message_new ();
1048
1049                         if (boost::dynamic_pointer_cast<AudioTrack>(r)) {
1050                                 lo_message_add_string (reply, "AT");
1051                         } else if (boost::dynamic_pointer_cast<MidiTrack>(r)) {
1052                                 lo_message_add_string (reply, "MT");
1053                         } else {
1054                                 lo_message_add_string (reply, "B");
1055                         }
1056
1057                         lo_message_add_string (reply, r->name().c_str());
1058                         lo_message_add_int32 (reply, r->n_inputs().n_audio());
1059                         lo_message_add_int32 (reply, r->n_outputs().n_audio());
1060                         lo_message_add_int32 (reply, r->muted());
1061                         lo_message_add_int32 (reply, r->soloed());
1062                         /* XXX Can only use order at this point */
1063                         lo_message_add_int32 (reply, r->presentation_info().order());
1064
1065                         if (boost::dynamic_pointer_cast<AudioTrack>(r)
1066                                         || boost::dynamic_pointer_cast<MidiTrack>(r)) {
1067
1068                                 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track>(r);
1069                                 lo_message_add_int32 (reply, (int32_t) t->rec_enable_control()->get_value());
1070                         }
1071
1072                         //Automatically listen to routes listed
1073                         listen_to_route(r, lo_message_get_source (msg));
1074
1075                         lo_send_message (lo_message_get_source (msg), "#reply", reply);
1076                         lo_message_free (reply);
1077                 }
1078         }
1079
1080         // Send end of listing message
1081         lo_message reply = lo_message_new ();
1082
1083         lo_message_add_string (reply, "end_route_list");
1084         lo_message_add_int64 (reply, session->frame_rate());
1085         lo_message_add_int64 (reply, session->current_end_frame());
1086
1087         lo_send_message (lo_message_get_source (msg), "#reply", reply);
1088
1089         lo_message_free (reply);
1090 }
1091
1092 int
1093 OSC::set_surface (uint32_t b_size, uint32_t strips, uint32_t fb, uint32_t gm, lo_message msg)
1094 {
1095         OSCSurface *s = get_surface(lo_message_get_source (msg));
1096         s->bank_size = b_size;
1097         s->strip_types = strips;
1098         //next line could be a call that finds out how many strips there are
1099         s->nstrips = session->nroutes(); // need to do this for strips
1100         s->feedback = fb;
1101         s->gainmode = gm;
1102         // set bank and strip feedback
1103         set_bank(s->bank, msg);
1104
1105         global_feedback (s->feedback, msg, s->gainmode);
1106         return 0;
1107 }
1108
1109 int
1110 OSC::set_surface_bank_size (uint32_t bs, lo_message msg)
1111 {
1112         OSCSurface *s = get_surface(lo_message_get_source (msg));
1113         s->bank_size = bs;
1114
1115         // set bank and strip feedback
1116         set_bank(s->bank, msg);
1117         return 0;
1118 }
1119
1120
1121 int
1122 OSC::set_surface_strip_types (uint32_t st, lo_message msg)
1123 {
1124         OSCSurface *s = get_surface(lo_message_get_source (msg));
1125         s->strip_types = st;
1126         //next line could be a call that finds out how many strips there are
1127         s->nstrips = session->nroutes(); // need to do this for strips
1128
1129         // set bank and strip feedback
1130         set_bank(s->bank, msg);
1131         return 0;
1132 }
1133
1134
1135 int
1136 OSC::set_surface_feedback (uint32_t fb, lo_message msg)
1137 {
1138         OSCSurface *s = get_surface(lo_message_get_source (msg));
1139         s->feedback = fb;
1140
1141         // set bank and strip feedback
1142         set_bank(s->bank, msg);
1143
1144         // Set global/master feedback
1145         global_feedback (s->feedback, msg, s->gainmode);
1146         return 0;
1147 }
1148
1149
1150 int
1151 OSC::set_surface_gainmode (uint32_t gm, lo_message msg)
1152 {
1153         OSCSurface *s = get_surface(lo_message_get_source (msg));
1154         s->gainmode = gm;
1155
1156         // set bank and strip feedback
1157         set_bank(s->bank, msg);
1158
1159         // Set global/master feedback
1160         global_feedback (s->feedback, msg, s->gainmode);
1161         return 0;
1162 }
1163
1164 OSC::OSCSurface *
1165 OSC::get_surface (lo_address addr)
1166 {
1167         string r_url;
1168         char * rurl;
1169         rurl = lo_address_get_url (addr);
1170         r_url = rurl;
1171         free (rurl);
1172         for (uint32_t it = 0; it < _surface.size(); ++it) {
1173                 //find setup for this server
1174                 if (!_surface[it].remote_url.find(r_url)){
1175                         return &_surface[it];
1176                 }
1177         }
1178         // No surface create one with default values
1179         OSCSurface s;
1180         s.remote_url = r_url;
1181         s.bank = 1;
1182         s.bank_size = 0; // need to find out how many strips there are
1183         s.nstrips = session->nroutes(); // may need to do this after MARK below
1184         s.strip_types = 31; // 31 is tracks, busses, and VCAs (no master/monitor)
1185         s.feedback = 0;
1186         s.gainmode = 0;
1187         s.sel_obs = 0;
1188         s.surface_sel = 0;
1189         //get sorted should go here
1190         _surface.push_back (s);
1191         //MARK
1192         return &_surface[_surface.size() - 1];
1193 }
1194
1195 // setup global feedback for a surface
1196 void
1197 OSC::global_feedback (bitset<32> feedback, lo_address msg, uint32_t gainmode)
1198 {
1199         // first destroy global observer for this surface
1200         GlobalObservers::iterator x;
1201
1202         for (x = global_observers.begin(); x != global_observers.end();) {
1203
1204                 OSCGlobalObserver* ro;
1205
1206                 if ((ro = dynamic_cast<OSCGlobalObserver*>(*x)) != 0) {
1207
1208                         int res = strcmp(lo_address_get_url(ro->address()), lo_address_get_url(lo_message_get_source (msg)));
1209
1210                         if (res == 0) {
1211                                 delete *x;
1212                                 x = global_observers.erase (x);
1213                         } else {
1214                                 ++x;
1215                         }
1216                 } else {
1217                         ++x;
1218                 }
1219         }
1220         if (feedback[4] || feedback[3] || feedback[5] || feedback[6]) {
1221                 // create a new Global Observer for this surface
1222                 //OSCSurface *s = get_surface (lo_message_get_source (msg));
1223                 OSCGlobalObserver* o = new OSCGlobalObserver (*session, lo_message_get_source (msg), gainmode, /*s->*/feedback);
1224                 global_observers.push_back (o);
1225         }
1226 }
1227
1228 /*
1229  * This gets called not only when bank changes but also:
1230  *  - bank size change
1231  *  - feedback change
1232  *  - strip types changes
1233  *  - fadermode changes
1234  *  - stripable creation/deletion/flag
1235  *  - to refresh what is "displayed"
1236  * Basically any time the bank needs to be rebuilt
1237  */
1238 int
1239 OSC::set_bank (uint32_t bank_start, lo_message msg)
1240 {
1241         if (!session) {
1242                 return -1;
1243         }
1244         //StripableList strips;
1245         //session->get_stripables (strips);
1246         // no nstripables yet
1247         if (!session->nroutes()) {
1248                 return -1;
1249         }
1250         // don't include monitor or master in count for now
1251         uint32_t nstrips;
1252         if (session->monitor_out ()) {
1253                 nstrips = session->nroutes() - 2;
1254         } else {
1255                 nstrips = session->nroutes() - 1;
1256         }
1257         // reset local select
1258         _strip_select (0, lo_message_get_source (msg));
1259         // undo all listeners for this url
1260         for (int n = 0; n <= (int) nstrips; ++n) {
1261
1262                 boost::shared_ptr<Stripable> stp = session->get_remote_nth_stripable (n, PresentationInfo::Route);
1263
1264                 if (stp) {
1265                         end_listen (stp, lo_message_get_source (msg));
1266                 }
1267         }
1268
1269         OSCSurface *s = get_surface (lo_message_get_source (msg));
1270         uint32_t b_size;
1271
1272         if (!s->bank_size) {
1273                 // no banking
1274                 b_size = nstrips;
1275         } else {
1276                 b_size = s->bank_size;
1277         }
1278
1279         // Do limits checking - high end still not quite right
1280         if (bank_start < 1) bank_start = 1;
1281         if (b_size >= nstrips)  {
1282                 bank_start = 1;
1283         } else if ((bank_start > nstrips)) {
1284                 bank_start = (uint32_t)((nstrips - b_size) + 1);
1285         }
1286         //save bank in case we have had to change it
1287         s->bank = bank_start;
1288
1289         if (s->feedback[0] || s->feedback[1]) {
1290                 for (int n = bank_start; n < (int) (b_size + bank_start); ++n) {
1291                         // this next will eventually include strip types
1292                         boost::shared_ptr<Stripable> stp = session->get_remote_nth_stripable (n - 1, PresentationInfo::Route);
1293
1294                         if (stp) {
1295                         listen_to_route(stp, lo_message_get_source (msg));
1296                         }
1297                 }
1298                 // put in check for GUI_selects here.
1299         }
1300         return 0;
1301 }
1302
1303 int
1304 OSC::bank_up (lo_message msg)
1305 {
1306         if (!session) {
1307                 return -1;
1308         }
1309         OSCSurface *s = get_surface(lo_message_get_source (msg));
1310         set_bank (s->bank + s->bank_size, msg);
1311         return 0;
1312 }
1313
1314 int
1315 OSC::bank_down (lo_message msg)
1316 {
1317         if (!session) {
1318                 return -1;
1319         }
1320         OSCSurface *s = get_surface(lo_message_get_source (msg));
1321         if (s->bank < s->bank_size) {
1322                 set_bank (1, msg);
1323         } else {
1324                 set_bank (s->bank - s->bank_size, msg);
1325         }
1326         return 0;
1327 }
1328
1329 uint32_t
1330 OSC::get_sid (uint32_t rid, lo_address addr)
1331 {
1332         OSCSurface *s = get_surface(addr);
1333         return rid - s->bank + 1;
1334 }
1335
1336 uint32_t
1337 OSC::get_rid (uint32_t ssid, lo_address addr)
1338 {
1339         OSCSurface *s = get_surface(addr);
1340         return ssid + s->bank - 2;
1341 }
1342
1343 void
1344 OSC::transport_frame (lo_message msg)
1345 {
1346         if (!session) {
1347                 return;
1348         }
1349         framepos_t pos = session->transport_frame ();
1350
1351         lo_message reply = lo_message_new ();
1352         lo_message_add_int64 (reply, pos);
1353
1354         lo_send_message (lo_message_get_source (msg), "/transport_frame", reply);
1355
1356         lo_message_free (reply);
1357 }
1358
1359 void
1360 OSC::transport_speed (lo_message msg)
1361 {
1362         if (!session) {
1363                 return;
1364         }
1365         double ts = session->transport_speed ();
1366
1367         lo_message reply = lo_message_new ();
1368         lo_message_add_double (reply, ts);
1369
1370         lo_send_message (lo_message_get_source (msg), "/transport_speed", reply);
1371
1372         lo_message_free (reply);
1373 }
1374
1375 void
1376 OSC::record_enabled (lo_message msg)
1377 {
1378         if (!session) {
1379                 return;
1380         }
1381         int re = (int)session->get_record_enabled ();
1382
1383         lo_message reply = lo_message_new ();
1384         lo_message_add_int32 (reply, re);
1385
1386         lo_send_message (lo_message_get_source (msg), "/record_enabled", reply);
1387
1388         lo_message_free (reply);
1389 }
1390
1391 // master and monitor calls
1392 int
1393 OSC::master_set_gain (float dB)
1394 {
1395         if (!session) return -1;
1396         boost::shared_ptr<Stripable> s = session->master_out();
1397         if (s) {
1398                 if (dB < -192) {
1399                         s->gain_control()->set_value (0.0, PBD::Controllable::NoGroup);
1400                 } else {
1401                         s->gain_control()->set_value (dB_to_coefficient (dB), PBD::Controllable::NoGroup);
1402                 }
1403         }
1404         return 0;
1405 }
1406
1407 int
1408 OSC::master_set_fader (uint32_t position)
1409 {
1410         if (!session) return -1;
1411         boost::shared_ptr<Stripable> s = session->master_out();
1412         if (s) {
1413                 if ((position > 799.5) && (position < 800.5)) {
1414                         s->gain_control()->set_value (1.0, PBD::Controllable::NoGroup);
1415                 } else {
1416                         s->gain_control()->set_value (slider_position_to_gain_with_max (((float)position/1023), 2.0), PBD::Controllable::NoGroup);
1417                 }
1418         }
1419         return 0;
1420 }
1421
1422 int
1423 OSC::master_set_trim (float dB)
1424 {
1425         if (!session) return -1;
1426         boost::shared_ptr<Stripable> s = session->master_out();
1427
1428         if (s) {
1429                 s->trim_control()->set_value (dB_to_coefficient (dB), PBD::Controllable::NoGroup);
1430         }
1431
1432         return 0;
1433 }
1434
1435 int
1436 OSC::master_set_pan_stereo_position (float position)
1437 {
1438         if (!session) return -1;
1439
1440         boost::shared_ptr<Stripable> s = session->master_out();
1441
1442         if (s) {
1443                 if (s->pan_azimuth_control()) {
1444                         s->pan_azimuth_control()->set_value (position, PBD::Controllable::NoGroup);
1445                 }
1446         }
1447
1448         return 0;
1449 }
1450
1451 int
1452 OSC::master_set_mute (uint32_t state)
1453 {
1454         if (!session) return -1;
1455
1456         boost::shared_ptr<Stripable> s = session->master_out();
1457
1458         if (s) {
1459                 s->mute_control()->set_value (state, PBD::Controllable::NoGroup);
1460         }
1461
1462         return 0;
1463 }
1464
1465 int
1466 OSC::monitor_set_gain (float dB)
1467 {
1468         if (!session) return -1;
1469         boost::shared_ptr<Stripable> s = session->monitor_out();
1470
1471         if (s) {
1472                 if (dB < -192) {
1473                         s->gain_control()->set_value (0.0, PBD::Controllable::NoGroup);
1474                 } else {
1475                         s->gain_control()->set_value (dB_to_coefficient (dB), PBD::Controllable::NoGroup);
1476                 }
1477         }
1478         return 0;
1479 }
1480
1481 int
1482 OSC::monitor_set_fader (uint32_t position)
1483 {
1484         if (!session) return -1;
1485         boost::shared_ptr<Stripable> s = session->monitor_out();
1486         if (s) {
1487                 if ((position > 799.5) && (position < 800.5)) {
1488                         s->gain_control()->set_value (1.0, PBD::Controllable::NoGroup);
1489                 } else {
1490                         s->gain_control()->set_value (slider_position_to_gain_with_max (((float)position/1023), 2.0), PBD::Controllable::NoGroup);
1491                 }
1492         }
1493         return 0;
1494 }
1495
1496 // strip calls
1497 int
1498 OSC::route_mute (int ssid, int yn, lo_message msg)
1499 {
1500         if (!session) return -1;
1501         int rid = get_rid (ssid, lo_message_get_source (msg));
1502
1503         boost::shared_ptr<Stripable> s = session->get_remote_nth_stripable (rid, PresentationInfo::Route);
1504
1505         if (s) {
1506                 s->mute_control()->set_value (yn ? 1.0 : 0.0, PBD::Controllable::NoGroup);
1507         }
1508
1509         return 0;
1510 }
1511
1512 int
1513 OSC::sel_mute (uint32_t yn, lo_message msg)
1514 {
1515         OSCSurface *sur = get_surface(lo_message_get_source (msg));
1516         if (sur->surface_sel) {
1517                 return route_mute(sur->surface_sel, yn, msg);
1518         } else {
1519                 return route_send_fail ("mute", 0, 0, lo_message_get_source (msg));
1520         }
1521 }
1522
1523 int
1524 OSC::route_solo (int ssid, int yn, lo_message msg)
1525 {
1526         if (!session) return -1;
1527         int rid = get_rid (ssid, lo_message_get_source (msg));
1528
1529         boost::shared_ptr<Stripable> s = session->get_remote_nth_stripable (rid, PresentationInfo::Route);
1530
1531         if (s) {
1532                 s->solo_control()->set_value (yn ? 1.0 : 0.0, PBD::Controllable::NoGroup);
1533         }
1534
1535         return 0;
1536 }
1537
1538 int
1539 OSC::sel_solo (uint32_t yn, lo_message msg)
1540 {
1541         OSCSurface *sur = get_surface(lo_message_get_source (msg));
1542         if (sur->surface_sel) {
1543                 return route_solo(sur->surface_sel, yn, msg);
1544         } else {
1545                 return route_send_fail ("solo", 0, 0, lo_message_get_source (msg));
1546         }
1547 }
1548
1549 int
1550 OSC::sel_recenable (uint32_t yn, lo_message msg)
1551 {
1552         OSCSurface *sur = get_surface(lo_message_get_source (msg));
1553         if (sur->surface_sel) {
1554                 return route_recenable(sur->surface_sel, yn, msg);
1555         } else {
1556                 return route_send_fail ("recenable", 0, 0, lo_message_get_source (msg));
1557         }
1558 }
1559
1560 int
1561 OSC::route_recenable (int ssid, int yn, lo_message msg)
1562 {
1563         if (!session) return -1;
1564         int rid = get_rid (ssid, lo_message_get_source (msg));
1565
1566         boost::shared_ptr<Stripable> s = session->get_remote_nth_stripable (rid, PresentationInfo::Route);
1567
1568         if (s) {
1569                 if (s->rec_enable_control()) {
1570                         s->rec_enable_control()->set_value (yn, PBD::Controllable::UseGroup);
1571                         if (s->rec_enable_control()->get_value()) {
1572                                 return 0;
1573                         }
1574                 }
1575         }
1576         // hmm, not set for whatever reason tell surface
1577         return route_send_fail ("recenable", ssid, 0, lo_message_get_source (msg));
1578 }
1579
1580 int
1581 OSC::sel_recsafe (uint32_t yn, lo_message msg)
1582 {
1583         OSCSurface *sur = get_surface(lo_message_get_source (msg));
1584         if (sur->surface_sel) {
1585                 return route_recsafe(sur->surface_sel, yn, msg);
1586         } else {
1587                 return route_send_fail ("record_safe", 0, 0, lo_message_get_source (msg));
1588         }
1589 }
1590
1591 int
1592 OSC::route_recsafe (int ssid, int yn, lo_message msg)
1593 {
1594         if (!session) return -1;
1595         int rid = get_rid (ssid, lo_message_get_source (msg));
1596
1597         boost::shared_ptr<Stripable> s = session->get_remote_nth_stripable (rid, PresentationInfo::Route);
1598         if (s) {
1599                 if (s->rec_safe_control()) {
1600                         s->rec_safe_control()->set_value (yn, PBD::Controllable::UseGroup);
1601                         if (s->rec_safe_control()->get_value()) {
1602                                 return 0;
1603                         }
1604                 }
1605         }
1606         // hmm, not set for whatever reason tell surface
1607         return route_send_fail ("record_safe", ssid, 0,lo_message_get_source (msg));
1608 }
1609
1610 int
1611 OSC::route_monitor_input (int ssid, int yn, lo_message msg)
1612 {
1613         if (!session) return -1;
1614         int rid = get_rid (ssid, lo_message_get_source (msg));
1615
1616         boost::shared_ptr<Stripable> s = session->get_remote_nth_stripable (rid, PresentationInfo::Route);
1617
1618         if (s) {
1619                 boost::shared_ptr<Track> track = boost::dynamic_pointer_cast<Track> (s);
1620                 if (track) {
1621                         track->monitoring_control()->set_value (yn ? 1.0 : 0.0, PBD::Controllable::NoGroup);
1622                 } else {
1623                         route_send_fail ("monitor_input", ssid, 0, lo_message_get_source (msg));
1624                 }
1625         }
1626
1627         return 0;
1628 }
1629
1630 int
1631 OSC::sel_monitor_input (uint32_t yn, lo_message msg)
1632 {
1633         OSCSurface *sur = get_surface(lo_message_get_source (msg));
1634         if (sur->surface_sel) {
1635                 return route_monitor_input(sur->surface_sel, yn, msg);
1636         } else {
1637                 return route_send_fail ("monitor_input", 0, 0, lo_message_get_source (msg));
1638         }
1639 }
1640
1641 int
1642 OSC::route_monitor_disk (int ssid, int yn, lo_message msg)
1643 {
1644         if (!session) return -1;
1645         int rid = get_rid (ssid, lo_message_get_source (msg));
1646
1647         boost::shared_ptr<Stripable> s = session->get_remote_nth_stripable (rid, PresentationInfo::Route);
1648
1649         if (s) {
1650                 boost::shared_ptr<Track> track = boost::dynamic_pointer_cast<Track> (s);
1651                 if (track) {
1652                         track->monitoring_control()->set_value (yn ? 2.0 : 0.0, PBD::Controllable::NoGroup);
1653                 } else {
1654                         route_send_fail ("monitor_disk", ssid, 0, lo_message_get_source (msg));
1655                 }
1656         }
1657
1658         return 0;
1659 }
1660
1661 int
1662 OSC::sel_monitor_disk (uint32_t yn, lo_message msg)
1663 {
1664         OSCSurface *sur = get_surface(lo_message_get_source (msg));
1665         if (sur->surface_sel) {
1666                 return route_monitor_disk(sur->surface_sel, yn, msg);
1667         } else {
1668                 return route_send_fail ("monitor_disk", 0, 0, lo_message_get_source (msg));
1669         }
1670 }
1671
1672 int
1673 OSC::strip_select (int ssid, int yn, lo_message msg)
1674 {
1675         //ignore button release
1676         if (!yn) return 0;
1677
1678         return _strip_select ( ssid, lo_message_get_source (msg));
1679 }
1680
1681 int
1682 OSC::_strip_select (int ssid, lo_address addr)
1683 {
1684         if (!session) {
1685                 route_send_fail ("select", ssid, 0, addr);
1686                 return -1;
1687         }
1688         int rid = get_rid (ssid, addr);
1689         boost::shared_ptr<Stripable> s = session->get_remote_nth_stripable (rid, PresentationInfo::Route);
1690         OSCSurface *sur = get_surface(addr);
1691         if (sur->sel_obs) {
1692                 delete sur->sel_obs;
1693                 sur->sel_obs = 0;
1694         }
1695                 sur->surface_sel = 0;
1696
1697         if (s) {
1698                 sur->surface_sel = ssid;
1699                 OSCSelectObserver* sel_fb = new OSCSelectObserver (s, addr, ssid, sur->gainmode, sur->feedback);
1700                 sur->sel_obs = sel_fb;
1701         } else {
1702                 route_send_fail ("select", ssid, 0 , addr);
1703         }
1704         int b_s = sur->bank_size;
1705         if (!b_s) { // bank size 0 means we need to know how many strips there are.
1706                 b_s = sur->nstrips;
1707         }
1708         for (int i = 1;  i <= b_s; i++) {
1709                         if (i==(int)sur->surface_sel) {
1710                                 string path = "/strip/select";
1711                                 lo_message reply = lo_message_new ();
1712                                 if (sur->feedback[2]) {
1713                                         ostringstream os;
1714                                         os << path << "/" << ssid;
1715                                         path = os.str();
1716                                 } else {
1717                                 lo_message_add_int32 (reply, ssid);
1718                                 }
1719                                 lo_message_add_float (reply, (float) 1);
1720
1721                                 lo_send_message (addr, path.c_str(), reply);
1722                                 lo_message_free (reply);
1723                         } else {
1724                                 route_send_fail ("select", i, 0, addr);
1725                         }
1726         }
1727
1728         return 0;
1729 }
1730
1731 int
1732 OSC::strip_gui_select (int ssid, int yn, lo_message msg)
1733 {
1734         //ignore button release
1735         if (!yn) return 0;
1736
1737         if (!session) {
1738                 route_send_fail ("gui_select", ssid, 0, lo_message_get_source (msg));
1739                 return -1;
1740         }
1741         int ret = strip_select (ssid, yn, msg);
1742         if (ret != 0) {
1743                 return ret;
1744         }
1745         int rid = get_rid (ssid, lo_message_get_source (msg));
1746         boost::shared_ptr<Stripable> s = session->get_remote_nth_stripable (rid, PresentationInfo::Route);
1747         //OSCSurface *sur = get_surface(lo_message_get_source (msg));
1748
1749         if (s) {
1750                 //s->set_select();
1751                 //sur->surface_sel = ssid;
1752         } else {
1753                 route_send_fail ("gui_select", ssid, 0, lo_message_get_source (msg));
1754         }
1755
1756         return 0;
1757 }
1758
1759 int
1760 OSC::route_set_gain_abs (int rid, float level, lo_message msg)
1761 {
1762         if (!session) return -1;
1763         boost::shared_ptr<Stripable> s = session->get_remote_nth_stripable (rid, PresentationInfo::Route);
1764
1765         if (s) {
1766                 s->gain_control()->set_value (level, PBD::Controllable::NoGroup);
1767         }
1768
1769         return 0;
1770 }
1771
1772 int
1773 OSC::route_set_gain_dB (int ssid, float dB, lo_message msg)
1774 {
1775         if (!session) {
1776                 route_send_fail ("gain", ssid, -193, lo_message_get_source (msg));
1777                 return -1;
1778         }
1779         int ret;
1780         int rid = get_rid (ssid, lo_message_get_source (msg));
1781         if (dB < -192) {
1782                 ret = route_set_gain_abs (rid, 0.0, msg);
1783         } else {
1784                 ret = route_set_gain_abs (rid, dB_to_coefficient (dB), msg);
1785         }
1786         if (ret != 0) {
1787                 route_send_fail ("gain", ssid, -193, lo_message_get_source (msg));
1788         }
1789         return ret;
1790 }
1791
1792 int
1793 OSC::sel_gain (float val, lo_message msg)
1794 {
1795         OSCSurface *sur = get_surface(lo_message_get_source (msg));
1796         if (sur->surface_sel) {
1797                 return route_set_gain_dB(sur->surface_sel, val, msg);
1798         } else {
1799                 return route_send_fail ("gain", 0, -193, lo_message_get_source (msg));
1800         }
1801 }
1802
1803 int
1804 OSC::route_set_gain_fader (int ssid, float pos, lo_message msg)
1805 {
1806         if (!session) {
1807                 route_send_fail ("fader", ssid, 0, lo_message_get_source (msg));
1808                 return -1;
1809         }
1810         int ret;
1811         int rid = get_rid (ssid, lo_message_get_source (msg));
1812         if ((pos > 799.5) && (pos < 800.5)) {
1813                 ret = route_set_gain_abs (rid, 1.0, msg);
1814         } else {
1815                 ret = route_set_gain_abs (rid, slider_position_to_gain_with_max ((pos/1023), 2.0), msg);
1816         }
1817         if (ret != 0) {
1818                 route_send_fail ("fader", ssid, 0, lo_message_get_source (msg));
1819         }
1820         return ret;
1821 }
1822
1823 int
1824 OSC::sel_fader (float val, lo_message msg)
1825 {
1826         OSCSurface *sur = get_surface(lo_message_get_source (msg));
1827         if (sur->surface_sel) {
1828                 return route_set_gain_fader(sur->surface_sel, val, msg);
1829         } else {
1830                 return route_send_fail ("fader", 0, 0, lo_message_get_source (msg));
1831         }
1832 }
1833
1834 int
1835 OSC::route_set_trim_abs (int ssid, float level, lo_message msg)
1836 {
1837         if (!session) return -1;
1838         int rid = get_rid (ssid, lo_message_get_source (msg));
1839
1840         boost::shared_ptr<Stripable> s = session->get_remote_nth_stripable (rid, PresentationInfo::Route);
1841
1842         if (s) {
1843                 if (s->trim_control()) {
1844                         s->trim_control()->set_value (level, PBD::Controllable::NoGroup);
1845                 }
1846
1847         }
1848
1849         return 0;
1850 }
1851
1852 int
1853 OSC::route_set_trim_dB (int ssid, float dB, lo_message msg)
1854 {
1855         return route_set_trim_abs(ssid, dB_to_coefficient (dB), msg);
1856 }
1857
1858
1859 int
1860 OSC::route_set_pan_stereo_position (int ssid, float pos, lo_message msg)
1861 {
1862         if (!session) return -1;
1863         int rid = get_rid (ssid, lo_message_get_source (msg));
1864
1865         boost::shared_ptr<Stripable> s = session->get_remote_nth_stripable (rid, PresentationInfo::Route);
1866
1867         if (s) {
1868                 if(s->pan_azimuth_control()) {
1869                         s->pan_azimuth_control()->set_value (pos, PBD::Controllable::NoGroup);
1870                 }
1871         }
1872
1873         return 0;
1874
1875 }
1876
1877 int
1878 OSC::route_set_pan_stereo_width (int ssid, float pos, lo_message msg)
1879 {
1880         if (!session) return -1;
1881         int rid = get_rid (ssid, lo_message_get_source (msg));
1882
1883         boost::shared_ptr<Stripable> s = session->get_remote_nth_stripable (rid, PresentationInfo::Route);
1884
1885         if (s) {
1886                 if (s->pan_width_control()) {
1887                         s->pan_width_control()->set_value (pos, PBD::Controllable::NoGroup);
1888                 }
1889         }
1890
1891         return 0;
1892
1893 }
1894
1895 int
1896 OSC::route_set_send_gain_abs (int ssid, int sid, float val, lo_message msg)
1897 {
1898         if (!session) {
1899                 return -1;
1900         }
1901         int rid = get_rid (ssid, lo_message_get_source (msg));
1902
1903         boost::shared_ptr<Stripable> s = session->get_remote_nth_stripable (rid, PresentationInfo::Route);
1904
1905         if (!s) {
1906                 return -1;
1907         }
1908
1909         /* revert to zero-based counting */
1910
1911         if (sid > 0) {
1912                 --sid;
1913         }
1914
1915         if (s->send_level_controllable (sid)) {
1916                 s->send_level_controllable (sid)->set_value (val, PBD::Controllable::NoGroup);
1917         }
1918
1919         return 0;
1920 }
1921
1922 int
1923 OSC::route_set_send_gain_dB (int ssid, int sid, float val, lo_message msg)
1924 {
1925         return route_set_send_gain_abs (ssid, sid, dB_to_coefficient (val), msg);
1926 }
1927
1928 int
1929 OSC::route_plugin_parameter (int ssid, int piid, int par, float val, lo_message msg)
1930 {
1931         if (!session)
1932                 return -1;
1933         int rid = get_rid (ssid, lo_message_get_source (msg));
1934
1935         boost::shared_ptr<Route> r = session->get_remote_nth_route (rid);
1936
1937         if (!r) {
1938                 PBD::error << "OSC: Invalid Remote Control ID '" << rid << "'" << endmsg;
1939                 return -1;
1940         }
1941
1942         boost::shared_ptr<Processor> redi=r->nth_plugin (piid);
1943
1944         if (!redi) {
1945                 PBD::error << "OSC: cannot find plugin # " << piid << " for RID '" << rid << "'" << endmsg;
1946                 return -1;
1947         }
1948
1949         boost::shared_ptr<PluginInsert> pi;
1950
1951         if (!(pi = boost::dynamic_pointer_cast<PluginInsert>(redi))) {
1952                 PBD::error << "OSC: given processor # " << piid << " on RID '" << rid << "' is not a Plugin." << endmsg;
1953                 return -1;
1954         }
1955
1956         boost::shared_ptr<ARDOUR::Plugin> pip = pi->plugin();
1957         bool ok=false;
1958
1959         uint32_t controlid = pip->nth_parameter (par,ok);
1960
1961         if (!ok) {
1962                 PBD::error << "OSC: Cannot find parameter # " << par <<  " for plugin # " << piid << " on RID '" << rid << "'" << endmsg;
1963                 return -1;
1964         }
1965
1966         if (!pip->parameter_is_input(controlid)) {
1967                 PBD::error << "OSC: Parameter # " << par <<  " for plugin # " << piid << " on RID '" << rid << "' is not a control input" << endmsg;
1968                 return -1;
1969         }
1970
1971         ParameterDescriptor pd;
1972         pi->plugin()->get_parameter_descriptor (controlid,pd);
1973
1974         if (val >= pd.lower && val <= pd.upper) {
1975
1976                 boost::shared_ptr<AutomationControl> c = pi->automation_control (Evoral::Parameter(PluginAutomation, 0, controlid));
1977                 // cerr << "parameter:" << redi->describe_parameter(controlid) << " val:" << val << "\n";
1978                 c->set_value (val, PBD::Controllable::NoGroup);
1979         } else {
1980                 PBD::warning << "OSC: Parameter # " << par <<  " for plugin # " << piid << " on RID '" << rid << "' is out of range" << endmsg;
1981                 PBD::info << "OSC: Valid range min=" << pd.lower << " max=" << pd.upper << endmsg;
1982         }
1983
1984         return 0;
1985 }
1986
1987 //prints to cerr only
1988 int
1989 OSC::route_plugin_parameter_print (int ssid, int piid, int par, lo_message msg)
1990 {
1991         if (!session) {
1992                 return -1;
1993         }
1994         int rid = get_rid (ssid, lo_message_get_source (msg));
1995
1996         boost::shared_ptr<Route> r = session->get_remote_nth_route (rid);
1997
1998         if (!r) {
1999                 return -1;
2000         }
2001
2002         boost::shared_ptr<Processor> redi=r->nth_processor (piid);
2003
2004         if (!redi) {
2005                 return -1;
2006         }
2007
2008         boost::shared_ptr<PluginInsert> pi;
2009
2010         if (!(pi = boost::dynamic_pointer_cast<PluginInsert>(redi))) {
2011                 return -1;
2012         }
2013
2014         boost::shared_ptr<ARDOUR::Plugin> pip = pi->plugin();
2015         bool ok=false;
2016
2017         uint32_t controlid = pip->nth_parameter (par,ok);
2018
2019         if (!ok) {
2020                 return -1;
2021         }
2022
2023         ParameterDescriptor pd;
2024
2025         if (pi->plugin()->get_parameter_descriptor (controlid, pd) == 0) {
2026                 boost::shared_ptr<AutomationControl> c = pi->automation_control (Evoral::Parameter(PluginAutomation, 0, controlid));
2027
2028                 cerr << "parameter:     " << redi->describe_parameter(controlid)  << "\n";
2029                 cerr << "current value: " << c->get_value ();
2030                 cerr << "lower value:   " << pd.lower << "\n";
2031                 cerr << "upper value:   " << pd.upper << "\n";
2032         }
2033
2034         return 0;
2035 }
2036
2037 void
2038 OSC::gui_selection_changed (StripableNotificationListPtr stripables)
2039 {
2040         boost::shared_ptr<Stripable> strip;
2041
2042         if (!stripables->empty()) {
2043                 strip = stripables->front().lock();
2044         }
2045         if (strip) {
2046                 for (uint32_t it = 0; it < _surface.size(); ++it) {
2047                         OSCSurface* sur = &_surface[it];
2048                         if(!sur->feedback[10]) {
2049                                 uint32_t sel_strip = strip->presentation_info().order() + 1;
2050                                 if (!(sel_strip < sur->bank) && !(sel_strip >= (sur->bank + sur->bank_size))) {
2051                                         lo_address addr = lo_address_new_from_url (sur->remote_url.c_str());
2052                                         _strip_select ((sel_strip - sur->bank + 1), addr);
2053                                 }
2054                         }
2055                 }
2056         }
2057
2058 }
2059
2060 // timer callbacks
2061 bool
2062 OSC::periodic (void)
2063 {
2064         for (GlobalObservers::iterator x = global_observers.begin(); x != global_observers.end(); x++) {
2065
2066                 OSCGlobalObserver* go;
2067
2068                 if ((go = dynamic_cast<OSCGlobalObserver*>(*x)) != 0) {
2069                         go->tick();
2070                 }
2071         }
2072         for (RouteObservers::iterator x = route_observers.begin(); x != route_observers.end(); x++) {
2073
2074                 OSCRouteObserver* ro;
2075
2076                 if ((ro = dynamic_cast<OSCRouteObserver*>(*x)) != 0) {
2077                         ro->tick();
2078                 }
2079         }
2080         for (uint32_t it = 0; it < _surface.size(); ++it) {
2081                 OSCSurface* sur = &_surface[it];
2082                 OSCSelectObserver* so;
2083                 if ((so = dynamic_cast<OSCSelectObserver*>(sur->sel_obs)) != 0) {
2084                         so->tick();
2085                 }
2086         }
2087         return true;
2088 }
2089
2090 int
2091 OSC::route_send_fail (string path, uint32_t ssid, float val, lo_address addr)
2092 {
2093         OSCSurface *sur = get_surface(addr);
2094
2095         ostringstream os;
2096         lo_message reply;
2097         if (ssid) {
2098                 reply = lo_message_new ();
2099                 if (sur->feedback[2]) {
2100                         os << "/strip/" << path << "/" << ssid;
2101                 } else {
2102                         os << "/strip/" << path;
2103                         lo_message_add_int32 (reply, ssid);
2104                 }
2105                 string str_pth = os.str();
2106                 lo_message_add_float (reply, (float) val);
2107
2108                 lo_send_message (addr, str_pth.c_str(), reply);
2109                 lo_message_free (reply);
2110         }
2111         if (sur->surface_sel == ssid) {
2112                 os.str("");
2113                 os << "/select/" << path;
2114                 string sel_pth = os.str();
2115                 reply = lo_message_new ();
2116                 lo_message_add_float (reply, (float) val);
2117                 lo_send_message (addr, sel_pth.c_str(), reply);
2118                 lo_message_free (reply);
2119         }
2120
2121         return 0;
2122 }
2123
2124 XMLNode&
2125 OSC::get_state ()
2126 {
2127         XMLNode& node (ControlProtocol::get_state());
2128         node.add_property("debugmode", (int) _debugmode); // TODO: enum2str
2129         return node;
2130 }
2131
2132 int
2133 OSC::set_state (const XMLNode& node, int version)
2134 {
2135         if (ControlProtocol::set_state (node, version)) {
2136                 return -1;
2137         }
2138         XMLProperty const * p = node.property (X_("debugmode"));
2139         if (p) {
2140                 _debugmode = OSCDebugMode (PBD::atoi(p->value ()));
2141         }
2142
2143         return 0;
2144 }