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 || Profile->get_mixbus ())) {
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<IOProcessor> iop;
2203                 boost::shared_ptr<PluginInsert> pi;
2204                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
2205                         /* plugins connected via Split or Hide Match may have more channels.
2206                          * route/scratch buffers are needed for all of them
2207                          * The configuration may only be a subset (both input and output)
2208                          */
2209                         processor_max_streams = ChanCount::max(processor_max_streams, pi->required_buffers());
2210                 }
2211                 else if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*p)) != 0) {
2212                         processor_max_streams = ChanCount::max(processor_max_streams, iop->natural_input_streams());
2213                         processor_max_streams = ChanCount::max(processor_max_streams, iop->natural_output_streams());
2214                 }
2215                 out = c->second;
2216
2217                 if (boost::dynamic_pointer_cast<Delivery> (*p)
2218                                 && boost::dynamic_pointer_cast<Delivery> (*p)->role() == Delivery::Main) {
2219                         /* main delivery will increase port count to match input.
2220                          * the Delivery::Main is usually the last processor - followed only by
2221                          * 'MeterOutput'.
2222                          */
2223                         seen_mains_out = true;
2224                 }
2225                 if (!seen_mains_out) {
2226                         processor_out_streams = out;
2227                 }
2228         }
2229
2230
2231         if (_meter) {
2232                 _meter->set_max_channels (processor_max_streams);
2233         }
2234
2235         /* make sure we have sufficient scratch buffers to cope with the new processor
2236            configuration
2237         */
2238         _session.ensure_buffers (n_process_buffers ());
2239
2240         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
2241
2242         _in_configure_processors = false;
2243         return 0;
2244 }
2245
2246 /** Set all visible processors to a given active state (except Fader, whose state is not changed)
2247  *  @param state New active state for those processors.
2248  */
2249 void
2250 Route::all_visible_processors_active (bool state)
2251 {
2252         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2253
2254         if (_processors.empty()) {
2255                 return;
2256         }
2257
2258         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2259                 if (!(*i)->display_to_user() || boost::dynamic_pointer_cast<Amp> (*i)) {
2260                         continue;
2261                 }
2262
2263                 if (state) {
2264                         (*i)->activate ();
2265                 } else {
2266                         (*i)->deactivate ();
2267                 }
2268         }
2269
2270         _session.set_dirty ();
2271 }
2272
2273 bool
2274 Route::processors_reorder_needs_configure (const ProcessorList& new_order)
2275 {
2276         /* check if re-order requires re-configuration of any processors
2277          * -> compare channel configuration for all processors
2278          */
2279         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2280         ChanCount c = input_streams ();
2281
2282         for (ProcessorList::const_iterator j = new_order.begin(); j != new_order.end(); ++j) {
2283                 bool found = false;
2284                 if (c != (*j)->input_streams()) {
2285                         return true;
2286                 }
2287                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2288                         if (*i == *j) {
2289                                 found = true;
2290                                 if ((*i)->input_streams() != c) {
2291                                         return true;
2292                                 }
2293                                 c = (*i)->output_streams();
2294                                 break;
2295                         }
2296                 }
2297                 if (!found) {
2298                         return true;
2299                 }
2300         }
2301         return false;
2302 }
2303
2304 #ifdef __clang__
2305 __attribute__((annotate("realtime")))
2306 #endif
2307 void
2308 Route::apply_processor_order (const ProcessorList& new_order)
2309 {
2310         /* need to hold processor_lock; either read or write lock
2311          * and the engine process_lock.
2312          * Due to r/w lock ambiguity we can only assert the latter
2313          */
2314         assert (!AudioEngine::instance()->process_lock().trylock());
2315
2316
2317         /* "new_order" is an ordered list of processors to be positioned according to "placement".
2318          * NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
2319          * processors in the current actual processor list that are hidden. Any visible processors
2320          *  in the current list but not in "new_order" will be assumed to be deleted.
2321          */
2322
2323         /* "as_it_will_be" and "_processors" are lists of shared pointers.
2324          * actual memory usage is small, but insert/erase is not actually rt-safe :(
2325          * (note though that  ::processors_reorder_needs_configure() ensured that
2326          * this function will only ever be called from the rt-thread if no processor were removed)
2327          *
2328          * either way, I can't proove it, but an x-run due to re-order here is less likley
2329          * than an x-run-less 'ardour-silent cycle' both of which effectively "click".
2330          */
2331
2332         ProcessorList as_it_will_be;
2333         ProcessorList::iterator oiter;
2334         ProcessorList::const_iterator niter;
2335
2336         oiter = _processors.begin();
2337         niter = new_order.begin();
2338
2339         while (niter !=  new_order.end()) {
2340
2341                 /* if the next processor in the old list is invisible (i.e. should not be in the new order)
2342                    then append it to the temp list.
2343
2344                    Otherwise, see if the next processor in the old list is in the new list. if not,
2345                    its been deleted. If its there, append it to the temp list.
2346                    */
2347
2348                 if (oiter == _processors.end()) {
2349
2350                         /* no more elements in the old list, so just stick the rest of
2351                            the new order onto the temp list.
2352                            */
2353
2354                         as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
2355                         while (niter != new_order.end()) {
2356                                 ++niter;
2357                         }
2358                         break;
2359
2360                 } else {
2361
2362                         if (!(*oiter)->display_to_user()) {
2363
2364                                 as_it_will_be.push_back (*oiter);
2365
2366                         } else {
2367
2368                                 /* visible processor: check that its in the new order */
2369
2370                                 if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
2371                                         /* deleted: do nothing, shared_ptr<> will clean up */
2372                                 } else {
2373                                         /* ignore this one, and add the next item from the new order instead */
2374                                         as_it_will_be.push_back (*niter);
2375                                         ++niter;
2376                                 }
2377                         }
2378
2379                         /* now remove from old order - its taken care of no matter what */
2380                         oiter = _processors.erase (oiter);
2381                 }
2382
2383         }
2384         _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
2385
2386         /* If the meter is in a custom position, find it and make a rough note of its position */
2387         maybe_note_meter_position ();
2388 }
2389
2390 int
2391 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
2392 {
2393         // it a change is already queued, wait for it
2394         // (unless engine is stopped. apply immediately and proceed
2395         while (g_atomic_int_get (&_pending_process_reorder)) {
2396                 if (!AudioEngine::instance()->running()) {
2397                         DEBUG_TRACE (DEBUG::Processors, "offline apply queued processor re-order.\n");
2398                         Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2399
2400                         apply_processor_order(_pending_processor_order);
2401                         setup_invisible_processors ();
2402
2403                         g_atomic_int_set (&_pending_process_reorder, 0);
2404
2405                         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2406                         set_processor_positions ();
2407                 } else {
2408                         // TODO rather use a semaphore or something.
2409                         // but since ::reorder_processors() is called
2410                         // from the GUI thread, this is fine..
2411                         Glib::usleep(500);
2412                 }
2413         }
2414
2415         if (processors_reorder_needs_configure (new_order) || !AudioEngine::instance()->running()) {
2416
2417                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2418                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2419                 ProcessorState pstate (this);
2420
2421                 apply_processor_order (new_order);
2422
2423                 if (configure_processors_unlocked (err)) {
2424                         pstate.restore ();
2425                         return -1;
2426                 }
2427
2428                 lm.release();
2429                 lx.release();
2430
2431                 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2432                 set_processor_positions ();
2433
2434         } else {
2435                 DEBUG_TRACE (DEBUG::Processors, "Queue clickless processor re-order.\n");
2436                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2437
2438                 // _pending_processor_order is protected by _processor_lock
2439                 _pending_processor_order = new_order;
2440                 g_atomic_int_set (&_pending_process_reorder, 1);
2441         }
2442
2443         return 0;
2444 }
2445
2446 bool
2447 Route::add_remove_sidechain (boost::shared_ptr<Processor> proc, bool add)
2448 {
2449         boost::shared_ptr<PluginInsert> pi;
2450         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
2451                 return false;
2452         }
2453
2454         if (pi->has_sidechain () == add) {
2455                 return true; // ?? call failed, but result is as expected.
2456         }
2457
2458         {
2459                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2460                 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), proc);
2461                 if (i == _processors.end ()) {
2462                         return false;
2463                 }
2464         }
2465
2466         {
2467                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ()); // take before Writerlock to avoid deadlock
2468                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2469                 PBD::Unwinder<bool> uw (_in_sidechain_setup, true);
2470
2471                 lx.release (); // IO::add_port() and ~IO takes process lock  - XXX check if this is safe
2472                 if (add) {
2473                         if (!pi->add_sidechain ()) {
2474                                 return false;
2475                         }
2476                 } else {
2477                         if (!pi->del_sidechain ()) {
2478                                 return false;
2479                         }
2480                 }
2481
2482                 lx.acquire ();
2483                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2484                 lx.release ();
2485
2486                 if (c.empty()) {
2487                         if (add) {
2488                                 pi->del_sidechain ();
2489                         } else {
2490                                 pi->add_sidechain ();
2491                                 // TODO restore side-chain's state.
2492                         }
2493                         return false;
2494                 }
2495                 lx.acquire ();
2496                 configure_processors_unlocked (0);
2497         }
2498
2499         if (pi->has_sidechain ()) {
2500                 pi->sidechain_input ()->changed.connect_same_thread (*this, boost::bind (&Route::sidechain_change_handler, this, _1, _2));
2501         }
2502
2503         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2504         _session.set_dirty ();
2505         return true;
2506 }
2507
2508 bool
2509 Route::plugin_preset_output (boost::shared_ptr<Processor> proc, ChanCount outs)
2510 {
2511         boost::shared_ptr<PluginInsert> pi;
2512         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
2513                 return false;
2514         }
2515
2516         {
2517                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2518                 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), proc);
2519                 if (i == _processors.end ()) {
2520                         return false;
2521                 }
2522         }
2523
2524         {
2525                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2526                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2527
2528                 const ChanCount& old (pi->preset_out ());
2529                 if (!pi->set_preset_out (outs)) {
2530                         return true; // no change, OK
2531                 }
2532
2533                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2534                 if (c.empty()) {
2535                         /* not possible */
2536                         pi->set_preset_out (old);
2537                         return false;
2538                 }
2539                 configure_processors_unlocked (0);
2540         }
2541
2542         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2543         _session.set_dirty ();
2544         return true;
2545 }
2546
2547 bool
2548 Route::reset_plugin_insert (boost::shared_ptr<Processor> proc)
2549 {
2550         ChanCount unused;
2551         return customize_plugin_insert (proc, 0, unused);
2552 }
2553
2554 bool
2555 Route::customize_plugin_insert (boost::shared_ptr<Processor> proc, uint32_t count, ChanCount outs)
2556 {
2557         boost::shared_ptr<PluginInsert> pi;
2558         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
2559                 return false;
2560         }
2561
2562         {
2563                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2564                 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), proc);
2565                 if (i == _processors.end ()) {
2566                         return false;
2567                 }
2568         }
2569
2570         {
2571                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2572                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2573
2574                 bool      old_cust = pi->custom_cfg ();
2575                 uint32_t  old_cnt  = pi->get_count ();
2576                 ChanCount old_chan = pi->output_streams ();
2577
2578                 if (count == 0) {
2579                         pi->set_custom_cfg (false);
2580                 } else {
2581                         pi->set_custom_cfg (true);
2582                         pi->set_count (count);
2583                         pi->set_outputs (outs);
2584                 }
2585
2586                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2587                 if (c.empty()) {
2588                         /* not possible */
2589
2590                         pi->set_count (old_cnt);
2591                         pi->set_outputs (old_chan);
2592                         pi->set_custom_cfg (old_cust);
2593
2594                         return false;
2595                 }
2596                 configure_processors_unlocked (0);
2597         }
2598
2599         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2600         _session.set_dirty ();
2601         return true;
2602 }
2603
2604 bool
2605 Route::set_strict_io (const bool enable)
2606 {
2607         Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2608
2609         if (_strict_io != enable) {
2610                 _strict_io = enable;
2611                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2612                 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p) {
2613                         boost::shared_ptr<PluginInsert> pi;
2614                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
2615                                 pi->set_strict_io (_strict_io);
2616                         }
2617                 }
2618
2619                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2620
2621                 if (c.empty()) {
2622                         // not possible
2623                         _strict_io = !enable; // restore old value
2624                         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p) {
2625                                 boost::shared_ptr<PluginInsert> pi;
2626                                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
2627                                         pi->set_strict_io (_strict_io);
2628                                 }
2629                         }
2630                         return false;
2631                 }
2632                 lm.release ();
2633
2634                 configure_processors (0);
2635                 lx.release ();
2636
2637                 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2638                 _session.set_dirty ();
2639         }
2640         return true;
2641 }
2642
2643 XMLNode&
2644 Route::get_state()
2645 {
2646         return state(true);
2647 }
2648
2649 XMLNode&
2650 Route::get_template()
2651 {
2652         return state(false);
2653 }
2654
2655 XMLNode&
2656 Route::state(bool full_state)
2657 {
2658         if (!_session._template_state_dir.empty()) {
2659                 assert (!full_state); // only for templates
2660                 foreach_processor (sigc::bind (sigc::mem_fun (*this, &Route::set_plugin_state_dir), _session._template_state_dir));
2661         }
2662
2663         XMLNode *node = new XMLNode("Route");
2664         ProcessorList::iterator i;
2665         char buf[32];
2666
2667         id().print (buf, sizeof (buf));
2668         node->add_property("id", buf);
2669         node->add_property ("name", _name);
2670         node->add_property("default-type", _default_type.to_string());
2671         node->add_property ("strict-io", _strict_io);
2672
2673         if (_flags) {
2674                 node->add_property("flags", enum_2_string (_flags));
2675         }
2676
2677         node->add_property("active", _active?"yes":"no");
2678         string p;
2679         boost::to_string (_phase_invert, p);
2680         node->add_property("phase-invert", p);
2681         node->add_property("denormal-protection", _denormal_protection?"yes":"no");
2682         node->add_property("meter-point", enum_2_string (_meter_point));
2683
2684         node->add_property("meter-type", enum_2_string (_meter_type));
2685
2686         if (_route_group) {
2687                 node->add_property("route-group", _route_group->name());
2688         }
2689
2690         snprintf (buf, sizeof (buf), "%d", _order_key);
2691         node->add_property ("order-key", buf);
2692         node->add_property ("self-solo", (_self_solo ? "yes" : "no"));
2693         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_upstream);
2694         node->add_property ("soloed-by-upstream", buf);
2695         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_downstream);
2696         node->add_property ("soloed-by-downstream", buf);
2697         node->add_property ("solo-isolated", solo_isolated() ? "yes" : "no");
2698         node->add_property ("solo-safe", _solo_safe ? "yes" : "no");
2699
2700         node->add_child_nocopy (_input->state (full_state));
2701         node->add_child_nocopy (_output->state (full_state));
2702         node->add_child_nocopy (_solo_control->get_state ());
2703         node->add_child_nocopy (_mute_control->get_state ());
2704         node->add_child_nocopy (_mute_master->get_state ());
2705
2706         if (full_state) {
2707                 node->add_child_nocopy (Automatable::get_automation_xml_state ());
2708         }
2709
2710         XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
2711         snprintf (buf, sizeof (buf), "%d", _remote_control_id);
2712         remote_control_node->add_property (X_("id"), buf);
2713         node->add_child_nocopy (*remote_control_node);
2714
2715         if (_comment.length()) {
2716                 XMLNode *cmt = node->add_child ("Comment");
2717                 cmt->add_content (_comment);
2718         }
2719
2720         if (_pannable) {
2721                 node->add_child_nocopy (_pannable->state (full_state));
2722         }
2723
2724         for (i = _processors.begin(); i != _processors.end(); ++i) {
2725                 if (!full_state) {
2726                         /* template save: do not include internal sends functioning as
2727                            aux sends because the chance of the target ID
2728                            in the session where this template is used
2729                            is not very likely.
2730
2731                            similarly, do not save listen sends which connect to
2732                            the monitor section, because these will always be
2733                            added if necessary.
2734                         */
2735                         boost::shared_ptr<InternalSend> is;
2736
2737                         if ((is = boost::dynamic_pointer_cast<InternalSend> (*i)) != 0) {
2738                                 if (is->role() == Delivery::Listen) {
2739                                         continue;
2740                                 }
2741                         }
2742                 }
2743                 node->add_child_nocopy((*i)->state (full_state));
2744         }
2745
2746         if (_extra_xml) {
2747                 node->add_child_copy (*_extra_xml);
2748         }
2749
2750         if (_custom_meter_position_noted) {
2751                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
2752                 if (after) {
2753                         after->id().print (buf, sizeof (buf));
2754                         node->add_property (X_("processor-after-last-custom-meter"), buf);
2755                 }
2756         }
2757
2758         if (!_session._template_state_dir.empty()) {
2759                 foreach_processor (sigc::bind (sigc::mem_fun (*this, &Route::set_plugin_state_dir), ""));
2760         }
2761
2762         return *node;
2763 }
2764
2765 int
2766 Route::set_state (const XMLNode& node, int version)
2767 {
2768         if (version < 3000) {
2769                 return set_state_2X (node, version);
2770         }
2771
2772         XMLNodeList nlist;
2773         XMLNodeConstIterator niter;
2774         XMLNode *child;
2775         const XMLProperty *prop;
2776
2777         if (node.name() != "Route"){
2778                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2779                 return -1;
2780         }
2781
2782         if ((prop = node.property (X_("name"))) != 0) {
2783                 Route::set_name (prop->value());
2784         }
2785
2786         set_id (node);
2787         _initial_io_setup = true;
2788
2789         if ((prop = node.property (X_("flags"))) != 0) {
2790                 _flags = Flag (string_2_enum (prop->value(), _flags));
2791         } else {
2792                 _flags = Flag (0);
2793         }
2794
2795         if ((prop = node.property (X_("strict-io"))) != 0) {
2796                 _strict_io = string_is_affirmative (prop->value());
2797         }
2798
2799         if (is_master() || is_monitor() || is_auditioner()) {
2800                 _mute_master->set_solo_ignore (true);
2801         }
2802
2803         if (is_monitor()) {
2804                 /* monitor bus does not get a panner, but if (re)created
2805                    via XML, it will already have one by the time we
2806                    call ::set_state(). so ... remove it.
2807                 */
2808                 unpan ();
2809         }
2810
2811         /* add all processors (except amp, which is always present) */
2812
2813         nlist = node.children();
2814         XMLNode processor_state (X_("processor_state"));
2815
2816         Stateful::save_extra_xml (node);
2817
2818         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2819
2820                 child = *niter;
2821
2822                 if (child->name() == IO::state_node_name) {
2823                         if ((prop = child->property (X_("direction"))) == 0) {
2824                                 continue;
2825                         }
2826
2827                         if (prop->value() == "Input") {
2828                                 _input->set_state (*child, version);
2829                         } else if (prop->value() == "Output") {
2830                                 _output->set_state (*child, version);
2831                         }
2832                 }
2833
2834                 if (child->name() == X_("Processor")) {
2835                         processor_state.add_child_copy (*child);
2836                 }
2837
2838                 if (child->name() == X_("Pannable")) {
2839                         if (_pannable) {
2840                                 _pannable->set_state (*child, version);
2841                         } else {
2842                                 warning << string_compose (_("Pannable state found for route (%1) without a panner!"), name()) << endmsg;
2843                         }
2844                 }
2845         }
2846
2847         if ((prop = node.property (X_("meter-point"))) != 0) {
2848                 MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
2849                 set_meter_point (mp, true);
2850                 if (_meter) {
2851                         _meter->set_display_to_user (_meter_point == MeterCustom);
2852                 }
2853         }
2854
2855         if ((prop = node.property (X_("meter-type"))) != 0) {
2856                 _meter_type = MeterType (string_2_enum (prop->value (), _meter_type));
2857         }
2858
2859         _initial_io_setup = false;
2860
2861         set_processor_state (processor_state);
2862
2863         // this looks up the internal instrument in processors
2864         reset_instrument_info();
2865
2866         if ((prop = node.property ("self-solo")) != 0) {
2867                 set_self_solo (string_is_affirmative (prop->value()));
2868         }
2869
2870         if ((prop = node.property ("soloed-by-upstream")) != 0) {
2871                 _soloed_by_others_upstream = 0; // needed for mod_.... () to work
2872                 mod_solo_by_others_upstream (atoi (prop->value()));
2873         }
2874
2875         if ((prop = node.property ("soloed-by-downstream")) != 0) {
2876                 _soloed_by_others_downstream = 0; // needed for mod_.... () to work
2877                 mod_solo_by_others_downstream (atoi (prop->value()));
2878         }
2879
2880         if ((prop = node.property ("solo-isolated")) != 0) {
2881                 set_solo_isolated (string_is_affirmative (prop->value()), Controllable::NoGroup);
2882         }
2883
2884         if ((prop = node.property ("solo-safe")) != 0) {
2885                 set_solo_safe (string_is_affirmative (prop->value()), Controllable::NoGroup);
2886         }
2887
2888         if ((prop = node.property (X_("phase-invert"))) != 0) {
2889                 set_phase_invert (boost::dynamic_bitset<> (prop->value ()));
2890         }
2891
2892         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2893                 set_denormal_protection (string_is_affirmative (prop->value()));
2894         }
2895
2896         if ((prop = node.property (X_("active"))) != 0) {
2897                 bool yn = string_is_affirmative (prop->value());
2898                 _active = !yn; // force switch
2899                 set_active (yn, this);
2900         }
2901
2902         if ((prop = node.property (X_("order-key"))) != 0) { // New order key (no separate mixer/editor ordering)
2903                 set_order_key (atoi(prop->value()));
2904         }
2905
2906         if ((prop = node.property (X_("order-keys"))) != 0) { // Deprecated order keys
2907
2908                 int32_t n;
2909
2910                 string::size_type colon, equal;
2911                 string remaining = prop->value();
2912
2913                 while (remaining.length()) {
2914
2915                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2916                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2917                                       << endmsg;
2918                         } else {
2919                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2920                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2921                                               << endmsg;
2922                                 } else {
2923                                         string keyname = remaining.substr (0, equal);
2924
2925                                         if ((keyname == "EditorSort") || (keyname == "editor")) {
2926                                                 cerr << "Setting " << name() << " order key to " << n << " using saved Editor order." << endl;
2927                                                 set_order_key (n);
2928                                         }
2929                                 }
2930                         }
2931
2932                         colon = remaining.find_first_of (':');
2933
2934                         if (colon != string::npos) {
2935                                 remaining = remaining.substr (colon+1);
2936                         } else {
2937                                 break;
2938                         }
2939                 }
2940         }
2941
2942         if ((prop = node.property (X_("processor-after-last-custom-meter"))) != 0) {
2943                 PBD::ID id (prop->value ());
2944                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2945                 ProcessorList::const_iterator i = _processors.begin ();
2946                 while (i != _processors.end() && (*i)->id() != id) {
2947                         ++i;
2948                 }
2949
2950                 if (i != _processors.end ()) {
2951                         _processor_after_last_custom_meter = *i;
2952                         _custom_meter_position_noted = true;
2953                 }
2954         }
2955
2956         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2957                 child = *niter;
2958
2959                 if (child->name() == X_("Comment")) {
2960
2961                         /* XXX this is a terrible API design in libxml++ */
2962
2963                         XMLNode *cmt = *(child->children().begin());
2964                         _comment = cmt->content();
2965
2966                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2967                         if (prop->value() == "solo") {
2968                                 _solo_control->set_state (*child, version);
2969                         } else if (prop->value() == "mute") {
2970                                 _mute_control->set_state (*child, version);
2971                         }
2972
2973                 } else if (child->name() == X_("RemoteControl")) {
2974                         if ((prop = child->property (X_("id"))) != 0) {
2975                                 int32_t x;
2976                                 sscanf (prop->value().c_str(), "%d", &x);
2977                                 set_remote_control_id_internal (x);
2978                         }
2979
2980                 } else if (child->name() == X_("MuteMaster")) {
2981                         _mute_master->set_state (*child, version);
2982
2983                 } else if (child->name() == Automatable::xml_node_name) {
2984                         set_automation_xml_state (*child, Evoral::Parameter(NullAutomation));
2985                 }
2986         }
2987
2988         return 0;
2989 }
2990
2991 int
2992 Route::set_state_2X (const XMLNode& node, int version)
2993 {
2994         LocaleGuard lg (X_("C"));
2995         XMLNodeList nlist;
2996         XMLNodeConstIterator niter;
2997         XMLNode *child;
2998         const XMLProperty *prop;
2999
3000         /* 2X things which still remain to be handled:
3001          * default-type
3002          * automation
3003          * controlouts
3004          */
3005
3006         if (node.name() != "Route") {
3007                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
3008                 return -1;
3009         }
3010
3011         if ((prop = node.property (X_("flags"))) != 0) {
3012                 string f = prop->value ();
3013                 boost::replace_all (f, "ControlOut", "MonitorOut");
3014                 _flags = Flag (string_2_enum (f, _flags));
3015         } else {
3016                 _flags = Flag (0);
3017         }
3018
3019         if (is_master() || is_monitor() || is_auditioner()) {
3020                 _mute_master->set_solo_ignore (true);
3021         }
3022
3023         if ((prop = node.property (X_("phase-invert"))) != 0) {
3024                 boost::dynamic_bitset<> p (_input->n_ports().n_audio ());
3025                 if (string_is_affirmative (prop->value ())) {
3026                         p.set ();
3027                 }
3028                 set_phase_invert (p);
3029         }
3030
3031         if ((prop = node.property (X_("denormal-protection"))) != 0) {
3032                 set_denormal_protection (string_is_affirmative (prop->value()));
3033         }
3034
3035         if ((prop = node.property (X_("soloed"))) != 0) {
3036                 bool yn = string_is_affirmative (prop->value());
3037
3038                 /* XXX force reset of solo status */
3039
3040                 set_solo (yn);
3041         }
3042
3043         if ((prop = node.property (X_("muted"))) != 0) {
3044
3045                 bool first = true;
3046                 bool muted = string_is_affirmative (prop->value());
3047
3048                 if (muted) {
3049
3050                         string mute_point;
3051
3052                         if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
3053
3054                                 if (string_is_affirmative (prop->value())){
3055                                         mute_point = mute_point + "PreFader";
3056                                         first = false;
3057                                 }
3058                         }
3059
3060                         if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
3061
3062                                 if (string_is_affirmative (prop->value())){
3063
3064                                         if (!first) {
3065                                                 mute_point = mute_point + ",";
3066                                         }
3067
3068                                         mute_point = mute_point + "PostFader";
3069                                         first = false;
3070                                 }
3071                         }
3072
3073                         if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
3074
3075                                 if (string_is_affirmative (prop->value())){
3076
3077                                         if (!first) {
3078                                                 mute_point = mute_point + ",";
3079                                         }
3080
3081                                         mute_point = mute_point + "Listen";
3082                                         first = false;
3083                                 }
3084                         }
3085
3086                         if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
3087
3088                                 if (string_is_affirmative (prop->value())){
3089
3090                                         if (!first) {
3091                                                 mute_point = mute_point + ",";
3092                                         }
3093
3094                                         mute_point = mute_point + "Main";
3095                                 }
3096                         }
3097
3098                         _mute_master->set_mute_points (mute_point);
3099                         _mute_master->set_muted_by_self (true);
3100                 }
3101         }
3102
3103         if ((prop = node.property (X_("meter-point"))) != 0) {
3104                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
3105         }
3106
3107         /* do not carry over edit/mix groups from 2.X because (a) its hard (b) they
3108            don't mean the same thing.
3109         */
3110
3111         if ((prop = node.property (X_("order-keys"))) != 0) {
3112
3113                 int32_t n;
3114
3115                 string::size_type colon, equal;
3116                 string remaining = prop->value();
3117
3118                 while (remaining.length()) {
3119
3120                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
3121                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
3122                                         << endmsg;
3123                         } else {
3124                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
3125                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
3126                                                 << endmsg;
3127                                 } else {
3128                                         string keyname = remaining.substr (0, equal);
3129
3130                                         if (keyname == "EditorSort" || keyname == "editor") {
3131                                                 info << string_compose(_("Converting deprecated order key for %1 using Editor order %2"), name (), n) << endmsg;
3132                                                 set_order_key (n);
3133                                         }
3134                                 }
3135                         }
3136
3137                         colon = remaining.find_first_of (':');
3138
3139                         if (colon != string::npos) {
3140                                 remaining = remaining.substr (colon+1);
3141                         } else {
3142                                 break;
3143                         }
3144                 }
3145         }
3146
3147         /* IOs */
3148
3149         nlist = node.children ();
3150         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
3151
3152                 child = *niter;
3153
3154                 if (child->name() == IO::state_node_name) {
3155
3156                         /* there is a note in IO::set_state_2X() about why we have to call
3157                            this directly.
3158                            */
3159
3160                         _input->set_state_2X (*child, version, true);
3161                         _output->set_state_2X (*child, version, false);
3162
3163                         if ((prop = child->property (X_("name"))) != 0) {
3164                                 Route::set_name (prop->value ());
3165                         }
3166
3167                         set_id (*child);
3168
3169                         if ((prop = child->property (X_("active"))) != 0) {
3170                                 bool yn = string_is_affirmative (prop->value());
3171                                 _active = !yn; // force switch
3172                                 set_active (yn, this);
3173                         }
3174
3175                         if ((prop = child->property (X_("gain"))) != 0) {
3176                                 gain_t val;
3177
3178                                 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
3179                                         _amp->gain_control()->set_value (val, Controllable::NoGroup);
3180                                 }
3181                         }
3182
3183                         /* Set up Panners in the IO */
3184                         XMLNodeList io_nlist = child->children ();
3185
3186                         XMLNodeConstIterator io_niter;
3187                         XMLNode *io_child;
3188
3189                         for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
3190
3191                                 io_child = *io_niter;
3192
3193                                 if (io_child->name() == X_("Panner")) {
3194                                         _main_outs->panner_shell()->set_state(*io_child, version);
3195                                 } else if (io_child->name() == X_("Automation")) {
3196                                         /* IO's automation is for the fader */
3197                                         _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
3198                                 }
3199                         }
3200                 }
3201         }
3202
3203         XMLNodeList redirect_nodes;
3204
3205         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
3206
3207                 child = *niter;
3208
3209                 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
3210                         redirect_nodes.push_back(child);
3211                 }
3212
3213         }
3214
3215         set_processor_state_2X (redirect_nodes, version);
3216
3217         Stateful::save_extra_xml (node);
3218
3219         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
3220                 child = *niter;
3221
3222                 if (child->name() == X_("Comment")) {
3223
3224                         /* XXX this is a terrible API design in libxml++ */
3225
3226                         XMLNode *cmt = *(child->children().begin());
3227                         _comment = cmt->content();
3228
3229                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
3230                         if (prop->value() == X_("solo")) {
3231                                 _solo_control->set_state (*child, version);
3232                         } else if (prop->value() == X_("mute")) {
3233                                 _mute_control->set_state (*child, version);
3234                         }
3235
3236                 } else if (child->name() == X_("RemoteControl")) {
3237                         if ((prop = child->property (X_("id"))) != 0) {
3238                                 int32_t x;
3239                                 sscanf (prop->value().c_str(), "%d", &x);
3240                                 set_remote_control_id_internal (x);
3241                         }
3242
3243                 }
3244         }
3245
3246         return 0;
3247 }
3248
3249 XMLNode&
3250 Route::get_processor_state ()
3251 {
3252         XMLNode* root = new XMLNode (X_("redirects"));
3253         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3254                 root->add_child_nocopy ((*i)->state (true));
3255         }
3256
3257         return *root;
3258 }
3259
3260 void
3261 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
3262 {
3263         /* We don't bother removing existing processors not in nList, as this
3264            method will only be called when creating a Route from scratch, not
3265            for undo purposes.  Just put processors in at the appropriate place
3266            in the list.
3267         */
3268
3269         for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
3270                 add_processor_from_xml_2X (**i, version);
3271         }
3272 }
3273
3274 void
3275 Route::set_processor_state (const XMLNode& node)
3276 {
3277         const XMLNodeList &nlist = node.children();
3278         XMLNodeConstIterator niter;
3279         ProcessorList new_order;
3280         bool must_configure = false;
3281
3282         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
3283
3284                 XMLProperty* prop = (*niter)->property ("type");
3285
3286                 if (prop->value() == "amp") {
3287                         _amp->set_state (**niter, Stateful::current_state_version);
3288                         new_order.push_back (_amp);
3289                 } else if (prop->value() == "trim") {
3290                         _trim->set_state (**niter, Stateful::current_state_version);
3291                         new_order.push_back (_trim);
3292                 } else if (prop->value() == "meter") {
3293                         _meter->set_state (**niter, Stateful::current_state_version);
3294                         new_order.push_back (_meter);
3295                 } else if (prop->value() == "delay") {
3296                         if (_delayline) {
3297                                 _delayline->set_state (**niter, Stateful::current_state_version);
3298                                 new_order.push_back (_delayline);
3299                         }
3300                 } else if (prop->value() == "main-outs") {
3301                         _main_outs->set_state (**niter, Stateful::current_state_version);
3302                 } else if (prop->value() == "intreturn") {
3303                         if (!_intreturn) {
3304                                 _intreturn.reset (new InternalReturn (_session));
3305                                 must_configure = true;
3306                         }
3307                         _intreturn->set_state (**niter, Stateful::current_state_version);
3308                 } else if (is_monitor() && prop->value() == "monitor") {
3309                         if (!_monitor_control) {
3310                                 _monitor_control.reset (new MonitorProcessor (_session));
3311                                 must_configure = true;
3312                         }
3313                         _monitor_control->set_state (**niter, Stateful::current_state_version);
3314                 } else if (prop->value() == "capture") {
3315                         /* CapturingProcessor should never be restored, it's always
3316                            added explicitly when needed */
3317                 } else {
3318                         ProcessorList::iterator o;
3319
3320                         for (o = _processors.begin(); o != _processors.end(); ++o) {
3321                                 XMLProperty* id_prop = (*niter)->property(X_("id"));
3322                                 if (id_prop && (*o)->id() == id_prop->value()) {
3323                                         (*o)->set_state (**niter, Stateful::current_state_version);
3324                                         new_order.push_back (*o);
3325                                         break;
3326                                 }
3327                         }
3328
3329                         // If the processor (*niter) is not on the route then create it
3330
3331                         if (o == _processors.end()) {
3332
3333                                 boost::shared_ptr<Processor> processor;
3334
3335                                 if (prop->value() == "intsend") {
3336
3337                                         processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), boost::shared_ptr<Route>(), Delivery::Aux, true));
3338
3339                                 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
3340                                            prop->value() == "lv2" ||
3341                                            prop->value() == "windows-vst" ||
3342                                            prop->value() == "lxvst" ||
3343                                            prop->value() == "luaproc" ||
3344                                            prop->value() == "audiounit") {
3345
3346                                         if (_session.get_disable_all_loaded_plugins ()) {
3347                                                 processor.reset (new UnknownProcessor (_session, **niter));
3348                                         } else {
3349                                                 processor.reset (new PluginInsert (_session));
3350                                                 processor->set_owner (this);
3351                                                 if (_strict_io) {
3352                                                         boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(processor);
3353                                                         pi->set_strict_io (true);
3354                                                 }
3355
3356                                         }
3357                                 } else if (prop->value() == "port") {
3358
3359                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
3360
3361                                 } else if (prop->value() == "send") {
3362
3363                                         processor.reset (new Send (_session, _pannable, _mute_master, Delivery::Send, true));
3364
3365                                 } else {
3366                                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
3367                                         continue;
3368                                 }
3369
3370                                 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
3371                                         /* This processor could not be configured.  Turn it into a UnknownProcessor */
3372                                         processor.reset (new UnknownProcessor (_session, **niter));
3373                                 }
3374
3375                                 /* subscribe to Sidechain IO changes */
3376                                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (processor);
3377                                 if (pi && pi->has_sidechain ()) {
3378                                         pi->sidechain_input ()->changed.connect_same_thread (*this, boost::bind (&Route::sidechain_change_handler, this, _1, _2));
3379                                 }
3380
3381                                 /* we have to note the monitor send here, otherwise a new one will be created
3382                                    and the state of this one will be lost.
3383                                 */
3384                                 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
3385                                 if (isend && isend->role() == Delivery::Listen) {
3386                                         _monitor_send = isend;
3387                                 }
3388
3389                                 /* it doesn't matter if invisible processors are added here, as they
3390                                    will be sorted out by setup_invisible_processors () shortly.
3391                                 */
3392
3393                                 new_order.push_back (processor);
3394                                 must_configure = true;
3395                         }
3396                 }
3397         }
3398
3399         {
3400                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3401                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3402                 _processors = new_order;
3403
3404                 if (must_configure) {
3405                         configure_processors_unlocked (0);
3406                 }
3407
3408                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3409
3410                         (*i)->set_owner (this);
3411                         (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
3412
3413                         boost::shared_ptr<PluginInsert> pi;
3414
3415                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
3416                                 if (pi->has_no_inputs ()) {
3417                                         _have_internal_generator = true;
3418                                         break;
3419                                 }
3420                         }
3421                 }
3422         }
3423
3424         reset_instrument_info ();
3425         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
3426         set_processor_positions ();
3427 }
3428
3429 void
3430 Route::curve_reallocate ()
3431 {
3432 //      _gain_automation_curve.finish_resize ();
3433 //      _pan_automation_curve.finish_resize ();
3434 }
3435
3436 void
3437 Route::silence (framecnt_t nframes)
3438 {
3439         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3440         if (!lm.locked()) {
3441                 return;
3442         }
3443
3444         silence_unlocked (nframes);
3445 }
3446
3447 void
3448 Route::silence_unlocked (framecnt_t nframes)
3449 {
3450         /* Must be called with the processor lock held */
3451
3452         if (!_silent) {
3453
3454                 _output->silence (nframes);
3455
3456                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3457                         boost::shared_ptr<PluginInsert> pi;
3458
3459                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
3460                                 // skip plugins, they don't need anything when we're not active
3461                                 continue;
3462                         }
3463
3464                         (*i)->silence (nframes);
3465                 }
3466
3467                 if (nframes == _session.get_block_size()) {
3468                         // _silent = true;
3469                 }
3470         }
3471 }
3472
3473 void
3474 Route::add_internal_return ()
3475 {
3476         if (!_intreturn) {
3477                 _intreturn.reset (new InternalReturn (_session));
3478                 add_processor (_intreturn, PreFader);
3479         }
3480 }
3481
3482 void
3483 Route::add_send_to_internal_return (InternalSend* send)
3484 {
3485         Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3486
3487         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
3488                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
3489
3490                 if (d) {
3491                         return d->add_send (send);
3492                 }
3493         }
3494 }
3495
3496 void
3497 Route::remove_send_from_internal_return (InternalSend* send)
3498 {
3499         Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3500
3501         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
3502                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
3503
3504                 if (d) {
3505                         return d->remove_send (send);
3506                 }
3507         }
3508 }
3509
3510 void
3511 Route::enable_monitor_send ()
3512 {
3513         /* Caller must hold process lock */
3514         assert (!AudioEngine::instance()->process_lock().trylock());
3515
3516         /* master never sends to monitor section via the normal mechanism */
3517         assert (!is_master ());
3518         assert (!is_monitor ());
3519
3520         /* make sure we have one */
3521         if (!_monitor_send) {
3522                 _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), _session.monitor_out(), Delivery::Listen));
3523                 _monitor_send->set_display_to_user (false);
3524         }
3525
3526         /* set it up */
3527         configure_processors (0);
3528 }
3529
3530 /** Add an aux send to a route.
3531  *  @param route route to send to.
3532  *  @param before Processor to insert before, or 0 to insert at the end.
3533  */
3534 int
3535 Route::add_aux_send (boost::shared_ptr<Route> route, boost::shared_ptr<Processor> before)
3536 {
3537         assert (route != _session.monitor_out ());
3538
3539         {
3540                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3541
3542                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3543
3544                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
3545
3546                         if (d && d->target_route() == route) {
3547                                 /* already listening via the specified IO: do nothing */
3548                                 return 0;
3549                         }
3550                 }
3551         }
3552
3553         try {
3554
3555                 boost::shared_ptr<InternalSend> listener;
3556
3557                 {
3558                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3559                         boost::shared_ptr<Pannable> sendpan (new Pannable (_session));
3560                         listener.reset (new InternalSend (_session, sendpan, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), route, Delivery::Aux));
3561                 }
3562
3563                 add_processor (listener, before);
3564
3565         } catch (failed_constructor& err) {
3566                 return -1;
3567         }
3568
3569         return 0;
3570 }
3571
3572 void
3573 Route::remove_aux_or_listen (boost::shared_ptr<Route> route)
3574 {
3575         ProcessorStreams err;
3576         ProcessorList::iterator tmp;
3577
3578         {
3579                 Glib::Threads::RWLock::ReaderLock rl(_processor_lock);
3580
3581                 /* have to do this early because otherwise processor reconfig
3582                  * will put _monitor_send back in the list
3583                  */
3584
3585                 if (route == _session.monitor_out()) {
3586                         _monitor_send.reset ();
3587                 }
3588
3589           again:
3590                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3591
3592                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
3593
3594                         if (d && d->target_route() == route) {
3595                                 rl.release ();
3596                                 if (remove_processor (*x, &err, false) > 0) {
3597                                         rl.acquire ();
3598                                         continue;
3599                                 }
3600                                 rl.acquire ();
3601
3602                                 /* list could have been demolished while we dropped the lock
3603                                    so start over.
3604                                 */
3605                                 if (_session.engine().connected()) {
3606                                         /* i/o processors cannot be removed if the engine is not running
3607                                          * so don't live-loop in case the engine is N/A or dies
3608                                          */
3609                                         goto again;
3610                                 }
3611                         }
3612                 }
3613         }
3614 }
3615
3616 void
3617 Route::set_comment (string cmt, void *src)
3618 {
3619         _comment = cmt;
3620         comment_changed ();
3621         _session.set_dirty ();
3622 }
3623
3624 bool
3625 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
3626 {
3627         FeedRecord fr (other, via_sends_only);
3628
3629         pair<FedBy::iterator,bool> result =  _fed_by.insert (fr);
3630
3631         if (!result.second) {
3632
3633                 /* already a record for "other" - make sure sends-only information is correct */
3634                 if (!via_sends_only && result.first->sends_only) {
3635                         FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
3636                         frp->sends_only = false;
3637                 }
3638         }
3639
3640         return result.second;
3641 }
3642
3643 void
3644 Route::clear_fed_by ()
3645 {
3646         _fed_by.clear ();
3647 }
3648
3649 bool
3650 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
3651 {
3652         const FedBy& fed_by (other->fed_by());
3653
3654         for (FedBy::const_iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
3655                 boost::shared_ptr<Route> sr = f->r.lock();
3656
3657                 if (sr && (sr.get() == this)) {
3658
3659                         if (via_sends_only) {
3660                                 *via_sends_only = f->sends_only;
3661                         }
3662
3663                         return true;
3664                 }
3665         }
3666
3667         return false;
3668 }
3669
3670 IOVector
3671 Route::all_inputs () const
3672 {
3673         /* TODO, if this works as expected,
3674          * cache the IOVector and maintain it via
3675          * input_change_handler(), sidechain_change_handler() etc
3676          */
3677         IOVector ios;
3678         ios.push_back (_input);
3679
3680         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3681         for (ProcessorList::const_iterator r = _processors.begin(); r != _processors.end(); ++r) {
3682
3683                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3684                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*r);
3685                 if (pi != 0) {
3686                         assert (iop == 0);
3687                         iop = pi->sidechain();
3688                 }
3689
3690                 if (iop != 0 && iop->input()) {
3691                         ios.push_back (iop->input());
3692                 }
3693         }
3694         return ios;
3695 }
3696
3697 IOVector
3698 Route::all_outputs () const
3699 {
3700         IOVector ios;
3701         // _output is included via Delivery
3702         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3703         for (ProcessorList::const_iterator r = _processors.begin(); r != _processors.end(); ++r) {
3704                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3705                 if (iop != 0 && iop->output()) {
3706                         ios.push_back (iop->output());
3707                 }
3708         }
3709         return ios;
3710 }
3711
3712 bool
3713 Route::direct_feeds_according_to_reality (boost::shared_ptr<Route> other, bool* via_send_only)
3714 {
3715         DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
3716         if (other->all_inputs().fed_by (_output)) {
3717                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
3718                 if (via_send_only) {
3719                         *via_send_only = false;
3720                 }
3721
3722                 return true;
3723         }
3724
3725
3726         Glib::Threads::RWLock::ReaderLock lm (_processor_lock); // XXX
3727         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
3728
3729                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3730                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*r);
3731                 if (pi != 0) {
3732                         assert (iop == 0);
3733                         iop = pi->sidechain();
3734                 }
3735
3736                 if (iop != 0) {
3737                         boost::shared_ptr<const IO> iop_out = iop->output();
3738                         if ((iop_out && other->all_inputs().fed_by (iop_out)) || iop->feeds (other)) {
3739                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
3740                                 if (via_send_only) {
3741                                         *via_send_only = true;
3742                                 }
3743                                 return true;
3744                         } else {
3745                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
3746                         }
3747                 } else {
3748                         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
3749                 }
3750
3751         }
3752
3753         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tdoes NOT feed %1\n", other->name()));
3754         return false;
3755 }
3756
3757 bool
3758 Route::direct_feeds_according_to_graph (boost::shared_ptr<Route> other, bool* via_send_only)
3759 {
3760         return _session._current_route_graph.has (shared_from_this (), other, via_send_only);
3761 }
3762
3763 bool
3764 Route::feeds_according_to_graph (boost::shared_ptr<Route> other)
3765 {
3766         return _session._current_route_graph.feeds (shared_from_this (), other);
3767 }
3768
3769 /** Called from the (non-realtime) butler thread when the transport is stopped */
3770 void
3771 Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool /*did_locate*/, bool can_flush_processors)
3772 {
3773         framepos_t now = _session.transport_frame();
3774
3775         {
3776                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3777
3778                 Automatable::transport_stopped (now);
3779
3780                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3781
3782                         if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && can_flush_processors)) {
3783                                 (*i)->flush ();
3784                         }
3785
3786                         (*i)->transport_stopped (now);
3787                 }
3788         }
3789
3790         _roll_delay = _initial_delay;
3791 }
3792
3793 void
3794 Route::input_change_handler (IOChange change, void * /*src*/)
3795 {
3796         if ((change.type & IOChange::ConfigurationChanged)) {
3797                 /* This is called with the process lock held if change
3798                    contains ConfigurationChanged
3799                 */
3800                 configure_processors (0);
3801                 _phase_invert.resize (_input->n_ports().n_audio ());
3802                 io_changed (); /* EMIT SIGNAL */
3803         }
3804
3805         if (_soloed_by_others_upstream || _solo_isolated_by_upstream) {
3806                 int sbou = 0;
3807                 int ibou = 0;
3808                 boost::shared_ptr<RouteList> routes = _session.get_routes ();
3809                 if (_input->connected()) {
3810                         for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3811                                 if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3812                                         continue;
3813                                 }
3814                                 bool sends_only;
3815                                 bool does_feed = (*i)->direct_feeds_according_to_reality (shared_from_this(), &sends_only);
3816                                 if (does_feed && !sends_only) {
3817                                         if ((*i)->soloed()) {
3818                                                 ++sbou;
3819                                         }
3820                                         if ((*i)->solo_isolated()) {
3821                                                 ++ibou;
3822                                         }
3823                                 }
3824                         }
3825                 }
3826
3827                 int delta  = sbou - _soloed_by_others_upstream;
3828                 int idelta = ibou - _solo_isolated_by_upstream;
3829
3830                 if (idelta < -1) {
3831                         PBD::warning << string_compose (
3832                                         _("Invalid Solo-Isolate propagation: from:%1 new:%2 - old:%3 = delta:%4"),
3833                                         _name, ibou, _solo_isolated_by_upstream, idelta)
3834                                      << endmsg;
3835
3836                 }
3837
3838                 if (_soloed_by_others_upstream) {
3839                         // ignore new connections (they're not propagated)
3840                         if (delta <= 0) {
3841                                 mod_solo_by_others_upstream (delta);
3842                         }
3843                 }
3844
3845                 if (_solo_isolated_by_upstream) {
3846                         // solo-isolate currently only propagates downstream
3847                         if (idelta < 0) {
3848                                 mod_solo_isolated_by_upstream (false);
3849                         }
3850                         // TODO think: mod_solo_isolated_by_upstream() does not take delta arg,
3851                         // but idelta can't be smaller than -1, can it?
3852                         //_solo_isolated_by_upstream = ibou;
3853                 }
3854
3855                 // Session::route_solo_changed  does not propagate indirect solo-changes
3856                 // propagate downstream to tracks
3857                 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3858                         if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3859                                 continue;
3860                         }
3861                         bool sends_only;
3862                         bool does_feed = feeds (*i, &sends_only);
3863                         if (delta <= 0 && does_feed && !sends_only) {
3864                                 (*i)->mod_solo_by_others_upstream (delta);
3865                         }
3866
3867                         if (idelta < 0 && does_feed && !sends_only) {
3868                                 (*i)->mod_solo_isolated_by_upstream (false);
3869                         }
3870                 }
3871         }
3872 }
3873
3874 void
3875 Route::output_change_handler (IOChange change, void * /*src*/)
3876 {
3877         if (_initial_io_setup) {
3878                 return;
3879         }
3880
3881         if ((change.type & IOChange::ConfigurationChanged)) {
3882                 /* This is called with the process lock held if change
3883                    contains ConfigurationChanged
3884                 */
3885                 configure_processors (0);
3886
3887                 if (is_master()) {
3888                         _session.reset_monitor_section();
3889                 }
3890
3891                 io_changed (); /* EMIT SIGNAL */
3892         }
3893
3894         if (_soloed_by_others_downstream) {
3895                 int sbod = 0;
3896                 /* checking all all downstream routes for
3897                  * explicit of implict solo is a rather drastic measure,
3898                  * ideally the input_change_handler() of the other route
3899                  * would propagate the change to us.
3900                  */
3901                 boost::shared_ptr<RouteList> routes = _session.get_routes ();
3902                 if (_output->connected()) {
3903                         for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3904                                 if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3905                                         continue;
3906                                 }
3907                                 bool sends_only;
3908                                 bool does_feed = direct_feeds_according_to_reality (*i, &sends_only);
3909                                 if (does_feed && !sends_only) {
3910                                         if ((*i)->soloed()) {
3911                                                 ++sbod;
3912                                                 break;
3913                                         }
3914                                 }
3915                         }
3916                 }
3917                 int delta = sbod - _soloed_by_others_downstream;
3918                 if (delta <= 0) {
3919                         // do not allow new connections to change implicit solo (no propagation)
3920                         mod_solo_by_others_downstream (delta);
3921                         // Session::route_solo_changed() does not propagate indirect solo-changes
3922                         // propagate upstream to tracks
3923                         for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3924                                 if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3925                                         continue;
3926                                 }
3927                                 bool sends_only;
3928                                 bool does_feed = (*i)->feeds (shared_from_this(), &sends_only);
3929                                 if (delta != 0 && does_feed && !sends_only) {
3930                                         (*i)->mod_solo_by_others_downstream (delta);
3931                                 }
3932                         }
3933
3934                 }
3935         }
3936 }
3937
3938 void
3939 Route::sidechain_change_handler (IOChange change, void * /*src*/)
3940 {
3941         if (_initial_io_setup || _in_sidechain_setup) {
3942                 return;
3943         }
3944
3945         if ((change.type & IOChange::ConfigurationChanged)) {
3946                 /* This is called with the process lock held if change
3947                    contains ConfigurationChanged
3948                 */
3949                 configure_processors (0);
3950         }
3951 }
3952
3953 uint32_t
3954 Route::pans_required () const
3955 {
3956         if (n_outputs().n_audio() < 2) {
3957                 return 0;
3958         }
3959
3960         return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
3961 }
3962
3963 int
3964 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
3965 {
3966         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3967
3968         if (!lm.locked()) {
3969                 return 0;
3970         }
3971
3972         if (n_outputs().n_total() == 0) {
3973                 return 0;
3974         }
3975
3976         if (!_active || n_inputs() == ChanCount::ZERO)  {
3977                 silence_unlocked (nframes);
3978                 return 0;
3979         }
3980
3981         if (session_state_changing) {
3982                 if (_session.transport_speed() != 0.0f) {
3983                         /* we're rolling but some state is changing (e.g. our diskstream contents)
3984                            so we cannot use them. Be silent till this is over.
3985
3986                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
3987                         */
3988                         silence_unlocked (nframes);
3989                         return 0;
3990                 }
3991                 /* we're really not rolling, so we're either delivery silence or actually
3992                    monitoring, both of which are safe to do while session_state_changing is true.
3993                 */
3994         }
3995
3996         BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
3997
3998         fill_buffers_with_input (bufs, _input, nframes);
3999
4000         if (_meter_point == MeterInput) {
4001                 _meter->run (bufs, start_frame, end_frame, nframes, true);
4002         }
4003
4004         _amp->apply_gain_automation (false);
4005         _trim->apply_gain_automation (false);
4006         passthru (bufs, start_frame, end_frame, nframes, 0);
4007
4008         return 0;
4009 }
4010
4011 int
4012 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& /* need_butler */)
4013 {
4014         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
4015         if (!lm.locked()) {
4016                 return 0;
4017         }
4018
4019         if (n_outputs().n_total() == 0) {
4020                 return 0;
4021         }
4022
4023         if (!_active || n_inputs().n_total() == 0) {
4024                 silence_unlocked (nframes);
4025                 return 0;
4026         }
4027
4028         framepos_t unused = 0;
4029
4030         if ((nframes = check_initial_delay (nframes, unused)) == 0) {
4031                 return 0;
4032         }
4033
4034         _silent = false;
4035
4036         BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
4037
4038         fill_buffers_with_input (bufs, _input, nframes);
4039
4040         if (_meter_point == MeterInput) {
4041                 _meter->run (bufs, start_frame, end_frame, nframes, true);
4042         }
4043
4044         passthru (bufs, start_frame, end_frame, nframes, declick);
4045
4046         return 0;
4047 }
4048
4049 int
4050 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& /* need_butler */)
4051 {
4052         silence (nframes);
4053         return 0;
4054 }
4055
4056 void
4057 Route::flush_processors ()
4058 {
4059         /* XXX shouldn't really try to take this lock, since
4060            this is called from the RT audio thread.
4061         */
4062
4063         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4064
4065         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4066                 (*i)->flush ();
4067         }
4068 }
4069
4070 #ifdef __clang__
4071 __attribute__((annotate("realtime")))
4072 #endif
4073 bool
4074 Route::apply_processor_changes_rt ()
4075 {
4076         int emissions = EmitNone;
4077
4078         if (_pending_meter_point != _meter_point) {
4079                 Glib::Threads::RWLock::WriterLock pwl (_processor_lock, Glib::Threads::TRY_LOCK);
4080                 if (pwl.locked()) {
4081                         /* meters always have buffers for 'processor_max_streams'
4082                          * they can be re-positioned without re-allocation */
4083                         if (set_meter_point_unlocked()) {
4084                                 emissions |= EmitMeterChanged | EmitMeterVisibilityChange;;
4085                         } else {
4086                                 emissions |= EmitMeterChanged;
4087                         }
4088                 }
4089         }
4090
4091         bool changed = false;
4092
4093         if (g_atomic_int_get (&_pending_process_reorder)) {
4094                 Glib::Threads::RWLock::WriterLock pwl (_processor_lock, Glib::Threads::TRY_LOCK);
4095                 if (pwl.locked()) {
4096                         apply_processor_order (_pending_processor_order);
4097                         setup_invisible_processors ();
4098                         changed = true;
4099                         g_atomic_int_set (&_pending_process_reorder, 0);
4100                         emissions |= EmitRtProcessorChange;
4101                 }
4102         }
4103         if (changed) {
4104                 set_processor_positions ();
4105         }
4106         if (emissions != 0) {
4107                 g_atomic_int_set (&_pending_signals, emissions);
4108                 return true;
4109         }
4110         return false;
4111 }
4112
4113 void
4114 Route::emit_pending_signals ()
4115 {
4116
4117         int sig = g_atomic_int_and (&_pending_signals, 0);
4118         if (sig & EmitMeterChanged) {
4119                 _meter->emit_configuration_changed();
4120                 meter_change (); /* EMIT SIGNAL */
4121                 if (sig & EmitMeterVisibilityChange) {
4122                 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, true)); /* EMIT SIGNAL */
4123                 } else {
4124                 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, false)); /* EMIT SIGNAL */
4125                 }
4126         }
4127         if (sig & EmitRtProcessorChange) {
4128                 processors_changed (RouteProcessorChange (RouteProcessorChange::RealTimeChange)); /* EMIT SIGNAL */
4129         }
4130 }
4131
4132 void
4133 Route::set_meter_point (MeterPoint p, bool force)
4134 {
4135         if (_pending_meter_point == p && !force) {
4136                 return;
4137         }
4138
4139         if (force || !AudioEngine::instance()->running()) {
4140                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
4141                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
4142                 _pending_meter_point = p;
4143                 _meter->emit_configuration_changed();
4144                 meter_change (); /* EMIT SIGNAL */
4145                 if (set_meter_point_unlocked()) {
4146                         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, true)); /* EMIT SIGNAL */
4147                 } else {
4148                         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, false)); /* EMIT SIGNAL */
4149                 }
4150         } else {
4151                 _pending_meter_point = p;
4152         }
4153 }
4154
4155
4156 #ifdef __clang__
4157 __attribute__((annotate("realtime")))
4158 #endif
4159 bool
4160 Route::set_meter_point_unlocked ()
4161 {
4162 #ifndef NDEBUG
4163         /* Caller must hold process and processor write lock */
4164         assert (!AudioEngine::instance()->process_lock().trylock());
4165         Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
4166         assert (!lm.locked ());
4167 #endif
4168
4169         _meter_point = _pending_meter_point;
4170
4171         bool meter_was_visible_to_user = _meter->display_to_user ();
4172
4173         if (!_custom_meter_position_noted) {
4174                 maybe_note_meter_position ();
4175         }
4176
4177         if (_meter_point != MeterCustom) {
4178
4179                 _meter->set_display_to_user (false);
4180
4181                 setup_invisible_processors ();
4182
4183         } else {
4184                 _meter->set_display_to_user (true);
4185
4186                 /* If we have a previous position for the custom meter, try to put it there */
4187                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
4188                 if (after) {
4189                         ProcessorList::iterator i = find (_processors.begin(), _processors.end(), after);
4190                         if (i != _processors.end ()) {
4191                                 _processors.remove (_meter);
4192                                 _processors.insert (i, _meter);
4193                         }
4194                 } else {// at end, right before the mains_out/panner
4195                         _processors.remove (_meter);
4196                         ProcessorList::iterator main = _processors.end();
4197                         _processors.insert (--main, _meter);
4198                 }
4199         }
4200
4201         /* Set up the meter for its new position */
4202
4203         ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
4204
4205         ChanCount m_in;
4206
4207         if (loc == _processors.begin()) {
4208                 m_in = _input->n_ports();
4209         } else {
4210                 ProcessorList::iterator before = loc;
4211                 --before;
4212                 m_in = (*before)->output_streams ();
4213         }
4214
4215         _meter->reflect_inputs (m_in);
4216
4217         /* we do not need to reconfigure the processors, because the meter
4218            (a) is always ready to handle processor_max_streams
4219            (b) is always an N-in/N-out processor, and thus moving
4220            it doesn't require any changes to the other processors.
4221         */
4222
4223         /* these should really be done after releasing the lock
4224          * but all those signals are subscribed to with gui_thread()
4225          * so we're safe.
4226          */
4227          return (_meter->display_to_user() != meter_was_visible_to_user);
4228 }
4229
4230 void
4231 Route::listen_position_changed ()
4232 {
4233         {
4234                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
4235                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
4236                 ProcessorState pstate (this);
4237
4238                 if (configure_processors_unlocked (0)) {
4239                         DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
4240                         pstate.restore ();
4241                         configure_processors_unlocked (0); // it worked before we tried to add it ...
4242                         return;
4243                 }
4244         }
4245
4246         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
4247         _session.set_dirty ();
4248 }
4249
4250 boost::shared_ptr<CapturingProcessor>
4251 Route::add_export_point()
4252 {
4253         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4254         if (!_capturing_processor) {
4255                 lm.release();
4256                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
4257                 Glib::Threads::RWLock::WriterLock lw (_processor_lock);
4258
4259                 _capturing_processor.reset (new CapturingProcessor (_session));
4260                 _capturing_processor->activate ();
4261
4262                 configure_processors_unlocked (0);
4263
4264         }
4265
4266         return _capturing_processor;
4267 }
4268
4269 framecnt_t
4270 Route::update_signal_latency ()
4271 {
4272         framecnt_t l = _output->user_latency();
4273         framecnt_t lamp = 0;
4274         bool before_amp = true;
4275         framecnt_t ltrim = 0;
4276         bool before_trim = true;
4277
4278         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4279                 if ((*i)->active ()) {
4280                         l += (*i)->signal_latency ();
4281                 }
4282                 if ((*i) == _amp) {
4283                         before_amp = false;
4284                 }
4285                 if ((*i) == _trim) {
4286                         before_amp = false;
4287                 }
4288                 if (before_amp) {
4289                         lamp = l;
4290                 }
4291                 if (before_trim) {
4292                         lamp = l;
4293                 }
4294         }
4295
4296         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l));
4297
4298         // TODO: (lamp - _signal_latency) to sync to output (read-ahed),  currently _roll_delay shifts this around
4299         _signal_latency_at_amp_position = lamp;
4300         _signal_latency_at_trim_position = ltrim;
4301
4302         if (_signal_latency != l) {
4303                 _signal_latency = l;
4304                 signal_latency_changed (); /* EMIT SIGNAL */
4305         }
4306
4307         return _signal_latency;
4308 }
4309
4310 void
4311 Route::set_user_latency (framecnt_t nframes)
4312 {
4313         _output->set_user_latency (nframes);
4314         _session.update_latency_compensation ();
4315 }
4316
4317 void
4318 Route::set_latency_compensation (framecnt_t longest_session_latency)
4319 {
4320         framecnt_t old = _initial_delay;
4321
4322         if (_signal_latency < longest_session_latency) {
4323                 _initial_delay = longest_session_latency - _signal_latency;
4324         } else {
4325                 _initial_delay = 0;
4326         }
4327
4328         DEBUG_TRACE (DEBUG::Latency, string_compose (
4329                              "%1: compensate for maximum latency of %2,"
4330                              "given own latency of %3, using initial delay of %4\n",
4331                              name(), longest_session_latency, _signal_latency, _initial_delay));
4332
4333         if (_initial_delay != old) {
4334                 initial_delay_changed (); /* EMIT SIGNAL */
4335         }
4336
4337         if (_session.transport_stopped()) {
4338                 _roll_delay = _initial_delay;
4339         }
4340 }
4341
4342 void
4343 Route::set_block_size (pframes_t nframes)
4344 {
4345         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4346                 (*i)->set_block_size (nframes);
4347         }
4348
4349         _session.ensure_buffers (n_process_buffers ());
4350 }
4351
4352 void
4353 Route::protect_automation ()
4354 {
4355         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
4356                 (*i)->protect_automation();
4357 }
4358
4359 /** @param declick 1 to set a pending declick fade-in,
4360  *                -1 to set a pending declick fade-out
4361  */
4362 void
4363 Route::set_pending_declick (int declick)
4364 {
4365         if (_declickable) {
4366                 /* this call is not allowed to turn off a pending declick */
4367                 if (declick) {
4368                         _pending_declick = declick;
4369                 }
4370         } else {
4371                 _pending_declick = 0;
4372         }
4373 }
4374
4375 /** Shift automation forwards from a particular place, thereby inserting time.
4376  *  Adds undo commands for any shifts that are performed.
4377  *
4378  * @param pos Position to start shifting from.
4379  * @param frames Amount to shift forwards by.
4380  */
4381
4382 void
4383 Route::shift (framepos_t pos, framecnt_t frames)
4384 {
4385         /* gain automation */
4386         {
4387                 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
4388
4389                 XMLNode &before = gc->alist()->get_state ();
4390                 gc->alist()->shift (pos, frames);
4391                 XMLNode &after = gc->alist()->get_state ();
4392                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
4393         }
4394
4395         /* gain automation */
4396         {
4397                 boost::shared_ptr<AutomationControl> gc = _trim->gain_control();
4398
4399                 XMLNode &before = gc->alist()->get_state ();
4400                 gc->alist()->shift (pos, frames);
4401                 XMLNode &after = gc->alist()->get_state ();
4402                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
4403         }
4404
4405         // TODO mute automation ??
4406
4407         /* pan automation */
4408         if (_pannable) {
4409                 ControlSet::Controls& c (_pannable->controls());
4410
4411                 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
4412                         boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
4413                         if (pc) {
4414                                 boost::shared_ptr<AutomationList> al = pc->alist();
4415                                 XMLNode& before = al->get_state ();
4416                                 al->shift (pos, frames);
4417                                 XMLNode& after = al->get_state ();
4418                                 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
4419                         }
4420                 }
4421         }
4422
4423         /* redirect automation */
4424         {
4425                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4426                 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
4427
4428                         set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
4429
4430                         for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
4431                                 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
4432                                 if (ac) {
4433                                         boost::shared_ptr<AutomationList> al = ac->alist();
4434                                         XMLNode &before = al->get_state ();
4435                                         al->shift (pos, frames);
4436                                         XMLNode &after = al->get_state ();
4437                                         _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
4438                                 }
4439                         }
4440                 }
4441         }
4442 }
4443
4444 void
4445 Route::set_plugin_state_dir (boost::weak_ptr<Processor> p, const std::string& d)
4446 {
4447         boost::shared_ptr<Processor> processor (p.lock ());
4448         boost::shared_ptr<PluginInsert> pi  = boost::dynamic_pointer_cast<PluginInsert> (processor);
4449         if (!pi) {
4450                 return;
4451         }
4452         pi->set_state_dir (d);
4453 }
4454
4455 int
4456 Route::save_as_template (const string& path, const string& name)
4457 {
4458         std::string state_dir = path.substr (0, path.find_last_of ('.')); // strip template_suffix
4459         PBD::Unwinder<std::string> uw (_session._template_state_dir, state_dir);
4460
4461         XMLNode& node (state (false));
4462
4463         XMLTree tree;
4464
4465         IO::set_name_in_state (*node.children().front(), name);
4466
4467         tree.set_root (&node);
4468
4469         /* return zero on success, non-zero otherwise */
4470         return !tree.write (path.c_str());
4471 }
4472
4473
4474 bool
4475 Route::set_name (const string& str)
4476 {
4477         if (str == name()) {
4478                 return true;
4479         }
4480
4481         string name = Route::ensure_track_or_route_name (str, _session);
4482         SessionObject::set_name (name);
4483
4484         bool ret = (_input->set_name(name) && _output->set_name(name));
4485
4486         if (ret) {
4487                 /* rename the main outs. Leave other IO processors
4488                  * with whatever name they already have, because its
4489                  * just fine as it is (it will not contain the route
4490                  * name if its a port insert, port send or port return).
4491                  */
4492
4493                 if (_main_outs) {
4494                         if (_main_outs->set_name (name)) {
4495                                 /* XXX returning false here is stupid because
4496                                    we already changed the route name.
4497                                 */
4498                                 return false;
4499                         }
4500                 }
4501         }
4502
4503         return ret;
4504 }
4505
4506 /** Set the name of a route in an XML description.
4507  *  @param node XML <Route> node to set the name in.
4508  *  @param name New name.
4509  */
4510 void
4511 Route::set_name_in_state (XMLNode& node, string const & name, bool rename_playlist)
4512 {
4513         node.add_property (X_("name"), name);
4514
4515         XMLNodeList children = node.children();
4516         for (XMLNodeIterator i = children.begin(); i != children.end(); ++i) {
4517
4518                 if ((*i)->name() == X_("IO")) {
4519
4520                         IO::set_name_in_state (**i, name);
4521
4522                 } else if ((*i)->name() == X_("Processor")) {
4523
4524                         XMLProperty* role = (*i)->property (X_("role"));
4525                         if (role && role->value() == X_("Main")) {
4526                                 (*i)->add_property (X_("name"), name);
4527                         }
4528
4529                 } else if ((*i)->name() == X_("Diskstream")) {
4530
4531                         if (rename_playlist) {
4532                                 (*i)->add_property (X_("playlist"), string_compose ("%1.1", name).c_str());
4533                         }
4534                         (*i)->add_property (X_("name"), name);
4535
4536                 }
4537         }
4538 }
4539
4540 boost::shared_ptr<Send>
4541 Route::internal_send_for (boost::shared_ptr<const Route> target) const
4542 {
4543         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4544
4545         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4546                 boost::shared_ptr<InternalSend> send;
4547
4548                 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
4549                         if (send->target_route() == target) {
4550                                 return send;
4551                         }
4552                 }
4553         }
4554
4555         return boost::shared_ptr<Send>();
4556 }
4557
4558 /** @param c Audio channel index.
4559  *  @param yn true to invert phase, otherwise false.
4560  */
4561 void
4562 Route::set_phase_invert (uint32_t c, bool yn)
4563 {
4564         if (_phase_invert[c] != yn) {
4565                 _phase_invert[c] = yn;
4566                 phase_invert_changed (); /* EMIT SIGNAL */
4567                 _phase_control->Changed(); /* EMIT SIGNAL */
4568                 _session.set_dirty ();
4569         }
4570 }
4571
4572 void
4573 Route::set_phase_invert (boost::dynamic_bitset<> p)
4574 {
4575         if (_phase_invert != p) {
4576                 _phase_invert = p;
4577                 phase_invert_changed (); /* EMIT SIGNAL */
4578                 _session.set_dirty ();
4579         }
4580 }
4581
4582 bool
4583 Route::phase_invert (uint32_t c) const
4584 {
4585         return _phase_invert[c];
4586 }
4587
4588 boost::dynamic_bitset<>
4589 Route::phase_invert () const
4590 {
4591         return _phase_invert;
4592 }
4593
4594 void
4595 Route::set_denormal_protection (bool yn)
4596 {
4597         if (_denormal_protection != yn) {
4598                 _denormal_protection = yn;
4599                 denormal_protection_changed (); /* EMIT SIGNAL */
4600         }
4601 }
4602
4603 bool
4604 Route::denormal_protection () const
4605 {
4606         return _denormal_protection;
4607 }
4608
4609 void
4610 Route::set_active (bool yn, void* src)
4611 {
4612         if (_session.transport_rolling()) {
4613                 return;
4614         }
4615
4616         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
4617                 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
4618                 return;
4619         }
4620
4621         if (_active != yn) {
4622                 _active = yn;
4623                 _input->set_active (yn);
4624                 _output->set_active (yn);
4625                 active_changed (); // EMIT SIGNAL
4626                 _session.set_dirty ();
4627         }
4628 }
4629
4630 boost::shared_ptr<Pannable>
4631 Route::pannable() const
4632 {
4633         return _pannable;
4634 }
4635
4636 boost::shared_ptr<Panner>
4637 Route::panner() const
4638 {
4639         /* may be null ! */
4640         return _main_outs->panner_shell()->panner();
4641 }
4642
4643 boost::shared_ptr<PannerShell>
4644 Route::panner_shell() const
4645 {
4646         return _main_outs->panner_shell();
4647 }
4648
4649 boost::shared_ptr<GainControl>
4650 Route::gain_control() const
4651 {
4652         return _gain_control;
4653 }
4654
4655 boost::shared_ptr<GainControl>
4656 Route::trim_control() const
4657 {
4658         return _trim_control;
4659 }
4660
4661 boost::shared_ptr<Route::PhaseControllable>
4662 Route::phase_control() const
4663 {
4664         if (phase_invert().size()) {
4665                 return _phase_control;
4666         } else {
4667                 return boost::shared_ptr<PhaseControllable>();
4668         }
4669 }
4670
4671 boost::shared_ptr<AutomationControl>
4672 Route::get_control (const Evoral::Parameter& param)
4673 {
4674         /* either we own the control or .... */
4675
4676         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
4677
4678         if (!c) {
4679
4680                 /* maybe one of our processors does or ... */
4681
4682                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
4683                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4684                         if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
4685                                 break;
4686                         }
4687                 }
4688         }
4689
4690         if (!c) {
4691
4692                 /* nobody does so we'll make a new one */
4693
4694                 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
4695                 add_control(c);
4696         }
4697
4698         return c;
4699 }
4700
4701 boost::shared_ptr<Processor>
4702 Route::nth_plugin (uint32_t n) const
4703 {
4704         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4705         ProcessorList::const_iterator i;
4706
4707         for (i = _processors.begin(); i != _processors.end(); ++i) {
4708                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
4709                         if (n-- == 0) {
4710                                 return *i;
4711                         }
4712                 }
4713         }
4714
4715         return boost::shared_ptr<Processor> ();
4716 }
4717
4718 boost::shared_ptr<Processor>
4719 Route::nth_send (uint32_t n) const
4720 {
4721         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4722         ProcessorList::const_iterator i;
4723
4724         for (i = _processors.begin(); i != _processors.end(); ++i) {
4725                 if (boost::dynamic_pointer_cast<Send> (*i)) {
4726
4727                         if ((*i)->name().find (_("Monitor")) == 0) {
4728                                 /* send to monitor section is not considered
4729                                    to be an accessible send.
4730                                 */
4731                                 continue;
4732                         }
4733
4734                         if (n-- == 0) {
4735                                 return *i;
4736                         }
4737                 }
4738         }
4739
4740         return boost::shared_ptr<Processor> ();
4741 }
4742
4743 bool
4744 Route::has_io_processor_named (const string& name)
4745 {
4746         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4747         ProcessorList::iterator i;
4748
4749         for (i = _processors.begin(); i != _processors.end(); ++i) {
4750                 if (boost::dynamic_pointer_cast<Send> (*i) ||
4751                     boost::dynamic_pointer_cast<PortInsert> (*i)) {
4752                         if ((*i)->name() == name) {
4753                                 return true;
4754                         }
4755                 }
4756         }
4757
4758         return false;
4759 }
4760
4761 MuteMaster::MutePoint
4762 Route::mute_points () const
4763 {
4764         return _mute_master->mute_points ();
4765 }
4766
4767 void
4768 Route::set_processor_positions ()
4769 {
4770         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4771
4772         bool had_amp = false;
4773         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4774                 (*i)->set_pre_fader (!had_amp);
4775                 if (*i == _amp) {
4776                         had_amp = true;
4777                 }
4778         }
4779 }
4780
4781 /** Called when there is a proposed change to the input port count */
4782 bool
4783 Route::input_port_count_changing (ChanCount to)
4784 {
4785         list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
4786         if (c.empty()) {
4787                 /* The processors cannot be configured with the new input arrangement, so
4788                    block the change.
4789                 */
4790                 return true;
4791         }
4792
4793         /* The change is ok */
4794         return false;
4795 }
4796
4797 /** Called when there is a proposed change to the output port count */
4798 bool
4799 Route::output_port_count_changing (ChanCount to)
4800 {
4801         if (_strict_io && !_in_configure_processors) {
4802                 return true;
4803         }
4804         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
4805                 if (processor_out_streams.get(*t) > to.get(*t)) {
4806                         return true;
4807                 }
4808         }
4809         /* The change is ok */
4810         return false;
4811 }
4812
4813 list<string>
4814 Route::unknown_processors () const
4815 {
4816         list<string> p;
4817
4818         if (_session.get_disable_all_loaded_plugins ()) {
4819                 // Do not list "missing plugins" if they are explicitly disabled
4820                 return p;
4821         }
4822
4823         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4824         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4825                 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
4826                         p.push_back ((*i)->name ());
4827                 }
4828         }
4829
4830         return p;
4831 }
4832
4833
4834 framecnt_t
4835 Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecnt_t our_latency) const
4836 {
4837         /* we assume that all our input ports feed all our output ports. its not
4838            universally true, but the alternative is way too corner-case to worry about.
4839         */
4840
4841         LatencyRange all_connections;
4842
4843         if (from.empty()) {
4844                 all_connections.min = 0;
4845                 all_connections.max = 0;
4846         } else {
4847                 all_connections.min = ~((pframes_t) 0);
4848                 all_connections.max = 0;
4849
4850                 /* iterate over all "from" ports and determine the latency range for all of their
4851                    connections to the "outside" (outside of this Route).
4852                 */
4853
4854                 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
4855
4856                         LatencyRange range;
4857
4858                         p->get_connected_latency_range (range, playback);
4859
4860                         all_connections.min = min (all_connections.min, range.min);
4861                         all_connections.max = max (all_connections.max, range.max);
4862                 }
4863         }
4864
4865         /* set the "from" port latencies to the max/min range of all their connections */
4866
4867         for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
4868                 p->set_private_latency_range (all_connections, playback);
4869         }
4870
4871         /* set the ports "in the direction of the flow" to the same value as above plus our own signal latency */
4872
4873         all_connections.min += our_latency;
4874         all_connections.max += our_latency;
4875
4876         for (PortSet::iterator p = to.begin(); p != to.end(); ++p) {
4877                 p->set_private_latency_range (all_connections, playback);
4878         }
4879
4880         return all_connections.max;
4881 }
4882
4883 framecnt_t
4884 Route::set_private_port_latencies (bool playback) const
4885 {
4886         framecnt_t own_latency = 0;
4887
4888         /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD
4889            OR LATENCY CALLBACK.
4890
4891            This is called (early) from the latency callback. It computes the REAL
4892            latency associated with each port and stores the result as the "private"
4893            latency of the port. A later call to Route::set_public_port_latencies()
4894            sets all ports to the same value to reflect the fact that we do latency
4895            compensation and so all signals are delayed by the same amount as they
4896            flow through ardour.
4897         */
4898
4899         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4900                 if ((*i)->active ()) {
4901                         own_latency += (*i)->signal_latency ();
4902                 }
4903         }
4904
4905         if (playback) {
4906                 /* playback: propagate latency from "outside the route" to outputs to inputs */
4907                 return update_port_latencies (_output->ports (), _input->ports (), true, own_latency);
4908         } else {
4909                 /* capture: propagate latency from "outside the route" to inputs to outputs */
4910                 return update_port_latencies (_input->ports (), _output->ports (), false, own_latency);
4911         }
4912 }
4913
4914 void
4915 Route::set_public_port_latencies (framecnt_t value, bool playback) const
4916 {
4917         /* this is called to set the JACK-visible port latencies, which take
4918            latency compensation into account.
4919         */
4920
4921         LatencyRange range;
4922
4923         range.min = value;
4924         range.max = value;
4925
4926         {
4927                 const PortSet& ports (_input->ports());
4928                 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
4929                         p->set_public_latency_range (range, playback);
4930                 }
4931         }
4932
4933         {
4934                 const PortSet& ports (_output->ports());
4935                 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
4936                         p->set_public_latency_range (range, playback);
4937                 }
4938         }
4939 }
4940
4941 /** Put the invisible processors in the right place in _processors.
4942  *  Must be called with a writer lock on _processor_lock held.
4943  */
4944 #ifdef __clang__
4945 __attribute__((annotate("realtime")))
4946 #endif
4947 void
4948 Route::setup_invisible_processors ()
4949 {
4950 #ifndef NDEBUG
4951         Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
4952         assert (!lm.locked ());
4953 #endif
4954
4955         if (!_main_outs) {
4956                 /* too early to be doing this stuff */
4957                 return;
4958         }
4959
4960         /* we'll build this new list here and then use it
4961          *
4962          * TODO put the ProcessorList is on the stack for RT-safety.
4963          */
4964
4965         ProcessorList new_processors;
4966
4967         /* find visible processors */
4968
4969         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4970                 if ((*i)->display_to_user ()) {
4971                         new_processors.push_back (*i);
4972                 }
4973         }
4974
4975         /* find the amp */
4976
4977         ProcessorList::iterator amp = new_processors.begin ();
4978         while (amp != new_processors.end() && *amp != _amp) {
4979                 ++amp;
4980         }
4981
4982         assert (amp != new_processors.end ());
4983
4984         /* and the processor after the amp */
4985
4986         ProcessorList::iterator after_amp = amp;
4987         ++after_amp;
4988
4989         /* METER */
4990
4991         if (_meter) {
4992                 switch (_meter_point) {
4993                 case MeterInput:
4994                         assert (!_meter->display_to_user ());
4995                         new_processors.push_front (_meter);
4996                         break;
4997                 case MeterPreFader:
4998                         assert (!_meter->display_to_user ());
4999                         new_processors.insert (amp, _meter);
5000                         break;
5001                 case MeterPostFader:
5002                         /* do nothing here */
5003                         break;
5004                 case MeterOutput:
5005                         /* do nothing here */
5006                         break;
5007                 case MeterCustom:
5008                         /* the meter is visible, so we don't touch it here */
5009                         break;
5010                 }
5011         }
5012
5013         /* MAIN OUTS */
5014
5015         assert (_main_outs);
5016         assert (!_main_outs->display_to_user ());
5017         new_processors.push_back (_main_outs);
5018
5019         /* iterator for the main outs */
5020
5021         ProcessorList::iterator main = new_processors.end();
5022         --main;
5023
5024         /* OUTPUT METERING */
5025
5026         if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
5027                 assert (!_meter->display_to_user ());
5028
5029                 /* add the processor just before or just after the main outs */
5030
5031                 ProcessorList::iterator meter_point = main;
5032
5033                 if (_meter_point == MeterOutput) {
5034                         ++meter_point;
5035                 }
5036                 new_processors.insert (meter_point, _meter);
5037         }
5038
5039         /* MONITOR SEND */
5040
5041         if (_monitor_send && !is_monitor ()) {
5042                 assert (!_monitor_send->display_to_user ());
5043                 switch (Config->get_listen_position ()) {
5044                 case PreFaderListen:
5045                         switch (Config->get_pfl_position ()) {
5046                         case PFLFromBeforeProcessors:
5047                                 new_processors.push_front (_monitor_send);
5048                                 break;
5049                         case PFLFromAfterProcessors:
5050                                 new_processors.insert (amp, _monitor_send);
5051                                 break;
5052                         }
5053                         _monitor_send->set_can_pan (false);
5054                         break;
5055                 case AfterFaderListen:
5056                         switch (Config->get_afl_position ()) {
5057                         case AFLFromBeforeProcessors:
5058                                 new_processors.insert (after_amp, _monitor_send);
5059                                 break;
5060                         case AFLFromAfterProcessors:
5061                                 new_processors.insert (new_processors.end(), _monitor_send);
5062                                 break;
5063                         }
5064                         _monitor_send->set_can_pan (true);
5065                         break;
5066                 }
5067         }
5068
5069 #if 0 // not used - just yet
5070         if (!is_master() && !is_monitor() && !is_auditioner()) {
5071                 new_processors.push_front (_delayline);
5072         }
5073 #endif
5074
5075         /* MONITOR CONTROL */
5076
5077         if (_monitor_control && is_monitor ()) {
5078                 assert (!_monitor_control->display_to_user ());
5079                 new_processors.insert (amp, _monitor_control);
5080         }
5081
5082         /* INTERNAL RETURN */
5083
5084         /* doing this here means that any monitor control will come just after
5085            the return.
5086         */
5087
5088         if (_intreturn) {
5089                 assert (!_intreturn->display_to_user ());
5090                 new_processors.push_front (_intreturn);
5091         }
5092
5093         if (_trim && _trim->active()) {
5094                 assert (!_trim->display_to_user ());
5095                 new_processors.push_front (_trim);
5096         }
5097         /* EXPORT PROCESSOR */
5098
5099         if (_capturing_processor) {
5100                 assert (!_capturing_processor->display_to_user ());
5101                 new_processors.push_front (_capturing_processor);
5102         }
5103
5104         _processors = new_processors;
5105
5106         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
5107                 if (!(*i)->display_to_user () && !(*i)->active () && (*i) != _monitor_send) {
5108                         (*i)->activate ();
5109                 }
5110         }
5111
5112         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
5113         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
5114                 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
5115         }
5116 }
5117
5118 void
5119 Route::unpan ()
5120 {
5121         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
5122         Glib::Threads::RWLock::ReaderLock lp (_processor_lock);
5123
5124         _pannable.reset ();
5125
5126         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
5127                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery>(*i);
5128                 if (d) {
5129                         d->unpan ();
5130                 }
5131         }
5132 }
5133
5134 /** If the meter point is `Custom', make a note of where the meter is.
5135  *  This is so that if the meter point is subsequently set to something else,
5136  *  and then back to custom, we can put the meter back where it was last time
5137  *  custom was enabled.
5138  *
5139  *  Must be called with the _processor_lock held.
5140  */
5141 void
5142 Route::maybe_note_meter_position ()
5143 {
5144         if (_meter_point != MeterCustom) {
5145                 return;
5146         }
5147
5148         _custom_meter_position_noted = true;
5149         /* custom meter points range from after trim to before panner/main_outs
5150          * this is a limitation by the current processor UI
5151          */
5152         bool seen_trim = false;
5153         _processor_after_last_custom_meter.reset();
5154         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
5155                 if ((*i) == _trim) {
5156                         seen_trim = true;
5157                 }
5158                 if ((*i) == _main_outs) {
5159                         _processor_after_last_custom_meter = *i;
5160                         break;
5161                 }
5162                 if (boost::dynamic_pointer_cast<PeakMeter> (*i)) {
5163                         if (!seen_trim) {
5164                                 _processor_after_last_custom_meter = _trim;
5165                         } else {
5166                                 ProcessorList::iterator j = i;
5167                                 ++j;
5168                                 assert(j != _processors.end ()); // main_outs should be before
5169                                 _processor_after_last_custom_meter = *j;
5170                         }
5171                         break;
5172                 }
5173         }
5174         assert(_processor_after_last_custom_meter.lock());
5175 }
5176
5177 boost::shared_ptr<Processor>
5178 Route::processor_by_id (PBD::ID id) const
5179 {
5180         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
5181         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
5182                 if ((*i)->id() == id) {
5183                         return *i;
5184                 }
5185         }
5186
5187         return boost::shared_ptr<Processor> ();
5188 }
5189
5190 /** @return the monitoring state, or in other words what data we are pushing
5191  *  into the route (data from the inputs, data from disk or silence)
5192  */
5193 MonitorState
5194 Route::monitoring_state () const
5195 {
5196         return MonitoringInput;
5197 }
5198
5199 /** @return what we should be metering; either the data coming from the input
5200  *  IO or the data that is flowing through the route.
5201  */
5202 MeterState
5203 Route::metering_state () const
5204 {
5205         return MeteringRoute;
5206 }
5207
5208 bool
5209 Route::has_external_redirects () const
5210 {
5211         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
5212
5213                 /* ignore inactive processors and obviously ignore the main
5214                  * outs since everything has them and we don't care.
5215                  */
5216
5217                 if ((*i)->active() && (*i) != _main_outs && (*i)->does_routing()) {
5218                         return true;;
5219                 }
5220         }
5221
5222         return false;
5223 }
5224
5225 boost::shared_ptr<Processor>
5226 Route::the_instrument () const
5227 {
5228         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
5229         return the_instrument_unlocked ();
5230 }
5231
5232 boost::shared_ptr<Processor>
5233 Route::the_instrument_unlocked () const
5234 {
5235         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
5236                 if (boost::dynamic_pointer_cast<PluginInsert>(*i)) {
5237                         if ((*i)->input_streams().n_midi() > 0 &&
5238                             (*i)->output_streams().n_audio() > 0) {
5239                                 return (*i);
5240                         }
5241                 }
5242         }
5243         return boost::shared_ptr<Processor>();
5244 }
5245
5246
5247
5248 void
5249 Route::non_realtime_locate (framepos_t pos)
5250 {
5251         if (_pannable) {
5252                 _pannable->transport_located (pos);
5253         }
5254
5255         if (_delayline.get()) {
5256                 _delayline.get()->flush();
5257         }
5258
5259         {
5260                 //Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
5261                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
5262
5263                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
5264                         (*i)->transport_located (pos);
5265                 }
5266         }
5267         _roll_delay = _initial_delay;
5268 }
5269
5270 void
5271 Route::fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes)
5272 {
5273         size_t n_buffers;
5274         size_t i;
5275
5276         /* MIDI
5277          *
5278          * We don't currently mix MIDI input together, so we don't need the
5279          * complex logic of the audio case.
5280          */
5281
5282         n_buffers = bufs.count().n_midi ();
5283
5284         for (i = 0; i < n_buffers; ++i) {
5285
5286                 boost::shared_ptr<MidiPort> source_port = io->midi (i);
5287                 MidiBuffer& buf (bufs.get_midi (i));
5288
5289                 if (source_port) {
5290                         buf.copy (source_port->get_midi_buffer(nframes));
5291                 } else {
5292                         buf.silence (nframes);
5293                 }
5294         }
5295
5296         /* AUDIO */
5297
5298         n_buffers = bufs.count().n_audio();
5299
5300         size_t n_ports = io->n_ports().n_audio();
5301         float scaling = 1.0f;
5302
5303         if (n_ports > n_buffers) {
5304                 scaling = ((float) n_buffers) / n_ports;
5305         }
5306
5307         for (i = 0; i < n_ports; ++i) {
5308
5309                 /* if there are more ports than buffers, map them onto buffers
5310                  * in a round-robin fashion
5311                  */
5312
5313                 boost::shared_ptr<AudioPort> source_port = io->audio (i);
5314                 AudioBuffer& buf (bufs.get_audio (i%n_buffers));
5315
5316
5317                 if (i < n_buffers) {
5318
5319                         /* first time through just copy a channel into
5320                            the output buffer.
5321                         */
5322
5323                         buf.read_from (source_port->get_audio_buffer (nframes), nframes);
5324
5325                         if (scaling != 1.0f) {
5326                                 buf.apply_gain (scaling, nframes);
5327                         }
5328
5329                 } else {
5330
5331                         /* on subsequent times around, merge data from
5332                          * the port with what is already there
5333                          */
5334
5335                         if (scaling != 1.0f) {
5336                                 buf.accumulate_with_gain_from (source_port->get_audio_buffer (nframes), nframes, 0, scaling);
5337                         } else {
5338                                 buf.accumulate_from (source_port->get_audio_buffer (nframes), nframes);
5339                         }
5340                 }
5341         }
5342
5343         /* silence any remaining buffers */
5344
5345         for (; i < n_buffers; ++i) {
5346                 AudioBuffer& buf (bufs.get_audio (i));
5347                 buf.silence (nframes);
5348         }
5349
5350         /* establish the initial setup of the buffer set, reflecting what was
5351            copied into it. unless, of course, we are the auditioner, in which
5352            case nothing was fed into it from the inputs at all.
5353         */
5354
5355         if (!is_auditioner()) {
5356                 bufs.set_count (io->n_ports());
5357         }
5358 }
5359
5360 boost::shared_ptr<AutomationControl>
5361 Route::pan_azimuth_control() const
5362 {
5363 #ifdef MIXBUS
5364         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5365         if (!plug) {
5366                 return boost::shared_ptr<AutomationControl>();
5367         }
5368         const uint32_t port_channel_post_pan = 2; // gtk2_ardour/mixbus_ports.h
5369         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_channel_post_pan)));
5370 #else
5371         if (!_pannable || !panner()) {
5372                 return boost::shared_ptr<AutomationControl>();
5373         }
5374         return _pannable->pan_azimuth_control;
5375 #endif
5376 }
5377
5378 boost::shared_ptr<AutomationControl>
5379 Route::pan_elevation_control() const
5380 {
5381         if (Profile->get_mixbus() || !_pannable || !panner()) {
5382                 return boost::shared_ptr<AutomationControl>();
5383         }
5384
5385         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
5386
5387         if (c.find (PanElevationAutomation) != c.end()) {
5388                 return _pannable->pan_elevation_control;
5389         } else {
5390                 return boost::shared_ptr<AutomationControl>();
5391         }
5392 }
5393 boost::shared_ptr<AutomationControl>
5394 Route::pan_width_control() const
5395 {
5396         if (Profile->get_mixbus() || !_pannable || !panner()) {
5397                 return boost::shared_ptr<AutomationControl>();
5398         }
5399
5400         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
5401
5402         if (c.find (PanWidthAutomation) != c.end()) {
5403                 return _pannable->pan_width_control;
5404         } else {
5405                 return boost::shared_ptr<AutomationControl>();
5406         }
5407 }
5408 boost::shared_ptr<AutomationControl>
5409 Route::pan_frontback_control() const
5410 {
5411         if (Profile->get_mixbus() || !_pannable || !panner()) {
5412                 return boost::shared_ptr<AutomationControl>();
5413         }
5414
5415         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
5416
5417         if (c.find (PanFrontBackAutomation) != c.end()) {
5418                 return _pannable->pan_frontback_control;
5419         } else {
5420                 return boost::shared_ptr<AutomationControl>();
5421         }
5422 }
5423 boost::shared_ptr<AutomationControl>
5424 Route::pan_lfe_control() const
5425 {
5426         if (Profile->get_mixbus() || !_pannable || !panner()) {
5427                 return boost::shared_ptr<AutomationControl>();
5428         }
5429
5430         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
5431
5432         if (c.find (PanLFEAutomation) != c.end()) {
5433                 return _pannable->pan_lfe_control;
5434         } else {
5435                 return boost::shared_ptr<AutomationControl>();
5436         }
5437 }
5438
5439 uint32_t
5440 Route::eq_band_cnt () const
5441 {
5442         if (Profile->get_mixbus()) {
5443                 return 3;
5444         } else {
5445                 /* Ardour has no well-known EQ object */
5446                 return 0;
5447         }
5448 }
5449
5450 boost::shared_ptr<AutomationControl>
5451 Route::eq_gain_controllable (uint32_t band) const
5452 {
5453 #ifdef MIXBUS
5454         boost::shared_ptr<PluginInsert> eq = ch_eq();
5455
5456         if (!eq) {
5457                 return boost::shared_ptr<AutomationControl>();
5458         }
5459
5460         uint32_t port_number;
5461         switch (band) {
5462         case 0:
5463                 if (is_master() || mixbus()) {
5464                         port_number = 4;
5465                 } else {
5466                         port_number = 8;
5467                 }
5468                 break;
5469         case 1:
5470                 if (is_master() || mixbus()) {
5471                         port_number = 3;
5472                 } else {
5473                         port_number = 6;
5474                 }
5475                 break;
5476         case 2:
5477                 if (is_master() || mixbus()) {
5478                         port_number = 2;
5479                 } else {
5480                         port_number = 4;
5481                 }
5482                 break;
5483         default:
5484                 return boost::shared_ptr<AutomationControl>();
5485         }
5486
5487         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_number)));
5488 #else
5489         return boost::shared_ptr<AutomationControl>();
5490 #endif
5491 }
5492 boost::shared_ptr<AutomationControl>
5493 Route::eq_freq_controllable (uint32_t band) const
5494 {
5495 #ifdef MIXBUS
5496
5497         if (mixbus() || is_master()) {
5498                 /* no frequency controls for mixbusses or master */
5499                 return boost::shared_ptr<AutomationControl>();
5500         }
5501
5502         boost::shared_ptr<PluginInsert> eq = ch_eq();
5503
5504         if (!eq) {
5505                 return boost::shared_ptr<AutomationControl>();
5506         }
5507
5508         uint32_t port_number;
5509         switch (band) {
5510         case 0:
5511                 port_number = 7;
5512                 break;
5513         case 1:
5514                 port_number = 5;
5515                 break;
5516         case 2:
5517                 port_number = 3;
5518                 break;
5519         default:
5520                 return boost::shared_ptr<AutomationControl>();
5521         }
5522
5523         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_number)));
5524 #else
5525         return boost::shared_ptr<AutomationControl>();
5526 #endif
5527 }
5528
5529 boost::shared_ptr<AutomationControl>
5530 Route::eq_q_controllable (uint32_t band) const
5531 {
5532         return boost::shared_ptr<AutomationControl>();
5533 }
5534
5535 boost::shared_ptr<AutomationControl>
5536 Route::eq_shape_controllable (uint32_t band) const
5537 {
5538         return boost::shared_ptr<AutomationControl>();
5539 }
5540
5541 boost::shared_ptr<AutomationControl>
5542 Route::eq_enable_controllable () const
5543 {
5544 #ifdef MIXBUS
5545         boost::shared_ptr<PluginInsert> eq = ch_eq();
5546
5547         if (!eq) {
5548                 return boost::shared_ptr<AutomationControl>();
5549         }
5550
5551         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 1)));
5552 #else
5553         return boost::shared_ptr<AutomationControl>();
5554 #endif
5555 }
5556
5557 boost::shared_ptr<AutomationControl>
5558 Route::eq_hpf_controllable () const
5559 {
5560 #ifdef MIXBUS
5561         boost::shared_ptr<PluginInsert> eq = ch_eq();
5562
5563         if (!eq) {
5564                 return boost::shared_ptr<AutomationControl>();
5565         }
5566
5567         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
5568 #else
5569         return boost::shared_ptr<AutomationControl>();
5570 #endif
5571 }
5572
5573 string
5574 Route::eq_band_name (uint32_t band) const
5575 {
5576         if (Profile->get_mixbus()) {
5577                 switch (band) {
5578                 case 0:
5579                         return _("lo");
5580                 case 1:
5581                         return _("mid");
5582                 case 2:
5583                         return _("hi");
5584                 default:
5585                         return string();
5586                 }
5587         } else {
5588                 return string ();
5589         }
5590 }
5591
5592 boost::shared_ptr<AutomationControl>
5593 Route::comp_enable_controllable () const
5594 {
5595 #ifdef MIXBUS
5596         boost::shared_ptr<PluginInsert> comp = ch_comp();
5597
5598         if (!comp) {
5599                 return boost::shared_ptr<AutomationControl>();
5600         }
5601
5602         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 1)));
5603 #else
5604         return boost::shared_ptr<AutomationControl>();
5605 #endif
5606 }
5607 boost::shared_ptr<AutomationControl>
5608 Route::comp_threshold_controllable () const
5609 {
5610 #ifdef MIXBUS
5611         boost::shared_ptr<PluginInsert> comp = ch_comp();
5612
5613         if (!comp) {
5614                 return boost::shared_ptr<AutomationControl>();
5615         }
5616
5617         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
5618
5619 #else
5620         return boost::shared_ptr<AutomationControl>();
5621 #endif
5622 }
5623 boost::shared_ptr<AutomationControl>
5624 Route::comp_speed_controllable () const
5625 {
5626 #ifdef MIXBUS
5627         boost::shared_ptr<PluginInsert> comp = ch_comp();
5628
5629         if (!comp) {
5630                 return boost::shared_ptr<AutomationControl>();
5631         }
5632
5633         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 3)));
5634 #else
5635         return boost::shared_ptr<AutomationControl>();
5636 #endif
5637 }
5638 boost::shared_ptr<AutomationControl>
5639 Route::comp_mode_controllable () const
5640 {
5641 #ifdef MIXBUS
5642         boost::shared_ptr<PluginInsert> comp = ch_comp();
5643
5644         if (!comp) {
5645                 return boost::shared_ptr<AutomationControl>();
5646         }
5647
5648         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 4)));
5649 #else
5650         return boost::shared_ptr<AutomationControl>();
5651 #endif
5652 }
5653 boost::shared_ptr<AutomationControl>
5654 Route::comp_makeup_controllable () const
5655 {
5656 #ifdef MIXBUS
5657         boost::shared_ptr<PluginInsert> comp = ch_comp();
5658
5659         if (!comp) {
5660                 return boost::shared_ptr<AutomationControl>();
5661         }
5662
5663         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 5)));
5664 #else
5665         return boost::shared_ptr<AutomationControl>();
5666 #endif
5667 }
5668 boost::shared_ptr<AutomationControl>
5669 Route::comp_redux_controllable () const
5670 {
5671 #ifdef MIXBUS
5672         boost::shared_ptr<PluginInsert> comp = ch_comp();
5673
5674         if (!comp) {
5675                 return boost::shared_ptr<AutomationControl>();
5676         }
5677
5678         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 6)));
5679 #else
5680         return boost::shared_ptr<AutomationControl>();
5681 #endif
5682 }
5683
5684 string
5685 Route::comp_mode_name (uint32_t mode) const
5686 {
5687 #ifdef MIXBUS
5688         switch (mode) {
5689         case 0:
5690                 return _("Leveler");
5691         case 1:
5692                 return _("Compressor");
5693         case 2:
5694                 return _("Limiter");
5695         case 3:
5696                 return mixbus() ? _("Sidechain") : _("Limiter");
5697         }
5698
5699         return _("???");
5700 #else
5701         return _("???");
5702 #endif
5703 }
5704
5705 string
5706 Route::comp_speed_name (uint32_t mode) const
5707 {
5708 #ifdef MIXBUS
5709         switch (mode) {
5710         case 0:
5711                 return _("Attk");
5712         case 1:
5713                 return _("Ratio");
5714         case 2:
5715         case 3:
5716                 return _("Rels");
5717         }
5718         return _("???");
5719 #else
5720         return _("???");
5721 #endif
5722 }
5723
5724 boost::shared_ptr<AutomationControl>
5725 Route::send_level_controllable (uint32_t n) const
5726 {
5727 #ifdef  MIXBUS
5728         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5729         if (!plug) {
5730                 return boost::shared_ptr<AutomationControl>();
5731         }
5732
5733         if (n >= 8) {
5734                 /* no such bus */
5735                 return boost::shared_ptr<AutomationControl>();
5736         }
5737
5738         const uint32_t port_id = port_channel_post_aux1_level + (2*n); // gtk2_ardour/mixbus_ports.h
5739         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_id)));
5740 #else
5741         boost::shared_ptr<Send> s = boost::dynamic_pointer_cast<Send>(nth_send (n));
5742         if (!s) {
5743                 return boost::shared_ptr<AutomationControl>();
5744         }
5745         return s->gain_control ();
5746 #endif
5747 }
5748
5749 boost::shared_ptr<AutomationControl>
5750 Route::send_enable_controllable (uint32_t n) const
5751 {
5752 #ifdef  MIXBUS
5753         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5754         if (!plug) {
5755                 return boost::shared_ptr<AutomationControl>();
5756         }
5757
5758         if (n >= 8) {
5759                 /* no such bus */
5760                 return boost::shared_ptr<AutomationControl>();
5761         }
5762
5763         const uint32_t port_id = port_channel_post_aux1_asgn + (2*n); // gtk2_ardour/mixbus_ports.h
5764         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_id)));
5765 #else
5766         /* although Ardour sends have enable/disable as part of the Processor
5767            API, it is not exposed as a controllable.
5768
5769            XXX: we should fix this.
5770         */
5771         return boost::shared_ptr<AutomationControl>();
5772 #endif
5773 }
5774
5775 string
5776 Route::send_name (uint32_t n) const
5777 {
5778 #ifdef MIXBUS
5779         if (n >= 8) {
5780                 return string();
5781         }
5782         boost::shared_ptr<Route> r = _session.get_mixbus (n);
5783         assert (r);
5784         return r->name();
5785 #else
5786         boost::shared_ptr<Processor> p = nth_send (n);
5787         if (p) {
5788                 return p->name();
5789         } else {
5790                 return string();
5791         }
5792 #endif
5793 }
5794
5795 boost::shared_ptr<AutomationControl>
5796 Route::master_send_enable_controllable () const
5797 {
5798 #ifdef  MIXBUS
5799         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5800         if (!plug) {
5801                 return boost::shared_ptr<AutomationControl>();
5802         }
5803         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_channel_post_mstr_assign)));
5804 #else
5805         return boost::shared_ptr<AutomationControl>();
5806 #endif
5807 }