libs/ardour/route.cc

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