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