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