libs/ardour/route.cc

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