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