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