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