libs/ardour/route.cc

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