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