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