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