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