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 <cassert>
  26 #include <algorithm>
  27
  28 #include <glibmm.h>
  29 #include <boost/algorithm/string.hpp>
  30
  31 #include "pbd/xml++.h"
  32 #include "pbd/enumwriter.h"
  33 #include "pbd/memento_command.h"
  34 #include "pbd/stacktrace.h"
  35 #include "pbd/convert.h"
  36 #include "pbd/unwind.h"
  37
  38 #include "ardour/amp.h"
  39 #include "ardour/audio_buffer.h"
  40 #include "ardour/audio_track.h"
  41 #include "ardour/audio_port.h"
  42 #include "ardour/audioengine.h"
  43 #include "ardour/boost_debug.h"
  44 #include "ardour/buffer.h"
  45 #include "ardour/buffer_set.h"
  46 #include "ardour/capturing_processor.h"
  47 #include "ardour/debug.h"
  48 #include "ardour/delivery.h"
  49 #include "ardour/event_type_map.h"
  50 #include "ardour/gain_control.h"
  51 #include "ardour/internal_return.h"
  52 #include "ardour/internal_send.h"
  53 #include "ardour/meter.h"
  54 #include "ardour/delayline.h"
  55 #include "ardour/midi_buffer.h"
  56 #include "ardour/midi_port.h"
  57 #include "ardour/monitor_processor.h"
  58 #include "ardour/pannable.h"
  59 #include "ardour/panner.h"
  60 #include "ardour/panner_shell.h"
  61 #include "ardour/parameter_descriptor.h"
  62 #include "ardour/phase_control.h"
  63 #include "ardour/plugin_insert.h"
  64 #include "ardour/port.h"
  65 #include "ardour/port_insert.h"
  66 #include "ardour/processor.h"
  67 #include "ardour/profile.h"
  68 #include "ardour/route.h"
  69 #include "ardour/route_group.h"
  70 #include "ardour/send.h"
  71 #include "ardour/session.h"
  72 #include "ardour/solo_control.h"
  73 #include "ardour/solo_isolate_control.h"
  74 #include "ardour/unknown_processor.h"
  75 #include "ardour/utils.h"
  76 #include "ardour/vca.h"
  77
  78 #include "pbd/i18n.h"
  79
  80 using namespace std;
  81 using namespace ARDOUR;
  82 using namespace PBD;
  83
  84 PBD::Signal3<int,boost::shared_ptr<Route>, boost::shared_ptr<PluginInsert>, Route::PluginSetupOptions > Route::PluginSetup;
  85
  86 /** Base class for all routable/mixable objects (tracks and busses) */
  87 Route::Route (Session& sess, string name, PresentationInfo::Flag flag, DataType default_type)
  88         : Stripable (sess, name, PresentationInfo (flag))
  89         , GraphNode (sess._process_graph)
  90         , Muteable (sess, name)
  91         , Automatable (sess)
  92         , _active (true)
  93         , _signal_latency (0)
  94         , _signal_latency_at_amp_position (0)
  95         , _signal_latency_at_trim_position (0)
  96         , _initial_delay (0)
  97         , _roll_delay (0)
  98         , _pending_process_reorder (0)
  99         , _pending_signals (0)
 100         , _pending_declick (true)
 101         , _meter_point (MeterPostFader)
 102         , _pending_meter_point (MeterPostFader)
 103         , _meter_type (MeterPeak)
 104         , _denormal_protection (false)
 105         , _recordable (true)
 106         , _silent (false)
 107         , _declickable (false)
 108         , _have_internal_generator (false)
 109         , _default_type (default_type)
 110         , _track_number (0)
 111         , _in_configure_processors (false)
 112         , _initial_io_setup (false)
 113         , _in_sidechain_setup (false)
 114         , _strict_io (false)
 115         , _custom_meter_position_noted (false)
 116         , _pinmgr_proxy (0)
 117 {
 118         processor_max_streams.reset();
 119 }
 120
 121 boost::weak_ptr<Route>
 122 Route::weakroute () {
 123         return boost::weak_ptr<Route> (shared_from_this ());
 124 }
 125
 126 int
 127 Route::init ()
 128 {
 129         /* set default meter type */
 130         if (is_master()) {
 131                 _meter_type = Config->get_meter_type_master ();
 132         }
 133         else if (dynamic_cast<Track*>(this)) {
 134                 _meter_type = Config->get_meter_type_track ();
 135         } else {
 136                 _meter_type = Config->get_meter_type_bus ();
 137         }
 138
 139         /* add standard controls */
 140
 141         _gain_control.reset (new GainControl (_session, GainAutomation));
 142         add_control (_gain_control);
 143
 144         _trim_control.reset (new GainControl (_session, TrimAutomation));
 145         add_control (_trim_control);
 146
 147         _solo_control.reset (new SoloControl (_session, X_("solo"), *this, *this));
 148         add_control (_solo_control);
 149         _solo_control->Changed.connect_same_thread (*this, boost::bind (&Route::solo_control_changed, this, _1, _2));
 150
 151         _mute_control.reset (new MuteControl (_session, X_("mute"), *this));
 152         add_control (_mute_control);
 153
 154         _phase_control.reset (new PhaseControl (_session, X_("phase")));
 155         add_control (_phase_control);
 156
 157         _solo_isolate_control.reset (new SoloIsolateControl (_session, X_("solo-iso"), *this, *this));
 158         add_control (_solo_isolate_control);
 159
 160         _solo_safe_control.reset (new SoloSafeControl (_session, X_("solo-safe")));
 161         add_control (_solo_safe_control);
 162
 163         /* panning */
 164
 165         if (!(_presentation_info.flags() & PresentationInfo::MonitorOut)) {
 166                 _pannable.reset (new Pannable (_session));
 167         }
 168
 169         /* input and output objects */
 170
 171         _input.reset (new IO (_session, _name, IO::Input, _default_type));
 172         _output.reset (new IO (_session, _name, IO::Output, _default_type));
 173
 174         _input->changed.connect_same_thread (*this, boost::bind (&Route::input_change_handler, this, _1, _2));
 175         _input->PortCountChanging.connect_same_thread (*this, boost::bind (&Route::input_port_count_changing, this, _1));
 176
 177         _output->changed.connect_same_thread (*this, boost::bind (&Route::output_change_handler, this, _1, _2));
 178         _output->PortCountChanging.connect_same_thread (*this, boost::bind (&Route::output_port_count_changing, this, _1));
 179
 180         /* add the amp/fader processor.
 181          * it should be the first processor to be added on every route.
 182          */
 183
 184         _amp.reset (new Amp (_session, X_("Fader"), _gain_control, true));
 185         add_processor (_amp, PostFader);
 186
 187         if (is_monitor ()) {
 188                 _amp->set_display_name (_("Monitor"));
 189         }
 190
 191 #if 0 // not used - just yet
 192         if (!is_master() && !is_monitor() && !is_auditioner()) {
 193                 _delayline.reset (new DelayLine (_session, _name));
 194                 add_processor (_delayline, PreFader);
 195         }
 196 #endif
 197
 198         /* and input trim */
 199
 200         _trim.reset (new Amp (_session, X_("Trim"), _trim_control, false));
 201         _trim->set_display_to_user (false);
 202
 203         if (dynamic_cast<AudioTrack*>(this)) {
 204                 /* we can't do this in the AudioTrack's constructor
 205                  * because _trim does not exit then
 206                  */
 207                 _trim->activate();
 208         }
 209         else if (!dynamic_cast<Track*>(this) && ! ( is_monitor() || is_auditioner() )) {
 210                 /* regular bus */
 211                 _trim->activate();
 212         }
 213
 214         /* create standard processors: meter, main outs, monitor out;
 215            they will be added to _processors by setup_invisible_processors ()
 216         */
 217
 218         _meter.reset (new PeakMeter (_session, _name));
 219         _meter->set_owner (this);
 220         _meter->set_display_to_user (false);
 221         _meter->activate ();
 222
 223         _main_outs.reset (new Delivery (_session, _output, _pannable, _mute_master, _name, Delivery::Main));
 224         _main_outs->activate ();
 225
 226         if (is_monitor()) {
 227                 /* where we listen to tracks */
 228                 _intreturn.reset (new InternalReturn (_session));
 229                 _intreturn->activate ();
 230
 231                 /* the thing that provides proper control over a control/monitor/listen bus
 232                    (such as per-channel cut, dim, solo, invert, etc).
 233                 */
 234                 _monitor_control.reset (new MonitorProcessor (_session));
 235                 _monitor_control->activate ();
 236         }
 237
 238         /* now that we have _meter, its safe to connect to this */
 239
 240         {
 241                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
 242                 configure_processors (0);
 243         }
 244
 245         return 0;
 246 }
 247
 248 Route::~Route ()
 249 {
 250         DEBUG_TRACE (DEBUG::Destruction, string_compose ("route %1 destructor\n", _name));
 251
 252         /* do this early so that we don't get incoming signals as we are going through destruction
 253          */
 254
 255         drop_connections ();
 256
 257         /* don't use clear_processors here, as it depends on the session which may
 258            be half-destroyed by now
 259         */
 260
 261         Glib::Threads::RWLock::WriterLock lm (_processor_lock);
 262         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 263                 (*i)->drop_references ();
 264         }
 265
 266         _processors.clear ();
 267 }
 268
 269 string
 270 Route::ensure_track_or_route_name(string name, Session &session)
 271 {
 272         string newname = name;
 273
 274         while (!session.io_name_is_legal (newname)) {
 275                 newname = bump_name_once (newname, ' ');
 276         }
 277
 278         return newname;
 279 }
 280
 281 void
 282 Route::set_trim (gain_t val, Controllable::GroupControlDisposition /* group override */)
 283 {
 284         // TODO route group, see set_gain()
 285         // _trim_control->route_set_value (val);
 286 }
 287
 288 void
 289 Route::maybe_declick (BufferSet&, framecnt_t, int)
 290 {
 291         /* this is the "bus" implementation and they never declick.
 292          */
 293         return;
 294 }
 295
 296 /** Process this route for one (sub) cycle (process thread)
 297  *
 298  * @param bufs Scratch buffers to use for the signal path
 299  * @param start_frame Initial transport frame
 300  * @param end_frame Final transport frame
 301  * @param nframes Number of frames to output (to ports)
 302  *
 303  * Note that (end_frame - start_frame) may not be equal to nframes when the
 304  * transport speed isn't 1.0 (eg varispeed).
 305  */
 306 void
 307 Route::process_output_buffers (BufferSet& bufs,
 308                                framepos_t start_frame, framepos_t end_frame, pframes_t nframes,
 309                                int declick, bool gain_automation_ok)
 310 {
 311         /* Caller must hold process lock */
 312         assert (!AudioEngine::instance()->process_lock().trylock());
 313
 314         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
 315         if (!lm.locked()) {
 316                 // can this actually happen? functions calling process_output_buffers()
 317                 // already take a reader-lock.
 318                 bufs.silence (nframes, 0);
 319                 return;
 320         }
 321
 322         _mute_control->automation_run (start_frame, nframes);
 323
 324         /* figure out if we're going to use gain automation */
 325         if (gain_automation_ok) {
 326                 _amp->set_gain_automation_buffer (_session.gain_automation_buffer ());
 327                 _amp->setup_gain_automation (
 328                                 start_frame + _signal_latency_at_amp_position,
 329                                 end_frame + _signal_latency_at_amp_position,
 330                                 nframes);
 331
 332                 _trim->set_gain_automation_buffer (_session.trim_automation_buffer ());
 333                 _trim->setup_gain_automation (
 334                                 start_frame + _signal_latency_at_trim_position,
 335                                 end_frame + _signal_latency_at_trim_position,
 336                                 nframes);
 337         } else {
 338                 _amp->apply_gain_automation (false);
 339                 _trim->apply_gain_automation (false);
 340         }
 341
 342         /* Tell main outs what to do about monitoring.  We do this so that
 343            on a transition between monitoring states we get a de-clicking gain
 344            change in the _main_outs delivery, if config.get_use_monitor_fades()
 345            is true.
 346
 347            We override this in the case where we have an internal generator.
 348         */
 349         bool silence = _have_internal_generator ? false : (monitoring_state () == MonitoringSilence);
 350
 351         _main_outs->no_outs_cuz_we_no_monitor (silence);
 352
 353         /* -------------------------------------------------------------------------------------------
 354            GLOBAL DECLICK (for transport changes etc.)
 355            ----------------------------------------------------------------------------------------- */
 356
 357         maybe_declick (bufs, nframes, declick);
 358         _pending_declick = 0;
 359
 360         /* -------------------------------------------------------------------------------------------
 361            DENORMAL CONTROL/PHASE INVERT
 362            ----------------------------------------------------------------------------------------- */
 363
 364         if (!_phase_control->none()) {
 365
 366                 int chn = 0;
 367
 368                 if (_denormal_protection || Config->get_denormal_protection()) {
 369
 370                         for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
 371                                 Sample* const sp = i->data();
 372
 373                                 if (_phase_control->inverted (chn)) {
 374                                         for (pframes_t nx = 0; nx < nframes; ++nx) {
 375                                                 sp[nx]  = -sp[nx];
 376                                                 sp[nx] += 1.0e-27f;
 377                                         }
 378                                 } else {
 379                                         for (pframes_t nx = 0; nx < nframes; ++nx) {
 380                                                 sp[nx] += 1.0e-27f;
 381                                         }
 382                                 }
 383                         }
 384
 385                 } else {
 386
 387                         for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
 388                                 Sample* const sp = i->data();
 389
 390                                 if (_phase_control->inverted (chn)) {
 391                                         for (pframes_t nx = 0; nx < nframes; ++nx) {
 392                                                 sp[nx] = -sp[nx];
 393                                         }
 394                                 }
 395                         }
 396                 }
 397
 398         } else {
 399
 400                 if (_denormal_protection || Config->get_denormal_protection()) {
 401
 402                         for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
 403                                 Sample* const sp = i->data();
 404                                 for (pframes_t nx = 0; nx < nframes; ++nx) {
 405                                         sp[nx] += 1.0e-27f;
 406                                 }
 407                         }
 408
 409                 }
 410         }
 411
 412         /* -------------------------------------------------------------------------------------------
 413            and go ....
 414            ----------------------------------------------------------------------------------------- */
 415
 416         /* set this to be true if the meter will already have been ::run() earlier */
 417         bool const meter_already_run = metering_state() == MeteringInput;
 418
 419         framecnt_t latency = 0;
 420         const double speed = _session.transport_speed ();
 421
 422         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
 423
 424                 if (meter_already_run && boost::dynamic_pointer_cast<PeakMeter> (*i)) {
 425                         /* don't ::run() the meter, otherwise it will have its previous peak corrupted */
 426                         continue;
 427                 }
 428
 429 #ifndef NDEBUG
 430                 /* if it has any inputs, make sure they match */
 431                 if (boost::dynamic_pointer_cast<UnknownProcessor> (*i) == 0 && (*i)->input_streams() != ChanCount::ZERO) {
 432                         if (bufs.count() != (*i)->input_streams()) {
 433                                 DEBUG_TRACE (
 434                                         DEBUG::Processors, string_compose (
 435                                                 "input port mismatch %1 bufs = %2 input for %3 = %4\n",
 436                                                 _name, bufs.count(), (*i)->name(), (*i)->input_streams()
 437                                                 )
 438                                         );
 439                         }
 440                 }
 441 #endif
 442
 443                 /* should we NOT run plugins here if the route is inactive?
 444                    do we catch route != active somewhere higher?
 445                 */
 446
 447                 if (boost::dynamic_pointer_cast<Send>(*i) != 0) {
 448                         boost::dynamic_pointer_cast<Send>(*i)->set_delay_in(_signal_latency - latency);
 449                 }
 450                 if (boost::dynamic_pointer_cast<PluginInsert>(*i) != 0) {
 451                         const framecnt_t longest_session_latency = _initial_delay + _signal_latency;
 452                         boost::dynamic_pointer_cast<PluginInsert>(*i)->set_sidechain_latency (
 453                                         _initial_delay + latency, longest_session_latency - latency);
 454                 }
 455
 456                 (*i)->run (bufs, start_frame - latency, end_frame - latency, speed, nframes, *i != _processors.back());
 457                 bufs.set_count ((*i)->output_streams());
 458
 459                 if ((*i)->active ()) {
 460                         latency += (*i)->signal_latency ();
 461                 }
 462         }
 463 }
 464
 465 void
 466 Route::bounce_process (BufferSet& buffers, framepos_t start, framecnt_t nframes,
 467                 boost::shared_ptr<Processor> endpoint,
 468                 bool include_endpoint, bool for_export, bool for_freeze)
 469 {
 470         /* If no processing is required, there's no need to go any further. */
 471         if (!endpoint && !include_endpoint) {
 472                 return;
 473         }
 474
 475         framecnt_t latency = bounce_get_latency(_amp, false, for_export, for_freeze);
 476         _amp->set_gain_automation_buffer (_session.gain_automation_buffer ());
 477         _amp->setup_gain_automation (start - latency, start - latency + nframes, nframes);
 478
 479         /* trim is always at the top, for bounce no latency compensation is needed */
 480         _trim->set_gain_automation_buffer (_session.trim_automation_buffer ());
 481         _trim->setup_gain_automation (start, start + nframes, nframes);
 482
 483         latency = 0;
 484         const double speed = _session.transport_speed ();
 485         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 486
 487                 if (!include_endpoint && (*i) == endpoint) {
 488                         break;
 489                 }
 490
 491                 /* if we're *not* exporting, stop processing if we come across a routing processor. */
 492                 if (!for_export && boost::dynamic_pointer_cast<PortInsert>(*i)) {
 493                         break;
 494                 }
 495                 if (!for_export && for_freeze && (*i)->does_routing() && (*i)->active()) {
 496                         break;
 497                 }
 498
 499                 /* special case the panner (export outputs)
 500                  * Ideally we'd only run the panner, not the delivery itself...
 501                  * but panners need separate input/output buffers and some context
 502                  * (panshell, panner type, etc). AFAICT there is no ill side effect
 503                  * of re-using the main delivery when freewheeling/exporting a region.
 504                  */
 505                 if ((*i) == _main_outs) {
 506                         assert ((*i)->does_routing());
 507                         (*i)->run (buffers, start - latency, start - latency + nframes, speed, nframes, true);
 508                         buffers.set_count ((*i)->output_streams());
 509                 }
 510
 511                 /* don't run any processors that do routing.
 512                  * Also don't bother with metering.
 513                  */
 514                 if (!(*i)->does_routing() && !boost::dynamic_pointer_cast<PeakMeter>(*i)) {
 515                         (*i)->run (buffers, start - latency, start - latency + nframes, 1.0, nframes, true);
 516                         buffers.set_count ((*i)->output_streams());
 517                         latency += (*i)->signal_latency ();
 518                 }
 519
 520                 if ((*i) == endpoint) {
 521                         break;
 522                 }
 523         }
 524 }
 525
 526 framecnt_t
 527 Route::bounce_get_latency (boost::shared_ptr<Processor> endpoint,
 528                 bool include_endpoint, bool for_export, bool for_freeze) const
 529 {
 530         framecnt_t latency = 0;
 531         if (!endpoint && !include_endpoint) {
 532                 return latency;
 533         }
 534
 535         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
 536                 if (!include_endpoint && (*i) == endpoint) {
 537                         break;
 538                 }
 539                 if (!for_export && boost::dynamic_pointer_cast<PortInsert>(*i)) {
 540                         break;
 541                 }
 542                 if (!for_export && for_freeze && (*i)->does_routing() && (*i)->active()) {
 543                         break;
 544                 }
 545                 if (!(*i)->does_routing() && !boost::dynamic_pointer_cast<PeakMeter>(*i)) {
 546                         latency += (*i)->signal_latency ();
 547                 }
 548                 if ((*i) == endpoint) {
 549                         break;
 550                 }
 551         }
 552         return latency;
 553 }
 554
 555 ChanCount
 556 Route::bounce_get_output_streams (ChanCount &cc, boost::shared_ptr<Processor> endpoint,
 557                 bool include_endpoint, bool for_export, bool for_freeze) const
 558 {
 559         if (!endpoint && !include_endpoint) {
 560                 return cc;
 561         }
 562
 563         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
 564                 if (!include_endpoint && (*i) == endpoint) {
 565                         break;
 566                 }
 567                 if (!for_export && boost::dynamic_pointer_cast<PortInsert>(*i)) {
 568                         break;
 569                 }
 570                 if (!for_export && for_freeze && (*i)->does_routing() && (*i)->active()) {
 571                         break;
 572                 }
 573                 if (!(*i)->does_routing() && !boost::dynamic_pointer_cast<PeakMeter>(*i)) {
 574                         cc = (*i)->output_streams();
 575                 }
 576                 if ((*i) == endpoint) {
 577                         break;
 578                 }
 579         }
 580         return cc;
 581 }
 582
 583 ChanCount
 584 Route::n_process_buffers ()
 585 {
 586         return max (_input->n_ports(), processor_max_streams);
 587 }
 588
 589 void
 590 Route::monitor_run (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
 591 {
 592         assert (is_monitor());
 593         BufferSet& bufs (_session.get_route_buffers (n_process_buffers()));
 594         fill_buffers_with_input (bufs, _input, nframes);
 595         passthru (bufs, start_frame, end_frame, nframes, declick);
 596 }
 597
 598 void
 599 Route::passthru (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
 600 {
 601         _silent = false;
 602
 603         if (is_monitor() && _session.listening() && !_session.is_auditioning()) {
 604
 605                 /* control/monitor bus ignores input ports when something is
 606                    feeding the listen "stream". data will "arrive" into the
 607                    route from the intreturn processor element.
 608                 */
 609
 610                 bufs.silence (nframes, 0);
 611         }
 612
 613         write_out_of_band_data (bufs, start_frame, end_frame, nframes);
 614         process_output_buffers (bufs, start_frame, end_frame, nframes, declick, true);
 615 }
 616
 617 void
 618 Route::passthru_silence (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
 619 {
 620         BufferSet& bufs (_session.get_route_buffers (n_process_buffers(), true));
 621
 622         bufs.set_count (_input->n_ports());
 623         write_out_of_band_data (bufs, start_frame, end_frame, nframes);
 624         process_output_buffers (bufs, start_frame, end_frame, nframes, declick, false);
 625 }
 626
 627 void
 628 Route::set_listen (bool yn)
 629 {
 630         if (_monitor_send) {
 631                 if (_monitor_send->active() == yn) {
 632                         return;
 633                 }
 634                 if (yn) {
 635                         _monitor_send->activate ();
 636                 } else {
 637                         _monitor_send->deactivate ();
 638                 }
 639         }
 640 }
 641
 642 void
 643 Route::solo_control_changed (bool, Controllable::GroupControlDisposition)
 644 {
 645         /* nothing to do if we're not using AFL/PFL. But if we are, we need
 646            to alter the active state of the monitor send.
 647         */
 648
 649         if (Config->get_solo_control_is_listen_control ()) {
 650                 set_listen (_solo_control->self_soloed() || _solo_control->get_masters_value());
 651         }
 652 }
 653
 654 void
 655 Route::push_solo_isolate_upstream (int32_t delta)
 656 {
 657         /* forward propagate solo-isolate status to everything fed by this route, but not those via sends only */
 658
 659         boost::shared_ptr<RouteList> routes = _session.get_routes ();
 660         for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
 661
 662                 if ((*i).get() == this || !(*i)->can_solo()) {
 663                         continue;
 664                 }
 665
 666                 bool sends_only;
 667                 bool does_feed = feeds (*i, &sends_only);
 668
 669                 if (does_feed && !sends_only) {
 670                         (*i)->solo_isolate_control()->mod_solo_isolated_by_upstream (delta);
 671                 }
 672         }
 673 }
 674
 675 void
 676 Route::push_solo_upstream (int delta)
 677 {
 678         DEBUG_TRACE (DEBUG::Solo, string_compose("\t ... INVERT push from %1\n", _name));
 679         for (FedBy::iterator i = _fed_by.begin(); i != _fed_by.end(); ++i) {
 680                 if (i->sends_only) {
 681                         continue;
 682                 }
 683                 boost::shared_ptr<Route> sr (i->r.lock());
 684                 if (sr) {
 685                         sr->solo_control()->mod_solo_by_others_downstream (-delta);
 686                 }
 687         }
 688 }
 689
 690 #if 0
 691 static void
 692 dump_processors(const string& name, const list<boost::shared_ptr<Processor> >& procs)
 693 {
 694         cerr << name << " {" << endl;
 695         for (list<boost::shared_ptr<Processor> >::const_iterator p = procs.begin();
 696                         p != procs.end(); ++p) {
 697                 cerr << "\t" << (*p)->name() << " ID = " << (*p)->id() << " @ " << (*p) << endl;
 698         }
 699         cerr << "}" << endl;
 700 }
 701 #endif
 702
 703 /** Supposing that we want to insert a Processor at a given Placement, return
 704  *  the processor to add the new one before (or 0 to add at the end).
 705  */
 706 boost::shared_ptr<Processor>
 707 Route::before_processor_for_placement (Placement p)
 708 {
 709         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
 710
 711         ProcessorList::iterator loc;
 712
 713         if (p == PreFader) {
 714                 /* generic pre-fader: insert immediately before the amp */
 715                 loc = find (_processors.begin(), _processors.end(), _amp);
 716         } else {
 717                 /* generic post-fader: insert right before the main outs */
 718                 loc = find (_processors.begin(), _processors.end(), _main_outs);
 719         }
 720
 721         return loc != _processors.end() ? *loc : boost::shared_ptr<Processor> ();
 722 }
 723
 724 /** Supposing that we want to insert a Processor at a given index, return
 725  *  the processor to add the new one before (or 0 to add at the end).
 726  */
 727 boost::shared_ptr<Processor>
 728 Route::before_processor_for_index (int index)
 729 {
 730         if (index == -1) {
 731                 return boost::shared_ptr<Processor> ();
 732         }
 733
 734         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
 735
 736         ProcessorList::iterator i = _processors.begin ();
 737         int j = 0;
 738         while (i != _processors.end() && j < index) {
 739                 if ((*i)->display_to_user()) {
 740                         ++j;
 741                 }
 742
 743                 ++i;
 744         }
 745
 746         return (i != _processors.end() ? *i : boost::shared_ptr<Processor> ());
 747 }
 748
 749 /** Add a processor either pre- or post-fader
 750  *  @return 0 on success, non-0 on failure.
 751  */
 752 int
 753 Route::add_processor (boost::shared_ptr<Processor> processor, Placement placement, ProcessorStreams* err, bool activation_allowed)
 754 {
 755         return add_processor (processor, before_processor_for_placement (placement), err, activation_allowed);
 756 }
 757
 758
 759 /** Add a processor to a route such that it ends up with a given index into the visible processors.
 760  *  @param index Index to add the processor at, or -1 to add at the end of the list.
 761  *  @return 0 on success, non-0 on failure.
 762  */
 763 int
 764 Route::add_processor_by_index (boost::shared_ptr<Processor> processor, int index, ProcessorStreams* err, bool activation_allowed)
 765 {
 766         return add_processor (processor, before_processor_for_index (index), err, activation_allowed);
 767 }
 768
 769 /** Add a processor to the route.
 770  *  @param before An existing processor in the list, or 0; the new processor will be inserted immediately before it (or at the end).
 771  *  @return 0 on success, non-0 on failure.
 772  */
 773 int
 774 Route::add_processor (boost::shared_ptr<Processor> processor, boost::shared_ptr<Processor> before, ProcessorStreams* err, bool activation_allowed)
 775 {
 776         assert (processor != _meter);
 777         assert (processor != _main_outs);
 778
 779         DEBUG_TRACE (DEBUG::Processors, string_compose (
 780                              "%1 adding processor %2\n", name(), processor->name()));
 781
 782         ProcessorList pl;
 783
 784         pl.push_back (processor);
 785         int rv = add_processors (pl, before, err);
 786
 787         if (rv) {
 788                 return rv;
 789         }
 790
 791         if (activation_allowed && (!_session.get_bypass_all_loaded_plugins () || !processor->display_to_user ())) {
 792                 processor->activate ();
 793         }
 794
 795         return 0;
 796 }
 797
 798 void
 799 Route::processor_selfdestruct (boost::weak_ptr<Processor> wp)
 800 {
 801         /* We cannot destruct the processor here (usually RT-thread
 802          * with various locks held - in case of sends also io_locks).
 803          * Queue for deletion in low-priority thread.
 804          */
 805         Glib::Threads::Mutex::Lock lx (selfdestruct_lock);
 806         selfdestruct_sequence.push_back (wp);
 807 }
 808
 809 bool
 810 Route::add_processor_from_xml_2X (const XMLNode& node, int version)
 811 {
 812         XMLProperty const * prop;
 813
 814         try {
 815                 boost::shared_ptr<Processor> processor;
 816
 817                 /* bit of a hack: get the `placement' property from the <Redirect> tag here
 818                    so that we can add the processor in the right place (pre/post-fader)
 819                 */
 820
 821                 XMLNodeList const & children = node.children ();
 822                 XMLNodeList::const_iterator i = children.begin ();
 823
 824                 while (i != children.end() && (*i)->name() != X_("Redirect")) {
 825                         ++i;
 826                 }
 827
 828                 Placement placement = PreFader;
 829
 830                 if (i != children.end()) {
 831                         if ((prop = (*i)->property (X_("placement"))) != 0) {
 832                                 placement = Placement (string_2_enum (prop->value(), placement));
 833                         }
 834                 }
 835
 836                 if (node.name() == "Insert") {
 837
 838                         if ((prop = node.property ("type")) != 0) {
 839
 840                                 if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
 841                                                 prop->value() == "lv2" ||
 842                                                 prop->value() == "windows-vst" ||
 843                                                 prop->value() == "mac-vst" ||
 844                                                 prop->value() == "lxvst" ||
 845                                                 prop->value() == "audiounit") {
 846
 847                                         if (_session.get_disable_all_loaded_plugins ()) {
 848                                                 processor.reset (new UnknownProcessor (_session, node));
 849                                         } else {
 850                                                 processor.reset (new PluginInsert (_session));
 851                                                 processor->set_owner (this);
 852                                         }
 853
 854                                 } else {
 855
 856                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
 857                                 }
 858
 859                         }
 860
 861                 } else if (node.name() == "Send") {
 862
 863                         boost::shared_ptr<Pannable> sendpan (new Pannable (_session));
 864                         processor.reset (new Send (_session, sendpan, _mute_master));
 865
 866                 } else {
 867
 868                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), node.name()) << endmsg;
 869                         return false;
 870                 }
 871
 872                 if (processor->set_state (node, version)) {
 873                         return false;
 874                 }
 875
 876                 //A2 uses the "active" flag in the toplevel redirect node, not in the child plugin/IO
 877                 if (i != children.end()) {
 878                         if ((prop = (*i)->property (X_("active"))) != 0) {
 879                                 if ( string_is_affirmative (prop->value()) && (!_session.get_bypass_all_loaded_plugins () || !processor->display_to_user () ) )
 880                                         processor->activate();
 881                                 else
 882                                         processor->deactivate();
 883                         }
 884                 }
 885
 886                 return (add_processor (processor, placement, 0, false) == 0);
 887         }
 888
 889         catch (failed_constructor &err) {
 890                 warning << _("processor could not be created. Ignored.") << endmsg;
 891                 return false;
 892         }
 893 }
 894
 895
 896 inline Route::PluginSetupOptions operator|= (Route::PluginSetupOptions& a, const Route::PluginSetupOptions& b) {
 897         return a = static_cast<Route::PluginSetupOptions> (static_cast <int>(a) | static_cast<int> (b));
 898 }
 899
 900 inline Route::PluginSetupOptions operator&= (Route::PluginSetupOptions& a, const Route::PluginSetupOptions& b) {
 901         return a = static_cast<Route::PluginSetupOptions> (static_cast <int>(a) & static_cast<int> (b));
 902 }
 903
 904 int
 905 Route::add_processors (const ProcessorList& others, boost::shared_ptr<Processor> before, ProcessorStreams* err)
 906 {
 907         ProcessorList::iterator loc;
 908         boost::shared_ptr <PluginInsert> fanout;
 909
 910         if (g_atomic_int_get (&_pending_process_reorder)) {
 911                 /* we need to flush any pending re-order changes */
 912                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
 913                 apply_processor_changes_rt ();
 914         }
 915
 916         if (before) {
 917                 loc = find(_processors.begin(), _processors.end(), before);
 918                 if (loc == _processors.end ()) {
 919                         return 1;
 920                 }
 921         } else {
 922                 /* nothing specified - at end */
 923                 loc = _processors.end ();
 924         }
 925
 926         if (!AudioEngine::instance()->connected()) {
 927                 return 1;
 928         }
 929
 930         if (others.empty()) {
 931                 return 0;
 932         }
 933
 934         ProcessorList to_skip;
 935
 936         // check if there's an instrument to replace or configure
 937         for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
 938                 boost::shared_ptr<PluginInsert> pi;
 939                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) == 0) {
 940                         continue;
 941                 }
 942                 if (!pi->plugin ()->get_info ()->is_instrument ()) {
 943                         continue;
 944                 }
 945                 boost::shared_ptr<Processor> instrument = the_instrument ();
 946                 ChanCount in (DataType::MIDI, 1);
 947                 ChanCount out (DataType::AUDIO, 2); // XXX route's out?!
 948
 949                 PluginSetupOptions flags = None;
 950                 if (instrument) {
 951                         flags |= CanReplace;
 952                         in = instrument->input_streams ();
 953                         out = instrument->output_streams ();
 954                 }
 955                 if (pi->has_output_presets (in, out)) {
 956                         flags |= MultiOut;
 957                 }
 958
 959                 pi->set_strict_io (_strict_io);
 960
 961                 PluginSetupOptions mask = None;
 962                 if (Config->get_ask_replace_instrument ()) {
 963                         mask |= CanReplace;
 964                 }
 965                 if (Config->get_ask_setup_instrument ()) {
 966                         mask |= MultiOut;
 967                 }
 968
 969                 flags &= mask;
 970
 971                 if (flags != None) {
 972                         boost::optional<int> rv = PluginSetup (shared_from_this (), pi, flags);  /* EMIT SIGNAL */
 973                         int mode = rv.get_value_or (0);
 974                         switch (mode & 3) {
 975                                 case 1:
 976                                         to_skip.push_back (*i); // don't add this one;
 977                                         break;
 978                                 case 2:
 979                                         replace_processor (instrument, *i, err);
 980                                         to_skip.push_back (*i);
 981                                         break;
 982                                 default:
 983                                         break;
 984                         }
 985                         if ((mode & 5) == 4) {
 986                                 fanout = pi;
 987                         }
 988                 }
 989         }
 990
 991         {
 992                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
 993                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
 994                 ProcessorState pstate (this);
 995
 996                 for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
 997
 998                         if (*i == _meter) {
 999                                 continue;
1000                         }
1001                         ProcessorList::iterator check = find (to_skip.begin(), to_skip.end(), *i);
1002                         if (check != to_skip.end()) {
1003                                 continue;
1004                         }
1005
1006                         boost::shared_ptr<PluginInsert> pi;
1007
1008                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1009                                 pi->set_strict_io (_strict_io);
1010                         }
1011
1012                         if (*i == _amp) {
1013                                 /* Ensure that only one amp is in the list at any time */
1014                                 ProcessorList::iterator check = find (_processors.begin(), _processors.end(), *i);
1015                                 if (check != _processors.end()) {
1016                                         if (before == _amp) {
1017                                                 /* Already in position; all is well */
1018                                                 continue;
1019                                         } else {
1020                                                 _processors.erase (check);
1021                                         }
1022                                 }
1023                         }
1024
1025                         assert (find (_processors.begin(), _processors.end(), *i) == _processors.end ());
1026
1027                         _processors.insert (loc, *i);
1028                         (*i)->set_owner (this);
1029
1030                         {
1031                                 if (configure_processors_unlocked (err, &lm)) {
1032                                         pstate.restore ();
1033                                         configure_processors_unlocked (0, &lm); // it worked before we tried to add it ...
1034                                         return -1;
1035                                 }
1036                         }
1037
1038                         if (pi && pi->has_sidechain ()) {
1039                                 pi->sidechain_input ()->changed.connect_same_thread (*this, boost::bind (&Route::sidechain_change_handler, this, _1, _2));
1040                         }
1041
1042                         if ((*i)->active()) {
1043                                 // emit ActiveChanged() and latency_changed() if needed
1044                                 (*i)->activate ();
1045                         }
1046
1047                         (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
1048
1049                         boost::shared_ptr<Send> send;
1050                         if ((send = boost::dynamic_pointer_cast<Send> (*i))) {
1051                                 send->SelfDestruct.connect_same_thread (*this,
1052                                                 boost::bind (&Route::processor_selfdestruct, this, boost::weak_ptr<Processor> (*i)));
1053                         }
1054                 }
1055
1056                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
1057                         boost::shared_ptr<PluginInsert> pi;
1058
1059                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1060                                 if (pi->has_no_inputs ()) {
1061                                         _have_internal_generator = true;
1062                                         break;
1063                                 }
1064                         }
1065                 }
1066
1067                 _output->set_user_latency (0);
1068         }
1069
1070         reset_instrument_info ();
1071         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1072         set_processor_positions ();
1073
1074         if (fanout && fanout->configured ()
1075                         && fanout->output_streams().n_audio() > 2
1076                         && boost::dynamic_pointer_cast<PluginInsert> (the_instrument ()) == fanout) {
1077                 fan_out (); /* EMIT SIGNAL */
1078         }
1079         return 0;
1080 }
1081
1082 void
1083 Route::placement_range(Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end)
1084 {
1085         if (p == PreFader) {
1086                 start = _processors.begin();
1087                 end = find(_processors.begin(), _processors.end(), _amp);
1088         } else {
1089                 start = find(_processors.begin(), _processors.end(), _amp);
1090                 ++start;
1091                 end = _processors.end();
1092         }
1093 }
1094
1095 /** Turn off all processors with a given placement
1096  * @param p Placement of processors to disable
1097  */
1098 void
1099 Route::disable_processors (Placement p)
1100 {
1101         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1102
1103         ProcessorList::iterator start, end;
1104         placement_range(p, start, end);
1105
1106         for (ProcessorList::iterator i = start; i != end; ++i) {
1107                 (*i)->enable (false);
1108         }
1109
1110         _session.set_dirty ();
1111 }
1112
1113 /** Turn off all redirects
1114  */
1115 void
1116 Route::disable_processors ()
1117 {
1118         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1119
1120         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1121                 (*i)->enable (false);
1122         }
1123
1124         _session.set_dirty ();
1125 }
1126
1127 /** Turn off all redirects with a given placement
1128  * @param p Placement of redirects to disable
1129  */
1130 void
1131 Route::disable_plugins (Placement p)
1132 {
1133         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1134
1135         ProcessorList::iterator start, end;
1136         placement_range(p, start, end);
1137
1138         for (ProcessorList::iterator i = start; i != end; ++i) {
1139                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1140                         (*i)->enable (false);
1141                 }
1142         }
1143
1144         _session.set_dirty ();
1145 }
1146
1147 /** Turn off all plugins
1148  */
1149 void
1150 Route::disable_plugins ()
1151 {
1152         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1153
1154         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1155                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1156                         (*i)->enable (false);
1157                 }
1158         }
1159
1160         _session.set_dirty ();
1161 }
1162
1163
1164 void
1165 Route::ab_plugins (bool forward)
1166 {
1167         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1168
1169         if (forward) {
1170
1171                 /* forward = turn off all active redirects, and mark them so that the next time
1172                    we go the other way, we will revert them
1173                 */
1174
1175                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1176                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1177                                 continue;
1178                         }
1179                         if (!(*i)->display_to_user ()) {
1180                                 continue;
1181                         }
1182 #ifdef MIXBUS
1183                         if (boost::dynamic_pointer_cast<PluginInsert> (*i)->is_channelstrip()) {
1184                                 continue;
1185                         }
1186 #endif
1187
1188                         if ((*i)->enabled ()) {
1189                                 (*i)->enable (false);
1190                                 (*i)->set_next_ab_is_active (true);
1191                         } else {
1192                                 (*i)->set_next_ab_is_active (false);
1193                         }
1194                 }
1195
1196         } else {
1197
1198                 /* backward = if the redirect was marked to go active on the next ab, do so */
1199
1200                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1201                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1202                                 continue;
1203                         }
1204                         if (!(*i)->display_to_user ()) {
1205                                 continue;
1206                         }
1207 #ifdef MIXBUS
1208                         if (boost::dynamic_pointer_cast<PluginInsert> (*i)->is_channelstrip()) {
1209                                 continue;
1210                         }
1211 #endif
1212
1213                         (*i)->enable ((*i)->get_next_ab_is_active ());
1214                 }
1215         }
1216
1217         _session.set_dirty ();
1218 }
1219
1220
1221 /** Remove processors with a given placement.
1222  * @param p Placement of processors to remove.
1223  */
1224 void
1225 Route::clear_processors (Placement p)
1226 {
1227         if (!_session.engine().connected()) {
1228                 return;
1229         }
1230
1231         bool already_deleting = _session.deletion_in_progress();
1232         if (!already_deleting) {
1233                 _session.set_deletion_in_progress();
1234         }
1235
1236         {
1237                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1238                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1239                 ProcessorList new_list;
1240                 ProcessorStreams err;
1241                 bool seen_amp = false;
1242
1243                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1244
1245                         if (*i == _amp) {
1246                                 seen_amp = true;
1247                         }
1248
1249                         if ((*i) == _amp || (*i) == _meter || (*i) == _main_outs || (*i) == _delayline || (*i) == _trim) {
1250
1251                                 /* you can't remove these */
1252
1253                                 new_list.push_back (*i);
1254
1255                         } else {
1256                                 if (seen_amp) {
1257
1258                                         switch (p) {
1259                                         case PreFader:
1260                                                 new_list.push_back (*i);
1261                                                 break;
1262                                         case PostFader:
1263                                                 (*i)->drop_references ();
1264                                                 break;
1265                                         }
1266
1267                                 } else {
1268
1269                                         switch (p) {
1270                                         case PreFader:
1271                                                 (*i)->drop_references ();
1272                                                 break;
1273                                         case PostFader:
1274                                                 new_list.push_back (*i);
1275                                                 break;
1276                                         }
1277                                 }
1278                         }
1279                 }
1280
1281                 _processors = new_list;
1282                 configure_processors_unlocked (&err, &lm); // this can't fail
1283         }
1284
1285         processor_max_streams.reset();
1286         _have_internal_generator = false;
1287         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1288         set_processor_positions ();
1289
1290         reset_instrument_info ();
1291
1292         if (!already_deleting) {
1293                 _session.clear_deletion_in_progress();
1294         }
1295 }
1296
1297 int
1298 Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err, bool need_process_lock)
1299 {
1300         // TODO once the export point can be configured properly, do something smarter here
1301         if (processor == _capturing_processor) {
1302                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1303                 if (need_process_lock) {
1304                         lx.acquire();
1305                 }
1306
1307                 _capturing_processor.reset();
1308
1309                 if (need_process_lock) {
1310                         lx.release();
1311                 }
1312         }
1313
1314         /* these can never be removed */
1315
1316         if (processor == _amp || processor == _meter || processor == _main_outs || processor == _delayline || processor == _trim) {
1317                 return 0;
1318         }
1319
1320         if (!_session.engine().connected()) {
1321                 return 1;
1322         }
1323
1324         processor_max_streams.reset();
1325
1326         {
1327                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1328                 if (need_process_lock) {
1329                         lx.acquire();
1330                 }
1331
1332                 /* Caller must hold process lock */
1333                 assert (!AudioEngine::instance()->process_lock().trylock());
1334
1335                 Glib::Threads::RWLock::WriterLock lm (_processor_lock); // XXX deadlock after export
1336
1337                 ProcessorState pstate (this);
1338
1339                 ProcessorList::iterator i;
1340                 bool removed = false;
1341
1342                 for (i = _processors.begin(); i != _processors.end(); ) {
1343                         if (*i == processor) {
1344
1345                                 /* move along, see failure case for configure_processors()
1346                                    where we may need to reconfigure the processor.
1347                                 */
1348
1349                                 /* stop redirects that send signals to JACK ports
1350                                    from causing noise as a result of no longer being
1351                                    run.
1352                                 */
1353
1354                                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
1355                                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*i);
1356
1357                                 if (pi != 0) {
1358                                         assert (iop == 0);
1359                                         iop = pi->sidechain();
1360                                 }
1361
1362                                 if (iop != 0) {
1363                                         iop->disconnect ();
1364                                 }
1365
1366                                 i = _processors.erase (i);
1367                                 removed = true;
1368                                 break;
1369
1370                         } else {
1371                                 ++i;
1372                         }
1373
1374                         _output->set_user_latency (0);
1375                 }
1376
1377                 if (!removed) {
1378                         /* what? */
1379                         return 1;
1380                 }
1381
1382                 if (configure_processors_unlocked (err, &lm)) {
1383                         pstate.restore ();
1384                         /* we know this will work, because it worked before :) */
1385                         configure_processors_unlocked (0, &lm);
1386                         return -1;
1387                 }
1388
1389                 _have_internal_generator = false;
1390
1391                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1392                         boost::shared_ptr<PluginInsert> pi;
1393
1394                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1395                                 if (pi->has_no_inputs ()) {
1396                                         _have_internal_generator = true;
1397                                         break;
1398                                 }
1399                         }
1400                 }
1401                 if (need_process_lock) {
1402                         lx.release();
1403                 }
1404         }
1405
1406         reset_instrument_info ();
1407         processor->drop_references ();
1408         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1409         set_processor_positions ();
1410
1411         return 0;
1412 }
1413
1414 int
1415 Route::replace_processor (boost::shared_ptr<Processor> old, boost::shared_ptr<Processor> sub, ProcessorStreams* err)
1416 {
1417         /* these can never be removed */
1418         if (old == _amp || old == _meter || old == _main_outs || old == _delayline || old == _trim) {
1419                 return 1;
1420         }
1421         /* and can't be used as substitute, either */
1422         if (sub == _amp || sub == _meter || sub == _main_outs || sub == _delayline || sub == _trim) {
1423                 return 1;
1424         }
1425
1426         /* I/Os are out, too */
1427         if (boost::dynamic_pointer_cast<IOProcessor> (old) || boost::dynamic_pointer_cast<IOProcessor> (sub)) {
1428                 return 1;
1429         }
1430
1431         /* this function cannot be used to swap/reorder processors */
1432         if (find (_processors.begin(), _processors.end(), sub) != _processors.end ()) {
1433                 return 1;
1434         }
1435
1436         if (!AudioEngine::instance()->connected() || !old || !sub) {
1437                 return 1;
1438         }
1439
1440         /* ensure that sub is not owned by another route */
1441         if (sub->owner ()) {
1442                 return 1;
1443         }
1444
1445         {
1446                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1447                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1448                 ProcessorState pstate (this);
1449
1450                 assert (find (_processors.begin(), _processors.end(), sub) == _processors.end ());
1451
1452                 ProcessorList::iterator i;
1453                 bool replaced = false;
1454                 bool enable = old->enabled ();
1455
1456                 for (i = _processors.begin(); i != _processors.end(); ) {
1457                         if (*i == old) {
1458                                 i = _processors.erase (i);
1459                                 _processors.insert (i, sub);
1460                                 sub->set_owner (this);
1461                                 replaced = true;
1462                                 break;
1463                         } else {
1464                                 ++i;
1465                         }
1466                 }
1467
1468                 if (!replaced) {
1469                         return 1;
1470                 }
1471
1472                 if (_strict_io) {
1473                         boost::shared_ptr<PluginInsert> pi;
1474                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(sub)) != 0) {
1475                                 pi->set_strict_io (true);
1476                         }
1477                 }
1478
1479                 if (configure_processors_unlocked (err, &lm)) {
1480                         pstate.restore ();
1481                         configure_processors_unlocked (0, &lm);
1482                         return -1;
1483                 }
1484
1485                 _have_internal_generator = false;
1486
1487                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1488                         boost::shared_ptr<PluginInsert> pi;
1489                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1490                                 if (pi->has_no_inputs ()) {
1491                                         _have_internal_generator = true;
1492                                         break;
1493                                 }
1494                         }
1495                 }
1496
1497                 if (enable) {
1498                         sub->enable (true);
1499                 }
1500
1501                 sub->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
1502                 _output->set_user_latency (0);
1503         }
1504
1505         reset_instrument_info ();
1506         old->drop_references ();
1507         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1508         set_processor_positions ();
1509         return 0;
1510 }
1511
1512 int
1513 Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
1514 {
1515         ProcessorList deleted;
1516
1517         if (!_session.engine().connected()) {
1518                 return 1;
1519         }
1520
1521         processor_max_streams.reset();
1522
1523         {
1524                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1525                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1526                 ProcessorState pstate (this);
1527
1528                 ProcessorList::iterator i;
1529                 boost::shared_ptr<Processor> processor;
1530
1531                 for (i = _processors.begin(); i != _processors.end(); ) {
1532
1533                         processor = *i;
1534
1535                         /* these can never be removed */
1536
1537                         if (processor == _amp || processor == _meter || processor == _main_outs || processor == _delayline || processor == _trim) {
1538                                 ++i;
1539                                 continue;
1540                         }
1541
1542                         /* see if its in the list of processors to delete */
1543
1544                         if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
1545                                 ++i;
1546                                 continue;
1547                         }
1548
1549                         /* stop IOProcessors that send to JACK ports
1550                            from causing noise as a result of no longer being
1551                            run.
1552                         */
1553
1554                         boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(processor);
1555                         boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(processor);
1556                         if (pi != 0) {
1557                                 assert (iop == 0);
1558                                 iop = pi->sidechain();
1559                         }
1560
1561                         if (iop != 0) {
1562                                 iop->disconnect ();
1563                         }
1564
1565                         deleted.push_back (processor);
1566                         i = _processors.erase (i);
1567                 }
1568
1569                 if (deleted.empty()) {
1570                         /* none of those in the requested list were found */
1571                         return 0;
1572                 }
1573
1574                 _output->set_user_latency (0);
1575
1576                 if (configure_processors_unlocked (err, &lm)) {
1577                         pstate.restore ();
1578                         /* we know this will work, because it worked before :) */
1579                         configure_processors_unlocked (0, &lm);
1580                         return -1;
1581                 }
1582                 //lx.unlock();
1583
1584                 _have_internal_generator = false;
1585
1586                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1587                         boost::shared_ptr<PluginInsert> pi;
1588
1589                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1590                                 if (pi->has_no_inputs ()) {
1591                                         _have_internal_generator = true;
1592                                         break;
1593                                 }
1594                         }
1595                 }
1596         }
1597
1598         /* now try to do what we need to so that those that were removed will be deleted */
1599
1600         for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
1601                 (*i)->drop_references ();
1602         }
1603
1604         reset_instrument_info ();
1605         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1606         set_processor_positions ();
1607
1608         return 0;
1609 }
1610
1611 void
1612 Route::reset_instrument_info ()
1613 {
1614         boost::shared_ptr<Processor> instr = the_instrument();
1615         if (instr) {
1616                 _instrument_info.set_internal_instrument (instr);
1617         }
1618 }
1619
1620 /** Caller must hold process lock */
1621 int
1622 Route::configure_processors (ProcessorStreams* err)
1623 {
1624 #ifndef PLATFORM_WINDOWS
1625         assert (!AudioEngine::instance()->process_lock().trylock());
1626 #endif
1627
1628         if (!_in_configure_processors) {
1629                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1630                 return configure_processors_unlocked (err, &lm);
1631         }
1632
1633         return 0;
1634 }
1635
1636 ChanCount
1637 Route::input_streams () const
1638 {
1639         return _input->n_ports ();
1640 }
1641
1642 list<pair<ChanCount, ChanCount> >
1643 Route::try_configure_processors (ChanCount in, ProcessorStreams* err)
1644 {
1645         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1646
1647         return try_configure_processors_unlocked (in, err);
1648 }
1649
1650 list<pair<ChanCount, ChanCount> >
1651 Route::try_configure_processors_unlocked (ChanCount in, ProcessorStreams* err)
1652 {
1653         // Check each processor in order to see if we can configure as requested
1654         ChanCount out;
1655         list<pair<ChanCount, ChanCount> > configuration;
1656         uint32_t index = 0;
1657
1658         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
1659         DEBUG_TRACE (DEBUG::Processors, "{\n");
1660
1661         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1662
1663                 if ((*p)->can_support_io_configuration(in, out)) {
1664
1665                         if (boost::dynamic_pointer_cast<Delivery> (*p)
1666                                         && boost::dynamic_pointer_cast<Delivery> (*p)->role() == Delivery::Main
1667                                         && !is_auditioner()
1668                                         && (is_monitor() || _strict_io || Profile->get_mixbus ())) {
1669                                 /* with strict I/O the panner + output are forced to
1670                                  * follow the last processor's output.
1671                                  *
1672                                  * Delivery::can_support_io_configuration() will only add ports,
1673                                  * but not remove excess ports.
1674                                  *
1675                                  * This works because the delivery only requires
1676                                  * as many outputs as there are inputs.
1677                                  * Delivery::configure_io() will do the actual removal
1678                                  * by calling _output->ensure_io()
1679                                  */
1680                                 if (!is_master() && _session.master_out () && in.n_audio() > 0) {
1681                                         /* ..but at least as many as there are master-inputs, if
1682                                          * the delivery is dealing with audio */
1683                                         // XXX this may need special-casing for mixbus (master-outputs)
1684                                         // and should maybe be a preference anyway ?!
1685                                         out = ChanCount::max (in, _session.master_out ()->n_inputs ());
1686                                 } else {
1687                                         out = in;
1688                                 }
1689                         }
1690
1691                         DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID=%2 in=%3 out=%4\n",(*p)->name(), (*p)->id(), in, out));
1692                         configuration.push_back(make_pair(in, out));
1693
1694                         if (is_monitor()) {
1695                                 // restriction for Monitor Section Processors
1696                                 if (in.n_audio() != out.n_audio() || out.n_midi() > 0) {
1697                                         /* Note: The Monitor follows the master-bus and has no panner.
1698                                          *
1699                                          * The general idea is to only allow plugins that retain the channel-count
1700                                          * and plugins with MIDI in (e.g VSTs with control that will remain unconnected).
1701                                          * Then again 5.1 in, monitor stereo is a valid use-case.
1702                                          *
1703                                          * and worse: we only refuse adding plugins *here*.
1704                                          *
1705                                          * 1) stereo-master, stereo-mon, add a stereo-plugin, OK
1706                                          * 2) change master-bus, add a channel
1707                                          * 2a) monitor-secion follows
1708                                          * 3) monitor processors fail to re-reconfigure (stereo plugin)
1709                                          * 4) re-load session, monitor-processor remains unconfigured, crash.
1710                                          */
1711                                         DEBUG_TRACE (DEBUG::Processors, "Monitor: Channel configuration change.\n");
1712                                 }
1713                                 if (boost::dynamic_pointer_cast<InternalSend> (*p)) {
1714                                         // internal sends make no sense, only feedback
1715                                         DEBUG_TRACE (DEBUG::Processors, "Monitor: No Sends allowed.\n");
1716                                         return list<pair<ChanCount, ChanCount> > ();
1717                                 }
1718                                 if (boost::dynamic_pointer_cast<PortInsert> (*p)) {
1719                                         /* External Sends can be problematic. one can add/remove ports
1720                                          * there signal leaves the DAW to external monitors anyway, so there's
1721                                          * no real use for allowing them here anyway.
1722                                          */
1723                                         DEBUG_TRACE (DEBUG::Processors, "Monitor: No External Sends allowed.\n");
1724                                         return list<pair<ChanCount, ChanCount> > ();
1725                                 }
1726                                 if (boost::dynamic_pointer_cast<Send> (*p)) {
1727                                         // ditto
1728                                         DEBUG_TRACE (DEBUG::Processors, "Monitor: No Sends allowed.\n");
1729                                         return list<pair<ChanCount, ChanCount> > ();
1730                                 }
1731                         }
1732                         in = out;
1733                 } else {
1734                         if (err) {
1735                                 err->index = index;
1736                                 err->count = in;
1737                         }
1738                         DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
1739                         DEBUG_TRACE (DEBUG::Processors, string_compose ("---- %1 cannot support in=%2 out=%3\n", (*p)->name(), in, out));
1740                         DEBUG_TRACE (DEBUG::Processors, "}\n");
1741                         return list<pair<ChanCount, ChanCount> > ();
1742                 }
1743         }
1744
1745         DEBUG_TRACE (DEBUG::Processors, "}\n");
1746
1747         return configuration;
1748 }
1749
1750 /** Set the input/output configuration of each processor in the processors list.
1751  *  Caller must hold process lock.
1752  *  Return 0 on success, otherwise configuration is impossible.
1753  */
1754 int
1755 Route::configure_processors_unlocked (ProcessorStreams* err, Glib::Threads::RWLock::WriterLock* lm)
1756 {
1757 #ifndef PLATFORM_WINDOWS
1758         assert (!AudioEngine::instance()->process_lock().trylock());
1759 #endif
1760
1761         if (_in_configure_processors) {
1762                 return 0;
1763         }
1764
1765         /* put invisible processors where they should be */
1766         setup_invisible_processors ();
1767
1768         _in_configure_processors = true;
1769
1770         list<pair<ChanCount, ChanCount> > configuration = try_configure_processors_unlocked (input_streams (), err);
1771
1772         if (configuration.empty ()) {
1773                 _in_configure_processors = false;
1774                 return -1;
1775         }
1776
1777         ChanCount out;
1778         bool seen_mains_out = false;
1779         processor_out_streams = _input->n_ports();
1780         processor_max_streams.reset();
1781
1782         /* processor configure_io() may result in adding ports
1783          * e.g. Delivery::configure_io -> ARDOUR::IO::ensure_io ()
1784          *
1785          * with jack2 adding ports results in a graph-order callback,
1786          * which calls Session::resort_routes() and eventually
1787          * Route::direct_feeds_according_to_reality()
1788          * which takes a ReaderLock (_processor_lock).
1789          *
1790          * so we can't hold a WriterLock here until jack2 threading
1791          * is fixed.
1792          *
1793          * NB. we still hold the process lock
1794          *
1795          * (ardour's own engines do call graph-order from the
1796          * process-thread and hence do not have this issue; besides
1797          * merely adding ports won't trigger a graph-order, only
1798          * making connections does)
1799          */
1800         lm->release ();
1801
1802         // TODO check for a potential ReaderLock after ReaderLock ??
1803         Glib::Threads::RWLock::ReaderLock lr (_processor_lock);
1804
1805         list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1806         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1807
1808                 if (!(*p)->configure_io(c->first, c->second)) {
1809                         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration failed\n", _name));
1810                         _in_configure_processors = false;
1811                         lr.release ();
1812                         lm->acquire ();
1813                         return -1;
1814                 }
1815                 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1816                 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1817
1818                 boost::shared_ptr<IOProcessor> iop;
1819                 boost::shared_ptr<PluginInsert> pi;
1820                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
1821                         /* plugins connected via Split or Hide Match may have more channels.
1822                          * route/scratch buffers are needed for all of them
1823                          * The configuration may only be a subset (both input and output)
1824                          */
1825                         processor_max_streams = ChanCount::max(processor_max_streams, pi->required_buffers());
1826                 }
1827                 else if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*p)) != 0) {
1828                         processor_max_streams = ChanCount::max(processor_max_streams, iop->natural_input_streams());
1829                         processor_max_streams = ChanCount::max(processor_max_streams, iop->natural_output_streams());
1830                 }
1831                 out = c->second;
1832
1833                 if (boost::dynamic_pointer_cast<Delivery> (*p)
1834                                 && boost::dynamic_pointer_cast<Delivery> (*p)->role() == Delivery::Main) {
1835                         /* main delivery will increase port count to match input.
1836                          * the Delivery::Main is usually the last processor - followed only by
1837                          * 'MeterOutput'.
1838                          */
1839                         seen_mains_out = true;
1840                 }
1841                 if (!seen_mains_out) {
1842                         processor_out_streams = out;
1843                 }
1844         }
1845
1846         lr.release ();
1847         lm->acquire ();
1848
1849
1850         if (_meter) {
1851                 _meter->set_max_channels (processor_max_streams);
1852         }
1853
1854         /* make sure we have sufficient scratch buffers to cope with the new processor
1855            configuration
1856         */
1857         _session.ensure_buffers (n_process_buffers ());
1858
1859         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
1860
1861         _in_configure_processors = false;
1862         return 0;
1863 }
1864
1865 /** Set all visible processors to a given active state (except Fader, whose state is not changed)
1866  *  @param state New active state for those processors.
1867  */
1868 void
1869 Route::all_visible_processors_active (bool state)
1870 {
1871         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1872
1873         if (_processors.empty()) {
1874                 return;
1875         }
1876
1877         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1878                 if (!(*i)->display_to_user() || boost::dynamic_pointer_cast<Amp> (*i)) {
1879                         continue;
1880                 }
1881 #ifdef MIXBUS
1882                 boost::shared_ptr<PluginInsert> pi;
1883                 if (0 != (pi = boost::dynamic_pointer_cast<PluginInsert>(*i))) {
1884                         if (pi->is_channelstrip ()) {
1885                                 continue;
1886                         }
1887                 }
1888 #endif
1889                 (*i)->enable (state);
1890         }
1891
1892         _session.set_dirty ();
1893 }
1894
1895 bool
1896 Route::processors_reorder_needs_configure (const ProcessorList& new_order)
1897 {
1898         /* check if re-order requires re-configuration of any processors
1899          * -> compare channel configuration for all processors
1900          */
1901         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1902         ChanCount c = input_streams ();
1903
1904         for (ProcessorList::const_iterator j = new_order.begin(); j != new_order.end(); ++j) {
1905                 bool found = false;
1906                 if (c != (*j)->input_streams()) {
1907                         return true;
1908                 }
1909                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
1910                         if (*i == *j) {
1911                                 found = true;
1912                                 if ((*i)->input_streams() != c) {
1913                                         return true;
1914                                 }
1915                                 c = (*i)->output_streams();
1916                                 break;
1917                         }
1918                 }
1919                 if (!found) {
1920                         return true;
1921                 }
1922         }
1923         return false;
1924 }
1925
1926 #ifdef __clang__
1927 __attribute__((annotate("realtime")))
1928 #endif
1929 void
1930 Route::apply_processor_order (const ProcessorList& new_order)
1931 {
1932         /* need to hold processor_lock; either read or write lock
1933          * and the engine process_lock.
1934          * Due to r/w lock ambiguity we can only assert the latter
1935          */
1936         assert (!AudioEngine::instance()->process_lock().trylock());
1937
1938
1939         /* "new_order" is an ordered list of processors to be positioned according to "placement".
1940          * NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
1941          * processors in the current actual processor list that are hidden. Any visible processors
1942          *  in the current list but not in "new_order" will be assumed to be deleted.
1943          */
1944
1945         /* "as_it_will_be" and "_processors" are lists of shared pointers.
1946          * actual memory usage is small, but insert/erase is not actually rt-safe :(
1947          * (note though that  ::processors_reorder_needs_configure() ensured that
1948          * this function will only ever be called from the rt-thread if no processor were removed)
1949          *
1950          * either way, I can't proove it, but an x-run due to re-order here is less likley
1951          * than an x-run-less 'ardour-silent cycle' both of which effectively "click".
1952          */
1953
1954         ProcessorList as_it_will_be;
1955         ProcessorList::iterator oiter;
1956         ProcessorList::const_iterator niter;
1957
1958         oiter = _processors.begin();
1959         niter = new_order.begin();
1960
1961         while (niter !=  new_order.end()) {
1962
1963                 /* if the next processor in the old list is invisible (i.e. should not be in the new order)
1964                    then append it to the temp list.
1965
1966                    Otherwise, see if the next processor in the old list is in the new list. if not,
1967                    its been deleted. If its there, append it to the temp list.
1968                    */
1969
1970                 if (oiter == _processors.end()) {
1971
1972                         /* no more elements in the old list, so just stick the rest of
1973                            the new order onto the temp list.
1974                            */
1975
1976                         as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
1977                         while (niter != new_order.end()) {
1978                                 ++niter;
1979                         }
1980                         break;
1981
1982                 } else {
1983
1984                         if (!(*oiter)->display_to_user()) {
1985
1986                                 as_it_will_be.push_back (*oiter);
1987
1988                         } else {
1989
1990                                 /* visible processor: check that its in the new order */
1991
1992                                 if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
1993                                         /* deleted: do nothing, shared_ptr<> will clean up */
1994                                 } else {
1995                                         /* ignore this one, and add the next item from the new order instead */
1996                                         as_it_will_be.push_back (*niter);
1997                                         ++niter;
1998                                 }
1999                         }
2000
2001                         /* now remove from old order - its taken care of no matter what */
2002                         oiter = _processors.erase (oiter);
2003                 }
2004
2005         }
2006         _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
2007
2008         /* If the meter is in a custom position, find it and make a rough note of its position */
2009         maybe_note_meter_position ();
2010 }
2011
2012 void
2013 Route::move_instrument_down (bool postfader)
2014 {
2015         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2016         ProcessorList new_order;
2017         boost::shared_ptr<Processor> instrument;
2018         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2019                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*i);
2020                 if (pi && pi->plugin ()->get_info ()->is_instrument ()) {
2021                         instrument = *i;
2022                 } else if (instrument && *i == _amp) {
2023                         if (postfader) {
2024                                 new_order.push_back (*i);
2025                                 new_order.push_back (instrument);
2026                         } else {
2027                                 new_order.push_back (instrument);
2028                                 new_order.push_back (*i);
2029                         }
2030                 } else {
2031                         new_order.push_back (*i);
2032                 }
2033         }
2034         if (!instrument) {
2035                 return;
2036         }
2037         lm.release ();
2038         reorder_processors (new_order, 0);
2039 }
2040
2041 int
2042 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
2043 {
2044         // it a change is already queued, wait for it
2045         // (unless engine is stopped. apply immediately and proceed
2046         while (g_atomic_int_get (&_pending_process_reorder)) {
2047                 if (!AudioEngine::instance()->running()) {
2048                         DEBUG_TRACE (DEBUG::Processors, "offline apply queued processor re-order.\n");
2049                         Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2050
2051                         apply_processor_order(_pending_processor_order);
2052                         setup_invisible_processors ();
2053
2054                         g_atomic_int_set (&_pending_process_reorder, 0);
2055
2056                         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2057                         set_processor_positions ();
2058                 } else {
2059                         // TODO rather use a semaphore or something.
2060                         // but since ::reorder_processors() is called
2061                         // from the GUI thread, this is fine..
2062                         Glib::usleep(500);
2063                 }
2064         }
2065
2066         if (processors_reorder_needs_configure (new_order) || !AudioEngine::instance()->running()) {
2067
2068                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2069                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2070                 ProcessorState pstate (this);
2071
2072                 apply_processor_order (new_order);
2073
2074                 if (configure_processors_unlocked (err, &lm)) {
2075                         pstate.restore ();
2076                         return -1;
2077                 }
2078
2079                 lm.release();
2080                 lx.release();
2081
2082                 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2083                 set_processor_positions ();
2084
2085         } else {
2086                 DEBUG_TRACE (DEBUG::Processors, "Queue clickless processor re-order.\n");
2087                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2088
2089                 // _pending_processor_order is protected by _processor_lock
2090                 _pending_processor_order = new_order;
2091                 g_atomic_int_set (&_pending_process_reorder, 1);
2092         }
2093
2094         return 0;
2095 }
2096
2097 bool
2098 Route::add_remove_sidechain (boost::shared_ptr<Processor> proc, bool add)
2099 {
2100         boost::shared_ptr<PluginInsert> pi;
2101         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
2102                 return false;
2103         }
2104
2105         if (pi->has_sidechain () == add) {
2106                 return true; // ?? call failed, but result is as expected.
2107         }
2108
2109         {
2110                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2111                 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), proc);
2112                 if (i == _processors.end ()) {
2113                         return false;
2114                 }
2115         }
2116
2117         {
2118                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ()); // take before Writerlock to avoid deadlock
2119                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2120                 PBD::Unwinder<bool> uw (_in_sidechain_setup, true);
2121
2122                 lx.release (); // IO::add_port() and ~IO takes process lock  - XXX check if this is safe
2123                 if (add) {
2124                         if (!pi->add_sidechain ()) {
2125                                 return false;
2126                         }
2127                 } else {
2128                         if (!pi->del_sidechain ()) {
2129                                 return false;
2130                         }
2131                 }
2132
2133                 lx.acquire ();
2134                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2135                 lx.release ();
2136
2137                 if (c.empty()) {
2138                         if (add) {
2139                                 pi->del_sidechain ();
2140                         } else {
2141                                 pi->add_sidechain ();
2142                                 // TODO restore side-chain's state.
2143                         }
2144                         return false;
2145                 }
2146                 lx.acquire ();
2147                 configure_processors_unlocked (0, &lm);
2148         }
2149
2150         if (pi->has_sidechain ()) {
2151                 pi->sidechain_input ()->changed.connect_same_thread (*this, boost::bind (&Route::sidechain_change_handler, this, _1, _2));
2152         }
2153
2154         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2155         _session.set_dirty ();
2156         return true;
2157 }
2158
2159 bool
2160 Route::plugin_preset_output (boost::shared_ptr<Processor> proc, ChanCount outs)
2161 {
2162         boost::shared_ptr<PluginInsert> pi;
2163         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
2164                 return false;
2165         }
2166
2167         {
2168                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2169                 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), proc);
2170                 if (i == _processors.end ()) {
2171                         return false;
2172                 }
2173         }
2174
2175         {
2176                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2177                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2178
2179                 const ChanCount& old (pi->preset_out ());
2180                 if (!pi->set_preset_out (outs)) {
2181                         return true; // no change, OK
2182                 }
2183
2184                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2185                 if (c.empty()) {
2186                         /* not possible */
2187                         pi->set_preset_out (old);
2188                         return false;
2189                 }
2190                 configure_processors_unlocked (0, &lm);
2191         }
2192
2193         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2194         _session.set_dirty ();
2195         return true;
2196 }
2197
2198 bool
2199 Route::reset_plugin_insert (boost::shared_ptr<Processor> proc)
2200 {
2201         ChanCount unused;
2202         return customize_plugin_insert (proc, 0, unused, unused);
2203 }
2204
2205 bool
2206 Route::customize_plugin_insert (boost::shared_ptr<Processor> proc, uint32_t count, ChanCount outs, ChanCount sinks)
2207 {
2208         boost::shared_ptr<PluginInsert> pi;
2209         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
2210                 return false;
2211         }
2212
2213         {
2214                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2215                 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), proc);
2216                 if (i == _processors.end ()) {
2217                         return false;
2218                 }
2219         }
2220
2221         {
2222                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2223                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2224
2225                 bool      old_cust  = pi->custom_cfg ();
2226                 uint32_t  old_cnt   = pi->get_count ();
2227                 ChanCount old_chan  = pi->output_streams ();
2228                 ChanCount old_sinks = pi->natural_input_streams ();
2229
2230                 if (count == 0) {
2231                         pi->set_custom_cfg (false);
2232                 } else {
2233                         pi->set_custom_cfg (true);
2234                         pi->set_count (count);
2235                         pi->set_outputs (outs);
2236                         pi->set_sinks (sinks);
2237                 }
2238
2239                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2240                 if (c.empty()) {
2241                         /* not possible */
2242
2243                         pi->set_count (old_cnt);
2244                         pi->set_sinks (old_sinks);
2245                         pi->set_outputs (old_chan);
2246                         pi->set_custom_cfg (old_cust);
2247
2248                         return false;
2249                 }
2250                 configure_processors_unlocked (0, &lm);
2251         }
2252
2253         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2254         _session.set_dirty ();
2255         return true;
2256 }
2257
2258 bool
2259 Route::set_strict_io (const bool enable)
2260 {
2261         Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2262
2263         if (_strict_io != enable) {
2264                 _strict_io = enable;
2265                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2266                 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p) {
2267                         boost::shared_ptr<PluginInsert> pi;
2268                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
2269                                 pi->set_strict_io (_strict_io);
2270                         }
2271                 }
2272
2273                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2274
2275                 if (c.empty()) {
2276                         // not possible
2277                         _strict_io = !enable; // restore old value
2278                         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p) {
2279                                 boost::shared_ptr<PluginInsert> pi;
2280                                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
2281                                         pi->set_strict_io (_strict_io);
2282                                 }
2283                         }
2284                         return false;
2285                 }
2286                 lm.release ();
2287
2288                 configure_processors (0);
2289                 lx.release ();
2290
2291                 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2292                 _session.set_dirty ();
2293         }
2294         return true;
2295 }
2296
2297 XMLNode&
2298 Route::get_state()
2299 {
2300         return state(true);
2301 }
2302
2303 XMLNode&
2304 Route::get_template()
2305 {
2306         return state(false);
2307 }
2308
2309 XMLNode&
2310 Route::state(bool full_state)
2311 {
2312         LocaleGuard lg;
2313         if (!_session._template_state_dir.empty()) {
2314                 foreach_processor (sigc::bind (sigc::mem_fun (*this, &Route::set_plugin_state_dir), _session._template_state_dir));
2315         }
2316
2317         XMLNode *node = new XMLNode("Route");
2318         ProcessorList::iterator i;
2319         char buf[32];
2320
2321         id().print (buf, sizeof (buf));
2322         node->add_property("id", buf);
2323         node->add_property ("name", _name);
2324         node->add_property("default-type", _default_type.to_string());
2325         node->add_property ("strict-io", _strict_io);
2326
2327         node->add_child_nocopy (_presentation_info.get_state());
2328
2329         node->add_property("active", _active?"yes":"no");
2330         string p;
2331         node->add_property("denormal-protection", _denormal_protection?"yes":"no");
2332         node->add_property("meter-point", enum_2_string (_meter_point));
2333
2334         node->add_property("meter-type", enum_2_string (_meter_type));
2335
2336         if (_route_group) {
2337                 node->add_property("route-group", _route_group->name());
2338         }
2339
2340         node->add_child_nocopy (_solo_control->get_state ());
2341         node->add_child_nocopy (_solo_isolate_control->get_state ());
2342         node->add_child_nocopy (_solo_safe_control->get_state ());
2343
2344         node->add_child_nocopy (_input->state (full_state));
2345         node->add_child_nocopy (_output->state (full_state));
2346         node->add_child_nocopy (_mute_master->get_state ());
2347
2348         node->add_child_nocopy (_mute_control->get_state ());
2349         node->add_child_nocopy (_phase_control->get_state ());
2350
2351         if (full_state) {
2352                 node->add_child_nocopy (Automatable::get_automation_xml_state ());
2353         }
2354
2355         if (_comment.length()) {
2356                 XMLNode *cmt = node->add_child ("Comment");
2357                 cmt->add_content (_comment);
2358         }
2359
2360         if (_pannable) {
2361                 node->add_child_nocopy (_pannable->state (full_state));
2362         }
2363
2364         {
2365                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2366                 for (i = _processors.begin(); i != _processors.end(); ++i) {
2367                         if (!full_state) {
2368                                 /* template save: do not include internal sends functioning as
2369                                          aux sends because the chance of the target ID
2370                                          in the session where this template is used
2371                                          is not very likely.
2372
2373                                          similarly, do not save listen sends which connect to
2374                                          the monitor section, because these will always be
2375                                          added if necessary.
2376                                          */
2377                                 boost::shared_ptr<InternalSend> is;
2378
2379                                 if ((is = boost::dynamic_pointer_cast<InternalSend> (*i)) != 0) {
2380                                         if (is->role() == Delivery::Listen) {
2381                                                 continue;
2382                                         }
2383                                 }
2384                         }
2385                         node->add_child_nocopy((*i)->state (full_state));
2386                 }
2387         }
2388
2389         if (_extra_xml) {
2390                 node->add_child_copy (*_extra_xml);
2391         }
2392
2393         if (_custom_meter_position_noted) {
2394                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
2395                 if (after) {
2396                         after->id().print (buf, sizeof (buf));
2397                         node->add_property (X_("processor-after-last-custom-meter"), buf);
2398                 }
2399         }
2400
2401         if (!_session._template_state_dir.empty()) {
2402                 foreach_processor (sigc::bind (sigc::mem_fun (*this, &Route::set_plugin_state_dir), ""));
2403         }
2404
2405         node->add_child_copy (Slavable::get_state());
2406
2407         return *node;
2408 }
2409
2410 int
2411 Route::set_state (const XMLNode& node, int version)
2412 {
2413         if (version < 3000) {
2414                 return set_state_2X (node, version);
2415         }
2416
2417         XMLNodeList nlist;
2418         XMLNodeConstIterator niter;
2419         XMLNode *child;
2420         XMLProperty const * prop;
2421
2422         if (node.name() != "Route"){
2423                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2424                 return -1;
2425         }
2426
2427         if ((prop = node.property (X_("name"))) != 0) {
2428                 Route::set_name (prop->value());
2429         }
2430
2431         set_id (node);
2432         _initial_io_setup = true;
2433
2434         Stripable::set_state (node, version);
2435
2436         if ((prop = node.property (X_("strict-io"))) != 0) {
2437                 _strict_io = string_is_affirmative (prop->value());
2438         }
2439
2440         if (is_monitor()) {
2441                 /* monitor bus does not get a panner, but if (re)created
2442                    via XML, it will already have one by the time we
2443                    call ::set_state(). so ... remove it.
2444                 */
2445                 unpan ();
2446         }
2447
2448         /* add all processors (except amp, which is always present) */
2449
2450         nlist = node.children();
2451         XMLNode processor_state (X_("processor_state"));
2452
2453         Stateful::save_extra_xml (node);
2454
2455         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2456
2457                 child = *niter;
2458
2459                 if (child->name() == IO::state_node_name) {
2460                         if ((prop = child->property (X_("direction"))) == 0) {
2461                                 continue;
2462                         }
2463
2464                         if (prop->value() == "Input") {
2465                                 _input->set_state (*child, version);
2466                         } else if (prop->value() == "Output") {
2467                                 _output->set_state (*child, version);
2468                         }
2469
2470                 } else if (child->name() == X_("Processor")) {
2471                         processor_state.add_child_copy (*child);
2472                 } else if (child->name() == X_("Pannable")) {
2473                         if (_pannable) {
2474                                 _pannable->set_state (*child, version);
2475                         } else {
2476                                 warning << string_compose (_("Pannable state found for route (%1) without a panner!"), name()) << endmsg;
2477                         }
2478                 } else if (child->name() == Slavable::xml_node_name) {
2479                         Slavable::set_state (*child, version);
2480                 }
2481         }
2482
2483         if ((prop = node.property (X_("meter-point"))) != 0) {
2484                 MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
2485                 set_meter_point (mp, true);
2486                 if (_meter) {
2487                         _meter->set_display_to_user (_meter_point == MeterCustom);
2488                 }
2489         }
2490
2491         if ((prop = node.property (X_("meter-type"))) != 0) {
2492                 _meter_type = MeterType (string_2_enum (prop->value (), _meter_type));
2493         }
2494
2495         _initial_io_setup = false;
2496
2497         set_processor_state (processor_state);
2498
2499         // this looks up the internal instrument in processors
2500         reset_instrument_info();
2501
2502         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2503                 set_denormal_protection (string_is_affirmative (prop->value()));
2504         }
2505
2506         /* convert old 3001 state */
2507         if ((prop = node.property (X_("phase-invert"))) != 0) {
2508                 _phase_control->set_phase_invert (boost::dynamic_bitset<> (prop->value ()));
2509         }
2510
2511         if ((prop = node.property (X_("active"))) != 0) {
2512                 bool yn = string_is_affirmative (prop->value());
2513                 set_active (yn, this);
2514         }
2515
2516         if ((prop = node.property (X_("processor-after-last-custom-meter"))) != 0) {
2517                 PBD::ID id (prop->value ());
2518                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2519                 ProcessorList::const_iterator i = _processors.begin ();
2520                 while (i != _processors.end() && (*i)->id() != id) {
2521                         ++i;
2522                 }
2523
2524                 if (i != _processors.end ()) {
2525                         _processor_after_last_custom_meter = *i;
2526                         _custom_meter_position_noted = true;
2527                 }
2528         }
2529
2530         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2531                 child = *niter;
2532
2533                 if (child->name() == X_("Comment")) {
2534
2535                         /* XXX this is a terrible API design in libxml++ */
2536
2537                         XMLNode *cmt = *(child->children().begin());
2538                         _comment = cmt->content();
2539
2540                 }  else if (child->name() == Controllable::xml_node_name) {
2541                         if ((prop = child->property (X_("name"))) == 0) {
2542                                 continue;
2543                         }
2544
2545                         if (prop->value() == _gain_control->name()) {
2546                                 _gain_control->set_state (*child, version);
2547                         } else if (prop->value() == _solo_control->name()) {
2548                                 _solo_control->set_state (*child, version);
2549                         } else if (prop->value() == _solo_safe_control->name()) {
2550                                 _solo_safe_control->set_state (*child, version);
2551                         } else if (prop->value() == _solo_isolate_control->name()) {
2552                                 _solo_isolate_control->set_state (*child, version);
2553                         } else if (prop->value() == _mute_control->name()) {
2554                                 _mute_control->set_state (*child, version);
2555                         } else if (prop->value() == _phase_control->name()) {
2556                                 _phase_control->set_state (*child, version);
2557                         } else {
2558                                 Evoral::Parameter p = EventTypeMap::instance().from_symbol (prop->value());
2559                                 if (p.type () >= MidiCCAutomation && p.type () < MidiSystemExclusiveAutomation) {
2560                                         boost::shared_ptr<AutomationControl> ac = automation_control (p, true);
2561                                         if (ac) {
2562                                                 ac->set_state (*child, version);
2563                                         }
2564                                 }
2565                         }
2566                 } else if (child->name() == MuteMaster::xml_node_name) {
2567                         _mute_master->set_state (*child, version);
2568
2569                 } else if (child->name() == Automatable::xml_node_name) {
2570                         set_automation_xml_state (*child, Evoral::Parameter(NullAutomation));
2571                 }
2572         }
2573
2574         return 0;
2575 }
2576
2577 int
2578 Route::set_state_2X (const XMLNode& node, int version)
2579 {
2580         LocaleGuard lg;
2581         XMLNodeList nlist;
2582         XMLNodeConstIterator niter;
2583         XMLNode *child;
2584         XMLProperty const * prop;
2585
2586         /* 2X things which still remain to be handled:
2587          * default-type
2588          * automation
2589          * controlouts
2590          */
2591
2592         if (node.name() != "Route") {
2593                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2594                 return -1;
2595         }
2596
2597         Stripable::set_state (node, version);
2598
2599         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2600                 set_denormal_protection (string_is_affirmative (prop->value()));
2601         }
2602
2603         if ((prop = node.property (X_("muted"))) != 0) {
2604
2605                 bool first = true;
2606                 bool muted = string_is_affirmative (prop->value());
2607
2608                 if (muted) {
2609
2610                         string mute_point;
2611
2612                         if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
2613
2614                                 if (string_is_affirmative (prop->value())){
2615                                         mute_point = mute_point + "PreFader";
2616                                         first = false;
2617                                 }
2618                         }
2619
2620                         if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
2621
2622                                 if (string_is_affirmative (prop->value())){
2623
2624                                         if (!first) {
2625                                                 mute_point = mute_point + ",";
2626                                         }
2627
2628                                         mute_point = mute_point + "PostFader";
2629                                         first = false;
2630                                 }
2631                         }
2632
2633                         if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
2634
2635                                 if (string_is_affirmative (prop->value())){
2636
2637                                         if (!first) {
2638                                                 mute_point = mute_point + ",";
2639                                         }
2640
2641                                         mute_point = mute_point + "Listen";
2642                                         first = false;
2643                                 }
2644                         }
2645
2646                         if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
2647
2648                                 if (string_is_affirmative (prop->value())){
2649
2650                                         if (!first) {
2651                                                 mute_point = mute_point + ",";
2652                                         }
2653
2654                                         mute_point = mute_point + "Main";
2655                                 }
2656                         }
2657
2658                         _mute_master->set_mute_points (mute_point);
2659                         _mute_master->set_muted_by_self (true);
2660                 }
2661         }
2662
2663         if ((prop = node.property (X_("meter-point"))) != 0) {
2664                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2665         }
2666
2667         /* IOs */
2668
2669         nlist = node.children ();
2670         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2671
2672                 child = *niter;
2673
2674                 if (child->name() == IO::state_node_name) {
2675
2676                         /* there is a note in IO::set_state_2X() about why we have to call
2677                            this directly.
2678                            */
2679
2680                         _input->set_state_2X (*child, version, true);
2681                         _output->set_state_2X (*child, version, false);
2682
2683                         if ((prop = child->property (X_("name"))) != 0) {
2684                                 Route::set_name (prop->value ());
2685                         }
2686
2687                         set_id (*child);
2688
2689                         if ((prop = child->property (X_("active"))) != 0) {
2690                                 bool yn = string_is_affirmative (prop->value());
2691                                 _active = !yn; // force switch
2692                                 set_active (yn, this);
2693                         }
2694
2695                         if ((prop = child->property (X_("gain"))) != 0) {
2696                                 gain_t val;
2697
2698                                 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2699                                         _amp->gain_control()->set_value (val, Controllable::NoGroup);
2700                                 }
2701                         }
2702
2703                         /* Set up Panners in the IO */
2704                         XMLNodeList io_nlist = child->children ();
2705
2706                         XMLNodeConstIterator io_niter;
2707                         XMLNode *io_child;
2708
2709                         for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2710
2711                                 io_child = *io_niter;
2712
2713                                 if (io_child->name() == X_("Panner")) {
2714                                         _main_outs->panner_shell()->set_state(*io_child, version);
2715                                 } else if (io_child->name() == X_("Automation")) {
2716                                         /* IO's automation is for the fader */
2717                                         _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
2718                                 }
2719                         }
2720                 }
2721         }
2722
2723         XMLNodeList redirect_nodes;
2724
2725         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2726
2727                 child = *niter;
2728
2729                 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2730                         redirect_nodes.push_back(child);
2731                 }
2732
2733         }
2734
2735         set_processor_state_2X (redirect_nodes, version);
2736
2737         Stateful::save_extra_xml (node);
2738
2739         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2740                 child = *niter;
2741
2742                 if (child->name() == X_("Comment")) {
2743
2744                         /* XXX this is a terrible API design in libxml++ */
2745
2746                         XMLNode *cmt = *(child->children().begin());
2747                         _comment = cmt->content();
2748
2749                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2750                         if (prop->value() == X_("solo")) {
2751                                 _solo_control->set_state (*child, version);
2752                         } else if (prop->value() == X_("mute")) {
2753                                 _mute_control->set_state (*child, version);
2754                         }
2755
2756                 }
2757         }
2758
2759         return 0;
2760 }
2761
2762 XMLNode&
2763 Route::get_processor_state ()
2764 {
2765         XMLNode* root = new XMLNode (X_("redirects"));
2766         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2767                 root->add_child_nocopy ((*i)->state (true));
2768         }
2769
2770         return *root;
2771 }
2772
2773 void
2774 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2775 {
2776         /* We don't bother removing existing processors not in nList, as this
2777            method will only be called when creating a Route from scratch, not
2778            for undo purposes.  Just put processors in at the appropriate place
2779            in the list.
2780         */
2781
2782         for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2783                 add_processor_from_xml_2X (**i, version);
2784         }
2785 }
2786
2787 void
2788 Route::set_processor_state (const XMLNode& node)
2789 {
2790         const XMLNodeList &nlist = node.children();
2791         XMLNodeConstIterator niter;
2792         ProcessorList new_order;
2793         bool must_configure = false;
2794
2795         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2796
2797                 XMLProperty* prop = (*niter)->property ("type");
2798
2799                 if (prop->value() == "amp") {
2800                         _amp->set_state (**niter, Stateful::current_state_version);
2801                         new_order.push_back (_amp);
2802                 } else if (prop->value() == "trim") {
2803                         _trim->set_state (**niter, Stateful::current_state_version);
2804                         new_order.push_back (_trim);
2805                 } else if (prop->value() == "meter") {
2806                         _meter->set_state (**niter, Stateful::current_state_version);
2807                         new_order.push_back (_meter);
2808                 } else if (prop->value() == "delay") {
2809                         if (_delayline) {
2810                                 _delayline->set_state (**niter, Stateful::current_state_version);
2811                                 new_order.push_back (_delayline);
2812                         }
2813                 } else if (prop->value() == "main-outs") {
2814                         _main_outs->set_state (**niter, Stateful::current_state_version);
2815                 } else if (prop->value() == "intreturn") {
2816                         if (!_intreturn) {
2817                                 _intreturn.reset (new InternalReturn (_session));
2818                                 must_configure = true;
2819                         }
2820                         _intreturn->set_state (**niter, Stateful::current_state_version);
2821                 } else if (is_monitor() && prop->value() == "monitor") {
2822                         if (!_monitor_control) {
2823                                 _monitor_control.reset (new MonitorProcessor (_session));
2824                                 must_configure = true;
2825                         }
2826                         _monitor_control->set_state (**niter, Stateful::current_state_version);
2827                 } else if (prop->value() == "capture") {
2828                         /* CapturingProcessor should never be restored, it's always
2829                            added explicitly when needed */
2830                 } else {
2831                         ProcessorList::iterator o;
2832
2833                         for (o = _processors.begin(); o != _processors.end(); ++o) {
2834                                 XMLProperty const * id_prop = (*niter)->property(X_("id"));
2835                                 if (id_prop && (*o)->id() == id_prop->value()) {
2836                                         (*o)->set_state (**niter, Stateful::current_state_version);
2837                                         new_order.push_back (*o);
2838                                         break;
2839                                 }
2840                         }
2841
2842                         // If the processor (*niter) is not on the route then create it
2843
2844                         if (o == _processors.end()) {
2845
2846                                 boost::shared_ptr<Processor> processor;
2847
2848                                 if (prop->value() == "intsend") {
2849
2850                                         processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), boost::shared_ptr<Route>(), Delivery::Aux, true));
2851
2852                                 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2853                                            prop->value() == "lv2" ||
2854                                            prop->value() == "windows-vst" ||
2855                                            prop->value() == "mac-vst" ||
2856                                            prop->value() == "lxvst" ||
2857                                            prop->value() == "luaproc" ||
2858                                            prop->value() == "audiounit") {
2859
2860                                         if (_session.get_disable_all_loaded_plugins ()) {
2861                                                 processor.reset (new UnknownProcessor (_session, **niter));
2862                                         } else {
2863                                                 processor.reset (new PluginInsert (_session));
2864                                                 processor->set_owner (this);
2865                                                 if (_strict_io) {
2866                                                         boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(processor);
2867                                                         pi->set_strict_io (true);
2868                                                 }
2869
2870                                         }
2871                                 } else if (prop->value() == "port") {
2872
2873                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
2874
2875                                 } else if (prop->value() == "send") {
2876
2877                                         processor.reset (new Send (_session, _pannable, _mute_master, Delivery::Send, true));
2878                                         boost::shared_ptr<Send> send = boost::dynamic_pointer_cast<Send> (processor);
2879                                         send->SelfDestruct.connect_same_thread (*this,
2880                                                         boost::bind (&Route::processor_selfdestruct, this, boost::weak_ptr<Processor> (processor)));
2881
2882                                 } else {
2883                                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2884                                         continue;
2885                                 }
2886
2887                                 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2888                                         /* This processor could not be configured.  Turn it into a UnknownProcessor */
2889                                         processor.reset (new UnknownProcessor (_session, **niter));
2890                                 }
2891
2892                                 /* subscribe to Sidechain IO changes */
2893                                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (processor);
2894                                 if (pi && pi->has_sidechain ()) {
2895                                         pi->sidechain_input ()->changed.connect_same_thread (*this, boost::bind (&Route::sidechain_change_handler, this, _1, _2));
2896                                 }
2897
2898                                 /* we have to note the monitor send here, otherwise a new one will be created
2899                                    and the state of this one will be lost.
2900                                 */
2901                                 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
2902                                 if (isend && isend->role() == Delivery::Listen) {
2903                                         _monitor_send = isend;
2904                                 }
2905
2906                                 /* it doesn't matter if invisible processors are added here, as they
2907                                    will be sorted out by setup_invisible_processors () shortly.
2908                                 */
2909
2910                                 new_order.push_back (processor);
2911                                 must_configure = true;
2912                         }
2913                 }
2914         }
2915
2916         {
2917                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2918                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2919                 /* re-assign _processors w/o process-lock.
2920                  * if there's an IO-processor present in _processors but
2921                  * not in new_order, it will be deleted and ~IO takes
2922                  * a process lock.
2923                  */
2924                 _processors = new_order;
2925
2926                 if (must_configure) {
2927                         configure_processors_unlocked (0, &lm);
2928                 }
2929
2930                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2931
2932                         (*i)->set_owner (this);
2933                         (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
2934
2935                         boost::shared_ptr<PluginInsert> pi;
2936
2937                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
2938                                 if (pi->has_no_inputs ()) {
2939                                         _have_internal_generator = true;
2940                                         break;
2941                                 }
2942                         }
2943                 }
2944         }
2945
2946         reset_instrument_info ();
2947         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2948         set_processor_positions ();
2949 }
2950
2951 void
2952 Route::curve_reallocate ()
2953 {
2954 //      _gain_automation_curve.finish_resize ();
2955 //      _pan_automation_curve.finish_resize ();
2956 }
2957
2958 void
2959 Route::silence (framecnt_t nframes)
2960 {
2961         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
2962         if (!lm.locked()) {
2963                 return;
2964         }
2965
2966         silence_unlocked (nframes);
2967 }
2968
2969 void
2970 Route::silence_unlocked (framecnt_t nframes)
2971 {
2972         /* Must be called with the processor lock held */
2973
2974         const framepos_t now = _session.transport_frame ();
2975
2976         if (!_silent) {
2977
2978                 _output->silence (nframes);
2979
2980                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2981                         boost::shared_ptr<PluginInsert> pi;
2982
2983                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2984                                 // skip plugins, they don't need anything when we're not active
2985                                 continue;
2986                         }
2987
2988                         (*i)->silence (nframes, now);
2989                 }
2990
2991                 if (nframes == _session.get_block_size()) {
2992                         // _silent = true;
2993                 }
2994         }
2995 }
2996
2997 void
2998 Route::add_internal_return ()
2999 {
3000         if (!_intreturn) {
3001                 _intreturn.reset (new InternalReturn (_session));
3002                 add_processor (_intreturn, PreFader);
3003         }
3004 }
3005
3006 void
3007 Route::add_send_to_internal_return (InternalSend* send)
3008 {
3009         Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3010
3011         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
3012                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
3013
3014                 if (d) {
3015                         return d->add_send (send);
3016                 }
3017         }
3018 }
3019
3020 void
3021 Route::remove_send_from_internal_return (InternalSend* send)
3022 {
3023         Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3024
3025         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
3026                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
3027
3028                 if (d) {
3029                         return d->remove_send (send);
3030                 }
3031         }
3032 }
3033
3034 void
3035 Route::enable_monitor_send ()
3036 {
3037         /* Caller must hold process lock */
3038         assert (!AudioEngine::instance()->process_lock().trylock());
3039
3040         /* master never sends to monitor section via the normal mechanism */
3041         assert (!is_master ());
3042         assert (!is_monitor ());
3043
3044         /* make sure we have one */
3045         if (!_monitor_send) {
3046                 _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), _session.monitor_out(), Delivery::Listen));
3047                 _monitor_send->set_display_to_user (false);
3048         }
3049
3050         /* set it up */
3051         configure_processors (0);
3052 }
3053
3054 /** Add an aux send to a route.
3055  *  @param route route to send to.
3056  *  @param before Processor to insert before, or 0 to insert at the end.
3057  */
3058 int
3059 Route::add_aux_send (boost::shared_ptr<Route> route, boost::shared_ptr<Processor> before)
3060 {
3061         assert (route != _session.monitor_out ());
3062
3063         {
3064                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3065
3066                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3067
3068                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
3069
3070                         if (d && d->target_route() == route) {
3071                                 /* already listening via the specified IO: do nothing */
3072                                 return 0;
3073                         }
3074                 }
3075         }
3076
3077         try {
3078
3079                 boost::shared_ptr<InternalSend> listener;
3080
3081                 {
3082                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3083                         listener.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), route, Delivery::Aux));
3084                 }
3085
3086                 add_processor (listener, before);
3087
3088         } catch (failed_constructor& err) {
3089                 return -1;
3090         }
3091
3092         return 0;
3093 }
3094
3095 void
3096 Route::remove_aux_or_listen (boost::shared_ptr<Route> route)
3097 {
3098         ProcessorStreams err;
3099         ProcessorList::iterator tmp;
3100
3101         {
3102                 Glib::Threads::RWLock::ReaderLock rl(_processor_lock);
3103
3104                 /* have to do this early because otherwise processor reconfig
3105                  * will put _monitor_send back in the list
3106                  */
3107
3108                 if (route == _session.monitor_out()) {
3109                         _monitor_send.reset ();
3110                 }
3111
3112           again:
3113                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3114
3115                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
3116
3117                         if (d && d->target_route() == route) {
3118                                 rl.release ();
3119                                 if (remove_processor (*x, &err, false) > 0) {
3120                                         rl.acquire ();
3121                                         continue;
3122                                 }
3123                                 rl.acquire ();
3124
3125                                 /* list could have been demolished while we dropped the lock
3126                                    so start over.
3127                                 */
3128                                 if (_session.engine().connected()) {
3129                                         /* i/o processors cannot be removed if the engine is not running
3130                                          * so don't live-loop in case the engine is N/A or dies
3131                                          */
3132                                         goto again;
3133                                 }
3134                         }
3135                 }
3136         }
3137 }
3138
3139 void
3140 Route::set_comment (string cmt, void *src)
3141 {
3142         _comment = cmt;
3143         comment_changed ();
3144         _session.set_dirty ();
3145 }
3146
3147 bool
3148 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
3149 {
3150         FeedRecord fr (other, via_sends_only);
3151
3152         pair<FedBy::iterator,bool> result =  _fed_by.insert (fr);
3153
3154         if (!result.second) {
3155
3156                 /* already a record for "other" - make sure sends-only information is correct */
3157                 if (!via_sends_only && result.first->sends_only) {
3158                         FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
3159                         frp->sends_only = false;
3160                 }
3161         }
3162
3163         return result.second;
3164 }
3165
3166 void
3167 Route::clear_fed_by ()
3168 {
3169         _fed_by.clear ();
3170 }
3171
3172 bool
3173 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
3174 {
3175         const FedBy& fed_by (other->fed_by());
3176
3177         for (FedBy::const_iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
3178                 boost::shared_ptr<Route> sr = f->r.lock();
3179
3180                 if (sr && (sr.get() == this)) {
3181
3182                         if (via_sends_only) {
3183                                 *via_sends_only = f->sends_only;
3184                         }
3185
3186                         return true;
3187                 }
3188         }
3189
3190         return false;
3191 }
3192
3193 IOVector
3194 Route::all_inputs () const
3195 {
3196         /* TODO, if this works as expected,
3197          * cache the IOVector and maintain it via
3198          * input_change_handler(), sidechain_change_handler() etc
3199          */
3200         IOVector ios;
3201         ios.push_back (_input);
3202
3203         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3204         for (ProcessorList::const_iterator r = _processors.begin(); r != _processors.end(); ++r) {
3205
3206                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3207                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*r);
3208                 if (pi != 0) {
3209                         assert (iop == 0);
3210                         iop = pi->sidechain();
3211                 }
3212
3213                 if (iop != 0 && iop->input()) {
3214                         ios.push_back (iop->input());
3215                 }
3216         }
3217         return ios;
3218 }
3219
3220 IOVector
3221 Route::all_outputs () const
3222 {
3223         IOVector ios;
3224         // _output is included via Delivery
3225         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3226         for (ProcessorList::const_iterator r = _processors.begin(); r != _processors.end(); ++r) {
3227                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3228                 if (iop != 0 && iop->output()) {
3229                         ios.push_back (iop->output());
3230                 }
3231         }
3232         return ios;
3233 }
3234
3235 bool
3236 Route::direct_feeds_according_to_reality (boost::shared_ptr<Route> other, bool* via_send_only)
3237 {
3238         DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
3239         if (other->all_inputs().fed_by (_output)) {
3240                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
3241                 if (via_send_only) {
3242                         *via_send_only = false;
3243                 }
3244
3245                 return true;
3246         }
3247
3248         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3249
3250         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
3251
3252                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3253                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*r);
3254                 if (pi != 0) {
3255                         assert (iop == 0);
3256                         iop = pi->sidechain();
3257                 }
3258
3259                 if (iop != 0) {
3260                         boost::shared_ptr<const IO> iop_out = iop->output();
3261                         if (other.get() == this && iop_out && iop->input() && iop_out->connected_to (iop->input())) {
3262                                 // TODO this needs a delaylines in the Insert to align connections (!)
3263                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed its own return (%2)\n", iop->name(), other->name()));
3264                                 continue;
3265                         }
3266                         if ((iop_out && other->all_inputs().fed_by (iop_out)) || iop->feeds (other)) {
3267                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
3268                                 if (via_send_only) {
3269                                         *via_send_only = true;
3270                                 }
3271                                 return true;
3272                         } else {
3273                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
3274                         }
3275                 } else {
3276                         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
3277                 }
3278
3279         }
3280
3281         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tdoes NOT feed %1\n", other->name()));
3282         return false;
3283 }
3284
3285 bool
3286 Route::direct_feeds_according_to_graph (boost::shared_ptr<Route> other, bool* via_send_only)
3287 {
3288         return _session._current_route_graph.has (shared_from_this (), other, via_send_only);
3289 }
3290
3291 bool
3292 Route::feeds_according_to_graph (boost::shared_ptr<Route> other)
3293 {
3294         return _session._current_route_graph.feeds (shared_from_this (), other);
3295 }
3296
3297 /** Called from the (non-realtime) butler thread when the transport is stopped */
3298 void
3299 Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool /*did_locate*/, bool can_flush_processors)
3300 {
3301         framepos_t now = _session.transport_frame();
3302
3303         {
3304                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3305
3306                 Automatable::transport_stopped (now);
3307
3308                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3309
3310                         if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && can_flush_processors)) {
3311                                 (*i)->flush ();
3312                         }
3313
3314                         (*i)->transport_stopped (now);
3315                 }
3316         }
3317
3318         _roll_delay = _initial_delay;
3319 }
3320
3321 void
3322 Route::input_change_handler (IOChange change, void * /*src*/)
3323 {
3324         if ((change.type & IOChange::ConfigurationChanged)) {
3325                 /* This is called with the process lock held if change
3326                    contains ConfigurationChanged
3327                 */
3328                 configure_processors (0);
3329                 _phase_control->resize (_input->n_ports().n_audio ());
3330                 io_changed (); /* EMIT SIGNAL */
3331         }
3332
3333         if (_solo_control->soloed_by_others_upstream() || _solo_isolate_control->solo_isolated_by_upstream()) {
3334                 int sbou = 0;
3335                 int ibou = 0;
3336                 boost::shared_ptr<RouteList> routes = _session.get_routes ();
3337                 if (_input->connected()) {
3338                         for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3339                                 if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3340                                         continue;
3341                                 }
3342                                 bool sends_only;
3343                                 bool does_feed = (*i)->direct_feeds_according_to_reality (shared_from_this(), &sends_only);
3344                                 if (does_feed && !sends_only) {
3345                                         if ((*i)->soloed()) {
3346                                                 ++sbou;
3347                                         }
3348                                         if ((*i)->solo_isolate_control()->solo_isolated()) {
3349                                                 ++ibou;
3350                                         }
3351                                 }
3352                         }
3353                 }
3354
3355                 int delta  = sbou - _solo_control->soloed_by_others_upstream();
3356                 int idelta = ibou - _solo_isolate_control->solo_isolated_by_upstream();
3357
3358                 if (idelta < -1) {
3359                         PBD::warning << string_compose (
3360                                         _("Invalid Solo-Isolate propagation: from:%1 new:%2 - old:%3 = delta:%4"),
3361                                         _name, ibou, _solo_isolate_control->solo_isolated_by_upstream(), idelta)
3362                                      << endmsg;
3363
3364                 }
3365
3366                 if (_solo_control->soloed_by_others_upstream()) {
3367                         // ignore new connections (they're not propagated)
3368                         if (delta <= 0) {
3369                                 _solo_control->mod_solo_by_others_upstream (delta);
3370                         }
3371                 }
3372
3373                 if (_solo_isolate_control->solo_isolated_by_upstream()) {
3374                         // solo-isolate currently only propagates downstream
3375                         if (idelta < 0) {
3376                                 _solo_isolate_control->mod_solo_isolated_by_upstream (1);
3377                         }
3378                         //_solo_isolated_by_upstream = ibou;
3379                 }
3380
3381                 // Session::route_solo_changed  does not propagate indirect solo-changes
3382                 // propagate downstream to tracks
3383                 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3384                         if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3385                                 continue;
3386                         }
3387                         bool sends_only;
3388                         bool does_feed = feeds (*i, &sends_only);
3389                         if (delta <= 0 && does_feed && !sends_only) {
3390                                 (*i)->solo_control()->mod_solo_by_others_upstream (delta);
3391                         }
3392
3393                         if (idelta < 0 && does_feed && !sends_only) {
3394                                 (*i)->solo_isolate_control()->mod_solo_isolated_by_upstream (-1);
3395                         }
3396                 }
3397         }
3398 }
3399
3400 void
3401 Route::output_change_handler (IOChange change, void * /*src*/)
3402 {
3403         if (_initial_io_setup) {
3404                 return;
3405         }
3406
3407         if ((change.type & IOChange::ConfigurationChanged)) {
3408                 /* This is called with the process lock held if change
3409                    contains ConfigurationChanged
3410                 */
3411                 configure_processors (0);
3412
3413                 if (is_master()) {
3414                         _session.reset_monitor_section();
3415                 }
3416
3417                 io_changed (); /* EMIT SIGNAL */
3418         }
3419
3420         if ((change.type & IOChange::ConnectionsChanged)) {
3421
3422                 /* do this ONLY if connections have changed. Configuration
3423                  * changes do not, by themselves alter solo upstream or
3424                  * downstream status.
3425                  */
3426
3427                 if (_solo_control->soloed_by_others_downstream()) {
3428                         int sbod = 0;
3429                         /* checking all all downstream routes for
3430                          * explicit of implict solo is a rather drastic measure,
3431                          * ideally the input_change_handler() of the other route
3432                          * would propagate the change to us.
3433                          */
3434                         boost::shared_ptr<RouteList> routes = _session.get_routes ();
3435                         if (_output->connected()) {
3436                                 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3437                                         if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3438                                                 continue;
3439                                         }
3440                                         bool sends_only;
3441                                         bool does_feed = direct_feeds_according_to_reality (*i, &sends_only);
3442                                         if (does_feed && !sends_only) {
3443                                                 if ((*i)->soloed()) {
3444                                                         ++sbod;
3445                                                         break;
3446                                                 }
3447                                         }
3448                                 }
3449                         }
3450
3451                         int delta = sbod - _solo_control->soloed_by_others_downstream();
3452                         if (delta <= 0) {
3453                                 // do not allow new connections to change implicit solo (no propagation)
3454                                 _solo_control->mod_solo_by_others_downstream (delta);
3455                                 // Session::route_solo_changed() does not propagate indirect solo-changes
3456                                 // propagate upstream to tracks
3457                                 boost::shared_ptr<Route> shared_this = shared_from_this();
3458                                 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3459                                         if ((*i).get() == this || !can_solo()) {
3460                                                 continue;
3461                                         }
3462                                         bool sends_only;
3463                                         bool does_feed = (*i)->feeds (shared_this, &sends_only);
3464                                         if (delta != 0 && does_feed && !sends_only) {
3465                                                 (*i)->solo_control()->mod_solo_by_others_downstream (delta);
3466                                         }
3467                                 }
3468
3469                         }
3470                 }
3471         }
3472 }
3473
3474 void
3475 Route::sidechain_change_handler (IOChange change, void* src)
3476 {
3477         if (_initial_io_setup || _in_sidechain_setup) {
3478                 return;
3479         }
3480
3481         input_change_handler (change, src);
3482 }
3483
3484 uint32_t
3485 Route::pans_required () const
3486 {
3487         if (n_outputs().n_audio() < 2) {
3488                 return 0;
3489         }
3490
3491         return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
3492 }
3493
3494 void
3495 Route::flush_processor_buffers_locked (framecnt_t nframes)
3496 {
3497         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3498                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery> (*i);
3499                 if (d) {
3500                         d->flush_buffers (nframes);
3501                 } else {
3502                         boost::shared_ptr<PortInsert> p = boost::dynamic_pointer_cast<PortInsert> (*i);
3503                         if (p) {
3504                                 p->flush_buffers (nframes);
3505                         }
3506                 }
3507         }
3508 }
3509
3510 int
3511 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
3512 {
3513         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3514
3515         if (!lm.locked()) {
3516                 return 0;
3517         }
3518
3519         if (n_outputs().n_total() == 0) {
3520                 return 0;
3521         }
3522
3523         if (!_active || n_inputs() == ChanCount::ZERO)  {
3524                 silence_unlocked (nframes);
3525                 return 0;
3526         }
3527
3528         if (session_state_changing) {
3529                 if (_session.transport_speed() != 0.0f) {
3530                         /* we're rolling but some state is changing (e.g. our diskstream contents)
3531                            so we cannot use them. Be silent till this is over.
3532
3533                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
3534                         */
3535                         silence_unlocked (nframes);
3536                         return 0;
3537                 }
3538                 /* we're really not rolling, so we're either delivery silence or actually
3539                    monitoring, both of which are safe to do while session_state_changing is true.
3540                 */
3541         }
3542
3543         BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
3544
3545         fill_buffers_with_input (bufs, _input, nframes);
3546
3547         if (_meter_point == MeterInput) {
3548                 _meter->run (bufs, start_frame, end_frame, 0.0, nframes, true);
3549         }
3550
3551         _amp->apply_gain_automation (false);
3552         _trim->apply_gain_automation (false);
3553         passthru (bufs, start_frame, end_frame, nframes, 0);
3554
3555         flush_processor_buffers_locked (nframes);
3556
3557         return 0;
3558 }
3559
3560 int
3561 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& /* need_butler */)
3562 {
3563         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3564         if (!lm.locked()) {
3565                 return 0;
3566         }
3567
3568         if (n_outputs().n_total() == 0) {
3569                 return 0;
3570         }
3571
3572         if (!_active || n_inputs().n_total() == 0) {
3573                 silence_unlocked (nframes);
3574                 return 0;
3575         }
3576
3577         framepos_t unused = 0;
3578
3579         if ((nframes = check_initial_delay (nframes, unused)) == 0) {
3580                 return 0;
3581         }
3582
3583         _silent = false;
3584
3585         BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
3586
3587         fill_buffers_with_input (bufs, _input, nframes);
3588
3589         if (_meter_point == MeterInput) {
3590                 _meter->run (bufs, start_frame, end_frame, 1.0, nframes, true);
3591         }
3592
3593         passthru (bufs, start_frame, end_frame, nframes, declick);
3594
3595         flush_processor_buffers_locked (nframes);
3596
3597         return 0;
3598 }
3599
3600 int
3601 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& /* need_butler */)
3602 {
3603         silence (nframes);
3604         flush_processor_buffers_locked (nframes);
3605         return 0;
3606 }
3607
3608 void
3609 Route::flush_processors ()
3610 {
3611         /* XXX shouldn't really try to take this lock, since
3612            this is called from the RT audio thread.
3613         */
3614
3615         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3616
3617         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3618                 (*i)->flush ();
3619         }
3620 }
3621
3622 #ifdef __clang__
3623 __attribute__((annotate("realtime")))
3624 #endif
3625 bool
3626 Route::apply_processor_changes_rt ()
3627 {
3628         int emissions = EmitNone;
3629
3630         if (_pending_meter_point != _meter_point) {
3631                 Glib::Threads::RWLock::WriterLock pwl (_processor_lock, Glib::Threads::TRY_LOCK);
3632                 if (pwl.locked()) {
3633                         /* meters always have buffers for 'processor_max_streams'
3634                          * they can be re-positioned without re-allocation */
3635                         if (set_meter_point_unlocked()) {
3636                                 emissions |= EmitMeterChanged | EmitMeterVisibilityChange;;
3637                         } else {
3638                                 emissions |= EmitMeterChanged;
3639                         }
3640                 }
3641         }
3642
3643         bool changed = false;
3644
3645         if (g_atomic_int_get (&_pending_process_reorder)) {
3646                 Glib::Threads::RWLock::WriterLock pwl (_processor_lock, Glib::Threads::TRY_LOCK);
3647                 if (pwl.locked()) {
3648                         apply_processor_order (_pending_processor_order);
3649                         setup_invisible_processors ();
3650                         changed = true;
3651                         g_atomic_int_set (&_pending_process_reorder, 0);
3652                         emissions |= EmitRtProcessorChange;
3653                 }
3654         }
3655         if (changed) {
3656                 set_processor_positions ();
3657         }
3658         if (emissions != 0) {
3659                 g_atomic_int_set (&_pending_signals, emissions);
3660                 return true;
3661         }
3662         return (!selfdestruct_sequence.empty ());
3663 }
3664
3665 void
3666 Route::emit_pending_signals ()
3667 {
3668         int sig = g_atomic_int_and (&_pending_signals, 0);
3669         if (sig & EmitMeterChanged) {
3670                 _meter->emit_configuration_changed();
3671                 meter_change (); /* EMIT SIGNAL */
3672                 if (sig & EmitMeterVisibilityChange) {
3673                 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, true)); /* EMIT SIGNAL */
3674                 } else {
3675                 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, false)); /* EMIT SIGNAL */
3676                 }
3677         }
3678         if (sig & EmitRtProcessorChange) {
3679                 processors_changed (RouteProcessorChange (RouteProcessorChange::RealTimeChange)); /* EMIT SIGNAL */
3680         }
3681
3682         /* this would be a job for the butler.
3683          * Conceptually we should not take processe/processor locks here.
3684          * OTOH its more efficient (less overhead for summoning the butler and
3685          * telling her what do do) and signal emission is called
3686          * directly after the process callback, which decreases the chance
3687          * of x-runs when taking the locks.
3688          */
3689         while (!selfdestruct_sequence.empty ()) {
3690                 Glib::Threads::Mutex::Lock lx (selfdestruct_lock);
3691                 if (selfdestruct_sequence.empty ()) { break; } // re-check with lock
3692                 boost::shared_ptr<Processor> proc = selfdestruct_sequence.back ().lock ();
3693                 selfdestruct_sequence.pop_back ();
3694                 lx.release ();
3695                 if (proc) {
3696                         remove_processor (proc);
3697                 }
3698         }
3699 }
3700
3701 void
3702 Route::set_meter_point (MeterPoint p, bool force)
3703 {
3704         if (_pending_meter_point == p && !force) {
3705                 return;
3706         }
3707
3708         if (force || !AudioEngine::instance()->running()) {
3709                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3710                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3711                 _pending_meter_point = p;
3712                 _meter->emit_configuration_changed();
3713                 meter_change (); /* EMIT SIGNAL */
3714                 if (set_meter_point_unlocked()) {
3715                         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, true)); /* EMIT SIGNAL */
3716                 } else {
3717                         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, false)); /* EMIT SIGNAL */
3718                 }
3719         } else {
3720                 _pending_meter_point = p;
3721         }
3722 }
3723
3724
3725 #ifdef __clang__
3726 __attribute__((annotate("realtime")))
3727 #endif
3728 bool
3729 Route::set_meter_point_unlocked ()
3730 {
3731 #ifndef NDEBUG
3732         /* Caller must hold process and processor write lock */
3733         assert (!AudioEngine::instance()->process_lock().trylock());
3734         Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3735         assert (!lm.locked ());
3736 #endif
3737
3738         _meter_point = _pending_meter_point;
3739
3740         bool meter_was_visible_to_user = _meter->display_to_user ();
3741
3742         if (!_custom_meter_position_noted) {
3743                 maybe_note_meter_position ();
3744         }
3745
3746         if (_meter_point != MeterCustom) {
3747
3748                 _meter->set_display_to_user (false);
3749
3750                 setup_invisible_processors ();
3751
3752         } else {
3753                 _meter->set_display_to_user (true);
3754
3755                 /* If we have a previous position for the custom meter, try to put it there */
3756                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
3757                 if (after) {
3758                         ProcessorList::iterator i = find (_processors.begin(), _processors.end(), after);
3759                         if (i != _processors.end ()) {
3760                                 _processors.remove (_meter);
3761                                 _processors.insert (i, _meter);
3762                         }
3763                 } else {// at end, right before the mains_out/panner
3764                         _processors.remove (_meter);
3765                         ProcessorList::iterator main = _processors.end();
3766                         _processors.insert (--main, _meter);
3767                 }
3768         }
3769
3770         /* Set up the meter for its new position */
3771
3772         ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
3773
3774         ChanCount m_in;
3775
3776         if (loc == _processors.begin()) {
3777                 m_in = _input->n_ports();
3778         } else {
3779                 ProcessorList::iterator before = loc;
3780                 --before;
3781                 m_in = (*before)->output_streams ();
3782         }
3783
3784         _meter->reflect_inputs (m_in);
3785
3786         /* we do not need to reconfigure the processors, because the meter
3787            (a) is always ready to handle processor_max_streams
3788            (b) is always an N-in/N-out processor, and thus moving
3789            it doesn't require any changes to the other processors.
3790         */
3791
3792         /* these should really be done after releasing the lock
3793          * but all those signals are subscribed to with gui_thread()
3794          * so we're safe.
3795          */
3796          return (_meter->display_to_user() != meter_was_visible_to_user);
3797 }
3798
3799 void
3800 Route::listen_position_changed ()
3801 {
3802         {
3803                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3804                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3805                 ProcessorState pstate (this);
3806
3807                 if (configure_processors_unlocked (0, &lm)) {
3808                         DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
3809                         pstate.restore ();
3810                         configure_processors_unlocked (0, &lm); // it worked before we tried to add it ...
3811                         return;
3812                 }
3813         }
3814
3815         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
3816         _session.set_dirty ();
3817 }
3818
3819 boost::shared_ptr<CapturingProcessor>
3820 Route::add_export_point()
3821 {
3822         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3823         if (!_capturing_processor) {
3824                 lm.release();
3825                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3826                 Glib::Threads::RWLock::WriterLock lw (_processor_lock);
3827
3828                 // this aligns all tracks; but not tracks + busses
3829                 assert (_session.worst_track_latency () >= _initial_delay);
3830                 _capturing_processor.reset (new CapturingProcessor (_session, _session.worst_track_latency () - _initial_delay));
3831                 _capturing_processor->activate ();
3832
3833                 configure_processors_unlocked (0, &lw);
3834
3835         }
3836
3837         return _capturing_processor;
3838 }
3839
3840 framecnt_t
3841 Route::update_signal_latency ()
3842 {
3843         framecnt_t l = _output->user_latency();
3844         framecnt_t lamp = 0;
3845         bool before_amp = true;
3846         framecnt_t ltrim = 0;
3847         bool before_trim = true;
3848
3849         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3850                 if ((*i)->active ()) {
3851                         l += (*i)->signal_latency ();
3852                 }
3853                 if ((*i) == _amp) {
3854                         before_amp = false;
3855                 }
3856                 if ((*i) == _trim) {
3857                         before_amp = false;
3858                 }
3859                 if (before_amp) {
3860                         lamp = l;
3861                 }
3862                 if (before_trim) {
3863                         lamp = l;
3864                 }
3865         }
3866
3867         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l));
3868
3869         // TODO: (lamp - _signal_latency) to sync to output (read-ahed),  currently _roll_delay shifts this around
3870         _signal_latency_at_amp_position = lamp;
3871         _signal_latency_at_trim_position = ltrim;
3872
3873         if (_signal_latency != l) {
3874                 _signal_latency = l;
3875                 signal_latency_changed (); /* EMIT SIGNAL */
3876         }
3877
3878         return _signal_latency;
3879 }
3880
3881 void
3882 Route::set_user_latency (framecnt_t nframes)
3883 {
3884         _output->set_user_latency (nframes);
3885         _session.update_latency_compensation ();
3886 }
3887
3888 void
3889 Route::set_latency_compensation (framecnt_t longest_session_latency)
3890 {
3891         framecnt_t old = _initial_delay;
3892
3893         if (_signal_latency < longest_session_latency) {
3894                 _initial_delay = longest_session_latency - _signal_latency;
3895         } else {
3896                 _initial_delay = 0;
3897         }
3898
3899         DEBUG_TRACE (DEBUG::Latency, string_compose (
3900                              "%1: compensate for maximum latency of %2,"
3901                              "given own latency of %3, using initial delay of %4\n",
3902                              name(), longest_session_latency, _signal_latency, _initial_delay));
3903
3904         if (_initial_delay != old) {
3905                 initial_delay_changed (); /* EMIT SIGNAL */
3906         }
3907
3908         if (_session.transport_stopped()) {
3909                 _roll_delay = _initial_delay;
3910         }
3911 }
3912
3913 void
3914 Route::set_block_size (pframes_t nframes)
3915 {
3916         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3917                 (*i)->set_block_size (nframes);
3918         }
3919
3920         _session.ensure_buffers (n_process_buffers ());
3921 }
3922
3923 void
3924 Route::protect_automation ()
3925 {
3926         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3927                 (*i)->protect_automation();
3928 }
3929
3930 /** @param declick 1 to set a pending declick fade-in,
3931  *                -1 to set a pending declick fade-out
3932  */
3933 void
3934 Route::set_pending_declick (int declick)
3935 {
3936         if (_declickable) {
3937                 /* this call is not allowed to turn off a pending declick */
3938                 if (declick) {
3939                         _pending_declick = declick;
3940                 }
3941         } else {
3942                 _pending_declick = 0;
3943         }
3944 }
3945
3946 /** Shift automation forwards from a particular place, thereby inserting time.
3947  *  Adds undo commands for any shifts that are performed.
3948  *
3949  * @param pos Position to start shifting from.
3950  * @param frames Amount to shift forwards by.
3951  */
3952
3953 void
3954 Route::shift (framepos_t pos, framecnt_t frames)
3955 {
3956         /* gain automation */
3957         {
3958                 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
3959
3960                 XMLNode &before = gc->alist()->get_state ();
3961                 gc->alist()->shift (pos, frames);
3962                 XMLNode &after = gc->alist()->get_state ();
3963                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3964         }
3965
3966         /* gain automation */
3967         {
3968                 boost::shared_ptr<AutomationControl> gc = _trim->gain_control();
3969
3970                 XMLNode &before = gc->alist()->get_state ();
3971                 gc->alist()->shift (pos, frames);
3972                 XMLNode &after = gc->alist()->get_state ();
3973                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3974         }
3975
3976         // TODO mute automation ??
3977
3978         /* pan automation */
3979         if (_pannable) {
3980                 ControlSet::Controls& c (_pannable->controls());
3981
3982                 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
3983                         boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
3984                         if (pc) {
3985                                 boost::shared_ptr<AutomationList> al = pc->alist();
3986                                 XMLNode& before = al->get_state ();
3987                                 al->shift (pos, frames);
3988                                 XMLNode& after = al->get_state ();
3989                                 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3990                         }
3991                 }
3992         }
3993
3994         /* redirect automation */
3995         {
3996                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3997                 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
3998
3999                         set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
4000
4001                         for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
4002                                 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
4003                                 if (ac) {
4004                                         boost::shared_ptr<AutomationList> al = ac->alist();
4005                                         XMLNode &before = al->get_state ();
4006                                         al->shift (pos, frames);
4007                                         XMLNode &after = al->get_state ();
4008                                         _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
4009                                 }
4010                         }
4011                 }
4012         }
4013 }
4014
4015 void
4016 Route::set_plugin_state_dir (boost::weak_ptr<Processor> p, const std::string& d)
4017 {
4018         boost::shared_ptr<Processor> processor (p.lock ());
4019         boost::shared_ptr<PluginInsert> pi  = boost::dynamic_pointer_cast<PluginInsert> (processor);
4020         if (!pi) {
4021                 return;
4022         }
4023         pi->set_state_dir (d);
4024 }
4025
4026 int
4027 Route::save_as_template (const string& path, const string& name)
4028 {
4029         std::string state_dir = path.substr (0, path.find_last_of ('.')); // strip template_suffix
4030         PBD::Unwinder<std::string> uw (_session._template_state_dir, state_dir);
4031
4032         XMLNode& node (state (false));
4033
4034         XMLTree tree;
4035
4036         IO::set_name_in_state (*node.children().front(), name);
4037
4038         tree.set_root (&node);
4039
4040         /* return zero on success, non-zero otherwise */
4041         return !tree.write (path.c_str());
4042 }
4043
4044
4045 bool
4046 Route::set_name (const string& str)
4047 {
4048         if (str.empty ()) {
4049                 return false;
4050         }
4051
4052         if (str == name()) {
4053                 return true;
4054         }
4055
4056         string name = Route::ensure_track_or_route_name (str, _session);
4057         SessionObject::set_name (name);
4058
4059         bool ret = (_input->set_name(name) && _output->set_name(name));
4060
4061         if (ret) {
4062                 /* rename the main outs. Leave other IO processors
4063                  * with whatever name they already have, because its
4064                  * just fine as it is (it will not contain the route
4065                  * name if its a port insert, port send or port return).
4066                  */
4067
4068                 if (_main_outs) {
4069                         if (_main_outs->set_name (name)) {
4070                                 /* XXX returning false here is stupid because
4071                                    we already changed the route name.
4072                                 */
4073                                 return false;
4074                         }
4075                 }
4076         }
4077
4078         return ret;
4079 }
4080
4081 /** Set the name of a route in an XML description.
4082  *  @param node XML <Route> node to set the name in.
4083  *  @param name New name.
4084  */
4085 void
4086 Route::set_name_in_state (XMLNode& node, string const & name, bool rename_playlist)
4087 {
4088         node.add_property (X_("name"), name);
4089
4090         XMLNodeList children = node.children();
4091         for (XMLNodeIterator i = children.begin(); i != children.end(); ++i) {
4092
4093                 if ((*i)->name() == X_("IO")) {
4094
4095                         IO::set_name_in_state (**i, name);
4096
4097                 } else if ((*i)->name() == X_("Processor")) {
4098
4099                         XMLProperty const * role = (*i)->property (X_("role"));
4100                         if (role && role->value() == X_("Main")) {
4101                                 (*i)->add_property (X_("name"), name);
4102                         }
4103
4104                 } else if ((*i)->name() == X_("Diskstream")) {
4105
4106                         if (rename_playlist) {
4107                                 (*i)->add_property (X_("playlist"), string_compose ("%1.1", name).c_str());
4108                         }
4109                         (*i)->add_property (X_("name"), name);
4110
4111                 }
4112         }
4113 }
4114
4115 boost::shared_ptr<Send>
4116 Route::internal_send_for (boost::shared_ptr<const Route> target) const
4117 {
4118         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4119
4120         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4121                 boost::shared_ptr<InternalSend> send;
4122
4123                 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
4124                         if (send->target_route() == target) {
4125                                 return send;
4126                         }
4127                 }
4128         }
4129
4130         return boost::shared_ptr<Send>();
4131 }
4132
4133 void
4134 Route::set_denormal_protection (bool yn)
4135 {
4136         if (_denormal_protection != yn) {
4137                 _denormal_protection = yn;
4138                 denormal_protection_changed (); /* EMIT SIGNAL */
4139         }
4140 }
4141
4142 bool
4143 Route::denormal_protection () const
4144 {
4145         return _denormal_protection;
4146 }
4147
4148 void
4149 Route::set_active (bool yn, void* src)
4150 {
4151         if (_session.transport_rolling()) {
4152                 return;
4153         }
4154
4155         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
4156                 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
4157                 return;
4158         }
4159
4160         if (_active != yn) {
4161                 _active = yn;
4162                 _input->set_active (yn);
4163                 _output->set_active (yn);
4164                 active_changed (); // EMIT SIGNAL
4165                 _session.set_dirty ();
4166         }
4167 }
4168
4169 boost::shared_ptr<Pannable>
4170 Route::pannable() const
4171 {
4172         return _pannable;
4173 }
4174
4175 boost::shared_ptr<Panner>
4176 Route::panner() const
4177 {
4178         /* may be null ! */
4179         return _main_outs->panner_shell()->panner();
4180 }
4181
4182 boost::shared_ptr<PannerShell>
4183 Route::panner_shell() const
4184 {
4185         return _main_outs->panner_shell();
4186 }
4187
4188 boost::shared_ptr<GainControl>
4189 Route::gain_control() const
4190 {
4191         return _gain_control;
4192 }
4193
4194 boost::shared_ptr<GainControl>
4195 Route::trim_control() const
4196 {
4197         return _trim_control;
4198 }
4199
4200 boost::shared_ptr<PhaseControl>
4201 Route::phase_control() const
4202 {
4203         return _phase_control;
4204 }
4205
4206 boost::shared_ptr<AutomationControl>
4207 Route::get_control (const Evoral::Parameter& param)
4208 {
4209         /* either we own the control or .... */
4210
4211         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
4212
4213         if (!c) {
4214
4215                 /* maybe one of our processors does or ... */
4216
4217                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
4218                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4219                         if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
4220                                 break;
4221                         }
4222                 }
4223         }
4224
4225         if (!c) {
4226
4227                 /* nobody does so we'll make a new one */
4228
4229                 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
4230                 add_control(c);
4231         }
4232
4233         return c;
4234 }
4235
4236 boost::shared_ptr<Processor>
4237 Route::nth_plugin (uint32_t n) const
4238 {
4239         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4240         ProcessorList::const_iterator i;
4241
4242         for (i = _processors.begin(); i != _processors.end(); ++i) {
4243                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
4244                         if (n-- == 0) {
4245                                 return *i;
4246                         }
4247                 }
4248         }
4249
4250         return boost::shared_ptr<Processor> ();
4251 }
4252
4253 boost::shared_ptr<Processor>
4254 Route::nth_send (uint32_t n) const
4255 {
4256         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4257         ProcessorList::const_iterator i;
4258
4259         for (i = _processors.begin(); i != _processors.end(); ++i) {
4260                 if (boost::dynamic_pointer_cast<Send> (*i)) {
4261
4262                         if ((*i)->name().find (_("Monitor")) == 0) {
4263                                 /* send to monitor section is not considered
4264                                    to be an accessible send.
4265                                 */
4266                                 continue;
4267                         }
4268
4269                         if (n-- == 0) {
4270                                 return *i;
4271                         }
4272                 }
4273         }
4274
4275         return boost::shared_ptr<Processor> ();
4276 }
4277
4278 bool
4279 Route::has_io_processor_named (const string& name)
4280 {
4281         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4282         ProcessorList::iterator i;
4283
4284         for (i = _processors.begin(); i != _processors.end(); ++i) {
4285                 if (boost::dynamic_pointer_cast<Send> (*i) ||
4286                     boost::dynamic_pointer_cast<PortInsert> (*i)) {
4287                         if ((*i)->name() == name) {
4288                                 return true;
4289                         }
4290                 }
4291         }
4292
4293         return false;
4294 }
4295
4296 void
4297 Route::set_processor_positions ()
4298 {
4299         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4300
4301         bool had_amp = false;
4302         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4303                 (*i)->set_pre_fader (!had_amp);
4304                 if (*i == _amp) {
4305                         had_amp = true;
4306                 }
4307         }
4308 }
4309
4310 /** Called when there is a proposed change to the input port count */
4311 bool
4312 Route::input_port_count_changing (ChanCount to)
4313 {
4314         list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
4315         if (c.empty()) {
4316                 /* The processors cannot be configured with the new input arrangement, so
4317                    block the change.
4318                 */
4319                 return true;
4320         }
4321
4322         /* The change is ok */
4323         return false;
4324 }
4325
4326 /** Called when there is a proposed change to the output port count */
4327 bool
4328 Route::output_port_count_changing (ChanCount to)
4329 {
4330         if (_strict_io && !_in_configure_processors) {
4331                 return true;
4332         }
4333         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
4334                 if (processor_out_streams.get(*t) > to.get(*t)) {
4335                         return true;
4336                 }
4337         }
4338         /* The change is ok */
4339         return false;
4340 }
4341
4342 list<string>
4343 Route::unknown_processors () const
4344 {
4345         list<string> p;
4346
4347         if (_session.get_disable_all_loaded_plugins ()) {
4348                 // Do not list "missing plugins" if they are explicitly disabled
4349                 return p;
4350         }
4351
4352         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4353         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4354                 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
4355                         p.push_back ((*i)->name ());
4356                 }
4357         }
4358
4359         return p;
4360 }
4361
4362
4363 framecnt_t
4364 Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecnt_t our_latency) const
4365 {
4366         /* we assume that all our input ports feed all our output ports. its not
4367            universally true, but the alternative is way too corner-case to worry about.
4368         */
4369
4370         LatencyRange all_connections;
4371
4372         if (from.empty()) {
4373                 all_connections.min = 0;
4374                 all_connections.max = 0;
4375         } else {
4376                 all_connections.min = ~((pframes_t) 0);
4377                 all_connections.max = 0;
4378
4379                 /* iterate over all "from" ports and determine the latency range for all of their
4380                    connections to the "outside" (outside of this Route).
4381                 */
4382
4383                 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
4384
4385                         LatencyRange range;
4386
4387                         p->get_connected_latency_range (range, playback);
4388
4389                         all_connections.min = min (all_connections.min, range.min);
4390                         all_connections.max = max (all_connections.max, range.max);
4391                 }
4392         }
4393
4394         /* set the "from" port latencies to the max/min range of all their connections */
4395
4396         for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
4397                 p->set_private_latency_range (all_connections, playback);
4398         }
4399
4400         /* set the ports "in the direction of the flow" to the same value as above plus our own signal latency */
4401
4402         all_connections.min += our_latency;
4403         all_connections.max += our_latency;
4404
4405         for (PortSet::iterator p = to.begin(); p != to.end(); ++p) {
4406                 p->set_private_latency_range (all_connections, playback);
4407         }
4408
4409         return all_connections.max;
4410 }
4411
4412 framecnt_t
4413 Route::set_private_port_latencies (bool playback) const
4414 {
4415         framecnt_t own_latency = 0;
4416
4417         /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD
4418            OR LATENCY CALLBACK.
4419
4420            This is called (early) from the latency callback. It computes the REAL
4421            latency associated with each port and stores the result as the "private"
4422            latency of the port. A later call to Route::set_public_port_latencies()
4423            sets all ports to the same value to reflect the fact that we do latency
4424            compensation and so all signals are delayed by the same amount as they
4425            flow through ardour.
4426         */
4427
4428         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4429                 if ((*i)->active ()) {
4430                         own_latency += (*i)->signal_latency ();
4431                 }
4432         }
4433
4434         if (playback) {
4435                 /* playback: propagate latency from "outside the route" to outputs to inputs */
4436                 return update_port_latencies (_output->ports (), _input->ports (), true, own_latency);
4437         } else {
4438                 /* capture: propagate latency from "outside the route" to inputs to outputs */
4439                 return update_port_latencies (_input->ports (), _output->ports (), false, own_latency);
4440         }
4441 }
4442
4443 void
4444 Route::set_public_port_latencies (framecnt_t value, bool playback) const
4445 {
4446         /* this is called to set the JACK-visible port latencies, which take
4447            latency compensation into account.
4448         */
4449
4450         LatencyRange range;
4451
4452         range.min = value;
4453         range.max = value;
4454
4455         {
4456                 const PortSet& ports (_input->ports());
4457                 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
4458                         p->set_public_latency_range (range, playback);
4459                 }
4460         }
4461
4462         {
4463                 const PortSet& ports (_output->ports());
4464                 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
4465                         p->set_public_latency_range (range, playback);
4466                 }
4467         }
4468 }
4469
4470 /** Put the invisible processors in the right place in _processors.
4471  *  Must be called with a writer lock on _processor_lock held.
4472  */
4473 #ifdef __clang__
4474 __attribute__((annotate("realtime")))
4475 #endif
4476 void
4477 Route::setup_invisible_processors ()
4478 {
4479 #ifndef NDEBUG
4480         Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
4481         assert (!lm.locked ());
4482 #endif
4483
4484         if (!_main_outs) {
4485                 /* too early to be doing this stuff */
4486                 return;
4487         }
4488
4489         /* we'll build this new list here and then use it
4490          *
4491          * TODO put the ProcessorList is on the stack for RT-safety.
4492          */
4493
4494         ProcessorList new_processors;
4495
4496         /* find visible processors */
4497
4498         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4499                 if ((*i)->display_to_user ()) {
4500                         new_processors.push_back (*i);
4501                 }
4502         }
4503
4504         /* find the amp */
4505
4506         ProcessorList::iterator amp = find (new_processors.begin(), new_processors.end(), _amp);
4507
4508         if (amp == new_processors.end ()) {
4509                 error << string_compose (_("Amp/Fader on Route '%1' went AWOL. Re-added."), name()) << endmsg;
4510                 new_processors.push_front (_amp);
4511                 amp = find (new_processors.begin(), new_processors.end(), _amp);
4512         }
4513
4514         /* and the processor after the amp */
4515
4516         ProcessorList::iterator after_amp = amp;
4517         ++after_amp;
4518
4519         /* METER */
4520
4521         if (_meter) {
4522                 switch (_meter_point) {
4523                 case MeterInput:
4524                         assert (!_meter->display_to_user ());
4525                         new_processors.push_front (_meter);
4526                         break;
4527                 case MeterPreFader:
4528                         assert (!_meter->display_to_user ());
4529                         new_processors.insert (amp, _meter);
4530                         break;
4531                 case MeterPostFader:
4532                         /* do nothing here */
4533                         break;
4534                 case MeterOutput:
4535                         /* do nothing here */
4536                         break;
4537                 case MeterCustom:
4538                         /* the meter is visible, so we don't touch it here */
4539                         break;
4540                 }
4541         }
4542
4543         /* MAIN OUTS */
4544
4545         assert (_main_outs);
4546         assert (!_main_outs->display_to_user ());
4547         new_processors.push_back (_main_outs);
4548
4549         /* iterator for the main outs */
4550
4551         ProcessorList::iterator main = new_processors.end();
4552         --main;
4553
4554         /* OUTPUT METERING */
4555
4556         if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
4557                 assert (!_meter->display_to_user ());
4558
4559                 /* add the processor just before or just after the main outs */
4560
4561                 ProcessorList::iterator meter_point = main;
4562
4563                 if (_meter_point == MeterOutput) {
4564                         ++meter_point;
4565                 }
4566                 new_processors.insert (meter_point, _meter);
4567         }
4568
4569         /* MONITOR SEND */
4570
4571         if (_monitor_send && !is_monitor ()) {
4572                 assert (!_monitor_send->display_to_user ());
4573                 switch (Config->get_listen_position ()) {
4574                 case PreFaderListen:
4575                         switch (Config->get_pfl_position ()) {
4576                         case PFLFromBeforeProcessors:
4577                                 new_processors.push_front (_monitor_send);
4578                                 break;
4579                         case PFLFromAfterProcessors:
4580                                 new_processors.insert (amp, _monitor_send);
4581                                 break;
4582                         }
4583                         _monitor_send->set_can_pan (false);
4584                         break;
4585                 case AfterFaderListen:
4586                         switch (Config->get_afl_position ()) {
4587                         case AFLFromBeforeProcessors:
4588                                 new_processors.insert (after_amp, _monitor_send);
4589                                 break;
4590                         case AFLFromAfterProcessors:
4591                                 new_processors.insert (new_processors.end(), _monitor_send);
4592                                 break;
4593                         }
4594                         _monitor_send->set_can_pan (true);
4595                         break;
4596                 }
4597         }
4598
4599 #if 0 // not used - just yet
4600         if (!is_master() && !is_monitor() && !is_auditioner()) {
4601                 new_processors.push_front (_delayline);
4602         }
4603 #endif
4604
4605         /* MONITOR CONTROL */
4606
4607         if (_monitor_control && is_monitor ()) {
4608                 assert (!_monitor_control->display_to_user ());
4609                 new_processors.insert (amp, _monitor_control);
4610         }
4611
4612         /* TRIM CONTROL */
4613
4614         if (_trim && _trim->active()) {
4615                 assert (!_trim->display_to_user ());
4616                 new_processors.push_front (_trim);
4617         }
4618
4619         /* INTERNAL RETURN */
4620
4621         /* doing this here means that any monitor control will come after
4622            the return and trim.
4623         */
4624
4625         if (_intreturn) {
4626                 assert (!_intreturn->display_to_user ());
4627                 new_processors.push_front (_intreturn);
4628         }
4629
4630         /* EXPORT PROCESSOR */
4631
4632         if (_capturing_processor) {
4633                 assert (!_capturing_processor->display_to_user ());
4634                 new_processors.push_front (_capturing_processor);
4635         }
4636
4637         _processors = new_processors;
4638
4639         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4640                 if (!(*i)->display_to_user () && !(*i)->enabled () && (*i) != _monitor_send) {
4641                         (*i)->enable (true);
4642                 }
4643         }
4644
4645         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
4646         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4647                 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
4648         }
4649 }
4650
4651 void
4652 Route::unpan ()
4653 {
4654         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
4655         Glib::Threads::RWLock::ReaderLock lp (_processor_lock);
4656
4657         _pannable.reset ();
4658
4659         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4660                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery>(*i);
4661                 if (d) {
4662                         d->unpan ();
4663                 }
4664         }
4665 }
4666
4667 /** If the meter point is `Custom', make a note of where the meter is.
4668  *  This is so that if the meter point is subsequently set to something else,
4669  *  and then back to custom, we can put the meter back where it was last time
4670  *  custom was enabled.
4671  *
4672  *  Must be called with the _processor_lock held.
4673  */
4674 void
4675 Route::maybe_note_meter_position ()
4676 {
4677         if (_meter_point != MeterCustom) {
4678                 return;
4679         }
4680
4681         _custom_meter_position_noted = true;
4682         /* custom meter points range from after trim to before panner/main_outs
4683          * this is a limitation by the current processor UI
4684          */
4685         bool seen_trim = false;
4686         _processor_after_last_custom_meter.reset();
4687         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4688                 if ((*i) == _trim) {
4689                         seen_trim = true;
4690                 }
4691                 if ((*i) == _main_outs) {
4692                         _processor_after_last_custom_meter = *i;
4693                         break;
4694                 }
4695                 if (boost::dynamic_pointer_cast<PeakMeter> (*i)) {
4696                         if (!seen_trim) {
4697                                 _processor_after_last_custom_meter = _trim;
4698                         } else {
4699                                 ProcessorList::iterator j = i;
4700                                 ++j;
4701                                 assert(j != _processors.end ()); // main_outs should be before
4702                                 _processor_after_last_custom_meter = *j;
4703                         }
4704                         break;
4705                 }
4706         }
4707         assert(_processor_after_last_custom_meter.lock());
4708 }
4709
4710 boost::shared_ptr<Processor>
4711 Route::processor_by_id (PBD::ID id) const
4712 {
4713         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4714         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4715                 if ((*i)->id() == id) {
4716                         return *i;
4717                 }
4718         }
4719
4720         return boost::shared_ptr<Processor> ();
4721 }
4722
4723 /** @return the monitoring state, or in other words what data we are pushing
4724  *  into the route (data from the inputs, data from disk or silence)
4725  */
4726 MonitorState
4727 Route::monitoring_state () const
4728 {
4729         return MonitoringInput;
4730 }
4731
4732 /** @return what we should be metering; either the data coming from the input
4733  *  IO or the data that is flowing through the route.
4734  */
4735 MeterState
4736 Route::metering_state () const
4737 {
4738         return MeteringRoute;
4739 }
4740
4741 bool
4742 Route::has_external_redirects () const
4743 {
4744         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4745
4746                 /* ignore inactive processors and obviously ignore the main
4747                  * outs since everything has them and we don't care.
4748                  */
4749
4750                 if ((*i)->active() && (*i) != _main_outs && (*i)->does_routing()) {
4751                         return true;;
4752                 }
4753         }
4754
4755         return false;
4756 }
4757
4758 boost::shared_ptr<Processor>
4759 Route::the_instrument () const
4760 {
4761         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4762         return the_instrument_unlocked ();
4763 }
4764
4765 boost::shared_ptr<Processor>
4766 Route::the_instrument_unlocked () const
4767 {
4768         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4769                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*i);
4770                 if (pi && pi->plugin ()->get_info ()->is_instrument ()) {
4771                         return (*i);
4772                 }
4773         }
4774         return boost::shared_ptr<Processor>();
4775 }
4776
4777
4778
4779 void
4780 Route::non_realtime_locate (framepos_t pos)
4781 {
4782         if (_pannable) {
4783                 _pannable->transport_located (pos);
4784         }
4785
4786         if (_delayline.get()) {
4787                 _delayline.get()->flush();
4788         }
4789
4790         {
4791                 //Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
4792                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4793
4794                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4795                         (*i)->transport_located (pos);
4796                 }
4797         }
4798         _roll_delay = _initial_delay;
4799 }
4800
4801 void
4802 Route::fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes)
4803 {
4804         size_t n_buffers;
4805         size_t i;
4806
4807         /* MIDI
4808          *
4809          * We don't currently mix MIDI input together, so we don't need the
4810          * complex logic of the audio case.
4811          */
4812
4813         n_buffers = bufs.count().n_midi ();
4814
4815         for (i = 0; i < n_buffers; ++i) {
4816
4817                 boost::shared_ptr<MidiPort> source_port = io->midi (i);
4818                 MidiBuffer& buf (bufs.get_midi (i));
4819
4820                 if (source_port) {
4821                         buf.copy (source_port->get_midi_buffer(nframes));
4822                 } else {
4823                         buf.silence (nframes);
4824                 }
4825         }
4826
4827         /* AUDIO */
4828
4829         n_buffers = bufs.count().n_audio();
4830
4831         size_t n_ports = io->n_ports().n_audio();
4832         float scaling = 1.0f;
4833
4834         if (n_ports > n_buffers) {
4835                 scaling = ((float) n_buffers) / n_ports;
4836         }
4837
4838         for (i = 0; i < n_ports; ++i) {
4839
4840                 /* if there are more ports than buffers, map them onto buffers
4841                  * in a round-robin fashion
4842                  */
4843
4844                 boost::shared_ptr<AudioPort> source_port = io->audio (i);
4845                 AudioBuffer& buf (bufs.get_audio (i%n_buffers));
4846
4847
4848                 if (i < n_buffers) {
4849
4850                         /* first time through just copy a channel into
4851                            the output buffer.
4852                         */
4853
4854                         buf.read_from (source_port->get_audio_buffer (nframes), nframes);
4855
4856                         if (scaling != 1.0f) {
4857                                 buf.apply_gain (scaling, nframes);
4858                         }
4859
4860                 } else {
4861
4862                         /* on subsequent times around, merge data from
4863                          * the port with what is already there
4864                          */
4865
4866                         if (scaling != 1.0f) {
4867                                 buf.accumulate_with_gain_from (source_port->get_audio_buffer (nframes), nframes, 0, scaling);
4868                         } else {
4869                                 buf.accumulate_from (source_port->get_audio_buffer (nframes), nframes);
4870                         }
4871                 }
4872         }
4873
4874         /* silence any remaining buffers */
4875
4876         for (; i < n_buffers; ++i) {
4877                 AudioBuffer& buf (bufs.get_audio (i));
4878                 buf.silence (nframes);
4879         }
4880
4881         /* establish the initial setup of the buffer set, reflecting what was
4882            copied into it. unless, of course, we are the auditioner, in which
4883            case nothing was fed into it from the inputs at all.
4884         */
4885
4886         if (!is_auditioner()) {
4887                 bufs.set_count (io->n_ports());
4888         }
4889 }
4890
4891 boost::shared_ptr<AutomationControl>
4892 Route::pan_azimuth_control() const
4893 {
4894 #ifdef MIXBUS
4895         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
4896         if (!plug) {
4897                 return boost::shared_ptr<AutomationControl>();
4898         }
4899         const uint32_t port_channel_post_pan = 2; // gtk2_ardour/mixbus_ports.h
4900         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_channel_post_pan)));
4901 #else
4902         if (!_pannable || !panner()) {
4903                 return boost::shared_ptr<AutomationControl>();
4904         }
4905         return _pannable->pan_azimuth_control;
4906 #endif
4907 }
4908
4909 boost::shared_ptr<AutomationControl>
4910 Route::pan_elevation_control() const
4911 {
4912         if (Profile->get_mixbus() || !_pannable || !panner()) {
4913                 return boost::shared_ptr<AutomationControl>();
4914         }
4915
4916         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
4917
4918         if (c.find (PanElevationAutomation) != c.end()) {
4919                 return _pannable->pan_elevation_control;
4920         } else {
4921                 return boost::shared_ptr<AutomationControl>();
4922         }
4923 }
4924 boost::shared_ptr<AutomationControl>
4925 Route::pan_width_control() const
4926 {
4927         if (Profile->get_mixbus() || !_pannable || !panner()) {
4928                 return boost::shared_ptr<AutomationControl>();
4929         }
4930
4931         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
4932
4933         if (c.find (PanWidthAutomation) != c.end()) {
4934                 return _pannable->pan_width_control;
4935         } else {
4936                 return boost::shared_ptr<AutomationControl>();
4937         }
4938 }
4939 boost::shared_ptr<AutomationControl>
4940 Route::pan_frontback_control() const
4941 {
4942         if (Profile->get_mixbus() || !_pannable || !panner()) {
4943                 return boost::shared_ptr<AutomationControl>();
4944         }
4945
4946         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
4947
4948         if (c.find (PanFrontBackAutomation) != c.end()) {
4949                 return _pannable->pan_frontback_control;
4950         } else {
4951                 return boost::shared_ptr<AutomationControl>();
4952         }
4953 }
4954 boost::shared_ptr<AutomationControl>
4955 Route::pan_lfe_control() const
4956 {
4957         if (Profile->get_mixbus() || !_pannable || !panner()) {
4958                 return boost::shared_ptr<AutomationControl>();
4959         }
4960
4961         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
4962
4963         if (c.find (PanLFEAutomation) != c.end()) {
4964                 return _pannable->pan_lfe_control;
4965         } else {
4966                 return boost::shared_ptr<AutomationControl>();
4967         }
4968 }
4969
4970 uint32_t
4971 Route::eq_band_cnt () const
4972 {
4973         if (Profile->get_mixbus()) {
4974 #ifdef MIXBUS32C
4975                 if (is_master() || mixbus()) {
4976                         return 3;
4977                 } else {
4978                         return 4;
4979                 }
4980 #else
4981                 return 3;
4982 #endif
4983         } else {
4984                 /* Ardour has no well-known EQ object */
4985                 return 0;
4986         }
4987 }
4988
4989 boost::shared_ptr<AutomationControl>
4990 Route::eq_gain_controllable (uint32_t band) const
4991 {
4992 #ifdef MIXBUS
4993         boost::shared_ptr<PluginInsert> eq = ch_eq();
4994
4995         if (!eq) {
4996                 return boost::shared_ptr<AutomationControl>();
4997         }
4998
4999         uint32_t port_number;
5000         if (is_master() || mixbus()) {
5001                 switch (band) {
5002                         case 0: port_number = 4; break;
5003                         case 1: port_number = 3; break;
5004                         case 2: port_number = 2; break;
5005                         default:
5006                                 return boost::shared_ptr<AutomationControl>();
5007                 }
5008         } else {
5009 #ifdef MIXBUS32C
5010                 switch (band) {
5011                         case 0: port_number = 14; break;
5012                         case 1: port_number = 12; break;
5013                         case 2: port_number = 10; break;
5014                         case 3: port_number =  8; break;
5015                         default:
5016                                 return boost::shared_ptr<AutomationControl>();
5017                 }
5018 #else
5019                 switch (band) {
5020                         case 0: port_number = 8; break;
5021                         case 1: port_number = 6; break;
5022                         case 2: port_number = 4; break;
5023                         default:
5024                                 return boost::shared_ptr<AutomationControl>();
5025                 }
5026 #endif
5027         }
5028
5029         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_number)));
5030 #else
5031         return boost::shared_ptr<AutomationControl>();
5032 #endif
5033 }
5034 boost::shared_ptr<AutomationControl>
5035 Route::eq_freq_controllable (uint32_t band) const
5036 {
5037 #ifdef MIXBUS
5038         if (mixbus() || is_master()) {
5039                 /* no frequency controls for mixbusses or master */
5040                 return boost::shared_ptr<AutomationControl>();
5041         }
5042
5043         boost::shared_ptr<PluginInsert> eq = ch_eq();
5044
5045         if (!eq) {
5046                 return boost::shared_ptr<AutomationControl>();
5047         }
5048
5049         uint32_t port_number;
5050 #ifdef MIXBUS32C
5051         switch (band) {
5052                 case 0: port_number = 13; break;
5053                 case 1: port_number = 11; break;
5054                 case 2: port_number = 9; break;
5055                 case 3: port_number = 7; break;
5056                 default:
5057                         return boost::shared_ptr<AutomationControl>();
5058         }
5059 #else
5060         switch (band) {
5061                 case 0: port_number = 7; break;
5062                 case 1: port_number = 5; break;
5063                 case 2: port_number = 3; break;
5064                 default:
5065                         return boost::shared_ptr<AutomationControl>();
5066         }
5067 #endif
5068
5069         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_number)));
5070 #else
5071         return boost::shared_ptr<AutomationControl>();
5072 #endif
5073 }
5074
5075 boost::shared_ptr<AutomationControl>
5076 Route::eq_q_controllable (uint32_t band) const
5077 {
5078         return boost::shared_ptr<AutomationControl>();
5079 }
5080
5081 boost::shared_ptr<AutomationControl>
5082 Route::eq_shape_controllable (uint32_t band) const
5083 {
5084         return boost::shared_ptr<AutomationControl>();
5085 }
5086
5087 boost::shared_ptr<AutomationControl>
5088 Route::eq_enable_controllable () const
5089 {
5090 #ifdef MIXBUS
5091         boost::shared_ptr<PluginInsert> eq = ch_eq();
5092
5093         if (!eq) {
5094                 return boost::shared_ptr<AutomationControl>();
5095         }
5096
5097         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 1)));
5098 #else
5099         return boost::shared_ptr<AutomationControl>();
5100 #endif
5101 }
5102
5103 boost::shared_ptr<AutomationControl>
5104 Route::eq_hpf_controllable () const
5105 {
5106 #ifdef MIXBUS
5107         boost::shared_ptr<PluginInsert> eq = ch_eq();
5108
5109         if (is_master() || mixbus() || !eq) {
5110                 return boost::shared_ptr<AutomationControl>();
5111         }
5112 #ifdef MIXBUS32C
5113         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 3)));
5114 #else
5115         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
5116 #endif
5117
5118 #else
5119         return boost::shared_ptr<AutomationControl>();
5120 #endif
5121 }
5122
5123 string
5124 Route::eq_band_name (uint32_t band) const
5125 {
5126 #ifdef MIXBUS32C
5127         if (is_master() || mixbus()) {
5128 #endif
5129         if (Profile->get_mixbus()) {
5130                 switch (band) {
5131                         case 0: return _("lo");
5132                         case 1: return _("mid");
5133                         case 2: return _("hi");
5134                         default: return string();
5135                 }
5136         } else {
5137                 return string ();
5138         }
5139 #ifdef MIXBUS32C
5140         } else {
5141                 switch (band) {
5142                         case 0: return _("lo");
5143                         case 1: return _("lo mid");
5144                         case 2: return _("hi mid");
5145                         case 3: return _("hi");
5146                         default: return string();
5147                 }
5148         }
5149 #endif
5150 }
5151
5152 boost::shared_ptr<AutomationControl>
5153 Route::comp_enable_controllable () const
5154 {
5155 #ifdef MIXBUS
5156         boost::shared_ptr<PluginInsert> comp = ch_comp();
5157
5158         if (!comp) {
5159                 return boost::shared_ptr<AutomationControl>();
5160         }
5161
5162         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 1)));
5163 #else
5164         return boost::shared_ptr<AutomationControl>();
5165 #endif
5166 }
5167 boost::shared_ptr<AutomationControl>
5168 Route::comp_threshold_controllable () const
5169 {
5170 #ifdef MIXBUS
5171         boost::shared_ptr<PluginInsert> comp = ch_comp();
5172
5173         if (!comp) {
5174                 return boost::shared_ptr<AutomationControl>();
5175         }
5176
5177         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
5178
5179 #else
5180         return boost::shared_ptr<AutomationControl>();
5181 #endif
5182 }
5183 boost::shared_ptr<AutomationControl>
5184 Route::comp_speed_controllable () const
5185 {
5186 #ifdef MIXBUS
5187         boost::shared_ptr<PluginInsert> comp = ch_comp();
5188
5189         if (!comp) {
5190                 return boost::shared_ptr<AutomationControl>();
5191         }
5192
5193         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 3)));
5194 #else
5195         return boost::shared_ptr<AutomationControl>();
5196 #endif
5197 }
5198 boost::shared_ptr<AutomationControl>
5199 Route::comp_mode_controllable () const
5200 {
5201 #ifdef MIXBUS
5202         boost::shared_ptr<PluginInsert> comp = ch_comp();
5203
5204         if (!comp) {
5205                 return boost::shared_ptr<AutomationControl>();
5206         }
5207
5208         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 4)));
5209 #else
5210         return boost::shared_ptr<AutomationControl>();
5211 #endif
5212 }
5213 boost::shared_ptr<AutomationControl>
5214 Route::comp_makeup_controllable () const
5215 {
5216 #ifdef MIXBUS
5217         boost::shared_ptr<PluginInsert> comp = ch_comp();
5218
5219         if (!comp) {
5220                 return boost::shared_ptr<AutomationControl>();
5221         }
5222
5223         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 5)));
5224 #else
5225         return boost::shared_ptr<AutomationControl>();
5226 #endif
5227 }
5228 boost::shared_ptr<ReadOnlyControl>
5229 Route::comp_redux_controllable () const
5230 {
5231 #ifdef MIXBUS
5232         boost::shared_ptr<PluginInsert> comp = ch_comp();
5233
5234         if (!comp) {
5235                 return boost::shared_ptr<ReadOnlyControl>();
5236         }
5237         if (is_master()) {
5238                 return comp->control_output (2);
5239         } else {
5240                 return comp->control_output (6);
5241         }
5242
5243 #else
5244         return boost::shared_ptr<ReadOnlyControl>();
5245 #endif
5246 }
5247
5248 string
5249 Route::comp_mode_name (uint32_t mode) const
5250 {
5251 #ifdef MIXBUS
5252         switch (mode) {
5253         case 0:
5254                 return _("Leveler");
5255         case 1:
5256                 return _("Compressor");
5257         case 2:
5258                 return _("Limiter");
5259         case 3:
5260                 return mixbus() ? _("Sidechain") : _("Limiter");
5261         }
5262
5263         return _("???");
5264 #else
5265         return _("???");
5266 #endif
5267 }
5268
5269 string
5270 Route::comp_speed_name (uint32_t mode) const
5271 {
5272 #ifdef MIXBUS
5273         switch (mode) {
5274         case 0:
5275                 return _("Attk");
5276         case 1:
5277                 return _("Ratio");
5278         case 2:
5279         case 3:
5280                 return _("Rels");
5281         }
5282         return _("???");
5283 #else
5284         return _("???");
5285 #endif
5286 }
5287
5288 boost::shared_ptr<AutomationControl>
5289 Route::send_level_controllable (uint32_t n) const
5290 {
5291 #ifdef  MIXBUS
5292         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5293         if (!plug) {
5294                 return boost::shared_ptr<AutomationControl>();
5295         }
5296
5297         if (n >= 8) {
5298                 /* no such bus */
5299                 return boost::shared_ptr<AutomationControl>();
5300         }
5301
5302         const uint32_t port_id = port_channel_post_aux1_level + (2*n); // gtk2_ardour/mixbus_ports.h
5303         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_id)));
5304 #else
5305         boost::shared_ptr<Send> s = boost::dynamic_pointer_cast<Send>(nth_send (n));
5306         if (!s) {
5307                 return boost::shared_ptr<AutomationControl>();
5308         }
5309         return s->gain_control ();
5310 #endif
5311 }
5312
5313 boost::shared_ptr<AutomationControl>
5314 Route::send_enable_controllable (uint32_t n) const
5315 {
5316 #ifdef  MIXBUS
5317         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5318         if (!plug) {
5319                 return boost::shared_ptr<AutomationControl>();
5320         }
5321
5322         if (n >= 8) {
5323                 /* no such bus */
5324                 return boost::shared_ptr<AutomationControl>();
5325         }
5326
5327         const uint32_t port_id = port_channel_post_aux1_asgn + (2*n); // gtk2_ardour/mixbus_ports.h
5328         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_id)));
5329 #else
5330         /* although Ardour sends have enable/disable as part of the Processor
5331            API, it is not exposed as a controllable.
5332
5333            XXX: we should fix this.
5334         */
5335         return boost::shared_ptr<AutomationControl>();
5336 #endif
5337 }
5338
5339 string
5340 Route::send_name (uint32_t n) const
5341 {
5342 #ifdef MIXBUS
5343         if (n >= 8) {
5344                 return string();
5345         }
5346         boost::shared_ptr<Route> r = _session.get_mixbus (n);
5347         assert (r);
5348         return r->name();
5349 #else
5350         boost::shared_ptr<Processor> p = nth_send (n);
5351         if (p) {
5352                 return p->name();
5353         } else {
5354                 return string();
5355         }
5356 #endif
5357 }
5358
5359 boost::shared_ptr<AutomationControl>
5360 Route::master_send_enable_controllable () const
5361 {
5362 #ifdef  MIXBUS
5363         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5364         if (!plug) {
5365                 return boost::shared_ptr<AutomationControl>();
5366         }
5367         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_channel_post_mstr_assign)));
5368 #else
5369         return boost::shared_ptr<AutomationControl>();
5370 #endif
5371 }
5372
5373 bool
5374 Route::slaved () const
5375 {
5376         if (!_gain_control) {
5377                 return false;
5378         }
5379         /* just test one particular control, not all of them */
5380         return _gain_control->slaved ();
5381 }
5382
5383 bool
5384 Route::slaved_to (boost::shared_ptr<VCA> vca) const
5385 {
5386         if (!vca || !_gain_control) {
5387                 return false;
5388         }
5389
5390         /* just test one particular control, not all of them */
5391
5392         return _gain_control->slaved_to (vca->gain_control());
5393 }
5394
5395 bool
5396 Route::muted_by_others_soloing () const
5397 {
5398         if (!can_be_muted_by_others ()) {
5399                 return false;
5400         }
5401
5402         return  _session.soloing() && !_solo_control->soloed() && !_solo_isolate_control->solo_isolated();
5403 }
5404
5405 void
5406 Route::clear_all_solo_state ()
5407 {
5408         _solo_control->clear_all_solo_state ();
5409 }