libs/ardour/route.cc

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