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