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