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