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