libs/ardour/route.cc

   1 /*
   2     Copyright (C) 2000 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 #ifdef WAF_BUILD
  21 #include "libardour-config.h"
  22 #endif
  23
  24 #include <cmath>
  25 #include <fstream>
  26 #include <cassert>
  27 #include <algorithm>
  28
  29 #include <boost/algorithm/string.hpp>
  30
  31 #include "pbd/xml++.h"
  32 #include "pbd/enumwriter.h"
  33 #include "pbd/memento_command.h"
  34 #include "pbd/stacktrace.h"
  35 #include "pbd/convert.h"
  36 #include "pbd/boost_debug.h"
  37
  38 #include "ardour/amp.h"
  39 #include "ardour/audio_buffer.h"
  40 #include "ardour/audio_port.h"
  41 #include "ardour/audioengine.h"
  42 #include "ardour/buffer.h"
  43 #include "ardour/buffer_set.h"
  44 #include "ardour/capturing_processor.h"
  45 #include "ardour/debug.h"
  46 #include "ardour/delivery.h"
  47 #include "ardour/internal_return.h"
  48 #include "ardour/internal_send.h"
  49 #include "ardour/meter.h"
  50 #include "ardour/midi_buffer.h"
  51 #include "ardour/midi_port.h"
  52 #include "ardour/monitor_processor.h"
  53 #include "ardour/pannable.h"
  54 #include "ardour/panner_shell.h"
  55 #include "ardour/plugin_insert.h"
  56 #include "ardour/port.h"
  57 #include "ardour/port_insert.h"
  58 #include "ardour/processor.h"
  59 #include "ardour/route.h"
  60 #include "ardour/route_group.h"
  61 #include "ardour/send.h"
  62 #include "ardour/session.h"
  63 #include "ardour/unknown_processor.h"
  64 #include "ardour/utils.h"
  65
  66 #include "i18n.h"
  67
  68 using namespace std;
  69 using namespace ARDOUR;
  70 using namespace PBD;
  71
  72 PBD::Signal1<void,RouteSortOrderKey> Route::SyncOrderKeys;
  73 PBD::Signal0<void> Route::RemoteControlIDChange;
  74
  75 Route::Route (Session& sess, string name, Flag flg, DataType default_type)
  76         : SessionObject (sess, name)
  77         , Automatable (sess)
  78         , GraphNode (sess._process_graph)
  79         , _active (true)
  80         , _signal_latency (0)
  81         , _initial_delay (0)
  82         , _roll_delay (0)
  83         , _flags (flg)
  84         , _pending_declick (true)
  85         , _meter_point (MeterPostFader)
  86         , _meter_type (MeterPeak)
  87         , _self_solo (false)
  88         , _soloed_by_others_upstream (0)
  89         , _soloed_by_others_downstream (0)
  90         , _solo_isolated (0)
  91         , _denormal_protection (false)
  92         , _recordable (true)
  93         , _silent (false)
  94         , _declickable (false)
  95         , _mute_master (new MuteMaster (sess, name))
  96         , _have_internal_generator (false)
  97         , _solo_safe (false)
  98         , _default_type (default_type)
  99         , _remote_control_id (0)
 100         , _in_configure_processors (false)
 101         , _custom_meter_position_noted (false)
 102         , _last_custom_meter_was_at_end (false)
 103 {
 104         processor_max_streams.reset();
 105 }
 106
 107 int
 108 Route::init ()
 109 {
 110         /* add standard controls */
 111
 112         _solo_control.reset (new SoloControllable (X_("solo"), shared_from_this ()));
 113         _mute_control.reset (new MuteControllable (X_("mute"), shared_from_this ()));
 114
 115         _solo_control->set_flags (Controllable::Flag (_solo_control->flags() | Controllable::Toggle));
 116         _mute_control->set_flags (Controllable::Flag (_mute_control->flags() | Controllable::Toggle));
 117
 118         add_control (_solo_control);
 119         add_control (_mute_control);
 120
 121         /* panning */
 122
 123         if (!(_flags & Route::MonitorOut)) {
 124                 _pannable.reset (new Pannable (_session));
 125         }
 126
 127         /* input and output objects */
 128
 129         _input.reset (new IO (_session, _name, IO::Input, _default_type));
 130         _output.reset (new IO (_session, _name, IO::Output, _default_type));
 131
 132         _input->changed.connect_same_thread (*this, boost::bind (&Route::input_change_handler, this, _1, _2));
 133         _input->PortCountChanging.connect_same_thread (*this, boost::bind (&Route::input_port_count_changing, this, _1));
 134
 135         _output->changed.connect_same_thread (*this, boost::bind (&Route::output_change_handler, this, _1, _2));
 136
 137         /* add amp processor  */
 138
 139         _amp.reset (new Amp (_session));
 140         add_processor (_amp, PostFader);
 141
 142         /* create standard processors: meter, main outs, monitor out;
 143            they will be added to _processors by setup_invisible_processors ()
 144         */
 145
 146         _meter.reset (new PeakMeter (_session, _name));
 147         _meter->set_display_to_user (false);
 148         _meter->activate ();
 149
 150         _main_outs.reset (new Delivery (_session, _output, _pannable, _mute_master, _name, Delivery::Main));
 151         _main_outs->activate ();
 152
 153         if (is_monitor()) {
 154                 /* where we listen to tracks */
 155                 _intreturn.reset (new InternalReturn (_session));
 156                 _intreturn->activate ();
 157
 158                 /* the thing that provides proper control over a control/monitor/listen bus
 159                    (such as per-channel cut, dim, solo, invert, etc).
 160                 */
 161                 _monitor_control.reset (new MonitorProcessor (_session));
 162                 _monitor_control->activate ();
 163         }
 164
 165         if (is_master() || is_monitor() || is_auditioner()) {
 166                 _mute_master->set_solo_ignore (true);
 167         }
 168
 169         /* now that we have _meter, its safe to connect to this */
 170
 171         Metering::Meter.connect_same_thread (*this, (boost::bind (&Route::meter, this)));
 172
 173         {
 174                 /* run a configure so that the invisible processors get set up */
 175                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
 176                 configure_processors (0);
 177         }
 178
 179         return 0;
 180 }
 181
 182 Route::~Route ()
 183 {
 184         DEBUG_TRACE (DEBUG::Destruction, string_compose ("route %1 destructor\n", _name));
 185
 186         /* do this early so that we don't get incoming signals as we are going through destruction
 187          */
 188
 189         drop_connections ();
 190
 191         /* don't use clear_processors here, as it depends on the session which may
 192            be half-destroyed by now
 193         */
 194
 195         Glib::Threads::RWLock::WriterLock lm (_processor_lock);
 196         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 197                 (*i)->drop_references ();
 198         }
 199
 200         _processors.clear ();
 201 }
 202
 203 void
 204 Route::set_remote_control_id (uint32_t id, bool notify_class_listeners)
 205 {
 206         if (Config->get_remote_model() != UserOrdered) {
 207                 return;
 208         }
 209
 210         set_remote_control_id_internal (id, notify_class_listeners);
 211 }
 212
 213 void
 214 Route::set_remote_control_id_internal (uint32_t id, bool notify_class_listeners)
 215 {
 216         /* force IDs for master/monitor busses and prevent
 217            any other route from accidentally getting these IDs
 218            (i.e. legacy sessions)
 219         */
 220
 221         if (is_master() && id != MasterBusRemoteControlID) {
 222                 id = MasterBusRemoteControlID;
 223         }
 224
 225         if (is_monitor() && id != MonitorBusRemoteControlID) {
 226                 id = MonitorBusRemoteControlID;
 227         }
 228
 229         if (id < 1) {
 230                 return;
 231         }
 232
 233         /* don't allow it to collide */
 234
 235         if (!is_master () && !is_monitor() &&
 236             (id == MasterBusRemoteControlID || id == MonitorBusRemoteControlID)) {
 237                 id += MonitorBusRemoteControlID;
 238         }
 239
 240         if (id != remote_control_id()) {
 241                 _remote_control_id = id;
 242                 RemoteControlIDChanged ();
 243
 244                 if (notify_class_listeners) {
 245                         RemoteControlIDChange ();
 246                 }
 247         }
 248 }
 249
 250 uint32_t
 251 Route::remote_control_id() const
 252 {
 253         if (is_master()) {
 254                 return MasterBusRemoteControlID;
 255         }
 256
 257         if (is_monitor()) {
 258                 return MonitorBusRemoteControlID;
 259         }
 260
 261         return _remote_control_id;
 262 }
 263
 264 bool
 265 Route::has_order_key (RouteSortOrderKey key) const
 266 {
 267         return (order_keys.find (key) != order_keys.end());
 268 }
 269
 270 uint32_t
 271 Route::order_key (RouteSortOrderKey key) const
 272 {
 273         OrderKeys::const_iterator i = order_keys.find (key);
 274
 275         if (i == order_keys.end()) {
 276                 return 0;
 277         }
 278
 279         return i->second;
 280 }
 281
 282 void
 283 Route::sync_order_keys (RouteSortOrderKey base)
 284 {
 285         /* this is called after changes to 1 or more route order keys have been
 286          * made, and we want to sync up.
 287          */
 288
 289         OrderKeys::iterator i = order_keys.find (base);
 290
 291         if (i == order_keys.end()) {
 292                 return;
 293         }
 294
 295         for (OrderKeys::iterator k = order_keys.begin(); k != order_keys.end(); ++k) {
 296
 297                 if (k->first != base) {
 298                         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("%1 set key for %2 to %3 from %4\n",
 299                                                                        name(),
 300                                                                        enum_2_string (k->first),
 301                                                                        i->second,
 302                                                                        enum_2_string (base)));
 303
 304                         k->second = i->second;
 305                 }
 306         }
 307 }
 308
 309 void
 310 Route::set_remote_control_id_from_order_key (RouteSortOrderKey /*key*/, uint32_t rid)
 311 {
 312         if (is_master() || is_monitor() || is_auditioner()) {
 313                 /* hard-coded remote IDs, or no remote ID */
 314                 return;
 315         }
 316
 317         if (_remote_control_id != rid) {
 318                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("%1: set edit-based RID to %2\n", name(), rid));
 319                 _remote_control_id = rid;
 320                 RemoteControlIDChanged (); /* EMIT SIGNAL (per-route) */
 321         }
 322
 323         /* don't emit the class-level RID signal RemoteControlIDChange here,
 324            leave that to the entity that changed the order key, so that we
 325            don't get lots of emissions for no good reasons (e.g. when changing
 326            all route order keys).
 327
 328            See Session::sync_remote_id_from_order_keys() for the (primary|only)
 329            spot where that is emitted.
 330         */
 331 }
 332
 333 void
 334 Route::set_order_key (RouteSortOrderKey key, uint32_t n)
 335 {
 336         OrderKeys::iterator i = order_keys.find (key);
 337
 338         if (i != order_keys.end() && i->second == n) {
 339                 return;
 340         }
 341
 342         order_keys[key] = n;
 343
 344         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("%1 order key %2 set to %3\n",
 345                                                        name(), enum_2_string (key), order_key (key)));
 346
 347         _session.set_dirty ();
 348 }
 349
 350 string
 351 Route::ensure_track_or_route_name(string name, Session &session)
 352 {
 353         string newname = name;
 354
 355         while (!session.io_name_is_legal (newname)) {
 356                 newname = bump_name_once (newname, '.');
 357         }
 358
 359         return newname;
 360 }
 361
 362
 363 void
 364 Route::inc_gain (gain_t fraction, void *src)
 365 {
 366         _amp->inc_gain (fraction, src);
 367 }
 368
 369 void
 370 Route::set_gain (gain_t val, void *src)
 371 {
 372         if (src != 0 && _route_group && src != _route_group && _route_group->is_active() && _route_group->is_gain()) {
 373
 374                 if (_route_group->is_relative()) {
 375
 376                         gain_t usable_gain = _amp->gain();
 377                         if (usable_gain < 0.000001f) {
 378                                 usable_gain = 0.000001f;
 379                         }
 380
 381                         gain_t delta = val;
 382                         if (delta < 0.000001f) {
 383                                 delta = 0.000001f;
 384                         }
 385
 386                         delta -= usable_gain;
 387
 388                         if (delta == 0.0f)
 389                                 return;
 390
 391                         gain_t factor = delta / usable_gain;
 392
 393                         if (factor > 0.0f) {
 394                                 factor = _route_group->get_max_factor(factor);
 395                                 if (factor == 0.0f) {
 396                                         _amp->gain_control()->Changed(); /* EMIT SIGNAL */
 397                                         return;
 398                                 }
 399                         } else {
 400                                 factor = _route_group->get_min_factor(factor);
 401                                 if (factor == 0.0f) {
 402                                         _amp->gain_control()->Changed(); /* EMIT SIGNAL */
 403                                         return;
 404                                 }
 405                         }
 406
 407                         _route_group->foreach_route (boost::bind (&Route::inc_gain, _1, factor, _route_group));
 408
 409                 } else {
 410
 411                         _route_group->foreach_route (boost::bind (&Route::set_gain, _1, val, _route_group));
 412                 }
 413
 414                 return;
 415         }
 416
 417         if (val == _amp->gain()) {
 418                 return;
 419         }
 420
 421         _amp->set_gain (val, src);
 422 }
 423
 424 void
 425 Route::maybe_declick (BufferSet&, framecnt_t, int)
 426 {
 427         /* this is the "bus" implementation and they never declick.
 428          */
 429         return;
 430 }
 431
 432 /** Process this route for one (sub) cycle (process thread)
 433  *
 434  * @param bufs Scratch buffers to use for the signal path
 435  * @param start_frame Initial transport frame
 436  * @param end_frame Final transport frame
 437  * @param nframes Number of frames to output (to ports)
 438  *
 439  * Note that (end_frame - start_frame) may not be equal to nframes when the
 440  * transport speed isn't 1.0 (eg varispeed).
 441  */
 442 void
 443 Route::process_output_buffers (BufferSet& bufs,
 444                                framepos_t start_frame, framepos_t end_frame, pframes_t nframes,
 445                                int declick, bool gain_automation_ok)
 446 {
 447         bufs.set_is_silent (false);
 448
 449         /* figure out if we're going to use gain automation */
 450         if (gain_automation_ok) {
 451                 _amp->set_gain_automation_buffer (_session.gain_automation_buffer ());
 452                 _amp->setup_gain_automation (start_frame, end_frame, nframes);
 453         } else {
 454                 _amp->apply_gain_automation (false);
 455         }
 456
 457         /* Tell main outs what to do about monitoring.  We do this so that
 458            on a transition between monitoring states we get a de-clicking gain
 459            change in the _main_outs delivery.
 460         */
 461
 462         _main_outs->no_outs_cuz_we_no_monitor (monitoring_state () == MonitoringSilence);
 463
 464         /* -------------------------------------------------------------------------------------------
 465            GLOBAL DECLICK (for transport changes etc.)
 466            ----------------------------------------------------------------------------------------- */
 467
 468         maybe_declick (bufs, nframes, declick);
 469         _pending_declick = 0;
 470
 471         /* -------------------------------------------------------------------------------------------
 472            DENORMAL CONTROL/PHASE INVERT
 473            ----------------------------------------------------------------------------------------- */
 474
 475         if (_phase_invert.any ()) {
 476
 477                 int chn = 0;
 478
 479                 if (_denormal_protection || Config->get_denormal_protection()) {
 480
 481                         for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
 482                                 Sample* const sp = i->data();
 483
 484                                 if (_phase_invert[chn]) {
 485                                         for (pframes_t nx = 0; nx < nframes; ++nx) {
 486                                                 sp[nx]  = -sp[nx];
 487                                                 sp[nx] += 1.0e-27f;
 488                                         }
 489                                 } else {
 490                                         for (pframes_t nx = 0; nx < nframes; ++nx) {
 491                                                 sp[nx] += 1.0e-27f;
 492                                         }
 493                                 }
 494                         }
 495
 496                 } else {
 497
 498                         for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
 499                                 Sample* const sp = i->data();
 500
 501                                 if (_phase_invert[chn]) {
 502                                         for (pframes_t nx = 0; nx < nframes; ++nx) {
 503                                                 sp[nx] = -sp[nx];
 504                                         }
 505                                 }
 506                         }
 507                 }
 508
 509         } else {
 510
 511                 if (_denormal_protection || Config->get_denormal_protection()) {
 512
 513                         for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
 514                                 Sample* const sp = i->data();
 515                                 for (pframes_t nx = 0; nx < nframes; ++nx) {
 516                                         sp[nx] += 1.0e-27f;
 517                                 }
 518                         }
 519
 520                 }
 521         }
 522
 523         /* -------------------------------------------------------------------------------------------
 524            and go ....
 525            ----------------------------------------------------------------------------------------- */
 526
 527         /* set this to be true if the meter will already have been ::run() earlier */
 528         bool const meter_already_run = metering_state() == MeteringInput;
 529
 530         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 531
 532                 if (meter_already_run && boost::dynamic_pointer_cast<PeakMeter> (*i)) {
 533                         /* don't ::run() the meter, otherwise it will have its previous peak corrupted */
 534                         continue;
 535                 }
 536
 537 #ifndef NDEBUG
 538                 /* if it has any inputs, make sure they match */
 539                 if (boost::dynamic_pointer_cast<UnknownProcessor> (*i) == 0 && (*i)->input_streams() != ChanCount::ZERO) {
 540                         if (bufs.count() != (*i)->input_streams()) {
 541                                 DEBUG_TRACE (
 542                                         DEBUG::Processors, string_compose (
 543                                                 "%1 bufs = %2 input for %3 = %4\n",
 544                                                 _name, bufs.count(), (*i)->name(), (*i)->input_streams()
 545                                                 )
 546                                         );
 547                                 continue;
 548                         }
 549                 }
 550 #endif
 551
 552                 /* should we NOT run plugins here if the route is inactive?
 553                    do we catch route != active somewhere higher?
 554                 */
 555
 556                 (*i)->run (bufs, start_frame, end_frame, nframes, *i != _processors.back());
 557                 bufs.set_count ((*i)->output_streams());
 558         }
 559 }
 560
 561 ChanCount
 562 Route::n_process_buffers ()
 563 {
 564         return max (_input->n_ports(), processor_max_streams);
 565 }
 566
 567 void
 568 Route::monitor_run (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
 569 {
 570         assert (is_monitor());
 571         BufferSet& bufs (_session.get_scratch_buffers (n_process_buffers()));
 572         passthru (bufs, start_frame, end_frame, nframes, declick);
 573 }
 574
 575 void
 576 Route::passthru (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
 577 {
 578         _silent = false;
 579
 580         if (is_monitor() && _session.listening() && !_session.is_auditioning()) {
 581
 582                 /* control/monitor bus ignores input ports when something is
 583                    feeding the listen "stream". data will "arrive" into the
 584                    route from the intreturn processor element.
 585                 */
 586
 587                 bufs.silence (nframes, 0);
 588         }
 589
 590         write_out_of_band_data (bufs, start_frame, end_frame, nframes);
 591         process_output_buffers (bufs, start_frame, end_frame, nframes, declick, true);
 592 }
 593
 594 void
 595 Route::passthru_silence (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
 596 {
 597         BufferSet& bufs (_session.get_silent_buffers (n_process_buffers()));
 598
 599         bufs.set_count (_input->n_ports());
 600         write_out_of_band_data (bufs, start_frame, end_frame, nframes);
 601         process_output_buffers (bufs, start_frame, end_frame, nframes, declick, false);
 602 }
 603
 604 void
 605 Route::set_listen (bool yn, void* src)
 606 {
 607         if (_solo_safe) {
 608                 return;
 609         }
 610
 611         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
 612                 _route_group->foreach_route (boost::bind (&Route::set_listen, _1, yn, _route_group));
 613                 return;
 614         }
 615
 616         if (_monitor_send) {
 617                 if (yn != _monitor_send->active()) {
 618                         if (yn) {
 619                                 _monitor_send->activate ();
 620                                 _mute_master->set_soloed (true);
 621                         } else {
 622                                 _monitor_send->deactivate ();
 623                                 _mute_master->set_soloed (false);
 624                         }
 625
 626                         listen_changed (src); /* EMIT SIGNAL */
 627                 }
 628         }
 629 }
 630
 631 bool
 632 Route::listening_via_monitor () const
 633 {
 634         if (_monitor_send) {
 635                 return _monitor_send->active ();
 636         } else {
 637                 return false;
 638         }
 639 }
 640
 641 void
 642 Route::set_solo_safe (bool yn, void *src)
 643 {
 644         if (_solo_safe != yn) {
 645                 _solo_safe = yn;
 646                 solo_safe_changed (src);
 647         }
 648 }
 649
 650 bool
 651 Route::solo_safe() const
 652 {
 653         return _solo_safe;
 654 }
 655
 656 void
 657 Route::set_solo (bool yn, void *src)
 658 {
 659         if (_solo_safe) {
 660                 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 ignore solo change due to solo-safe\n", name()));
 661                 return;
 662         }
 663
 664         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
 665                 _route_group->foreach_route (boost::bind (&Route::set_solo, _1, yn, _route_group));
 666                 return;
 667         }
 668
 669         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1: set solo => %2, src: %3 grp ? %4 currently self-soloed ? %5\n",
 670                                                   name(), yn, src, (src == _route_group), self_soloed()));
 671
 672         if (self_soloed() != yn) {
 673                 set_self_solo (yn);
 674                 set_mute_master_solo ();
 675                 solo_changed (true, src); /* EMIT SIGNAL */
 676                 _solo_control->Changed (); /* EMIT SIGNAL */
 677         }
 678 }
 679
 680 void
 681 Route::set_self_solo (bool yn)
 682 {
 683         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1: set SELF solo => %2\n", name(), yn));
 684         _self_solo = yn;
 685 }
 686
 687 void
 688 Route::mod_solo_by_others_upstream (int32_t delta)
 689 {
 690         if (_solo_safe) {
 691                 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 ignore solo-by-upstream due to solo-safe\n", name()));
 692                 return;
 693         }
 694
 695         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 mod solo-by-upstream by %2, current up = %3 down = %4\n",
 696                                                   name(), delta, _soloed_by_others_upstream, _soloed_by_others_downstream));
 697
 698         uint32_t old_sbu = _soloed_by_others_upstream;
 699
 700         if (delta < 0) {
 701                 if (_soloed_by_others_upstream >= (uint32_t) abs (delta)) {
 702                         _soloed_by_others_upstream += delta;
 703                 } else {
 704                         _soloed_by_others_upstream = 0;
 705                 }
 706         } else {
 707                 _soloed_by_others_upstream += delta;
 708         }
 709
 710         DEBUG_TRACE (DEBUG::Solo, string_compose (
 711                              "%1 SbU delta %2 = %3 old = %4 sbd %5 ss %6 exclusive %7\n",
 712                              name(), delta, _soloed_by_others_upstream, old_sbu,
 713                              _soloed_by_others_downstream, _self_solo, Config->get_exclusive_solo()));
 714
 715         /* push the inverse solo change to everything that feeds us.
 716
 717            This is important for solo-within-group. When we solo 1 track out of N that
 718            feed a bus, that track will cause mod_solo_by_upstream (+1) to be called
 719            on the bus. The bus then needs to call mod_solo_by_downstream (-1) on all
 720            tracks that feed it. This will silence them if they were audible because
 721            of a bus solo, but the newly soloed track will still be audible (because
 722            it is self-soloed).
 723
 724            but .. do this only when we are being told to solo-by-upstream (i.e delta = +1),
 725            not in reverse.
 726         */
 727
 728         if ((_self_solo || _soloed_by_others_downstream) &&
 729             ((old_sbu == 0 && _soloed_by_others_upstream > 0) ||
 730              (old_sbu > 0 && _soloed_by_others_upstream == 0))) {
 731
 732                 if (delta > 0 || !Config->get_exclusive_solo()) {
 733                         DEBUG_TRACE (DEBUG::Solo, "\t ... INVERT push\n");
 734                         for (FedBy::iterator i = _fed_by.begin(); i != _fed_by.end(); ++i) {
 735                                 boost::shared_ptr<Route> sr = i->r.lock();
 736                                 if (sr) {
 737                                         sr->mod_solo_by_others_downstream (-delta);
 738                                 }
 739                         }
 740                 }
 741         }
 742
 743         set_mute_master_solo ();
 744         solo_changed (false, this);
 745 }
 746
 747 void
 748 Route::mod_solo_by_others_downstream (int32_t delta)
 749 {
 750         if (_solo_safe) {
 751                 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 ignore solo-by-downstream due to solo safe\n", name()));
 752                 return;
 753         }
 754
 755         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 mod solo-by-downstream by %2, current up = %3 down = %4\n",
 756                                                   name(), delta, _soloed_by_others_upstream, _soloed_by_others_downstream));
 757
 758         if (delta < 0) {
 759                 if (_soloed_by_others_downstream >= (uint32_t) abs (delta)) {
 760                         _soloed_by_others_downstream += delta;
 761                 } else {
 762                         _soloed_by_others_downstream = 0;
 763                 }
 764         } else {
 765                 _soloed_by_others_downstream += delta;
 766         }
 767
 768         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 SbD delta %2 = %3\n", name(), delta, _soloed_by_others_downstream));
 769
 770         set_mute_master_solo ();
 771         solo_changed (false, this);
 772 }
 773
 774 void
 775 Route::set_mute_master_solo ()
 776 {
 777         _mute_master->set_soloed (self_soloed() || soloed_by_others_downstream() || soloed_by_others_upstream());
 778 }
 779
 780 void
 781 Route::set_solo_isolated (bool yn, void *src)
 782 {
 783         if (is_master() || is_monitor() || is_auditioner()) {
 784                 return;
 785         }
 786
 787         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
 788                 _route_group->foreach_route (boost::bind (&Route::set_solo_isolated, _1, yn, _route_group));
 789                 return;
 790         }
 791
 792         /* forward propagate solo-isolate status to everything fed by this route, but not those via sends only */
 793
 794         boost::shared_ptr<RouteList> routes = _session.get_routes ();
 795         for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
 796
 797                 if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
 798                         continue;
 799                 }
 800
 801                 bool sends_only;
 802                 bool does_feed = direct_feeds_according_to_graph (*i, &sends_only); // we will recurse anyway, so don't use ::feeds()
 803
 804                 if (does_feed && !sends_only) {
 805                         (*i)->set_solo_isolated (yn, (*i)->route_group());
 806                 }
 807         }
 808
 809         /* XXX should we back-propagate as well? (April 2010: myself and chris goddard think not) */
 810
 811         bool changed = false;
 812
 813         if (yn) {
 814                 if (_solo_isolated == 0) {
 815                         _mute_master->set_solo_ignore (true);
 816                         changed = true;
 817                 }
 818                 _solo_isolated++;
 819         } else {
 820                 if (_solo_isolated > 0) {
 821                         _solo_isolated--;
 822                         if (_solo_isolated == 0) {
 823                                 _mute_master->set_solo_ignore (false);
 824                                 changed = true;
 825                         }
 826                 }
 827         }
 828
 829         if (changed) {
 830                 solo_isolated_changed (src);
 831         }
 832 }
 833
 834 bool
 835 Route::solo_isolated () const
 836 {
 837         return _solo_isolated > 0;
 838 }
 839
 840 void
 841 Route::set_mute_points (MuteMaster::MutePoint mp)
 842 {
 843         _mute_master->set_mute_points (mp);
 844         mute_points_changed (); /* EMIT SIGNAL */
 845
 846         if (_mute_master->muted_by_self()) {
 847                 mute_changed (this); /* EMIT SIGNAL */
 848                 _mute_control->Changed (); /* EMIT SIGNAL */
 849         }
 850 }
 851
 852 void
 853 Route::set_mute (bool yn, void *src)
 854 {
 855         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_mute()) {
 856                 _route_group->foreach_route (boost::bind (&Route::set_mute, _1, yn, _route_group));
 857                 return;
 858         }
 859
 860         if (muted() != yn) {
 861                 _mute_master->set_muted_by_self (yn);
 862                 /* allow any derived classes to respond to the mute change
 863                    before anybody else knows about it.
 864                 */
 865                 act_on_mute ();
 866                 /* tell everyone else */
 867                 mute_changed (src); /* EMIT SIGNAL */
 868                 _mute_control->Changed (); /* EMIT SIGNAL */
 869         }
 870 }
 871
 872 bool
 873 Route::muted () const
 874 {
 875         return _mute_master->muted_by_self();
 876 }
 877
 878 #if 0
 879 static void
 880 dump_processors(const string& name, const list<boost::shared_ptr<Processor> >& procs)
 881 {
 882         cerr << name << " {" << endl;
 883         for (list<boost::shared_ptr<Processor> >::const_iterator p = procs.begin();
 884                         p != procs.end(); ++p) {
 885                 cerr << "\t" << (*p)->name() << " ID = " << (*p)->id() << " @ " << (*p) << endl;
 886         }
 887         cerr << "}" << endl;
 888 }
 889 #endif
 890
 891 /** Supposing that we want to insert a Processor at a given Placement, return
 892  *  the processor to add the new one before (or 0 to add at the end).
 893  */
 894 boost::shared_ptr<Processor>
 895 Route::before_processor_for_placement (Placement p)
 896 {
 897         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
 898
 899         ProcessorList::iterator loc;
 900
 901         if (p == PreFader) {
 902                 /* generic pre-fader: insert immediately before the amp */
 903                 loc = find (_processors.begin(), _processors.end(), _amp);
 904         } else {
 905                 /* generic post-fader: insert right before the main outs */
 906                 loc = find (_processors.begin(), _processors.end(), _main_outs);
 907         }
 908
 909         return loc != _processors.end() ? *loc : boost::shared_ptr<Processor> ();
 910 }
 911
 912 /** Supposing that we want to insert a Processor at a given index, return
 913  *  the processor to add the new one before (or 0 to add at the end).
 914  */
 915 boost::shared_ptr<Processor>
 916 Route::before_processor_for_index (int index)
 917 {
 918         if (index == -1) {
 919                 return boost::shared_ptr<Processor> ();
 920         }
 921
 922         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
 923
 924         ProcessorList::iterator i = _processors.begin ();
 925         int j = 0;
 926         while (i != _processors.end() && j < index) {
 927                 if ((*i)->display_to_user()) {
 928                         ++j;
 929                 }
 930
 931                 ++i;
 932         }
 933
 934         return (i != _processors.end() ? *i : boost::shared_ptr<Processor> ());
 935 }
 936
 937 /** Add a processor either pre- or post-fader
 938  *  @return 0 on success, non-0 on failure.
 939  */
 940 int
 941 Route::add_processor (boost::shared_ptr<Processor> processor, Placement placement, ProcessorStreams* err, bool activation_allowed)
 942 {
 943         return add_processor (processor, before_processor_for_placement (placement), err, activation_allowed);
 944 }
 945
 946
 947 /** Add a processor to a route such that it ends up with a given index into the visible processors.
 948  *  @param index Index to add the processor at, or -1 to add at the end of the list.
 949  *  @return 0 on success, non-0 on failure.
 950  */
 951 int
 952 Route::add_processor_by_index (boost::shared_ptr<Processor> processor, int index, ProcessorStreams* err, bool activation_allowed)
 953 {
 954         return add_processor (processor, before_processor_for_index (index), err, activation_allowed);
 955 }
 956
 957 /** Add a processor to the route.
 958  *  @param before An existing processor in the list, or 0; the new processor will be inserted immediately before it (or at the end).
 959  *  @return 0 on success, non-0 on failure.
 960  */
 961 int
 962 Route::add_processor (boost::shared_ptr<Processor> processor, boost::shared_ptr<Processor> before, ProcessorStreams* err, bool activation_allowed)
 963 {
 964         assert (processor != _meter);
 965         assert (processor != _main_outs);
 966
 967         DEBUG_TRACE (DEBUG::Processors, string_compose (
 968                              "%1 adding processor %2\n", name(), processor->name()));
 969
 970         if (!_session.engine().connected() || !processor) {
 971                 return 1;
 972         }
 973
 974         {
 975                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
 976                 ProcessorState pstate (this);
 977
 978                 boost::shared_ptr<PluginInsert> pi;
 979                 boost::shared_ptr<PortInsert> porti;
 980
 981                 if (processor == _amp) {
 982                         /* Ensure that only one amp is in the list at any time */
 983                         ProcessorList::iterator check = find (_processors.begin(), _processors.end(), processor);
 984                         if (check != _processors.end()) {
 985                                 if (before == _amp) {
 986                                         /* Already in position; all is well */
 987                                         return 0;
 988                                 } else {
 989                                         _processors.erase (check);
 990                                 }
 991                         }
 992                 }
 993
 994                 assert (find (_processors.begin(), _processors.end(), processor) == _processors.end ());
 995
 996                 ProcessorList::iterator loc;
 997                 if (before) {
 998                         /* inserting before a processor; find it */
 999                         loc = find (_processors.begin(), _processors.end(), before);
1000                         if (loc == _processors.end ()) {
1001                                 /* Not found */
1002                                 return 1;
1003                         }
1004                 } else {
1005                         /* inserting at end */
1006                         loc = _processors.end ();
1007                 }
1008
1009                 _processors.insert (loc, processor);
1010
1011                 // Set up processor list channels.  This will set processor->[input|output]_streams(),
1012                 // configure redirect ports properly, etc.
1013
1014                 {
1015                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1016
1017                         if (configure_processors_unlocked (err)) {
1018                                 pstate.restore ();
1019                                 configure_processors_unlocked (0); // it worked before we tried to add it ...
1020                                 return -1;
1021                         }
1022                 }
1023
1024                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(processor)) != 0) {
1025
1026                         if (pi->has_no_inputs ()) {
1027                                 /* generator plugin */
1028                                 _have_internal_generator = true;
1029                         }
1030
1031                 }
1032
1033                 if (activation_allowed && !_session.get_disable_all_loaded_plugins()) {
1034                         processor->activate ();
1035                 }
1036
1037                 processor->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
1038
1039                 _output->set_user_latency (0);
1040         }
1041
1042         reset_instrument_info ();
1043         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1044         set_processor_positions ();
1045
1046         return 0;
1047 }
1048
1049 bool
1050 Route::add_processor_from_xml_2X (const XMLNode& node, int version)
1051 {
1052         const XMLProperty *prop;
1053
1054         try {
1055                 boost::shared_ptr<Processor> processor;
1056
1057                 /* bit of a hack: get the `placement' property from the <Redirect> tag here
1058                    so that we can add the processor in the right place (pre/post-fader)
1059                 */
1060
1061                 XMLNodeList const & children = node.children ();
1062                 XMLNodeList::const_iterator i = children.begin ();
1063
1064                 while (i != children.end() && (*i)->name() != X_("Redirect")) {
1065                         ++i;
1066                 }
1067
1068                 Placement placement = PreFader;
1069
1070                 if (i != children.end()) {
1071                         if ((prop = (*i)->property (X_("placement"))) != 0) {
1072                                 placement = Placement (string_2_enum (prop->value(), placement));
1073                         }
1074                 }
1075
1076                 if (node.name() == "Insert") {
1077
1078                         if ((prop = node.property ("type")) != 0) {
1079
1080                                 if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
1081                                                 prop->value() == "lv2" ||
1082                                                 prop->value() == "windows-vst" ||
1083                                                 prop->value() == "lxvst" ||
1084                                                 prop->value() == "audiounit") {
1085
1086                                         processor.reset (new PluginInsert (_session));
1087
1088                                 } else {
1089
1090                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
1091                                 }
1092
1093                         }
1094
1095                 } else if (node.name() == "Send") {
1096
1097                         processor.reset (new Send (_session, _pannable, _mute_master));
1098
1099                 } else {
1100
1101                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), node.name()) << endmsg;
1102                         return false;
1103                 }
1104
1105                 if (processor->set_state (node, version)) {
1106                         return false;
1107                 }
1108
1109                 return (add_processor (processor, placement) == 0);
1110         }
1111
1112         catch (failed_constructor &err) {
1113                 warning << _("processor could not be created. Ignored.") << endmsg;
1114                 return false;
1115         }
1116 }
1117
1118 int
1119 Route::add_processors (const ProcessorList& others, boost::shared_ptr<Processor> before, ProcessorStreams* err)
1120 {
1121         /* NOTE: this is intended to be used ONLY when copying
1122            processors from another Route. Hence the subtle
1123            differences between this and ::add_processor()
1124         */
1125
1126         ProcessorList::iterator loc;
1127
1128         if (before) {
1129                 loc = find(_processors.begin(), _processors.end(), before);
1130         } else {
1131                 /* nothing specified - at end */
1132                 loc = _processors.end ();
1133         }
1134
1135         if (!_session.engine().connected()) {
1136                 return 1;
1137         }
1138
1139         if (others.empty()) {
1140                 return 0;
1141         }
1142
1143         {
1144                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1145                 ProcessorState pstate (this);
1146
1147                 for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
1148
1149                         if (*i == _meter) {
1150                                 continue;
1151                         }
1152
1153                         boost::shared_ptr<PluginInsert> pi;
1154
1155                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1156                                 pi->set_count (1);
1157                         }
1158
1159                         _processors.insert (loc, *i);
1160
1161                         if ((*i)->active()) {
1162                                 (*i)->activate ();
1163                         }
1164
1165                         {
1166                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1167                                 if (configure_processors_unlocked (err)) {
1168                                         pstate.restore ();
1169                                         configure_processors_unlocked (0); // it worked before we tried to add it ...
1170                                         return -1;
1171                                 }
1172                         }
1173
1174                         (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
1175                 }
1176
1177                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
1178                         boost::shared_ptr<PluginInsert> pi;
1179
1180                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1181                                 if (pi->has_no_inputs ()) {
1182                                         _have_internal_generator = true;
1183                                         break;
1184                                 }
1185                         }
1186                 }
1187
1188                 _output->set_user_latency (0);
1189         }
1190
1191         reset_instrument_info ();
1192         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1193         set_processor_positions ();
1194
1195         return 0;
1196 }
1197
1198 void
1199 Route::placement_range(Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end)
1200 {
1201         if (p == PreFader) {
1202                 start = _processors.begin();
1203                 end = find(_processors.begin(), _processors.end(), _amp);
1204         } else {
1205                 start = find(_processors.begin(), _processors.end(), _amp);
1206                 ++start;
1207                 end = _processors.end();
1208         }
1209 }
1210
1211 /** Turn off all processors with a given placement
1212  * @param p Placement of processors to disable
1213  */
1214 void
1215 Route::disable_processors (Placement p)
1216 {
1217         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1218
1219         ProcessorList::iterator start, end;
1220         placement_range(p, start, end);
1221
1222         for (ProcessorList::iterator i = start; i != end; ++i) {
1223                 (*i)->deactivate ();
1224         }
1225
1226         _session.set_dirty ();
1227 }
1228
1229 /** Turn off all redirects
1230  */
1231 void
1232 Route::disable_processors ()
1233 {
1234         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1235
1236         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1237                 (*i)->deactivate ();
1238         }
1239
1240         _session.set_dirty ();
1241 }
1242
1243 /** Turn off all redirects with a given placement
1244  * @param p Placement of redirects to disable
1245  */
1246 void
1247 Route::disable_plugins (Placement p)
1248 {
1249         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1250
1251         ProcessorList::iterator start, end;
1252         placement_range(p, start, end);
1253
1254         for (ProcessorList::iterator i = start; i != end; ++i) {
1255                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1256                         (*i)->deactivate ();
1257                 }
1258         }
1259
1260         _session.set_dirty ();
1261 }
1262
1263 /** Turn off all plugins
1264  */
1265 void
1266 Route::disable_plugins ()
1267 {
1268         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1269
1270         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1271                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1272                         (*i)->deactivate ();
1273                 }
1274         }
1275
1276         _session.set_dirty ();
1277 }
1278
1279
1280 void
1281 Route::ab_plugins (bool forward)
1282 {
1283         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1284
1285         if (forward) {
1286
1287                 /* forward = turn off all active redirects, and mark them so that the next time
1288                    we go the other way, we will revert them
1289                 */
1290
1291                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1292                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1293                                 continue;
1294                         }
1295
1296                         if ((*i)->active()) {
1297                                 (*i)->deactivate ();
1298                                 (*i)->set_next_ab_is_active (true);
1299                         } else {
1300                                 (*i)->set_next_ab_is_active (false);
1301                         }
1302                 }
1303
1304         } else {
1305
1306                 /* backward = if the redirect was marked to go active on the next ab, do so */
1307
1308                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1309
1310                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1311                                 continue;
1312                         }
1313
1314                         if ((*i)->get_next_ab_is_active()) {
1315                                 (*i)->activate ();
1316                         } else {
1317                                 (*i)->deactivate ();
1318                         }
1319                 }
1320         }
1321
1322         _session.set_dirty ();
1323 }
1324
1325
1326 /** Remove processors with a given placement.
1327  * @param p Placement of processors to remove.
1328  */
1329 void
1330 Route::clear_processors (Placement p)
1331 {
1332         if (!_session.engine().connected()) {
1333                 return;
1334         }
1335
1336         bool already_deleting = _session.deletion_in_progress();
1337         if (!already_deleting) {
1338                 _session.set_deletion_in_progress();
1339         }
1340
1341         {
1342                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1343                 ProcessorList new_list;
1344                 ProcessorStreams err;
1345                 bool seen_amp = false;
1346
1347                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1348
1349                         if (*i == _amp) {
1350                                 seen_amp = true;
1351                         }
1352
1353                         if ((*i) == _amp || (*i) == _meter || (*i) == _main_outs) {
1354
1355                                 /* you can't remove these */
1356
1357                                 new_list.push_back (*i);
1358
1359                         } else {
1360                                 if (seen_amp) {
1361
1362                                         switch (p) {
1363                                         case PreFader:
1364                                                 new_list.push_back (*i);
1365                                                 break;
1366                                         case PostFader:
1367                                                 (*i)->drop_references ();
1368                                                 break;
1369                                         }
1370
1371                                 } else {
1372
1373                                         switch (p) {
1374                                         case PreFader:
1375                                                 (*i)->drop_references ();
1376                                                 break;
1377                                         case PostFader:
1378                                                 new_list.push_back (*i);
1379                                                 break;
1380                                         }
1381                                 }
1382                         }
1383                 }
1384
1385                 _processors = new_list;
1386
1387                 {
1388                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1389                         configure_processors_unlocked (&err); // this can't fail
1390                 }
1391         }
1392
1393         processor_max_streams.reset();
1394         _have_internal_generator = false;
1395         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1396         set_processor_positions ();
1397
1398         reset_instrument_info ();
1399
1400         if (!already_deleting) {
1401                 _session.clear_deletion_in_progress();
1402         }
1403 }
1404
1405 int
1406 Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err, bool need_process_lock)
1407 {
1408         // TODO once the export point can be configured properly, do something smarter here
1409         if (processor == _capturing_processor) {
1410                 _capturing_processor.reset();
1411         }
1412
1413         /* these can never be removed */
1414
1415         if (processor == _amp || processor == _meter || processor == _main_outs) {
1416                 return 0;
1417         }
1418
1419         if (!_session.engine().connected()) {
1420                 return 1;
1421         }
1422
1423         processor_max_streams.reset();
1424
1425         {
1426                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1427                 ProcessorState pstate (this);
1428
1429                 ProcessorList::iterator i;
1430                 bool removed = false;
1431
1432                 for (i = _processors.begin(); i != _processors.end(); ) {
1433                         if (*i == processor) {
1434
1435                                 /* move along, see failure case for configure_processors()
1436                                    where we may need to reconfigure the processor.
1437                                 */
1438
1439                                 /* stop redirects that send signals to JACK ports
1440                                    from causing noise as a result of no longer being
1441                                    run.
1442                                 */
1443
1444                                 boost::shared_ptr<IOProcessor> iop;
1445
1446                                 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (*i)) != 0) {
1447                                         iop->disconnect ();
1448                                 }
1449
1450                                 i = _processors.erase (i);
1451                                 removed = true;
1452                                 break;
1453
1454                         } else {
1455                                 ++i;
1456                         }
1457
1458                         _output->set_user_latency (0);
1459                 }
1460
1461                 if (!removed) {
1462                         /* what? */
1463                         return 1;
1464                 }
1465
1466                 if (need_process_lock) {
1467                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1468
1469                         if (configure_processors_unlocked (err)) {
1470                                 pstate.restore ();
1471                                 /* we know this will work, because it worked before :) */
1472                                 configure_processors_unlocked (0);
1473                                 return -1;
1474                         }
1475                 } else {
1476                         if (configure_processors_unlocked (err)) {
1477                                 pstate.restore ();
1478                                 /* we know this will work, because it worked before :) */
1479                                 configure_processors_unlocked (0);
1480                                 return -1;
1481                         }
1482                 }
1483
1484                 _have_internal_generator = false;
1485
1486                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1487                         boost::shared_ptr<PluginInsert> pi;
1488
1489                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1490                                 if (pi->has_no_inputs ()) {
1491                                         _have_internal_generator = true;
1492                                         break;
1493                                 }
1494                         }
1495                 }
1496         }
1497
1498         reset_instrument_info ();
1499         processor->drop_references ();
1500         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1501         set_processor_positions ();
1502
1503         return 0;
1504 }
1505
1506 int
1507 Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
1508 {
1509         ProcessorList deleted;
1510
1511         if (!_session.engine().connected()) {
1512                 return 1;
1513         }
1514
1515         processor_max_streams.reset();
1516
1517         {
1518                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1519                 ProcessorState pstate (this);
1520
1521                 ProcessorList::iterator i;
1522                 boost::shared_ptr<Processor> processor;
1523
1524                 for (i = _processors.begin(); i != _processors.end(); ) {
1525
1526                         processor = *i;
1527
1528                         /* these can never be removed */
1529
1530                         if (processor == _amp || processor == _meter || processor == _main_outs) {
1531                                 ++i;
1532                                 continue;
1533                         }
1534
1535                         /* see if its in the list of processors to delete */
1536
1537                         if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
1538                                 ++i;
1539                                 continue;
1540                         }
1541
1542                         /* stop IOProcessors that send to JACK ports
1543                            from causing noise as a result of no longer being
1544                            run.
1545                         */
1546
1547                         boost::shared_ptr<IOProcessor> iop;
1548
1549                         if ((iop = boost::dynamic_pointer_cast<IOProcessor> (processor)) != 0) {
1550                                 iop->disconnect ();
1551                         }
1552
1553                         deleted.push_back (processor);
1554                         i = _processors.erase (i);
1555                 }
1556
1557                 if (deleted.empty()) {
1558                         /* none of those in the requested list were found */
1559                         return 0;
1560                 }
1561
1562                 _output->set_user_latency (0);
1563
1564                 {
1565                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1566
1567                         if (configure_processors_unlocked (err)) {
1568                                 pstate.restore ();
1569                                 /* we know this will work, because it worked before :) */
1570                                 configure_processors_unlocked (0);
1571                                 return -1;
1572                         }
1573                 }
1574
1575                 _have_internal_generator = false;
1576
1577                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1578                         boost::shared_ptr<PluginInsert> pi;
1579
1580                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1581                                 if (pi->has_no_inputs ()) {
1582                                         _have_internal_generator = true;
1583                                         break;
1584                                 }
1585                         }
1586                 }
1587         }
1588
1589         /* now try to do what we need to so that those that were removed will be deleted */
1590
1591         for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
1592                 (*i)->drop_references ();
1593         }
1594
1595         reset_instrument_info ();
1596         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1597         set_processor_positions ();
1598
1599         return 0;
1600 }
1601
1602 void
1603 Route::reset_instrument_info ()
1604 {
1605         boost::shared_ptr<Processor> instr = the_instrument();
1606         if (instr) {
1607                 _instrument_info.set_internal_instrument (instr);
1608         }
1609 }
1610
1611 /** Caller must hold process lock */
1612 int
1613 Route::configure_processors (ProcessorStreams* err)
1614 {
1615 #ifndef WIN32
1616         assert (!AudioEngine::instance()->process_lock().trylock());
1617 #endif
1618
1619         if (!_in_configure_processors) {
1620                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1621                 return configure_processors_unlocked (err);
1622         }
1623
1624         return 0;
1625 }
1626
1627 ChanCount
1628 Route::input_streams () const
1629 {
1630         return _input->n_ports ();
1631 }
1632
1633 list<pair<ChanCount, ChanCount> >
1634 Route::try_configure_processors (ChanCount in, ProcessorStreams* err)
1635 {
1636         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1637
1638         return try_configure_processors_unlocked (in, err);
1639 }
1640
1641 list<pair<ChanCount, ChanCount> >
1642 Route::try_configure_processors_unlocked (ChanCount in, ProcessorStreams* err)
1643 {
1644         // Check each processor in order to see if we can configure as requested
1645         ChanCount out;
1646         list<pair<ChanCount, ChanCount> > configuration;
1647         uint32_t index = 0;
1648
1649         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
1650         DEBUG_TRACE (DEBUG::Processors, "{\n");
1651
1652         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1653
1654                 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1655                         DEBUG_TRACE (DEBUG::Processors, "--- CONFIGURE ABORTED due to unknown processor.\n");
1656                         break;
1657                 }
1658
1659                 if ((*p)->can_support_io_configuration(in, out)) {
1660                         DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID=%2 in=%3 out=%4\n",(*p)->name(), (*p)->id(), in, out));
1661                         configuration.push_back(make_pair(in, out));
1662                         in = out;
1663                 } else {
1664                         if (err) {
1665                                 err->index = index;
1666                                 err->count = in;
1667                         }
1668                         DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
1669                         DEBUG_TRACE (DEBUG::Processors, string_compose ("---- %1 cannot support in=%2 out=%3\n", (*p)->name(), in, out));
1670                         DEBUG_TRACE (DEBUG::Processors, "}\n");
1671                         return list<pair<ChanCount, ChanCount> > ();
1672                 }
1673         }
1674
1675         DEBUG_TRACE (DEBUG::Processors, "}\n");
1676
1677         return configuration;
1678 }
1679
1680 /** Set the input/output configuration of each processor in the processors list.
1681  *  Caller must hold process lock.
1682  *  Return 0 on success, otherwise configuration is impossible.
1683  */
1684 int
1685 Route::configure_processors_unlocked (ProcessorStreams* err)
1686 {
1687 #ifndef WIN32
1688         assert (!AudioEngine::instance()->process_lock().trylock());
1689 #endif
1690
1691         if (_in_configure_processors) {
1692                 return 0;
1693         }
1694
1695         /* put invisible processors where they should be */
1696         setup_invisible_processors ();
1697
1698         _in_configure_processors = true;
1699
1700         list<pair<ChanCount, ChanCount> > configuration = try_configure_processors_unlocked (input_streams (), err);
1701
1702         if (configuration.empty ()) {
1703                 _in_configure_processors = false;
1704                 return -1;
1705         }
1706
1707         ChanCount out;
1708
1709         list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1710         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1711
1712                 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1713                         break;
1714                 }
1715
1716                 (*p)->configure_io(c->first, c->second);
1717                 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1718                 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1719                 out = c->second;
1720         }
1721
1722         if (_meter) {
1723                 _meter->reset_max_channels (processor_max_streams);
1724         }
1725
1726         /* make sure we have sufficient scratch buffers to cope with the new processor
1727            configuration
1728         */
1729         _session.ensure_buffers (n_process_buffers ());
1730
1731         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
1732
1733         _in_configure_processors = false;
1734         return 0;
1735 }
1736
1737 /** Set all visible processors to a given active state (except Fader, whose state is not changed)
1738  *  @param state New active state for those processors.
1739  */
1740 void
1741 Route::all_visible_processors_active (bool state)
1742 {
1743         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1744
1745         if (_processors.empty()) {
1746                 return;
1747         }
1748
1749         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1750                 if (!(*i)->display_to_user() || boost::dynamic_pointer_cast<Amp> (*i)) {
1751                         continue;
1752                 }
1753
1754                 if (state) {
1755                         (*i)->activate ();
1756                 } else {
1757                         (*i)->deactivate ();
1758                 }
1759         }
1760
1761         _session.set_dirty ();
1762 }
1763
1764 int
1765 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
1766 {
1767         /* "new_order" is an ordered list of processors to be positioned according to "placement".
1768            NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
1769            processors in the current actual processor list that are hidden. Any visible processors
1770            in the current list but not in "new_order" will be assumed to be deleted.
1771         */
1772
1773         {
1774                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1775                 ProcessorState pstate (this);
1776
1777                 ProcessorList::iterator oiter;
1778                 ProcessorList::const_iterator niter;
1779                 ProcessorList as_it_will_be;
1780
1781                 oiter = _processors.begin();
1782                 niter = new_order.begin();
1783
1784                 while (niter !=  new_order.end()) {
1785
1786                         /* if the next processor in the old list is invisible (i.e. should not be in the new order)
1787                            then append it to the temp list.
1788
1789                            Otherwise, see if the next processor in the old list is in the new list. if not,
1790                            its been deleted. If its there, append it to the temp list.
1791                         */
1792
1793                         if (oiter == _processors.end()) {
1794
1795                                 /* no more elements in the old list, so just stick the rest of
1796                                    the new order onto the temp list.
1797                                 */
1798
1799                                 as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
1800                                 while (niter != new_order.end()) {
1801                                         ++niter;
1802                                 }
1803                                 break;
1804
1805                         } else {
1806
1807                                 if (!(*oiter)->display_to_user()) {
1808
1809                                         as_it_will_be.push_back (*oiter);
1810
1811                                 } else {
1812
1813                                         /* visible processor: check that its in the new order */
1814
1815                                         if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
1816                                                 /* deleted: do nothing, shared_ptr<> will clean up */
1817                                         } else {
1818                                                 /* ignore this one, and add the next item from the new order instead */
1819                                                 as_it_will_be.push_back (*niter);
1820                                                 ++niter;
1821                                         }
1822                                 }
1823
1824                                 /* now remove from old order - its taken care of no matter what */
1825                                 oiter = _processors.erase (oiter);
1826                         }
1827
1828                 }
1829
1830                 _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
1831
1832                 /* If the meter is in a custom position, find it and make a rough note of its position */
1833                 maybe_note_meter_position ();
1834
1835                 {
1836                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1837
1838                         if (configure_processors_unlocked (err)) {
1839                                 pstate.restore ();
1840                                 return -1;
1841                         }
1842                 }
1843         }
1844
1845         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1846         set_processor_positions ();
1847
1848         return 0;
1849 }
1850
1851 XMLNode&
1852 Route::get_state()
1853 {
1854         return state(true);
1855 }
1856
1857 XMLNode&
1858 Route::get_template()
1859 {
1860         return state(false);
1861 }
1862
1863 XMLNode&
1864 Route::state(bool full_state)
1865 {
1866         XMLNode *node = new XMLNode("Route");
1867         ProcessorList::iterator i;
1868         char buf[32];
1869
1870         id().print (buf, sizeof (buf));
1871         node->add_property("id", buf);
1872         node->add_property ("name", _name);
1873         node->add_property("default-type", _default_type.to_string());
1874
1875         if (_flags) {
1876                 node->add_property("flags", enum_2_string (_flags));
1877         }
1878
1879         node->add_property("active", _active?"yes":"no");
1880         string p;
1881         boost::to_string (_phase_invert, p);
1882         node->add_property("phase-invert", p);
1883         node->add_property("denormal-protection", _denormal_protection?"yes":"no");
1884         node->add_property("meter-point", enum_2_string (_meter_point));
1885
1886         node->add_property("meter-type", enum_2_string (_meter_type));
1887
1888         if (_route_group) {
1889                 node->add_property("route-group", _route_group->name());
1890         }
1891
1892         string order_string;
1893         OrderKeys::iterator x = order_keys.begin();
1894
1895         while (x != order_keys.end()) {
1896                 order_string += enum_2_string ((*x).first);
1897                 order_string += '=';
1898                 snprintf (buf, sizeof(buf), "%" PRId32, (*x).second);
1899                 order_string += buf;
1900
1901                 ++x;
1902
1903                 if (x == order_keys.end()) {
1904                         break;
1905                 }
1906
1907                 order_string += ':';
1908         }
1909         node->add_property ("order-keys", order_string);
1910         node->add_property ("self-solo", (_self_solo ? "yes" : "no"));
1911         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_upstream);
1912         node->add_property ("soloed-by-upstream", buf);
1913         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_downstream);
1914         node->add_property ("soloed-by-downstream", buf);
1915         node->add_property ("solo-isolated", solo_isolated() ? "yes" : "no");
1916         node->add_property ("solo-safe", _solo_safe ? "yes" : "no");
1917
1918         node->add_child_nocopy (_input->state (full_state));
1919         node->add_child_nocopy (_output->state (full_state));
1920         node->add_child_nocopy (_solo_control->get_state ());
1921         node->add_child_nocopy (_mute_control->get_state ());
1922         node->add_child_nocopy (_mute_master->get_state ());
1923
1924         XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
1925         snprintf (buf, sizeof (buf), "%d", _remote_control_id);
1926         remote_control_node->add_property (X_("id"), buf);
1927         node->add_child_nocopy (*remote_control_node);
1928
1929         if (_comment.length()) {
1930                 XMLNode *cmt = node->add_child ("Comment");
1931                 cmt->add_content (_comment);
1932         }
1933
1934         if (_pannable) {
1935                 node->add_child_nocopy (_pannable->state (full_state));
1936         }
1937
1938         for (i = _processors.begin(); i != _processors.end(); ++i) {
1939                 if (!full_state) {
1940                         /* template save: do not include internal sends functioning as
1941                            aux sends because the chance of the target ID
1942                            in the session where this template is used
1943                            is not very likely.
1944
1945                            similarly, do not save listen sends which connect to
1946                            the monitor section, because these will always be
1947                            added if necessary.
1948                         */
1949                         boost::shared_ptr<InternalSend> is;
1950
1951                         if ((is = boost::dynamic_pointer_cast<InternalSend> (*i)) != 0) {
1952                                 if (is->role() == Delivery::Listen) {
1953                                         continue;
1954                                 }
1955                         }
1956                 }
1957                 node->add_child_nocopy((*i)->state (full_state));
1958         }
1959
1960         if (_extra_xml) {
1961                 node->add_child_copy (*_extra_xml);
1962         }
1963
1964         if (_custom_meter_position_noted) {
1965                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
1966                 if (after) {
1967                         after->id().print (buf, sizeof (buf));
1968                         node->add_property (X_("processor-after-last-custom-meter"), buf);
1969                 }
1970
1971                 node->add_property (X_("last-custom-meter-was-at-end"), _last_custom_meter_was_at_end ? "yes" : "no");
1972         }
1973
1974         return *node;
1975 }
1976
1977 int
1978 Route::set_state (const XMLNode& node, int version)
1979 {
1980         if (version < 3000) {
1981                 return set_state_2X (node, version);
1982         }
1983
1984         XMLNodeList nlist;
1985         XMLNodeConstIterator niter;
1986         XMLNode *child;
1987         const XMLProperty *prop;
1988
1989         if (node.name() != "Route"){
1990                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1991                 return -1;
1992         }
1993
1994         if ((prop = node.property (X_("name"))) != 0) {
1995                 Route::set_name (prop->value());
1996         }
1997
1998         set_id (node);
1999
2000         if ((prop = node.property (X_("flags"))) != 0) {
2001                 _flags = Flag (string_2_enum (prop->value(), _flags));
2002         } else {
2003                 _flags = Flag (0);
2004         }
2005
2006         if (is_master() || is_monitor() || is_auditioner()) {
2007                 _mute_master->set_solo_ignore (true);
2008         }
2009
2010         if (is_monitor()) {
2011                 /* monitor bus does not get a panner, but if (re)created
2012                    via XML, it will already have one by the time we
2013                    call ::set_state(). so ... remove it.
2014                 */
2015                 unpan ();
2016         }
2017
2018         /* add all processors (except amp, which is always present) */
2019
2020         nlist = node.children();
2021         XMLNode processor_state (X_("processor_state"));
2022
2023         Stateful::save_extra_xml (node);
2024
2025         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2026
2027                 child = *niter;
2028
2029                 if (child->name() == IO::state_node_name) {
2030                         if ((prop = child->property (X_("direction"))) == 0) {
2031                                 continue;
2032                         }
2033
2034                         if (prop->value() == "Input") {
2035                                 _input->set_state (*child, version);
2036                         } else if (prop->value() == "Output") {
2037                                 _output->set_state (*child, version);
2038                         }
2039                 }
2040
2041                 if (child->name() == X_("Processor")) {
2042                         processor_state.add_child_copy (*child);
2043                 }
2044
2045                 if (child->name() == X_("Pannable")) {
2046                         if (_pannable) {
2047                                 _pannable->set_state (*child, version);
2048                         } else {
2049                                 warning << string_compose (_("Pannable state found for route (%1) without a panner!"), name()) << endmsg;
2050                         }
2051                 }
2052         }
2053
2054         if ((prop = node.property (X_("meter-point"))) != 0) {
2055                 MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
2056                 set_meter_point (mp, true);
2057                 if (_meter) {
2058                         _meter->set_display_to_user (_meter_point == MeterCustom);
2059                 }
2060         }
2061
2062         if ((prop = node.property (X_("meter-type"))) != 0) {
2063                 _meter_type = MeterType (string_2_enum (prop->value (), _meter_type));
2064         }
2065
2066         set_processor_state (processor_state);
2067
2068         // this looks up the internal instrument in processors
2069         reset_instrument_info();
2070
2071         if ((prop = node.property ("self-solo")) != 0) {
2072                 set_self_solo (string_is_affirmative (prop->value()));
2073         }
2074
2075         if ((prop = node.property ("soloed-by-upstream")) != 0) {
2076                 _soloed_by_others_upstream = 0; // needed for mod_.... () to work
2077                 mod_solo_by_others_upstream (atoi (prop->value()));
2078         }
2079
2080         if ((prop = node.property ("soloed-by-downstream")) != 0) {
2081                 _soloed_by_others_downstream = 0; // needed for mod_.... () to work
2082                 mod_solo_by_others_downstream (atoi (prop->value()));
2083         }
2084
2085         if ((prop = node.property ("solo-isolated")) != 0) {
2086                 set_solo_isolated (string_is_affirmative (prop->value()), this);
2087         }
2088
2089         if ((prop = node.property ("solo-safe")) != 0) {
2090                 set_solo_safe (string_is_affirmative (prop->value()), this);
2091         }
2092
2093         if ((prop = node.property (X_("phase-invert"))) != 0) {
2094                 set_phase_invert (boost::dynamic_bitset<> (prop->value ()));
2095         }
2096
2097         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2098                 set_denormal_protection (string_is_affirmative (prop->value()));
2099         }
2100
2101         if ((prop = node.property (X_("active"))) != 0) {
2102                 bool yn = string_is_affirmative (prop->value());
2103                 _active = !yn; // force switch
2104                 set_active (yn, this);
2105         }
2106
2107         if ((prop = node.property (X_("order-keys"))) != 0) {
2108
2109                 int32_t n;
2110
2111                 string::size_type colon, equal;
2112                 string remaining = prop->value();
2113
2114                 while (remaining.length()) {
2115
2116                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2117                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2118                                       << endmsg;
2119                         } else {
2120                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2121                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2122                                               << endmsg;
2123                                 } else {
2124                                         string keyname = remaining.substr (0, equal);
2125                                         RouteSortOrderKey sk;
2126
2127                                         if (keyname == "signal") {
2128                                                 sk = MixerSort;
2129                                         } else if (keyname == "editor") {
2130                                                 sk = EditorSort;
2131                                         } else {
2132                                                 sk = (RouteSortOrderKey) string_2_enum (remaining.substr (0, equal), sk);
2133                                         }
2134
2135                                         set_order_key (sk, n);
2136                                 }
2137                         }
2138
2139                         colon = remaining.find_first_of (':');
2140
2141                         if (colon != string::npos) {
2142                                 remaining = remaining.substr (colon+1);
2143                         } else {
2144                                 break;
2145                         }
2146                 }
2147         }
2148
2149         if ((prop = node.property (X_("processor-after-last-custom-meter"))) != 0) {
2150                 PBD::ID id (prop->value ());
2151                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2152                 ProcessorList::const_iterator i = _processors.begin ();
2153                 while (i != _processors.end() && (*i)->id() != id) {
2154                         ++i;
2155                 }
2156
2157                 if (i != _processors.end ()) {
2158                         _processor_after_last_custom_meter = *i;
2159                         _custom_meter_position_noted = true;
2160                 }
2161         }
2162
2163         if ((prop = node.property (X_("last-custom-meter-was-at-end"))) != 0) {
2164                 _last_custom_meter_was_at_end = string_is_affirmative (prop->value ());
2165         }
2166
2167         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2168                 child = *niter;
2169
2170                 if (child->name() == X_("Comment")) {
2171
2172                         /* XXX this is a terrible API design in libxml++ */
2173
2174                         XMLNode *cmt = *(child->children().begin());
2175                         _comment = cmt->content();
2176
2177                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2178                         if (prop->value() == "solo") {
2179                                 _solo_control->set_state (*child, version);
2180                         } else if (prop->value() == "mute") {
2181                                 _mute_control->set_state (*child, version);
2182                         }
2183
2184                 } else if (child->name() == X_("RemoteControl")) {
2185                         if ((prop = child->property (X_("id"))) != 0) {
2186                                 int32_t x;
2187                                 sscanf (prop->value().c_str(), "%d", &x);
2188                                 set_remote_control_id_internal (x);
2189                         }
2190
2191                 } else if (child->name() == X_("MuteMaster")) {
2192                         _mute_master->set_state (*child, version);
2193                 }
2194         }
2195
2196         return 0;
2197 }
2198
2199 int
2200 Route::set_state_2X (const XMLNode& node, int version)
2201 {
2202         XMLNodeList nlist;
2203         XMLNodeConstIterator niter;
2204         XMLNode *child;
2205         const XMLProperty *prop;
2206
2207         /* 2X things which still remain to be handled:
2208          * default-type
2209          * automation
2210          * controlouts
2211          */
2212
2213         if (node.name() != "Route") {
2214                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2215                 return -1;
2216         }
2217
2218         if ((prop = node.property (X_("flags"))) != 0) {
2219                 string f = prop->value ();
2220                 boost::replace_all (f, "ControlOut", "MonitorOut");
2221                 _flags = Flag (string_2_enum (f, _flags));
2222         } else {
2223                 _flags = Flag (0);
2224         }
2225
2226         if (is_master() || is_monitor() || is_auditioner()) {
2227                 _mute_master->set_solo_ignore (true);
2228         }
2229
2230         if ((prop = node.property (X_("phase-invert"))) != 0) {
2231                 boost::dynamic_bitset<> p (_input->n_ports().n_audio ());
2232                 if (string_is_affirmative (prop->value ())) {
2233                         p.set ();
2234                 }
2235                 set_phase_invert (p);
2236         }
2237
2238         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2239                 set_denormal_protection (string_is_affirmative (prop->value()));
2240         }
2241
2242         if ((prop = node.property (X_("soloed"))) != 0) {
2243                 bool yn = string_is_affirmative (prop->value());
2244
2245                 /* XXX force reset of solo status */
2246
2247                 set_solo (yn, this);
2248         }
2249
2250         if ((prop = node.property (X_("muted"))) != 0) {
2251
2252                 bool first = true;
2253                 bool muted = string_is_affirmative (prop->value());
2254
2255                 if (muted) {
2256
2257                         string mute_point;
2258
2259                         if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
2260
2261                                 if (string_is_affirmative (prop->value())){
2262                                         mute_point = mute_point + "PreFader";
2263                                         first = false;
2264                                 }
2265                         }
2266
2267                         if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
2268
2269                                 if (string_is_affirmative (prop->value())){
2270
2271                                         if (!first) {
2272                                                 mute_point = mute_point + ",";
2273                                         }
2274
2275                                         mute_point = mute_point + "PostFader";
2276                                         first = false;
2277                                 }
2278                         }
2279
2280                         if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
2281
2282                                 if (string_is_affirmative (prop->value())){
2283
2284                                         if (!first) {
2285                                                 mute_point = mute_point + ",";
2286                                         }
2287
2288                                         mute_point = mute_point + "Listen";
2289                                         first = false;
2290                                 }
2291                         }
2292
2293                         if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
2294
2295                                 if (string_is_affirmative (prop->value())){
2296
2297                                         if (!first) {
2298                                                 mute_point = mute_point + ",";
2299                                         }
2300
2301                                         mute_point = mute_point + "Main";
2302                                 }
2303                         }
2304
2305                         _mute_master->set_mute_points (mute_point);
2306                         _mute_master->set_muted_by_self (true);
2307                 }
2308         }
2309
2310         if ((prop = node.property (X_("meter-point"))) != 0) {
2311                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2312         }
2313
2314         /* do not carry over edit/mix groups from 2.X because (a) its hard (b) they
2315            don't mean the same thing.
2316         */
2317
2318         if ((prop = node.property (X_("order-keys"))) != 0) {
2319
2320                 int32_t n;
2321
2322                 string::size_type colon, equal;
2323                 string remaining = prop->value();
2324
2325                 while (remaining.length()) {
2326
2327                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2328                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2329                                         << endmsg;
2330                         } else {
2331                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2332                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2333                                                 << endmsg;
2334                                 } else {
2335                                         string keyname = remaining.substr (0, equal);
2336                                         RouteSortOrderKey sk;
2337
2338                                         if (keyname == "signal") {
2339                                                 sk = MixerSort;
2340                                         } else if (keyname == "editor") {
2341                                                 sk = EditorSort;
2342                                         } else {
2343                                                 sk = (RouteSortOrderKey) string_2_enum (remaining.substr (0, equal), sk);
2344                                         }
2345
2346                                         set_order_key (sk, n);
2347                                 }
2348                         }
2349
2350                         colon = remaining.find_first_of (':');
2351
2352                         if (colon != string::npos) {
2353                                 remaining = remaining.substr (colon+1);
2354                         } else {
2355                                 break;
2356                         }
2357                 }
2358         }
2359
2360         /* IOs */
2361
2362         nlist = node.children ();
2363         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2364
2365                 child = *niter;
2366
2367                 if (child->name() == IO::state_node_name) {
2368
2369                         /* there is a note in IO::set_state_2X() about why we have to call
2370                            this directly.
2371                            */
2372
2373                         _input->set_state_2X (*child, version, true);
2374                         _output->set_state_2X (*child, version, false);
2375
2376                         if ((prop = child->property (X_("name"))) != 0) {
2377                                 Route::set_name (prop->value ());
2378                         }
2379
2380                         set_id (*child);
2381
2382                         if ((prop = child->property (X_("active"))) != 0) {
2383                                 bool yn = string_is_affirmative (prop->value());
2384                                 _active = !yn; // force switch
2385                                 set_active (yn, this);
2386                         }
2387
2388                         if ((prop = child->property (X_("gain"))) != 0) {
2389                                 gain_t val;
2390
2391                                 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2392                                         _amp->gain_control()->set_value (val);
2393                                 }
2394                         }
2395
2396                         /* Set up Panners in the IO */
2397                         XMLNodeList io_nlist = child->children ();
2398
2399                         XMLNodeConstIterator io_niter;
2400                         XMLNode *io_child;
2401
2402                         for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2403
2404                                 io_child = *io_niter;
2405
2406                                 if (io_child->name() == X_("Panner")) {
2407                                         _main_outs->panner_shell()->set_state(*io_child, version);
2408                                 } else if (io_child->name() == X_("Automation")) {
2409                                         /* IO's automation is for the fader */
2410                                         _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
2411                                 }
2412                         }
2413                 }
2414         }
2415
2416         XMLNodeList redirect_nodes;
2417
2418         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2419
2420                 child = *niter;
2421
2422                 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2423                         redirect_nodes.push_back(child);
2424                 }
2425
2426         }
2427
2428         set_processor_state_2X (redirect_nodes, version);
2429
2430         Stateful::save_extra_xml (node);
2431
2432         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2433                 child = *niter;
2434
2435                 if (child->name() == X_("Comment")) {
2436
2437                         /* XXX this is a terrible API design in libxml++ */
2438
2439                         XMLNode *cmt = *(child->children().begin());
2440                         _comment = cmt->content();
2441
2442                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2443                         if (prop->value() == X_("solo")) {
2444                                 _solo_control->set_state (*child, version);
2445                         } else if (prop->value() == X_("mute")) {
2446                                 _mute_control->set_state (*child, version);
2447                         }
2448
2449                 } else if (child->name() == X_("RemoteControl")) {
2450                         if ((prop = child->property (X_("id"))) != 0) {
2451                                 int32_t x;
2452                                 sscanf (prop->value().c_str(), "%d", &x);
2453                                 set_remote_control_id_internal (x);
2454                         }
2455
2456                 }
2457         }
2458
2459         return 0;
2460 }
2461
2462 XMLNode&
2463 Route::get_processor_state ()
2464 {
2465         XMLNode* root = new XMLNode (X_("redirects"));
2466         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2467                 root->add_child_nocopy ((*i)->state (true));
2468         }
2469
2470         return *root;
2471 }
2472
2473 void
2474 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2475 {
2476         /* We don't bother removing existing processors not in nList, as this
2477            method will only be called when creating a Route from scratch, not
2478            for undo purposes.  Just put processors in at the appropriate place
2479            in the list.
2480         */
2481
2482         for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2483                 add_processor_from_xml_2X (**i, version);
2484         }
2485 }
2486
2487 void
2488 Route::set_processor_state (const XMLNode& node)
2489 {
2490         const XMLNodeList &nlist = node.children();
2491         XMLNodeConstIterator niter;
2492         ProcessorList new_order;
2493         bool must_configure = false;
2494
2495         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2496
2497                 XMLProperty* prop = (*niter)->property ("type");
2498
2499                 if (prop->value() == "amp") {
2500                         _amp->set_state (**niter, Stateful::current_state_version);
2501                         new_order.push_back (_amp);
2502                 } else if (prop->value() == "meter") {
2503                         _meter->set_state (**niter, Stateful::current_state_version);
2504                         new_order.push_back (_meter);
2505                 } else if (prop->value() == "main-outs") {
2506                         _main_outs->set_state (**niter, Stateful::current_state_version);
2507                 } else if (prop->value() == "intreturn") {
2508                         if (!_intreturn) {
2509                                 _intreturn.reset (new InternalReturn (_session));
2510                                 must_configure = true;
2511                         }
2512                         _intreturn->set_state (**niter, Stateful::current_state_version);
2513                 } else if (is_monitor() && prop->value() == "monitor") {
2514                         if (!_monitor_control) {
2515                                 _monitor_control.reset (new MonitorProcessor (_session));
2516                                 must_configure = true;
2517                         }
2518                         _monitor_control->set_state (**niter, Stateful::current_state_version);
2519                 } else if (prop->value() == "capture") {
2520                         /* CapturingProcessor should never be restored, it's always
2521                            added explicitly when needed */
2522                 } else {
2523                         ProcessorList::iterator o;
2524
2525                         for (o = _processors.begin(); o != _processors.end(); ++o) {
2526                                 XMLProperty* id_prop = (*niter)->property(X_("id"));
2527                                 if (id_prop && (*o)->id() == id_prop->value()) {
2528                                         (*o)->set_state (**niter, Stateful::current_state_version);
2529                                         new_order.push_back (*o);
2530                                         break;
2531                                 }
2532                         }
2533
2534                         // If the processor (*niter) is not on the route then create it
2535
2536                         if (o == _processors.end()) {
2537
2538                                 boost::shared_ptr<Processor> processor;
2539
2540                                 if (prop->value() == "intsend") {
2541
2542                                         processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::shared_ptr<Route>(), Delivery::Role (0)));
2543
2544                                 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2545                                            prop->value() == "lv2" ||
2546                                            prop->value() == "windows-vst" ||
2547                                            prop->value() == "lxvst" ||
2548                                            prop->value() == "audiounit") {
2549
2550                                         processor.reset (new PluginInsert(_session));
2551
2552                                 } else if (prop->value() == "port") {
2553
2554                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
2555
2556                                 } else if (prop->value() == "send") {
2557
2558                                         processor.reset (new Send (_session, _pannable, _mute_master));
2559
2560                                 } else {
2561                                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2562                                         continue;
2563                                 }
2564
2565 #ifndef NO_PLUGIN_STATE
2566                                 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2567                                         /* This processor could not be configured.  Turn it into a UnknownProcessor */
2568                                         processor.reset (new UnknownProcessor (_session, **niter));
2569                                 }
2570 #else
2571                                 if (boost::dynamic_pointer_cast<PluginInsert>(processor)) {
2572                                         if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2573                                                 /* This processor could not be configured.  Turn it into a UnknownProcessor */
2574                                                 processor.reset (new UnknownProcessor (_session, **niter));
2575                                         }
2576                                 } else {
2577                                         /* plugin, but ::set_state() not * allowed no message here - things will get too verbose */
2578                                 }
2579 #endif
2580
2581                                 /* we have to note the monitor send here, otherwise a new one will be created
2582                                    and the state of this one will be lost.
2583                                 */
2584                                 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
2585                                 if (isend && isend->role() == Delivery::Listen) {
2586                                         _monitor_send = isend;
2587                                 }
2588
2589                                 /* it doesn't matter if invisible processors are added here, as they
2590                                    will be sorted out by setup_invisible_processors () shortly.
2591                                 */
2592
2593                                 new_order.push_back (processor);
2594                                 must_configure = true;
2595                         }
2596                 }
2597         }
2598
2599         {
2600                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2601                 _processors = new_order;
2602
2603                 if (must_configure) {
2604                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2605                         configure_processors_unlocked (0);
2606                 }
2607
2608                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2609
2610                         (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
2611
2612                         boost::shared_ptr<PluginInsert> pi;
2613
2614                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
2615                                 if (pi->has_no_inputs ()) {
2616                                         _have_internal_generator = true;
2617                                         break;
2618                                 }
2619                         }
2620                 }
2621         }
2622
2623         reset_instrument_info ();
2624         processors_changed (RouteProcessorChange ());
2625         set_processor_positions ();
2626 }
2627
2628 void
2629 Route::curve_reallocate ()
2630 {
2631 //      _gain_automation_curve.finish_resize ();
2632 //      _pan_automation_curve.finish_resize ();
2633 }
2634
2635 void
2636 Route::silence (framecnt_t nframes)
2637 {
2638         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
2639         if (!lm.locked()) {
2640                 return;
2641         }
2642
2643         silence_unlocked (nframes);
2644 }
2645
2646 void
2647 Route::silence_unlocked (framecnt_t nframes)
2648 {
2649         /* Must be called with the processor lock held */
2650
2651         if (!_silent) {
2652
2653                 _output->silence (nframes);
2654
2655                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2656                         boost::shared_ptr<PluginInsert> pi;
2657
2658                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2659                                 // skip plugins, they don't need anything when we're not active
2660                                 continue;
2661                         }
2662
2663                         (*i)->silence (nframes);
2664                 }
2665
2666                 if (nframes == _session.get_block_size()) {
2667                         // _silent = true;
2668                 }
2669         }
2670 }
2671
2672 void
2673 Route::add_internal_return ()
2674 {
2675         if (!_intreturn) {
2676                 _intreturn.reset (new InternalReturn (_session));
2677                 add_processor (_intreturn, PreFader);
2678         }
2679 }
2680
2681 void
2682 Route::add_send_to_internal_return (InternalSend* send)
2683 {
2684         Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
2685
2686         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2687                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2688
2689                 if (d) {
2690                         return d->add_send (send);
2691                 }
2692         }
2693 }
2694
2695 void
2696 Route::remove_send_from_internal_return (InternalSend* send)
2697 {
2698         Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
2699
2700         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2701                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2702
2703                 if (d) {
2704                         return d->remove_send (send);
2705                 }
2706         }
2707 }
2708
2709 void
2710 Route::enable_monitor_send ()
2711 {
2712         /* Caller must hold process lock */
2713         assert (!AudioEngine::instance()->process_lock().trylock());
2714
2715         /* master never sends to monitor section via the normal mechanism */
2716         assert (!is_master ());
2717
2718         /* make sure we have one */
2719         if (!_monitor_send) {
2720                 _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, _session.monitor_out(), Delivery::Listen));
2721                 _monitor_send->set_display_to_user (false);
2722         }
2723
2724         /* set it up */
2725         configure_processors (0);
2726 }
2727
2728 /** Add an aux send to a route.
2729  *  @param route route to send to.
2730  *  @param before Processor to insert before, or 0 to insert at the end.
2731  */
2732 int
2733 Route::add_aux_send (boost::shared_ptr<Route> route, boost::shared_ptr<Processor> before)
2734 {
2735         assert (route != _session.monitor_out ());
2736
2737         {
2738                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
2739
2740                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2741
2742                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
2743
2744                         if (d && d->target_route() == route) {
2745                                 /* already listening via the specified IO: do nothing */
2746                                 return 0;
2747                         }
2748                 }
2749         }
2750
2751         try {
2752
2753                 boost::shared_ptr<InternalSend> listener;
2754
2755                 {
2756                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2757                         listener.reset (new InternalSend (_session, _pannable, _mute_master, route, Delivery::Aux));
2758                 }
2759
2760                 add_processor (listener, before);
2761
2762         } catch (failed_constructor& err) {
2763                 return -1;
2764         }
2765
2766         return 0;
2767 }
2768
2769 void
2770 Route::remove_aux_or_listen (boost::shared_ptr<Route> route)
2771 {
2772         ProcessorStreams err;
2773         ProcessorList::iterator tmp;
2774
2775         {
2776                 Glib::Threads::RWLock::ReaderLock rl(_processor_lock);
2777
2778                 /* have to do this early because otherwise processor reconfig
2779                  * will put _monitor_send back in the list
2780                  */
2781
2782                 if (route == _session.monitor_out()) {
2783                         _monitor_send.reset ();
2784                 }
2785
2786           again:
2787                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2788
2789                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2790
2791                         if (d && d->target_route() == route) {
2792                                 rl.release ();
2793                                 remove_processor (*x, &err, false);
2794                                 rl.acquire ();
2795
2796                                 /* list could have been demolished while we dropped the lock
2797                                    so start over.
2798                                 */
2799
2800                                 goto again;
2801                         }
2802                 }
2803         }
2804 }
2805
2806 void
2807 Route::set_comment (string cmt, void *src)
2808 {
2809         _comment = cmt;
2810         comment_changed (src);
2811         _session.set_dirty ();
2812 }
2813
2814 bool
2815 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
2816 {
2817         FeedRecord fr (other, via_sends_only);
2818
2819         pair<FedBy::iterator,bool> result =  _fed_by.insert (fr);
2820
2821         if (!result.second) {
2822
2823                 /* already a record for "other" - make sure sends-only information is correct */
2824                 if (!via_sends_only && result.first->sends_only) {
2825                         FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
2826                         frp->sends_only = false;
2827                 }
2828         }
2829
2830         return result.second;
2831 }
2832
2833 void
2834 Route::clear_fed_by ()
2835 {
2836         _fed_by.clear ();
2837 }
2838
2839 bool
2840 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
2841 {
2842         const FedBy& fed_by (other->fed_by());
2843
2844         for (FedBy::iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
2845                 boost::shared_ptr<Route> sr = f->r.lock();
2846
2847                 if (sr && (sr.get() == this)) {
2848
2849                         if (via_sends_only) {
2850                                 *via_sends_only = f->sends_only;
2851                         }
2852
2853                         return true;
2854                 }
2855         }
2856
2857         return false;
2858 }
2859
2860 bool
2861 Route::direct_feeds_according_to_reality (boost::shared_ptr<Route> other, bool* via_send_only)
2862 {
2863         DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
2864
2865         if (_output->connected_to (other->input())) {
2866                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
2867                 if (via_send_only) {
2868                         *via_send_only = false;
2869                 }
2870
2871                 return true;
2872         }
2873
2874
2875         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
2876
2877                 boost::shared_ptr<IOProcessor> iop;
2878
2879                 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
2880                         if (iop->feeds (other)) {
2881                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
2882                                 if (via_send_only) {
2883                                         *via_send_only = true;
2884                                 }
2885                                 return true;
2886                         } else {
2887                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
2888                         }
2889                 } else {
2890                         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
2891                 }
2892
2893         }
2894
2895         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tdoes NOT feed %1\n", other->name()));
2896         return false;
2897 }
2898
2899 bool
2900 Route::direct_feeds_according_to_graph (boost::shared_ptr<Route> other, bool* via_send_only)
2901 {
2902         return _session._current_route_graph.has (shared_from_this (), other, via_send_only);
2903 }
2904
2905 /** Called from the (non-realtime) butler thread when the transport is stopped */
2906 void
2907 Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool /*did_locate*/, bool can_flush_processors)
2908 {
2909         framepos_t now = _session.transport_frame();
2910
2911         {
2912                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2913
2914                 Automatable::transport_stopped (now);
2915
2916                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2917
2918                         if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && can_flush_processors)) {
2919                                 (*i)->flush ();
2920                         }
2921
2922                         (*i)->transport_stopped (now);
2923                 }
2924         }
2925
2926         _roll_delay = _initial_delay;
2927 }
2928
2929 void
2930 Route::input_change_handler (IOChange change, void * /*src*/)
2931 {
2932         bool need_to_queue_solo_change = true;
2933
2934         if ((change.type & IOChange::ConfigurationChanged)) {
2935                 /* This is called with the process lock held if change
2936                    contains ConfigurationChanged
2937                 */
2938                 need_to_queue_solo_change = false;
2939                 configure_processors (0);
2940                 _phase_invert.resize (_input->n_ports().n_audio ());
2941                 io_changed (); /* EMIT SIGNAL */
2942         }
2943
2944         if (!_input->connected() && _soloed_by_others_upstream) {
2945                 if (need_to_queue_solo_change) {
2946                         _session.cancel_solo_after_disconnect (shared_from_this(), true);
2947                 } else {
2948                         cancel_solo_after_disconnect (true);
2949                 }
2950         }
2951 }
2952
2953 void
2954 Route::output_change_handler (IOChange change, void * /*src*/)
2955 {
2956         bool need_to_queue_solo_change = true;
2957
2958         if ((change.type & IOChange::ConfigurationChanged)) {
2959                 /* This is called with the process lock held if change
2960                    contains ConfigurationChanged
2961                 */
2962                 need_to_queue_solo_change = false;
2963                 configure_processors (0);
2964                 io_changed (); /* EMIT SIGNAL */
2965         }
2966
2967         if (!_output->connected() && _soloed_by_others_downstream) {
2968                 if (need_to_queue_solo_change) {
2969                         _session.cancel_solo_after_disconnect (shared_from_this(), false);
2970                 } else {
2971                         cancel_solo_after_disconnect (false);
2972                 }
2973         }
2974 }
2975
2976 void
2977 Route::cancel_solo_after_disconnect (bool upstream)
2978 {
2979         if (upstream) {
2980                 _soloed_by_others_upstream = 0;
2981         } else {
2982                 _soloed_by_others_downstream = 0;
2983         }
2984         set_mute_master_solo ();
2985         solo_changed (false, this);
2986 }
2987
2988 uint32_t
2989 Route::pans_required () const
2990 {
2991         if (n_outputs().n_audio() < 2) {
2992                 return 0;
2993         }
2994
2995         return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
2996 }
2997
2998 int
2999 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
3000 {
3001         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3002
3003         if (!lm.locked()) {
3004                 return 0;
3005         }
3006
3007         if (n_outputs().n_total() == 0) {
3008                 return 0;
3009         }
3010
3011         if (!_active || n_inputs() == ChanCount::ZERO)  {
3012                 silence_unlocked (nframes);
3013                 return 0;
3014         }
3015
3016         if (session_state_changing) {
3017                 if (_session.transport_speed() != 0.0f) {
3018                         /* we're rolling but some state is changing (e.g. our diskstream contents)
3019                            so we cannot use them. Be silent till this is over.
3020
3021                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
3022                         */
3023                         silence_unlocked (nframes);
3024                         return 0;
3025                 }
3026                 /* we're really not rolling, so we're either delivery silence or actually
3027                    monitoring, both of which are safe to do while session_state_changing is true.
3028                 */
3029         }
3030
3031         BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers());
3032
3033         fill_buffers_with_input (bufs, _input, nframes);
3034
3035         if (_meter_point == MeterInput) {
3036                 _meter->run (bufs, start_frame, end_frame, nframes, true);
3037         }
3038
3039         _amp->apply_gain_automation (false);
3040         passthru (bufs, start_frame, end_frame, nframes, 0);
3041
3042         return 0;
3043 }
3044
3045 int
3046 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& /* need_butler */)
3047 {
3048         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3049         if (!lm.locked()) {
3050                 return 0;
3051         }
3052
3053         if (n_outputs().n_total() == 0) {
3054                 return 0;
3055         }
3056
3057         if (!_active || n_inputs().n_total() == 0) {
3058                 silence_unlocked (nframes);
3059                 return 0;
3060         }
3061
3062         framepos_t unused = 0;
3063
3064         if ((nframes = check_initial_delay (nframes, unused)) == 0) {
3065                 return 0;
3066         }
3067
3068         _silent = false;
3069
3070         BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers());
3071
3072         fill_buffers_with_input (bufs, _input, nframes);
3073
3074         if (_meter_point == MeterInput) {
3075                 _meter->run (bufs, start_frame, end_frame, nframes, true);
3076         }
3077
3078         passthru (bufs, start_frame, end_frame, nframes, declick);
3079
3080         return 0;
3081 }
3082
3083 int
3084 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& /* need_butler */)
3085 {
3086         silence (nframes);
3087         return 0;
3088 }
3089
3090 void
3091 Route::flush_processors ()
3092 {
3093         /* XXX shouldn't really try to take this lock, since
3094            this is called from the RT audio thread.
3095         */
3096
3097         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3098
3099         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3100                 (*i)->flush ();
3101         }
3102 }
3103
3104 void
3105 Route::set_meter_point (MeterPoint p, bool force)
3106 {
3107         if (_meter_point == p && !force) {
3108                 return;
3109         }
3110
3111         bool meter_was_visible_to_user = _meter->display_to_user ();
3112
3113         {
3114                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3115
3116                 maybe_note_meter_position ();
3117
3118                 _meter_point = p;
3119
3120                 if (_meter_point != MeterCustom) {
3121
3122                         _meter->set_display_to_user (false);
3123
3124                         setup_invisible_processors ();
3125
3126                 } else {
3127
3128                         _meter->set_display_to_user (true);
3129
3130                         /* If we have a previous position for the custom meter, try to put it there */
3131                         if (_custom_meter_position_noted) {
3132                                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
3133
3134                                 if (after) {
3135                                         ProcessorList::iterator i = find (_processors.begin(), _processors.end(), after);
3136                                         if (i != _processors.end ()) {
3137                                                 _processors.remove (_meter);
3138                                                 _processors.insert (i, _meter);
3139                                         }
3140                                 } else if (_last_custom_meter_was_at_end) {
3141                                         _processors.remove (_meter);
3142                                         _processors.push_back (_meter);
3143                                 }
3144                         }
3145                 }
3146
3147                 /* Set up the meter for its new position */
3148
3149                 ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
3150
3151                 ChanCount m_in;
3152
3153                 if (loc == _processors.begin()) {
3154                         m_in = _input->n_ports();
3155                 } else {
3156                         ProcessorList::iterator before = loc;
3157                         --before;
3158                         m_in = (*before)->output_streams ();
3159                 }
3160
3161                 _meter->reflect_inputs (m_in);
3162
3163                 /* we do not need to reconfigure the processors, because the meter
3164                    (a) is always ready to handle processor_max_streams
3165                    (b) is always an N-in/N-out processor, and thus moving
3166                    it doesn't require any changes to the other processors.
3167                 */
3168         }
3169
3170         meter_change (); /* EMIT SIGNAL */
3171
3172         bool const meter_visibly_changed = (_meter->display_to_user() != meter_was_visible_to_user);
3173
3174         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
3175 }
3176
3177 void
3178 Route::listen_position_changed ()
3179 {
3180         {
3181                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3182                 ProcessorState pstate (this);
3183
3184                 {
3185                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3186
3187                         if (configure_processors_unlocked (0)) {
3188                                 pstate.restore ();
3189                                 configure_processors_unlocked (0); // it worked before we tried to add it ...
3190                                 return;
3191                         }
3192                 }
3193         }
3194
3195         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
3196         _session.set_dirty ();
3197 }
3198
3199 boost::shared_ptr<CapturingProcessor>
3200 Route::add_export_point()
3201 {
3202         if (!_capturing_processor) {
3203
3204                 _capturing_processor.reset (new CapturingProcessor (_session));
3205                 _capturing_processor->activate ();
3206
3207                 {
3208                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3209                         configure_processors (0);
3210                 }
3211
3212         }
3213
3214         return _capturing_processor;
3215 }
3216
3217 framecnt_t
3218 Route::update_signal_latency ()
3219 {
3220         framecnt_t l = _output->user_latency();
3221
3222         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3223                 if ((*i)->active ()) {
3224                         l += (*i)->signal_latency ();
3225                 }
3226         }
3227
3228         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l));
3229
3230         if (_signal_latency != l) {
3231                 _signal_latency = l;
3232                 signal_latency_changed (); /* EMIT SIGNAL */
3233         }
3234
3235         return _signal_latency;
3236 }
3237
3238 void
3239 Route::set_user_latency (framecnt_t nframes)
3240 {
3241         _output->set_user_latency (nframes);
3242         _session.update_latency_compensation ();
3243 }
3244
3245 void
3246 Route::set_latency_compensation (framecnt_t longest_session_latency)
3247 {
3248         framecnt_t old = _initial_delay;
3249
3250         if (_signal_latency < longest_session_latency) {
3251                 _initial_delay = longest_session_latency - _signal_latency;
3252         } else {
3253                 _initial_delay = 0;
3254         }
3255
3256         DEBUG_TRACE (DEBUG::Latency, string_compose (
3257                              "%1: compensate for maximum latency of %2,"
3258                              "given own latency of %3, using initial delay of %4\n",
3259                              name(), longest_session_latency, _signal_latency, _initial_delay));
3260
3261         if (_initial_delay != old) {
3262                 initial_delay_changed (); /* EMIT SIGNAL */
3263         }
3264
3265         if (_session.transport_stopped()) {
3266                 _roll_delay = _initial_delay;
3267         }
3268 }
3269
3270 Route::SoloControllable::SoloControllable (std::string name, boost::shared_ptr<Route> r)
3271         : AutomationControl (r->session(), Evoral::Parameter (SoloAutomation),
3272                              boost::shared_ptr<AutomationList>(), name)
3273         , _route (r)
3274 {
3275         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
3276         set_list (gl);
3277 }
3278
3279 void
3280 Route::SoloControllable::set_value (double val)
3281 {
3282         bool bval = ((val >= 0.5f) ? true: false);
3283
3284         boost::shared_ptr<RouteList> rl (new RouteList);
3285
3286         boost::shared_ptr<Route> r = _route.lock ();
3287         if (!r) {
3288                 return;
3289         }
3290
3291         rl->push_back (r);
3292
3293         if (Config->get_solo_control_is_listen_control()) {
3294                 _session.set_listen (rl, bval);
3295         } else {
3296                 _session.set_solo (rl, bval);
3297         }
3298 }
3299
3300 double
3301 Route::SoloControllable::get_value () const
3302 {
3303         boost::shared_ptr<Route> r = _route.lock ();
3304         if (!r) {
3305                 return 0;
3306         }
3307
3308         if (Config->get_solo_control_is_listen_control()) {
3309                 return r->listening_via_monitor() ? 1.0f : 0.0f;
3310         } else {
3311                 return r->self_soloed() ? 1.0f : 0.0f;
3312         }
3313 }
3314
3315 Route::MuteControllable::MuteControllable (std::string name, boost::shared_ptr<Route> r)
3316         : AutomationControl (r->session(), Evoral::Parameter (MuteAutomation),
3317                              boost::shared_ptr<AutomationList>(), name)
3318         , _route (r)
3319 {
3320         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MuteAutomation)));
3321         set_list (gl);
3322 }
3323
3324 void
3325 Route::MuteControllable::set_value (double val)
3326 {
3327         bool bval = ((val >= 0.5f) ? true: false);
3328
3329         boost::shared_ptr<RouteList> rl (new RouteList);
3330
3331         boost::shared_ptr<Route> r = _route.lock ();
3332         if (!r) {
3333                 return;
3334         }
3335
3336         rl->push_back (r);
3337         _session.set_mute (rl, bval);
3338 }
3339
3340 double
3341 Route::MuteControllable::get_value () const
3342 {
3343         boost::shared_ptr<Route> r = _route.lock ();
3344         if (!r) {
3345                 return 0;
3346         }
3347
3348         return r->muted() ? 1.0f : 0.0f;
3349 }
3350
3351 void
3352 Route::set_block_size (pframes_t nframes)
3353 {
3354         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3355                 (*i)->set_block_size (nframes);
3356         }
3357
3358         _session.ensure_buffers (n_process_buffers ());
3359 }
3360
3361 void
3362 Route::protect_automation ()
3363 {
3364         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3365                 (*i)->protect_automation();
3366 }
3367
3368 /** @param declick 1 to set a pending declick fade-in,
3369  *                -1 to set a pending declick fade-out
3370  */
3371 void
3372 Route::set_pending_declick (int declick)
3373 {
3374         if (_declickable) {
3375                 /* this call is not allowed to turn off a pending declick */
3376                 if (declick) {
3377                         _pending_declick = declick;
3378                 }
3379         } else {
3380                 _pending_declick = 0;
3381         }
3382 }
3383
3384 /** Shift automation forwards from a particular place, thereby inserting time.
3385  *  Adds undo commands for any shifts that are performed.
3386  *
3387  * @param pos Position to start shifting from.
3388  * @param frames Amount to shift forwards by.
3389  */
3390
3391 void
3392 Route::shift (framepos_t pos, framecnt_t frames)
3393 {
3394         /* gain automation */
3395         {
3396                 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
3397
3398                 XMLNode &before = gc->alist()->get_state ();
3399                 gc->alist()->shift (pos, frames);
3400                 XMLNode &after = gc->alist()->get_state ();
3401                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3402         }
3403
3404         /* pan automation */
3405         if (_pannable) {
3406                 ControlSet::Controls& c (_pannable->controls());
3407
3408                 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
3409                         boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
3410                         if (pc) {
3411                                 boost::shared_ptr<AutomationList> al = pc->alist();
3412                                 XMLNode& before = al->get_state ();
3413                                 al->shift (pos, frames);
3414                                 XMLNode& after = al->get_state ();
3415                                 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3416                         }
3417                 }
3418         }
3419
3420         /* redirect automation */
3421         {
3422                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3423                 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
3424
3425                         set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
3426
3427                         for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
3428                                 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
3429                                 if (ac) {
3430                                         boost::shared_ptr<AutomationList> al = ac->alist();
3431                                         XMLNode &before = al->get_state ();
3432                                         al->shift (pos, frames);
3433                                         XMLNode &after = al->get_state ();
3434                                         _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3435                                 }
3436                         }
3437                 }
3438         }
3439 }
3440
3441
3442 int
3443 Route::save_as_template (const string& path, const string& name)
3444 {
3445         XMLNode& node (state (false));
3446         XMLTree tree;
3447
3448         IO::set_name_in_state (*node.children().front(), name);
3449
3450         tree.set_root (&node);
3451         return tree.write (path.c_str());
3452 }
3453
3454
3455 bool
3456 Route::set_name (const string& str)
3457 {
3458         bool ret;
3459         string ioproc_name;
3460         string name;
3461
3462         name = Route::ensure_track_or_route_name (str, _session);
3463         SessionObject::set_name (name);
3464
3465         ret = (_input->set_name(name) && _output->set_name(name));
3466
3467         if (ret) {
3468                 /* rename the main outs. Leave other IO processors
3469                  * with whatever name they already have, because its
3470                  * just fine as it is (it will not contain the route
3471                  * name if its a port insert, port send or port return).
3472                  */
3473
3474                 if (_main_outs) {
3475                         if (_main_outs->set_name (name)) {
3476                                 /* XXX returning false here is stupid because
3477                                    we already changed the route name.
3478                                 */
3479                                 return false;
3480                         }
3481                 }
3482         }
3483
3484         return ret;
3485 }
3486
3487 /** Set the name of a route in an XML description.
3488  *  @param node XML <Route> node to set the name in.
3489  *  @param name New name.
3490  */
3491 void
3492 Route::set_name_in_state (XMLNode& node, string const & name)
3493 {
3494         node.add_property (X_("name"), name);
3495
3496         XMLNodeList children = node.children();
3497         for (XMLNodeIterator i = children.begin(); i != children.end(); ++i) {
3498
3499                 if ((*i)->name() == X_("IO")) {
3500
3501                         IO::set_name_in_state (**i, name);
3502
3503                 } else if ((*i)->name() == X_("Processor")) {
3504
3505                         XMLProperty* role = (*i)->property (X_("role"));
3506                         if (role && role->value() == X_("Main")) {
3507                                 (*i)->add_property (X_("name"), name);
3508                         }
3509
3510                 } else if ((*i)->name() == X_("Diskstream")) {
3511
3512                         (*i)->add_property (X_("playlist"), string_compose ("%1.1", name).c_str());
3513                         (*i)->add_property (X_("name"), name);
3514
3515                 }
3516         }
3517 }
3518
3519 boost::shared_ptr<Send>
3520 Route::internal_send_for (boost::shared_ptr<const Route> target) const
3521 {
3522         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3523
3524         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3525                 boost::shared_ptr<InternalSend> send;
3526
3527                 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
3528                         if (send->target_route() == target) {
3529                                 return send;
3530                         }
3531                 }
3532         }
3533
3534         return boost::shared_ptr<Send>();
3535 }
3536
3537 /** @param c Audio channel index.
3538  *  @param yn true to invert phase, otherwise false.
3539  */
3540 void
3541 Route::set_phase_invert (uint32_t c, bool yn)
3542 {
3543         if (_phase_invert[c] != yn) {
3544                 _phase_invert[c] = yn;
3545                 phase_invert_changed (); /* EMIT SIGNAL */
3546                 _session.set_dirty ();
3547         }
3548 }
3549
3550 void
3551 Route::set_phase_invert (boost::dynamic_bitset<> p)
3552 {
3553         if (_phase_invert != p) {
3554                 _phase_invert = p;
3555                 phase_invert_changed (); /* EMIT SIGNAL */
3556                 _session.set_dirty ();
3557         }
3558 }
3559
3560 bool
3561 Route::phase_invert (uint32_t c) const
3562 {
3563         return _phase_invert[c];
3564 }
3565
3566 boost::dynamic_bitset<>
3567 Route::phase_invert () const
3568 {
3569         return _phase_invert;
3570 }
3571
3572 void
3573 Route::set_denormal_protection (bool yn)
3574 {
3575         if (_denormal_protection != yn) {
3576                 _denormal_protection = yn;
3577                 denormal_protection_changed (); /* EMIT SIGNAL */
3578         }
3579 }
3580
3581 bool
3582 Route::denormal_protection () const
3583 {
3584         return _denormal_protection;
3585 }
3586
3587 void
3588 Route::set_active (bool yn, void* src)
3589 {
3590         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
3591                 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
3592                 return;
3593         }
3594
3595         if (_active != yn) {
3596                 _active = yn;
3597                 _input->set_active (yn);
3598                 _output->set_active (yn);
3599                 active_changed (); // EMIT SIGNAL
3600                 _session.set_dirty ();
3601         }
3602 }
3603
3604 void
3605 Route::meter ()
3606 {
3607         Glib::Threads::RWLock::ReaderLock rm (_processor_lock, Glib::Threads::TRY_LOCK);
3608
3609         assert (_meter);
3610
3611         _meter->meter ();
3612
3613         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3614
3615                 boost::shared_ptr<Send> s;
3616                 boost::shared_ptr<Return> r;
3617
3618                 if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
3619                         s->meter()->meter();
3620                 } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
3621                         r->meter()->meter ();
3622                 }
3623         }
3624 }
3625
3626 boost::shared_ptr<Pannable>
3627 Route::pannable() const
3628 {
3629         return _pannable;
3630 }
3631
3632 boost::shared_ptr<Panner>
3633 Route::panner() const
3634 {
3635         /* may be null ! */
3636         return _main_outs->panner_shell()->panner();
3637 }
3638
3639 boost::shared_ptr<PannerShell>
3640 Route::panner_shell() const
3641 {
3642         return _main_outs->panner_shell();
3643 }
3644
3645 boost::shared_ptr<AutomationControl>
3646 Route::gain_control() const
3647 {
3648         return _amp->gain_control();
3649 }
3650
3651 boost::shared_ptr<AutomationControl>
3652 Route::get_control (const Evoral::Parameter& param)
3653 {
3654         /* either we own the control or .... */
3655
3656         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
3657
3658         if (!c) {
3659
3660                 /* maybe one of our processors does or ... */
3661
3662                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock, Glib::Threads::TRY_LOCK);
3663                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3664                         if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
3665                                 break;
3666                         }
3667                 }
3668         }
3669
3670         if (!c) {
3671
3672                 /* nobody does so we'll make a new one */
3673
3674                 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
3675                 add_control(c);
3676         }
3677
3678         return c;
3679 }
3680
3681 boost::shared_ptr<Processor>
3682 Route::nth_plugin (uint32_t n)
3683 {
3684         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3685         ProcessorList::iterator i;
3686
3687         for (i = _processors.begin(); i != _processors.end(); ++i) {
3688                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
3689                         if (n-- == 0) {
3690                                 return *i;
3691                         }
3692                 }
3693         }
3694
3695         return boost::shared_ptr<Processor> ();
3696 }
3697
3698 boost::shared_ptr<Processor>
3699 Route::nth_send (uint32_t n)
3700 {
3701         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3702         ProcessorList::iterator i;
3703
3704         for (i = _processors.begin(); i != _processors.end(); ++i) {
3705                 if (boost::dynamic_pointer_cast<Send> (*i)) {
3706                         if (n-- == 0) {
3707                                 return *i;
3708                         }
3709                 }
3710         }
3711
3712         return boost::shared_ptr<Processor> ();
3713 }
3714
3715 bool
3716 Route::has_io_processor_named (const string& name)
3717 {
3718         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3719         ProcessorList::iterator i;
3720
3721         for (i = _processors.begin(); i != _processors.end(); ++i) {
3722                 if (boost::dynamic_pointer_cast<Send> (*i) ||
3723                     boost::dynamic_pointer_cast<PortInsert> (*i)) {
3724                         if ((*i)->name() == name) {
3725                                 return true;
3726                         }
3727                 }
3728         }
3729
3730         return false;
3731 }
3732
3733 MuteMaster::MutePoint
3734 Route::mute_points () const
3735 {
3736         return _mute_master->mute_points ();
3737 }
3738
3739 void
3740 Route::set_processor_positions ()
3741 {
3742         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3743
3744         bool had_amp = false;
3745         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3746                 (*i)->set_pre_fader (!had_amp);
3747                 if (boost::dynamic_pointer_cast<Amp> (*i)) {
3748                         had_amp = true;
3749                 }
3750         }
3751 }
3752
3753 /** Called when there is a proposed change to the input port count */
3754 bool
3755 Route::input_port_count_changing (ChanCount to)
3756 {
3757         list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
3758         if (c.empty()) {
3759                 /* The processors cannot be configured with the new input arrangement, so
3760                    block the change.
3761                 */
3762                 return true;
3763         }
3764
3765         /* The change is ok */
3766         return false;
3767 }
3768
3769 list<string>
3770 Route::unknown_processors () const
3771 {
3772         list<string> p;
3773
3774         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3775         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3776                 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
3777                         p.push_back ((*i)->name ());
3778                 }
3779         }
3780
3781         return p;
3782 }
3783
3784
3785 framecnt_t
3786 Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecnt_t our_latency) const
3787 {
3788         /* we assume that all our input ports feed all our output ports. its not
3789            universally true, but the alternative is way too corner-case to worry about.
3790         */
3791
3792         jack_latency_range_t all_connections;
3793
3794         if (from.empty()) {
3795                 all_connections.min = 0;
3796                 all_connections.max = 0;
3797         } else {
3798                 all_connections.min = ~((jack_nframes_t) 0);
3799                 all_connections.max = 0;
3800
3801                 /* iterate over all "from" ports and determine the latency range for all of their
3802                    connections to the "outside" (outside of this Route).
3803                 */
3804
3805                 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
3806
3807                         jack_latency_range_t range;
3808
3809                         p->get_connected_latency_range (range, playback);
3810
3811                         all_connections.min = min (all_connections.min, range.min);
3812                         all_connections.max = max (all_connections.max, range.max);
3813                 }
3814         }
3815
3816         /* set the "from" port latencies to the max/min range of all their connections */
3817
3818         for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
3819                 p->set_private_latency_range (all_connections, playback);
3820         }
3821
3822         /* set the ports "in the direction of the flow" to the same value as above plus our own signal latency */
3823
3824         all_connections.min += our_latency;
3825         all_connections.max += our_latency;
3826
3827         for (PortSet::iterator p = to.begin(); p != to.end(); ++p) {
3828                 p->set_private_latency_range (all_connections, playback);
3829         }
3830
3831         return all_connections.max;
3832 }
3833
3834 framecnt_t
3835 Route::set_private_port_latencies (bool playback) const
3836 {
3837         framecnt_t own_latency = 0;
3838
3839         /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD
3840            OR LATENCY CALLBACK.
3841
3842            This is called (early) from the latency callback. It computes the REAL
3843            latency associated with each port and stores the result as the "private"
3844            latency of the port. A later call to Route::set_public_port_latencies()
3845            sets all ports to the same value to reflect the fact that we do latency
3846            compensation and so all signals are delayed by the same amount as they
3847            flow through ardour.
3848         */
3849
3850         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3851                 if ((*i)->active ()) {
3852                         own_latency += (*i)->signal_latency ();
3853                 }
3854         }
3855
3856         if (playback) {
3857                 /* playback: propagate latency from "outside the route" to outputs to inputs */
3858                 return update_port_latencies (_output->ports (), _input->ports (), true, own_latency);
3859         } else {
3860                 /* capture: propagate latency from "outside the route" to inputs to outputs */
3861                 return update_port_latencies (_input->ports (), _output->ports (), false, own_latency);
3862         }
3863 }
3864
3865 void
3866 Route::set_public_port_latencies (framecnt_t value, bool playback) const
3867 {
3868         /* this is called to set the JACK-visible port latencies, which take
3869            latency compensation into account.
3870         */
3871
3872         jack_latency_range_t range;
3873
3874         range.min = value;
3875         range.max = value;
3876
3877         {
3878                 const PortSet& ports (_input->ports());
3879                 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
3880                         p->set_public_latency_range (range, playback);
3881                 }
3882         }
3883
3884         {
3885                 const PortSet& ports (_output->ports());
3886                 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
3887                         p->set_public_latency_range (range, playback);
3888                 }
3889         }
3890 }
3891
3892 /** Put the invisible processors in the right place in _processors.
3893  *  Must be called with a writer lock on _processor_lock held.
3894  */
3895 void
3896 Route::setup_invisible_processors ()
3897 {
3898 #ifndef NDEBUG
3899         Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3900         assert (!lm.locked ());
3901 #endif
3902
3903         if (!_main_outs) {
3904                 /* too early to be doing this stuff */
3905                 return;
3906         }
3907
3908         /* we'll build this new list here and then use it */
3909
3910         ProcessorList new_processors;
3911
3912         /* find visible processors */
3913
3914         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3915                 if ((*i)->display_to_user ()) {
3916                         new_processors.push_back (*i);
3917                 }
3918         }
3919
3920         /* find the amp */
3921
3922         ProcessorList::iterator amp = new_processors.begin ();
3923         while (amp != new_processors.end() && boost::dynamic_pointer_cast<Amp> (*amp) == 0) {
3924                 ++amp;
3925         }
3926
3927         assert (amp != _processors.end ());
3928
3929         /* and the processor after the amp */
3930
3931         ProcessorList::iterator after_amp = amp;
3932         ++after_amp;
3933
3934         /* METER */
3935
3936         if (_meter) {
3937                 switch (_meter_point) {
3938                 case MeterInput:
3939                         assert (!_meter->display_to_user ());
3940                         new_processors.push_front (_meter);
3941                         break;
3942                 case MeterPreFader:
3943                         assert (!_meter->display_to_user ());
3944                         new_processors.insert (amp, _meter);
3945                         break;
3946                 case MeterPostFader:
3947                         /* do nothing here */
3948                         break;
3949                 case MeterOutput:
3950                         /* do nothing here */
3951                         break;
3952                 case MeterCustom:
3953                         /* the meter is visible, so we don't touch it here */
3954                         break;
3955                 }
3956         }
3957
3958         /* MAIN OUTS */
3959
3960         assert (_main_outs);
3961         assert (!_main_outs->display_to_user ());
3962         new_processors.push_back (_main_outs);
3963
3964         /* iterator for the main outs */
3965
3966         ProcessorList::iterator main = new_processors.end();
3967         --main;
3968
3969         /* OUTPUT METERING */
3970
3971         if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
3972                 assert (!_meter->display_to_user ());
3973
3974                 /* add the processor just before or just after the main outs */
3975
3976                 ProcessorList::iterator meter_point = main;
3977
3978                 if (_meter_point == MeterOutput) {
3979                         ++meter_point;
3980                 }
3981                 new_processors.insert (meter_point, _meter);
3982         }
3983
3984         /* MONITOR SEND */
3985
3986         if (_monitor_send && !is_monitor ()) {
3987                 assert (!_monitor_send->display_to_user ());
3988                 if (Config->get_solo_control_is_listen_control()) {
3989                         switch (Config->get_listen_position ()) {
3990                         case PreFaderListen:
3991                                 switch (Config->get_pfl_position ()) {
3992                                 case PFLFromBeforeProcessors:
3993                                         new_processors.push_front (_monitor_send);
3994                                         break;
3995                                 case PFLFromAfterProcessors:
3996                                         new_processors.insert (amp, _monitor_send);
3997                                         break;
3998                                 }
3999                                 _monitor_send->set_can_pan (false);
4000                                 break;
4001                         case AfterFaderListen:
4002                                 switch (Config->get_afl_position ()) {
4003                                 case AFLFromBeforeProcessors:
4004                                         new_processors.insert (after_amp, _monitor_send);
4005                                         break;
4006                                 case AFLFromAfterProcessors:
4007                                         new_processors.insert (new_processors.end(), _monitor_send);
4008                                         break;
4009                                 }
4010                                 _monitor_send->set_can_pan (true);
4011                                 break;
4012                         }
4013                 }  else {
4014                         new_processors.insert (new_processors.end(), _monitor_send);
4015                         _monitor_send->set_can_pan (false);
4016                 }
4017         }
4018
4019         /* MONITOR CONTROL */
4020
4021         if (_monitor_control && is_monitor ()) {
4022                 assert (!_monitor_control->display_to_user ());
4023                 new_processors.push_front (_monitor_control);
4024         }
4025
4026         /* INTERNAL RETURN */
4027
4028         /* doing this here means that any monitor control will come just after
4029            the return.
4030         */
4031
4032         if (_intreturn) {
4033                 assert (!_intreturn->display_to_user ());
4034                 new_processors.push_front (_intreturn);
4035         }
4036
4037         /* EXPORT PROCESSOR */
4038
4039         if (_capturing_processor) {
4040                 assert (!_capturing_processor->display_to_user ());
4041                 new_processors.push_front (_capturing_processor);
4042         }
4043
4044         _processors = new_processors;
4045
4046         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
4047         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4048                 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
4049         }
4050 }
4051
4052 void
4053 Route::unpan ()
4054 {
4055         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
4056         Glib::Threads::RWLock::ReaderLock lp (_processor_lock);
4057
4058         _pannable.reset ();
4059
4060         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4061                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery>(*i);
4062                 if (d) {
4063                         d->unpan ();
4064                 }
4065         }
4066 }
4067
4068 /** If the meter point is `Custom', make a note of where the meter is.
4069  *  This is so that if the meter point is subsequently set to something else,
4070  *  and then back to custom, we can put the meter back where it was last time
4071  *  custom was enabled.
4072  *
4073  *  Must be called with the _processor_lock held.
4074  */
4075 void
4076 Route::maybe_note_meter_position ()
4077 {
4078         if (_meter_point != MeterCustom) {
4079                 return;
4080         }
4081
4082         _custom_meter_position_noted = true;
4083         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4084                 if (boost::dynamic_pointer_cast<PeakMeter> (*i)) {
4085                         ProcessorList::iterator j = i;
4086                         ++j;
4087                         if (j != _processors.end ()) {
4088                                 _processor_after_last_custom_meter = *j;
4089                                 _last_custom_meter_was_at_end = false;
4090                         } else {
4091                                 _last_custom_meter_was_at_end = true;
4092                         }
4093                 }
4094         }
4095 }
4096
4097 boost::shared_ptr<Processor>
4098 Route::processor_by_id (PBD::ID id) const
4099 {
4100         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4101         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4102                 if ((*i)->id() == id) {
4103                         return *i;
4104                 }
4105         }
4106
4107         return boost::shared_ptr<Processor> ();
4108 }
4109
4110 /** @return the monitoring state, or in other words what data we are pushing
4111  *  into the route (data from the inputs, data from disk or silence)
4112  */
4113 MonitorState
4114 Route::monitoring_state () const
4115 {
4116         return MonitoringInput;
4117 }
4118
4119 /** @return what we should be metering; either the data coming from the input
4120  *  IO or the data that is flowing through the route.
4121  */
4122 MeterState
4123 Route::metering_state () const
4124 {
4125         return MeteringRoute;
4126 }
4127
4128 bool
4129 Route::has_external_redirects () const
4130 {
4131         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4132
4133                 /* ignore inactive processors and obviously ignore the main
4134                  * outs since everything has them and we don't care.
4135                  */
4136
4137                 if ((*i)->active() && (*i) != _main_outs && (*i)->does_routing()) {
4138                         return true;;
4139                 }
4140         }
4141
4142         return false;
4143 }
4144
4145 boost::shared_ptr<Processor>
4146 Route::the_instrument () const
4147 {
4148         Glib::Threads::RWLock::WriterLock lm (_processor_lock);
4149         return the_instrument_unlocked ();
4150 }
4151
4152 boost::shared_ptr<Processor>
4153 Route::the_instrument_unlocked () const
4154 {
4155         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4156                 if (boost::dynamic_pointer_cast<PluginInsert>(*i)) {
4157                         if ((*i)->input_streams().n_midi() > 0 &&
4158                             (*i)->output_streams().n_audio() > 0) {
4159                                 return (*i);
4160                         }
4161                 }
4162         }
4163         return boost::shared_ptr<Processor>();
4164 }
4165
4166
4167
4168 void
4169 Route::non_realtime_locate (framepos_t pos)
4170 {
4171         if (_pannable) {
4172                 _pannable->transport_located (pos);
4173         }
4174
4175         {
4176                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
4177
4178                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4179                         (*i)->transport_located (pos);
4180                 }
4181         }
4182 }
4183
4184 void
4185 Route::fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes)
4186 {
4187         size_t n_buffers;
4188         size_t i;
4189
4190         /* MIDI
4191          *
4192          * We don't currently mix MIDI input together, so we don't need the
4193          * complex logic of the audio case.
4194          */
4195
4196         n_buffers = bufs.count().n_midi ();
4197
4198         for (i = 0; i < n_buffers; ++i) {
4199
4200                 boost::shared_ptr<MidiPort> source_port = io->midi (i);
4201                 MidiBuffer& buf (bufs.get_midi (i));
4202
4203                 if (source_port) {
4204                         buf.copy (source_port->get_midi_buffer(nframes));
4205                 } else {
4206                         buf.silence (nframes);
4207                 }
4208         }
4209
4210         /* AUDIO */
4211
4212         n_buffers = bufs.count().n_audio();
4213
4214         size_t n_ports = io->n_ports().n_audio();
4215         float scaling = 1.0f;
4216
4217         if (n_ports > n_buffers) {
4218                 scaling = ((float) n_buffers) / n_ports;
4219         }
4220
4221         for (i = 0; i < n_ports; ++i) {
4222
4223                 /* if there are more ports than buffers, map them onto buffers
4224                  * in a round-robin fashion
4225                  */
4226
4227                 boost::shared_ptr<AudioPort> source_port = io->audio (i);
4228                 AudioBuffer& buf (bufs.get_audio (i%n_buffers));
4229
4230
4231                 if (i < n_buffers) {
4232
4233                         /* first time through just copy a channel into
4234                            the output buffer.
4235                         */
4236
4237                         buf.read_from (source_port->get_audio_buffer (nframes), nframes);
4238
4239                         if (scaling != 1.0f) {
4240                                 buf.apply_gain (scaling, nframes);
4241                         }
4242
4243                 } else {
4244
4245                         /* on subsequent times around, merge data from
4246                          * the port with what is already there
4247                          */
4248
4249                         if (scaling != 1.0f) {
4250                                 buf.accumulate_with_gain_from (source_port->get_audio_buffer (nframes), nframes, 0, scaling);
4251                         } else {
4252                                 buf.accumulate_from (source_port->get_audio_buffer (nframes), nframes);
4253                         }
4254                 }
4255         }
4256
4257         /* silence any remaining buffers */
4258
4259         for (; i < n_buffers; ++i) {
4260                 AudioBuffer& buf (bufs.get_audio (i));
4261                 buf.silence (nframes);
4262         }
4263
4264         /* establish the initial setup of the buffer set, reflecting what was
4265            copied into it. unless, of course, we are the auditioner, in which
4266            case nothing was fed into it from the inputs at all.
4267         */
4268
4269         if (!is_auditioner()) {
4270                 bufs.set_count (io->n_ports());
4271         }
4272 }