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