libs/ardour/route.cc

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