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