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