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