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