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