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         assert (!AudioEngine::instance()->process_lock().trylock());
1591
1592         if (!_in_configure_processors) {
1593                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1594                 return configure_processors_unlocked (err);
1595         }
1596
1597         return 0;
1598 }
1599
1600 ChanCount
1601 Route::input_streams () const
1602 {
1603         return _input->n_ports ();
1604 }
1605
1606 list<pair<ChanCount, ChanCount> >
1607 Route::try_configure_processors (ChanCount in, ProcessorStreams* err)
1608 {
1609         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1610
1611         return try_configure_processors_unlocked (in, err);
1612 }
1613
1614 list<pair<ChanCount, ChanCount> >
1615 Route::try_configure_processors_unlocked (ChanCount in, ProcessorStreams* err)
1616 {
1617         // Check each processor in order to see if we can configure as requested
1618         ChanCount out;
1619         list<pair<ChanCount, ChanCount> > configuration;
1620         uint32_t index = 0;
1621
1622         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
1623         DEBUG_TRACE (DEBUG::Processors, "{\n");
1624
1625         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1626
1627                 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1628                         DEBUG_TRACE (DEBUG::Processors, "--- CONFIGURE ABORTED due to unknown processor.\n");
1629                         DEBUG_TRACE (DEBUG::Processors, "}\n");
1630                         return list<pair<ChanCount, ChanCount> > ();
1631                 }
1632
1633                 if ((*p)->can_support_io_configuration(in, out)) {
1634                         DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID=%2 in=%3 out=%4\n",(*p)->name(), (*p)->id(), in, out));
1635                         configuration.push_back(make_pair(in, out));
1636                         in = out;
1637                 } else {
1638                         if (err) {
1639                                 err->index = index;
1640                                 err->count = in;
1641                         }
1642                         DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
1643                         DEBUG_TRACE (DEBUG::Processors, string_compose ("---- %1 cannot support in=%2 out=%3\n", (*p)->name(), in, out));
1644                         DEBUG_TRACE (DEBUG::Processors, "}\n");
1645                         return list<pair<ChanCount, ChanCount> > ();
1646                 }
1647         }
1648
1649         DEBUG_TRACE (DEBUG::Processors, "}\n");
1650
1651         return configuration;
1652 }
1653
1654 /** Set the input/output configuration of each processor in the processors list.
1655  *  Caller must hold process lock.
1656  *  Return 0 on success, otherwise configuration is impossible.
1657  */
1658 int
1659 Route::configure_processors_unlocked (ProcessorStreams* err)
1660 {
1661         assert (!AudioEngine::instance()->process_lock().trylock());
1662
1663         if (_in_configure_processors) {
1664                 return 0;
1665         }
1666
1667         /* put invisible processors where they should be */
1668         setup_invisible_processors ();
1669
1670         _in_configure_processors = true;
1671
1672         list<pair<ChanCount, ChanCount> > configuration = try_configure_processors_unlocked (input_streams (), err);
1673
1674         if (configuration.empty ()) {
1675                 _in_configure_processors = false;
1676                 return -1;
1677         }
1678
1679         ChanCount out;
1680         bool seen_mains_out = false;
1681         processor_out_streams = _input->n_ports();
1682         processor_max_streams.reset();
1683
1684         list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1685         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1686
1687                 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1688                         break;
1689                 }
1690
1691                 (*p)->configure_io(c->first, c->second);
1692                 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1693                 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1694                 out = c->second;
1695
1696                 if (boost::dynamic_pointer_cast<Delivery> (*p)
1697                                 && boost::dynamic_pointer_cast<Delivery> (*p)->role() == Delivery::Main) {
1698                         /* main delivery will increase port count to match input.
1699                          * the Delivery::Main is usually the last processor - followed only by
1700                          * 'MeterOutput'.
1701                          */
1702                         seen_mains_out = true;
1703                 }
1704                 if (!seen_mains_out) {
1705                         processor_out_streams = out;
1706                 }
1707         }
1708
1709
1710         if (_meter) {
1711                 _meter->reset_max_channels (processor_max_streams);
1712         }
1713
1714         /* make sure we have sufficient scratch buffers to cope with the new processor
1715            configuration
1716         */
1717         _session.ensure_buffers (n_process_buffers ());
1718
1719         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
1720
1721         _in_configure_processors = false;
1722         return 0;
1723 }
1724
1725 /** Set all visible processors to a given active state (except Fader, whose state is not changed)
1726  *  @param state New active state for those processors.
1727  */
1728 void
1729 Route::all_visible_processors_active (bool state)
1730 {
1731         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1732
1733         if (_processors.empty()) {
1734                 return;
1735         }
1736
1737         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1738                 if (!(*i)->display_to_user() || boost::dynamic_pointer_cast<Amp> (*i)) {
1739                         continue;
1740                 }
1741
1742                 if (state) {
1743                         (*i)->activate ();
1744                 } else {
1745                         (*i)->deactivate ();
1746                 }
1747         }
1748
1749         _session.set_dirty ();
1750 }
1751
1752 int
1753 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
1754 {
1755         /* "new_order" is an ordered list of processors to be positioned according to "placement".
1756            NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
1757            processors in the current actual processor list that are hidden. Any visible processors
1758            in the current list but not in "new_order" will be assumed to be deleted.
1759         */
1760
1761         {
1762                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1763                 ProcessorState pstate (this);
1764
1765                 ProcessorList::iterator oiter;
1766                 ProcessorList::const_iterator niter;
1767                 ProcessorList as_it_will_be;
1768
1769                 oiter = _processors.begin();
1770                 niter = new_order.begin();
1771
1772                 while (niter !=  new_order.end()) {
1773
1774                         /* if the next processor in the old list is invisible (i.e. should not be in the new order)
1775                            then append it to the temp list.
1776
1777                            Otherwise, see if the next processor in the old list is in the new list. if not,
1778                            its been deleted. If its there, append it to the temp list.
1779                         */
1780
1781                         if (oiter == _processors.end()) {
1782
1783                                 /* no more elements in the old list, so just stick the rest of
1784                                    the new order onto the temp list.
1785                                 */
1786
1787                                 as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
1788                                 while (niter != new_order.end()) {
1789                                         ++niter;
1790                                 }
1791                                 break;
1792
1793                         } else {
1794
1795                                 if (!(*oiter)->display_to_user()) {
1796
1797                                         as_it_will_be.push_back (*oiter);
1798
1799                                 } else {
1800
1801                                         /* visible processor: check that its in the new order */
1802
1803                                         if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
1804                                                 /* deleted: do nothing, shared_ptr<> will clean up */
1805                                         } else {
1806                                                 /* ignore this one, and add the next item from the new order instead */
1807                                                 as_it_will_be.push_back (*niter);
1808                                                 ++niter;
1809                                         }
1810                                 }
1811
1812                                 /* now remove from old order - its taken care of no matter what */
1813                                 oiter = _processors.erase (oiter);
1814                         }
1815
1816                 }
1817
1818                 _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
1819
1820                 /* If the meter is in a custom position, find it and make a rough note of its position */
1821                 maybe_note_meter_position ();
1822
1823                 {
1824                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1825
1826                         if (configure_processors_unlocked (err)) {
1827                                 pstate.restore ();
1828                                 return -1;
1829                         }
1830                 }
1831         }
1832
1833         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1834         set_processor_positions ();
1835
1836         return 0;
1837 }
1838
1839 XMLNode&
1840 Route::get_state()
1841 {
1842         return state(true);
1843 }
1844
1845 XMLNode&
1846 Route::get_template()
1847 {
1848         return state(false);
1849 }
1850
1851 XMLNode&
1852 Route::state(bool full_state)
1853 {
1854         XMLNode *node = new XMLNode("Route");
1855         ProcessorList::iterator i;
1856         char buf[32];
1857
1858         id().print (buf, sizeof (buf));
1859         node->add_property("id", buf);
1860         node->add_property ("name", _name);
1861         node->add_property("default-type", _default_type.to_string());
1862
1863         if (_flags) {
1864                 node->add_property("flags", enum_2_string (_flags));
1865         }
1866
1867         node->add_property("active", _active?"yes":"no");
1868         string p;
1869         boost::to_string (_phase_invert, p);
1870         node->add_property("phase-invert", p);
1871         node->add_property("denormal-protection", _denormal_protection?"yes":"no");
1872         node->add_property("meter-point", enum_2_string (_meter_point));
1873
1874         node->add_property("meter-type", enum_2_string (_meter_type));
1875
1876         if (_route_group) {
1877                 node->add_property("route-group", _route_group->name());
1878         }
1879
1880         snprintf (buf, sizeof (buf), "%d", _order_key);
1881         node->add_property ("order-key", buf);
1882         node->add_property ("self-solo", (_self_solo ? "yes" : "no"));
1883         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_upstream);
1884         node->add_property ("soloed-by-upstream", buf);
1885         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_downstream);
1886         node->add_property ("soloed-by-downstream", buf);
1887         node->add_property ("solo-isolated", solo_isolated() ? "yes" : "no");
1888         node->add_property ("solo-safe", _solo_safe ? "yes" : "no");
1889
1890         node->add_child_nocopy (_input->state (full_state));
1891         node->add_child_nocopy (_output->state (full_state));
1892         node->add_child_nocopy (_solo_control->get_state ());
1893         node->add_child_nocopy (_mute_control->get_state ());
1894         node->add_child_nocopy (_mute_master->get_state ());
1895
1896         XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
1897         snprintf (buf, sizeof (buf), "%d", _remote_control_id);
1898         remote_control_node->add_property (X_("id"), buf);
1899         node->add_child_nocopy (*remote_control_node);
1900
1901         if (_comment.length()) {
1902                 XMLNode *cmt = node->add_child ("Comment");
1903                 cmt->add_content (_comment);
1904         }
1905
1906         if (_pannable) {
1907                 node->add_child_nocopy (_pannable->state (full_state));
1908         }
1909
1910         for (i = _processors.begin(); i != _processors.end(); ++i) {
1911                 if (!full_state) {
1912                         /* template save: do not include internal sends functioning as
1913                            aux sends because the chance of the target ID
1914                            in the session where this template is used
1915                            is not very likely.
1916
1917                            similarly, do not save listen sends which connect to
1918                            the monitor section, because these will always be
1919                            added if necessary.
1920                         */
1921                         boost::shared_ptr<InternalSend> is;
1922
1923                         if ((is = boost::dynamic_pointer_cast<InternalSend> (*i)) != 0) {
1924                                 if (is->role() == Delivery::Listen) {
1925                                         continue;
1926                                 }
1927                         }
1928                 }
1929                 node->add_child_nocopy((*i)->state (full_state));
1930         }
1931
1932         if (_extra_xml) {
1933                 node->add_child_copy (*_extra_xml);
1934         }
1935
1936         if (_custom_meter_position_noted) {
1937                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
1938                 if (after) {
1939                         after->id().print (buf, sizeof (buf));
1940                         node->add_property (X_("processor-after-last-custom-meter"), buf);
1941                 }
1942
1943                 node->add_property (X_("last-custom-meter-was-at-end"), _last_custom_meter_was_at_end ? "yes" : "no");
1944         }
1945
1946         return *node;
1947 }
1948
1949 int
1950 Route::set_state (const XMLNode& node, int version)
1951 {
1952         if (version < 3000) {
1953                 return set_state_2X (node, version);
1954         }
1955
1956         XMLNodeList nlist;
1957         XMLNodeConstIterator niter;
1958         XMLNode *child;
1959         const XMLProperty *prop;
1960
1961         if (node.name() != "Route"){
1962                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1963                 return -1;
1964         }
1965
1966         if ((prop = node.property (X_("name"))) != 0) {
1967                 Route::set_name (prop->value());
1968         }
1969
1970         set_id (node);
1971         _initial_io_setup = true;
1972
1973         if ((prop = node.property (X_("flags"))) != 0) {
1974                 _flags = Flag (string_2_enum (prop->value(), _flags));
1975         } else {
1976                 _flags = Flag (0);
1977         }
1978
1979         if (is_master() || is_monitor() || is_auditioner()) {
1980                 _mute_master->set_solo_ignore (true);
1981         }
1982
1983         if (is_monitor()) {
1984                 /* monitor bus does not get a panner, but if (re)created
1985                    via XML, it will already have one by the time we
1986                    call ::set_state(). so ... remove it.
1987                 */
1988                 unpan ();
1989         }
1990
1991         /* add all processors (except amp, which is always present) */
1992
1993         nlist = node.children();
1994         XMLNode processor_state (X_("processor_state"));
1995
1996         Stateful::save_extra_xml (node);
1997
1998         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1999
2000                 child = *niter;
2001
2002                 if (child->name() == IO::state_node_name) {
2003                         if ((prop = child->property (X_("direction"))) == 0) {
2004                                 continue;
2005                         }
2006
2007                         if (prop->value() == "Input") {
2008                                 _input->set_state (*child, version);
2009                         } else if (prop->value() == "Output") {
2010                                 _output->set_state (*child, version);
2011                         }
2012                 }
2013
2014                 if (child->name() == X_("Processor")) {
2015                         processor_state.add_child_copy (*child);
2016                 }
2017
2018                 if (child->name() == X_("Pannable")) {
2019                         if (_pannable) {
2020                                 _pannable->set_state (*child, version);
2021                         } else {
2022                                 warning << string_compose (_("Pannable state found for route (%1) without a panner!"), name()) << endmsg;
2023                         }
2024                 }
2025         }
2026
2027         if ((prop = node.property (X_("meter-point"))) != 0) {
2028                 MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
2029                 set_meter_point (mp, true);
2030                 if (_meter) {
2031                         _meter->set_display_to_user (_meter_point == MeterCustom);
2032                 }
2033         }
2034
2035         if ((prop = node.property (X_("meter-type"))) != 0) {
2036                 _meter_type = MeterType (string_2_enum (prop->value (), _meter_type));
2037         }
2038
2039         _initial_io_setup = false;
2040
2041         set_processor_state (processor_state);
2042
2043         // this looks up the internal instrument in processors
2044         reset_instrument_info();
2045
2046         if ((prop = node.property ("self-solo")) != 0) {
2047                 set_self_solo (string_is_affirmative (prop->value()));
2048         }
2049
2050         if ((prop = node.property ("soloed-by-upstream")) != 0) {
2051                 _soloed_by_others_upstream = 0; // needed for mod_.... () to work
2052                 mod_solo_by_others_upstream (atoi (prop->value()));
2053         }
2054
2055         if ((prop = node.property ("soloed-by-downstream")) != 0) {
2056                 _soloed_by_others_downstream = 0; // needed for mod_.... () to work
2057                 mod_solo_by_others_downstream (atoi (prop->value()));
2058         }
2059
2060         if ((prop = node.property ("solo-isolated")) != 0) {
2061                 set_solo_isolated (string_is_affirmative (prop->value()), this);
2062         }
2063
2064         if ((prop = node.property ("solo-safe")) != 0) {
2065                 set_solo_safe (string_is_affirmative (prop->value()), this);
2066         }
2067
2068         if ((prop = node.property (X_("phase-invert"))) != 0) {
2069                 set_phase_invert (boost::dynamic_bitset<> (prop->value ()));
2070         }
2071
2072         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2073                 set_denormal_protection (string_is_affirmative (prop->value()));
2074         }
2075
2076         if ((prop = node.property (X_("active"))) != 0) {
2077                 bool yn = string_is_affirmative (prop->value());
2078                 _active = !yn; // force switch
2079                 set_active (yn, this);
2080         }
2081
2082         if ((prop = node.property (X_("order-key"))) != 0) { // New order key (no separate mixer/editor ordering)
2083                 set_order_key (atoi(prop->value()));
2084         }
2085
2086         if ((prop = node.property (X_("order-keys"))) != 0) { // Deprecated order keys
2087
2088                 int32_t n;
2089
2090                 string::size_type colon, equal;
2091                 string remaining = prop->value();
2092
2093                 while (remaining.length()) {
2094
2095                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2096                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2097                                       << endmsg;
2098                         } else {
2099                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2100                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2101                                               << endmsg;
2102                                 } else {
2103                                         string keyname = remaining.substr (0, equal);
2104
2105                                         if ((keyname == "EditorSort") || (keyname == "editor")) {
2106                                                 cerr << "Setting " << name() << " order key to " << n << " using saved Editor order." << endl;
2107                                                 set_order_key (n);
2108                                         }
2109                                 }
2110                         }
2111
2112                         colon = remaining.find_first_of (':');
2113
2114                         if (colon != string::npos) {
2115                                 remaining = remaining.substr (colon+1);
2116                         } else {
2117                                 break;
2118                         }
2119                 }
2120         }
2121
2122         if ((prop = node.property (X_("processor-after-last-custom-meter"))) != 0) {
2123                 PBD::ID id (prop->value ());
2124                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2125                 ProcessorList::const_iterator i = _processors.begin ();
2126                 while (i != _processors.end() && (*i)->id() != id) {
2127                         ++i;
2128                 }
2129
2130                 if (i != _processors.end ()) {
2131                         _processor_after_last_custom_meter = *i;
2132                         _custom_meter_position_noted = true;
2133                 }
2134         }
2135
2136         if ((prop = node.property (X_("last-custom-meter-was-at-end"))) != 0) {
2137                 _last_custom_meter_was_at_end = string_is_affirmative (prop->value ());
2138         }
2139
2140         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2141                 child = *niter;
2142
2143                 if (child->name() == X_("Comment")) {
2144
2145                         /* XXX this is a terrible API design in libxml++ */
2146
2147                         XMLNode *cmt = *(child->children().begin());
2148                         _comment = cmt->content();
2149
2150                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2151                         if (prop->value() == "solo") {
2152                                 _solo_control->set_state (*child, version);
2153                         } else if (prop->value() == "mute") {
2154                                 _mute_control->set_state (*child, version);
2155                         }
2156
2157                 } else if (child->name() == X_("RemoteControl")) {
2158                         if ((prop = child->property (X_("id"))) != 0) {
2159                                 int32_t x;
2160                                 sscanf (prop->value().c_str(), "%d", &x);
2161                                 set_remote_control_id_internal (x);
2162                         }
2163
2164                 } else if (child->name() == X_("MuteMaster")) {
2165                         _mute_master->set_state (*child, version);
2166                 }
2167         }
2168
2169         return 0;
2170 }
2171
2172 int
2173 Route::set_state_2X (const XMLNode& node, int version)
2174 {
2175         XMLNodeList nlist;
2176         XMLNodeConstIterator niter;
2177         XMLNode *child;
2178         const XMLProperty *prop;
2179
2180         /* 2X things which still remain to be handled:
2181          * default-type
2182          * automation
2183          * controlouts
2184          */
2185
2186         if (node.name() != "Route") {
2187                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2188                 return -1;
2189         }
2190
2191         if ((prop = node.property (X_("flags"))) != 0) {
2192                 string f = prop->value ();
2193                 boost::replace_all (f, "ControlOut", "MonitorOut");
2194                 _flags = Flag (string_2_enum (f, _flags));
2195         } else {
2196                 _flags = Flag (0);
2197         }
2198
2199         if (is_master() || is_monitor() || is_auditioner()) {
2200                 _mute_master->set_solo_ignore (true);
2201         }
2202
2203         if ((prop = node.property (X_("phase-invert"))) != 0) {
2204                 boost::dynamic_bitset<> p (_input->n_ports().n_audio ());
2205                 if (string_is_affirmative (prop->value ())) {
2206                         p.set ();
2207                 }
2208                 set_phase_invert (p);
2209         }
2210
2211         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2212                 set_denormal_protection (string_is_affirmative (prop->value()));
2213         }
2214
2215         if ((prop = node.property (X_("soloed"))) != 0) {
2216                 bool yn = string_is_affirmative (prop->value());
2217
2218                 /* XXX force reset of solo status */
2219
2220                 set_solo (yn, this);
2221         }
2222
2223         if ((prop = node.property (X_("muted"))) != 0) {
2224
2225                 bool first = true;
2226                 bool muted = string_is_affirmative (prop->value());
2227
2228                 if (muted) {
2229
2230                         string mute_point;
2231
2232                         if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
2233
2234                                 if (string_is_affirmative (prop->value())){
2235                                         mute_point = mute_point + "PreFader";
2236                                         first = false;
2237                                 }
2238                         }
2239
2240                         if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
2241
2242                                 if (string_is_affirmative (prop->value())){
2243
2244                                         if (!first) {
2245                                                 mute_point = mute_point + ",";
2246                                         }
2247
2248                                         mute_point = mute_point + "PostFader";
2249                                         first = false;
2250                                 }
2251                         }
2252
2253                         if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
2254
2255                                 if (string_is_affirmative (prop->value())){
2256
2257                                         if (!first) {
2258                                                 mute_point = mute_point + ",";
2259                                         }
2260
2261                                         mute_point = mute_point + "Listen";
2262                                         first = false;
2263                                 }
2264                         }
2265
2266                         if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
2267
2268                                 if (string_is_affirmative (prop->value())){
2269
2270                                         if (!first) {
2271                                                 mute_point = mute_point + ",";
2272                                         }
2273
2274                                         mute_point = mute_point + "Main";
2275                                 }
2276                         }
2277
2278                         _mute_master->set_mute_points (mute_point);
2279                         _mute_master->set_muted_by_self (true);
2280                 }
2281         }
2282
2283         if ((prop = node.property (X_("meter-point"))) != 0) {
2284                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2285         }
2286
2287         /* do not carry over edit/mix groups from 2.X because (a) its hard (b) they
2288            don't mean the same thing.
2289         */
2290
2291         if ((prop = node.property (X_("order-keys"))) != 0) {
2292
2293                 int32_t n;
2294
2295                 string::size_type colon, equal;
2296                 string remaining = prop->value();
2297
2298                 while (remaining.length()) {
2299
2300                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2301                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2302                                         << endmsg;
2303                         } else {
2304                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2305                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2306                                                 << endmsg;
2307                                 } else {
2308                                         string keyname = remaining.substr (0, equal);
2309
2310                                         if (keyname == "EditorSort" || keyname == "editor") {
2311                                                 info << string_compose(_("Converting deprecated order key for %1 using Editor order %2"), name (), n) << endmsg;
2312                                                 set_order_key (n);
2313                                         }
2314                                 }
2315                         }
2316
2317                         colon = remaining.find_first_of (':');
2318
2319                         if (colon != string::npos) {
2320                                 remaining = remaining.substr (colon+1);
2321                         } else {
2322                                 break;
2323                         }
2324                 }
2325         }
2326
2327         /* IOs */
2328
2329         nlist = node.children ();
2330         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2331
2332                 child = *niter;
2333
2334                 if (child->name() == IO::state_node_name) {
2335
2336                         /* there is a note in IO::set_state_2X() about why we have to call
2337                            this directly.
2338                            */
2339
2340                         _input->set_state_2X (*child, version, true);
2341                         _output->set_state_2X (*child, version, false);
2342
2343                         if ((prop = child->property (X_("name"))) != 0) {
2344                                 Route::set_name (prop->value ());
2345                         }
2346
2347                         set_id (*child);
2348
2349                         if ((prop = child->property (X_("active"))) != 0) {
2350                                 bool yn = string_is_affirmative (prop->value());
2351                                 _active = !yn; // force switch
2352                                 set_active (yn, this);
2353                         }
2354
2355                         if ((prop = child->property (X_("gain"))) != 0) {
2356                                 gain_t val;
2357
2358                                 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2359                                         _amp->gain_control()->set_value (val);
2360                                 }
2361                         }
2362
2363                         /* Set up Panners in the IO */
2364                         XMLNodeList io_nlist = child->children ();
2365
2366                         XMLNodeConstIterator io_niter;
2367                         XMLNode *io_child;
2368
2369                         for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2370
2371                                 io_child = *io_niter;
2372
2373                                 if (io_child->name() == X_("Panner")) {
2374                                         _main_outs->panner_shell()->set_state(*io_child, version);
2375                                 } else if (io_child->name() == X_("Automation")) {
2376                                         /* IO's automation is for the fader */
2377                                         _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
2378                                 }
2379                         }
2380                 }
2381         }
2382
2383         XMLNodeList redirect_nodes;
2384
2385         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2386
2387                 child = *niter;
2388
2389                 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2390                         redirect_nodes.push_back(child);
2391                 }
2392
2393         }
2394
2395         set_processor_state_2X (redirect_nodes, version);
2396
2397         Stateful::save_extra_xml (node);
2398
2399         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2400                 child = *niter;
2401
2402                 if (child->name() == X_("Comment")) {
2403
2404                         /* XXX this is a terrible API design in libxml++ */
2405
2406                         XMLNode *cmt = *(child->children().begin());
2407                         _comment = cmt->content();
2408
2409                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2410                         if (prop->value() == X_("solo")) {
2411                                 _solo_control->set_state (*child, version);
2412                         } else if (prop->value() == X_("mute")) {
2413                                 _mute_control->set_state (*child, version);
2414                         }
2415
2416                 } else if (child->name() == X_("RemoteControl")) {
2417                         if ((prop = child->property (X_("id"))) != 0) {
2418                                 int32_t x;
2419                                 sscanf (prop->value().c_str(), "%d", &x);
2420                                 set_remote_control_id_internal (x);
2421                         }
2422
2423                 }
2424         }
2425
2426         return 0;
2427 }
2428
2429 XMLNode&
2430 Route::get_processor_state ()
2431 {
2432         XMLNode* root = new XMLNode (X_("redirects"));
2433         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2434                 root->add_child_nocopy ((*i)->state (true));
2435         }
2436
2437         return *root;
2438 }
2439
2440 void
2441 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2442 {
2443         /* We don't bother removing existing processors not in nList, as this
2444            method will only be called when creating a Route from scratch, not
2445            for undo purposes.  Just put processors in at the appropriate place
2446            in the list.
2447         */
2448
2449         for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2450                 add_processor_from_xml_2X (**i, version);
2451         }
2452 }
2453
2454 void
2455 Route::set_processor_state (const XMLNode& node)
2456 {
2457         const XMLNodeList &nlist = node.children();
2458         XMLNodeConstIterator niter;
2459         ProcessorList new_order;
2460         bool must_configure = false;
2461
2462         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2463
2464                 XMLProperty* prop = (*niter)->property ("type");
2465
2466                 if (prop->value() == "amp") {
2467                         _amp->set_state (**niter, Stateful::current_state_version);
2468                         new_order.push_back (_amp);
2469                 } else if (prop->value() == "meter") {
2470                         _meter->set_state (**niter, Stateful::current_state_version);
2471                         new_order.push_back (_meter);
2472                 } else if (prop->value() == "main-outs") {
2473                         _main_outs->set_state (**niter, Stateful::current_state_version);
2474                 } else if (prop->value() == "intreturn") {
2475                         if (!_intreturn) {
2476                                 _intreturn.reset (new InternalReturn (_session));
2477                                 must_configure = true;
2478                         }
2479                         _intreturn->set_state (**niter, Stateful::current_state_version);
2480                 } else if (is_monitor() && prop->value() == "monitor") {
2481                         if (!_monitor_control) {
2482                                 _monitor_control.reset (new MonitorProcessor (_session));
2483                                 must_configure = true;
2484                         }
2485                         _monitor_control->set_state (**niter, Stateful::current_state_version);
2486                 } else if (prop->value() == "capture") {
2487                         /* CapturingProcessor should never be restored, it's always
2488                            added explicitly when needed */
2489                 } else {
2490                         ProcessorList::iterator o;
2491
2492                         for (o = _processors.begin(); o != _processors.end(); ++o) {
2493                                 XMLProperty* id_prop = (*niter)->property(X_("id"));
2494                                 if (id_prop && (*o)->id() == id_prop->value()) {
2495                                         (*o)->set_state (**niter, Stateful::current_state_version);
2496                                         new_order.push_back (*o);
2497                                         break;
2498                                 }
2499                         }
2500
2501                         // If the processor (*niter) is not on the route then create it
2502
2503                         if (o == _processors.end()) {
2504
2505                                 boost::shared_ptr<Processor> processor;
2506
2507                                 if (prop->value() == "intsend") {
2508
2509                                         processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::shared_ptr<Route>(), Delivery::Role (0)));
2510
2511                                 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2512                                            prop->value() == "lv2" ||
2513                                            prop->value() == "windows-vst" ||
2514                                            prop->value() == "lxvst" ||
2515                                            prop->value() == "audiounit") {
2516
2517                                         processor.reset (new PluginInsert(_session));
2518
2519                                 } else if (prop->value() == "port") {
2520
2521                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
2522
2523                                 } else if (prop->value() == "send") {
2524
2525                                         processor.reset (new Send (_session, _pannable, _mute_master));
2526
2527                                 } else {
2528                                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2529                                         continue;
2530                                 }
2531
2532                                 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2533                                         /* This processor could not be configured.  Turn it into a UnknownProcessor */
2534                                         processor.reset (new UnknownProcessor (_session, **niter));
2535                                 }
2536
2537                                 /* we have to note the monitor send here, otherwise a new one will be created
2538                                    and the state of this one will be lost.
2539                                 */
2540                                 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
2541                                 if (isend && isend->role() == Delivery::Listen) {
2542                                         _monitor_send = isend;
2543                                 }
2544
2545                                 /* it doesn't matter if invisible processors are added here, as they
2546                                    will be sorted out by setup_invisible_processors () shortly.
2547                                 */
2548
2549                                 new_order.push_back (processor);
2550                                 must_configure = true;
2551                         }
2552                 }
2553         }
2554
2555         {
2556                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2557                 _processors = new_order;
2558
2559                 if (must_configure) {
2560                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2561                         configure_processors_unlocked (0);
2562                 }
2563
2564                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2565
2566                         (*i)->set_owner (this);
2567                         (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
2568
2569                         boost::shared_ptr<PluginInsert> pi;
2570
2571                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
2572                                 if (pi->has_no_inputs ()) {
2573                                         _have_internal_generator = true;
2574                                         break;
2575                                 }
2576                         }
2577                 }
2578         }
2579
2580         reset_instrument_info ();
2581         processors_changed (RouteProcessorChange ());
2582         set_processor_positions ();
2583 }
2584
2585 void
2586 Route::curve_reallocate ()
2587 {
2588 //      _gain_automation_curve.finish_resize ();
2589 //      _pan_automation_curve.finish_resize ();
2590 }
2591
2592 void
2593 Route::silence (framecnt_t nframes)
2594 {
2595         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
2596         if (!lm.locked()) {
2597                 return;
2598         }
2599
2600         silence_unlocked (nframes);
2601 }
2602
2603 void
2604 Route::silence_unlocked (framecnt_t nframes)
2605 {
2606         /* Must be called with the processor lock held */
2607
2608         if (!_silent) {
2609
2610                 _output->silence (nframes);
2611
2612                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2613                         boost::shared_ptr<PluginInsert> pi;
2614
2615                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2616                                 // skip plugins, they don't need anything when we're not active
2617                                 continue;
2618                         }
2619
2620                         (*i)->silence (nframes);
2621                 }
2622
2623                 if (nframes == _session.get_block_size()) {
2624                         // _silent = true;
2625                 }
2626         }
2627 }
2628
2629 void
2630 Route::add_internal_return ()
2631 {
2632         if (!_intreturn) {
2633                 _intreturn.reset (new InternalReturn (_session));
2634                 add_processor (_intreturn, PreFader);
2635         }
2636 }
2637
2638 void
2639 Route::add_send_to_internal_return (InternalSend* send)
2640 {
2641         Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
2642
2643         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2644                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2645
2646                 if (d) {
2647                         return d->add_send (send);
2648                 }
2649         }
2650 }
2651
2652 void
2653 Route::remove_send_from_internal_return (InternalSend* send)
2654 {
2655         Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
2656
2657         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2658                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2659
2660                 if (d) {
2661                         return d->remove_send (send);
2662                 }
2663         }
2664 }
2665
2666 void
2667 Route::enable_monitor_send ()
2668 {
2669         /* Caller must hold process lock */
2670         assert (!AudioEngine::instance()->process_lock().trylock());
2671
2672         /* master never sends to monitor section via the normal mechanism */
2673         assert (!is_master ());
2674
2675         /* make sure we have one */
2676         if (!_monitor_send) {
2677                 _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, _session.monitor_out(), Delivery::Listen));
2678                 _monitor_send->set_display_to_user (false);
2679         }
2680
2681         /* set it up */
2682         configure_processors (0);
2683 }
2684
2685 /** Add an aux send to a route.
2686  *  @param route route to send to.
2687  *  @param before Processor to insert before, or 0 to insert at the end.
2688  */
2689 int
2690 Route::add_aux_send (boost::shared_ptr<Route> route, boost::shared_ptr<Processor> before)
2691 {
2692         assert (route != _session.monitor_out ());
2693
2694         {
2695                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
2696
2697                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2698
2699                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
2700
2701                         if (d && d->target_route() == route) {
2702                                 /* already listening via the specified IO: do nothing */
2703                                 return 0;
2704                         }
2705                 }
2706         }
2707
2708         try {
2709
2710                 boost::shared_ptr<InternalSend> listener;
2711
2712                 {
2713                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2714                         listener.reset (new InternalSend (_session, _pannable, _mute_master, route, Delivery::Aux));
2715                 }
2716
2717                 add_processor (listener, before);
2718
2719         } catch (failed_constructor& err) {
2720                 return -1;
2721         }
2722
2723         return 0;
2724 }
2725
2726 void
2727 Route::remove_aux_or_listen (boost::shared_ptr<Route> route)
2728 {
2729         ProcessorStreams err;
2730         ProcessorList::iterator tmp;
2731
2732         {
2733                 Glib::Threads::RWLock::ReaderLock rl(_processor_lock);
2734
2735                 /* have to do this early because otherwise processor reconfig
2736                  * will put _monitor_send back in the list
2737                  */
2738
2739                 if (route == _session.monitor_out()) {
2740                         _monitor_send.reset ();
2741                 }
2742
2743           again:
2744                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2745
2746                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2747
2748                         if (d && d->target_route() == route) {
2749                                 rl.release ();
2750                                 remove_processor (*x, &err, false);
2751                                 rl.acquire ();
2752
2753                                 /* list could have been demolished while we dropped the lock
2754                                    so start over.
2755                                 */
2756
2757                                 goto again;
2758                         }
2759                 }
2760         }
2761 }
2762
2763 void
2764 Route::set_comment (string cmt, void *src)
2765 {
2766         _comment = cmt;
2767         comment_changed (src);
2768         _session.set_dirty ();
2769 }
2770
2771 bool
2772 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
2773 {
2774         FeedRecord fr (other, via_sends_only);
2775
2776         pair<FedBy::iterator,bool> result =  _fed_by.insert (fr);
2777
2778         if (!result.second) {
2779
2780                 /* already a record for "other" - make sure sends-only information is correct */
2781                 if (!via_sends_only && result.first->sends_only) {
2782                         FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
2783                         frp->sends_only = false;
2784                 }
2785         }
2786
2787         return result.second;
2788 }
2789
2790 void
2791 Route::clear_fed_by ()
2792 {
2793         _fed_by.clear ();
2794 }
2795
2796 bool
2797 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
2798 {
2799         const FedBy& fed_by (other->fed_by());
2800
2801         for (FedBy::iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
2802                 boost::shared_ptr<Route> sr = f->r.lock();
2803
2804                 if (sr && (sr.get() == this)) {
2805
2806                         if (via_sends_only) {
2807                                 *via_sends_only = f->sends_only;
2808                         }
2809
2810                         return true;
2811                 }
2812         }
2813
2814         return false;
2815 }
2816
2817 bool
2818 Route::direct_feeds_according_to_reality (boost::shared_ptr<Route> other, bool* via_send_only)
2819 {
2820         DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
2821
2822         if (_output->connected_to (other->input())) {
2823                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
2824                 if (via_send_only) {
2825                         *via_send_only = false;
2826                 }
2827
2828                 return true;
2829         }
2830
2831
2832         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
2833
2834                 boost::shared_ptr<IOProcessor> iop;
2835
2836                 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
2837                         if (iop->feeds (other)) {
2838                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
2839                                 if (via_send_only) {
2840                                         *via_send_only = true;
2841                                 }
2842                                 return true;
2843                         } else {
2844                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
2845                         }
2846                 } else {
2847                         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
2848                 }
2849
2850         }
2851
2852         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tdoes NOT feed %1\n", other->name()));
2853         return false;
2854 }
2855
2856 bool
2857 Route::direct_feeds_according_to_graph (boost::shared_ptr<Route> other, bool* via_send_only)
2858 {
2859         return _session._current_route_graph.has (shared_from_this (), other, via_send_only);
2860 }
2861
2862 /** Called from the (non-realtime) butler thread when the transport is stopped */
2863 void
2864 Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool /*did_locate*/, bool can_flush_processors)
2865 {
2866         framepos_t now = _session.transport_frame();
2867
2868         {
2869                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2870
2871                 Automatable::transport_stopped (now);
2872
2873                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2874
2875                         if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && can_flush_processors)) {
2876                                 (*i)->flush ();
2877                         }
2878
2879                         (*i)->transport_stopped (now);
2880                 }
2881         }
2882
2883         _roll_delay = _initial_delay;
2884 }
2885
2886 void
2887 Route::input_change_handler (IOChange change, void * /*src*/)
2888 {
2889         bool need_to_queue_solo_change = true;
2890
2891         if ((change.type & IOChange::ConfigurationChanged)) {
2892                 /* This is called with the process lock held if change
2893                    contains ConfigurationChanged
2894                 */
2895                 need_to_queue_solo_change = false;
2896                 configure_processors (0);
2897                 _phase_invert.resize (_input->n_ports().n_audio ());
2898                 io_changed (); /* EMIT SIGNAL */
2899         }
2900
2901         if (!_input->connected() && _soloed_by_others_upstream) {
2902                 if (need_to_queue_solo_change) {
2903                         _session.cancel_solo_after_disconnect (shared_from_this(), true);
2904                 } else {
2905                         cancel_solo_after_disconnect (true);
2906                 }
2907         }
2908 }
2909
2910 void
2911 Route::output_change_handler (IOChange change, void * /*src*/)
2912 {
2913         bool need_to_queue_solo_change = true;
2914         if (_initial_io_setup) {
2915                 return;
2916         }
2917
2918         if ((change.type & IOChange::ConfigurationChanged)) {
2919                 /* This is called with the process lock held if change
2920                    contains ConfigurationChanged
2921                 */
2922                 need_to_queue_solo_change = false;
2923                 configure_processors (0);
2924                 io_changed (); /* EMIT SIGNAL */
2925         }
2926
2927         if (!_output->connected() && _soloed_by_others_downstream) {
2928                 if (need_to_queue_solo_change) {
2929                         _session.cancel_solo_after_disconnect (shared_from_this(), false);
2930                 } else {
2931                         cancel_solo_after_disconnect (false);
2932                 }
2933         }
2934 }
2935
2936 void
2937 Route::cancel_solo_after_disconnect (bool upstream)
2938 {
2939         if (upstream) {
2940                 _soloed_by_others_upstream = 0;
2941         } else {
2942                 _soloed_by_others_downstream = 0;
2943         }
2944         set_mute_master_solo ();
2945         solo_changed (false, this);
2946 }
2947
2948 uint32_t
2949 Route::pans_required () const
2950 {
2951         if (n_outputs().n_audio() < 2) {
2952                 return 0;
2953         }
2954
2955         return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
2956 }
2957
2958 int
2959 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
2960 {
2961         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
2962
2963         if (!lm.locked()) {
2964                 return 0;
2965         }
2966
2967         if (n_outputs().n_total() == 0) {
2968                 return 0;
2969         }
2970
2971         if (!_active || n_inputs() == ChanCount::ZERO)  {
2972                 silence_unlocked (nframes);
2973                 return 0;
2974         }
2975
2976         if (session_state_changing) {
2977                 if (_session.transport_speed() != 0.0f) {
2978                         /* we're rolling but some state is changing (e.g. our diskstream contents)
2979                            so we cannot use them. Be silent till this is over.
2980
2981                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
2982                         */
2983                         silence_unlocked (nframes);
2984                         return 0;
2985                 }
2986                 /* we're really not rolling, so we're either delivery silence or actually
2987                    monitoring, both of which are safe to do while session_state_changing is true.
2988                 */
2989         }
2990
2991         BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
2992
2993         fill_buffers_with_input (bufs, _input, nframes);
2994
2995         if (_meter_point == MeterInput) {
2996                 _meter->run (bufs, start_frame, end_frame, nframes, true);
2997         }
2998
2999         _amp->apply_gain_automation (false);
3000         passthru (bufs, start_frame, end_frame, nframes, 0);
3001
3002         return 0;
3003 }
3004
3005 int
3006 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& /* need_butler */)
3007 {
3008         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3009         if (!lm.locked()) {
3010                 return 0;
3011         }
3012
3013         if (n_outputs().n_total() == 0) {
3014                 return 0;
3015         }
3016
3017         if (!_active || n_inputs().n_total() == 0) {
3018                 silence_unlocked (nframes);
3019                 return 0;
3020         }
3021
3022         framepos_t unused = 0;
3023
3024         if ((nframes = check_initial_delay (nframes, unused)) == 0) {
3025                 return 0;
3026         }
3027
3028         _silent = false;
3029
3030         BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
3031
3032         fill_buffers_with_input (bufs, _input, nframes);
3033
3034         if (_meter_point == MeterInput) {
3035                 _meter->run (bufs, start_frame, end_frame, nframes, true);
3036         }
3037
3038         passthru (bufs, start_frame, end_frame, nframes, declick);
3039
3040         return 0;
3041 }
3042
3043 int
3044 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& /* need_butler */)
3045 {
3046         silence (nframes);
3047         return 0;
3048 }
3049
3050 void
3051 Route::flush_processors ()
3052 {
3053         /* XXX shouldn't really try to take this lock, since
3054            this is called from the RT audio thread.
3055         */
3056
3057         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3058
3059         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3060                 (*i)->flush ();
3061         }
3062 }
3063
3064 void
3065 Route::set_meter_point (MeterPoint p, bool force)
3066 {
3067         if (_meter_point == p && !force) {
3068                 return;
3069         }
3070
3071         bool meter_was_visible_to_user = _meter->display_to_user ();
3072
3073         {
3074                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3075
3076                 maybe_note_meter_position ();
3077
3078                 _meter_point = p;
3079
3080                 if (_meter_point != MeterCustom) {
3081
3082                         _meter->set_display_to_user (false);
3083
3084                         setup_invisible_processors ();
3085
3086                 } else {
3087
3088                         _meter->set_display_to_user (true);
3089
3090                         /* If we have a previous position for the custom meter, try to put it there */
3091                         if (_custom_meter_position_noted) {
3092                                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
3093
3094                                 if (after) {
3095                                         ProcessorList::iterator i = find (_processors.begin(), _processors.end(), after);
3096                                         if (i != _processors.end ()) {
3097                                                 _processors.remove (_meter);
3098                                                 _processors.insert (i, _meter);
3099                                         }
3100                                 } else if (_last_custom_meter_was_at_end) {
3101                                         _processors.remove (_meter);
3102                                         _processors.push_back (_meter);
3103                                 }
3104                         }
3105                 }
3106
3107                 /* Set up the meter for its new position */
3108
3109                 ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
3110
3111                 ChanCount m_in;
3112
3113                 if (loc == _processors.begin()) {
3114                         m_in = _input->n_ports();
3115                 } else {
3116                         ProcessorList::iterator before = loc;
3117                         --before;
3118                         m_in = (*before)->output_streams ();
3119                 }
3120
3121                 _meter->reflect_inputs (m_in);
3122
3123                 /* we do not need to reconfigure the processors, because the meter
3124                    (a) is always ready to handle processor_max_streams
3125                    (b) is always an N-in/N-out processor, and thus moving
3126                    it doesn't require any changes to the other processors.
3127                 */
3128         }
3129
3130         meter_change (); /* EMIT SIGNAL */
3131
3132         bool const meter_visibly_changed = (_meter->display_to_user() != meter_was_visible_to_user);
3133
3134         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
3135 }
3136
3137 void
3138 Route::listen_position_changed ()
3139 {
3140         {
3141                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3142                 ProcessorState pstate (this);
3143
3144                 {
3145                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3146
3147                         if (configure_processors_unlocked (0)) {
3148                                 pstate.restore ();
3149                                 configure_processors_unlocked (0); // it worked before we tried to add it ...
3150                                 return;
3151                         }
3152                 }
3153         }
3154
3155         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
3156         _session.set_dirty ();
3157 }
3158
3159 boost::shared_ptr<CapturingProcessor>
3160 Route::add_export_point()
3161 {
3162         if (!_capturing_processor) {
3163
3164                 _capturing_processor.reset (new CapturingProcessor (_session));
3165                 _capturing_processor->activate ();
3166
3167                 {
3168                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3169                         configure_processors (0);
3170                 }
3171
3172         }
3173
3174         return _capturing_processor;
3175 }
3176
3177 framecnt_t
3178 Route::update_signal_latency ()
3179 {
3180         framecnt_t l = _output->user_latency();
3181
3182         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3183                 if ((*i)->active ()) {
3184                         l += (*i)->signal_latency ();
3185                 }
3186         }
3187
3188         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l));
3189
3190         if (_signal_latency != l) {
3191                 _signal_latency = l;
3192                 signal_latency_changed (); /* EMIT SIGNAL */
3193         }
3194
3195         return _signal_latency;
3196 }
3197
3198 void
3199 Route::set_user_latency (framecnt_t nframes)
3200 {
3201         _output->set_user_latency (nframes);
3202         _session.update_latency_compensation ();
3203 }
3204
3205 void
3206 Route::set_latency_compensation (framecnt_t longest_session_latency)
3207 {
3208         framecnt_t old = _initial_delay;
3209
3210         if (_signal_latency < longest_session_latency) {
3211                 _initial_delay = longest_session_latency - _signal_latency;
3212         } else {
3213                 _initial_delay = 0;
3214         }
3215
3216         DEBUG_TRACE (DEBUG::Latency, string_compose (
3217                              "%1: compensate for maximum latency of %2,"
3218                              "given own latency of %3, using initial delay of %4\n",
3219                              name(), longest_session_latency, _signal_latency, _initial_delay));
3220
3221         if (_initial_delay != old) {
3222                 initial_delay_changed (); /* EMIT SIGNAL */
3223         }
3224
3225         if (_session.transport_stopped()) {
3226                 _roll_delay = _initial_delay;
3227         }
3228 }
3229
3230 Route::SoloControllable::SoloControllable (std::string name, boost::shared_ptr<Route> r)
3231         : AutomationControl (r->session(), Evoral::Parameter (SoloAutomation),
3232                              boost::shared_ptr<AutomationList>(), name)
3233         , _route (r)
3234 {
3235         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
3236         set_list (gl);
3237 }
3238
3239 void
3240 Route::SoloControllable::set_value (double val)
3241 {
3242         bool bval = ((val >= 0.5f) ? true: false);
3243
3244         boost::shared_ptr<RouteList> rl (new RouteList);
3245
3246         boost::shared_ptr<Route> r = _route.lock ();
3247         if (!r) {
3248                 return;
3249         }
3250
3251         rl->push_back (r);
3252
3253         if (Config->get_solo_control_is_listen_control()) {
3254                 _session.set_listen (rl, bval);
3255         } else {
3256                 _session.set_solo (rl, bval);
3257         }
3258 }
3259
3260 double
3261 Route::SoloControllable::get_value () const
3262 {
3263         boost::shared_ptr<Route> r = _route.lock ();
3264         if (!r) {
3265                 return 0;
3266         }
3267
3268         if (Config->get_solo_control_is_listen_control()) {
3269                 return r->listening_via_monitor() ? 1.0f : 0.0f;
3270         } else {
3271                 return r->self_soloed() ? 1.0f : 0.0f;
3272         }
3273 }
3274
3275 Route::MuteControllable::MuteControllable (std::string name, boost::shared_ptr<Route> r)
3276         : AutomationControl (r->session(), Evoral::Parameter (MuteAutomation),
3277                              boost::shared_ptr<AutomationList>(), name)
3278         , _route (r)
3279 {
3280         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MuteAutomation)));
3281         set_list (gl);
3282 }
3283
3284 void
3285 Route::MuteControllable::set_value (double val)
3286 {
3287         bool bval = ((val >= 0.5f) ? true: false);
3288
3289         boost::shared_ptr<RouteList> rl (new RouteList);
3290
3291         boost::shared_ptr<Route> r = _route.lock ();
3292         if (!r) {
3293                 return;
3294         }
3295
3296         rl->push_back (r);
3297         _session.set_mute (rl, bval);
3298 }
3299
3300 double
3301 Route::MuteControllable::get_value () const
3302 {
3303         boost::shared_ptr<Route> r = _route.lock ();
3304         if (!r) {
3305                 return 0;
3306         }
3307
3308         return r->muted() ? 1.0f : 0.0f;
3309 }
3310
3311 void
3312 Route::set_block_size (pframes_t nframes)
3313 {
3314         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3315                 (*i)->set_block_size (nframes);
3316         }
3317
3318         _session.ensure_buffers (n_process_buffers ());
3319 }
3320
3321 void
3322 Route::protect_automation ()
3323 {
3324         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3325                 (*i)->protect_automation();
3326 }
3327
3328 /** @param declick 1 to set a pending declick fade-in,
3329  *                -1 to set a pending declick fade-out
3330  */
3331 void
3332 Route::set_pending_declick (int declick)
3333 {
3334         if (_declickable) {
3335                 /* this call is not allowed to turn off a pending declick */
3336                 if (declick) {
3337                         _pending_declick = declick;
3338                 }
3339         } else {
3340                 _pending_declick = 0;
3341         }
3342 }
3343
3344 /** Shift automation forwards from a particular place, thereby inserting time.
3345  *  Adds undo commands for any shifts that are performed.
3346  *
3347  * @param pos Position to start shifting from.
3348  * @param frames Amount to shift forwards by.
3349  */
3350
3351 void
3352 Route::shift (framepos_t pos, framecnt_t frames)
3353 {
3354         /* gain automation */
3355         {
3356                 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
3357
3358                 XMLNode &before = gc->alist()->get_state ();
3359                 gc->alist()->shift (pos, frames);
3360                 XMLNode &after = gc->alist()->get_state ();
3361                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3362         }
3363
3364         /* pan automation */
3365         if (_pannable) {
3366                 ControlSet::Controls& c (_pannable->controls());
3367
3368                 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
3369                         boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
3370                         if (pc) {
3371                                 boost::shared_ptr<AutomationList> al = pc->alist();
3372                                 XMLNode& before = al->get_state ();
3373                                 al->shift (pos, frames);
3374                                 XMLNode& after = al->get_state ();
3375                                 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3376                         }
3377                 }
3378         }
3379
3380         /* redirect automation */
3381         {
3382                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3383                 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
3384
3385                         set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
3386
3387                         for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
3388                                 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
3389                                 if (ac) {
3390                                         boost::shared_ptr<AutomationList> al = ac->alist();
3391                                         XMLNode &before = al->get_state ();
3392                                         al->shift (pos, frames);
3393                                         XMLNode &after = al->get_state ();
3394                                         _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3395                                 }
3396                         }
3397                 }
3398         }
3399 }
3400
3401
3402 int
3403 Route::save_as_template (const string& path, const string& name)
3404 {
3405         XMLNode& node (state (false));
3406         XMLTree tree;
3407
3408         IO::set_name_in_state (*node.children().front(), name);
3409
3410         tree.set_root (&node);
3411         return tree.write (path.c_str());
3412 }
3413
3414
3415 bool
3416 Route::set_name (const string& str)
3417 {
3418         bool ret;
3419         string ioproc_name;
3420         string name;
3421
3422         name = Route::ensure_track_or_route_name (str, _session);
3423         SessionObject::set_name (name);
3424
3425         ret = (_input->set_name(name) && _output->set_name(name));
3426
3427         if (ret) {
3428                 /* rename the main outs. Leave other IO processors
3429                  * with whatever name they already have, because its
3430                  * just fine as it is (it will not contain the route
3431                  * name if its a port insert, port send or port return).
3432                  */
3433
3434                 if (_main_outs) {
3435                         if (_main_outs->set_name (name)) {
3436                                 /* XXX returning false here is stupid because
3437                                    we already changed the route name.
3438                                 */
3439                                 return false;
3440                         }
3441                 }
3442         }
3443
3444         return ret;
3445 }
3446
3447 /** Set the name of a route in an XML description.
3448  *  @param node XML <Route> node to set the name in.
3449  *  @param name New name.
3450  */
3451 void
3452 Route::set_name_in_state (XMLNode& node, string const & name)
3453 {
3454         node.add_property (X_("name"), name);
3455
3456         XMLNodeList children = node.children();
3457         for (XMLNodeIterator i = children.begin(); i != children.end(); ++i) {
3458
3459                 if ((*i)->name() == X_("IO")) {
3460
3461                         IO::set_name_in_state (**i, name);
3462
3463                 } else if ((*i)->name() == X_("Processor")) {
3464
3465                         XMLProperty* role = (*i)->property (X_("role"));
3466                         if (role && role->value() == X_("Main")) {
3467                                 (*i)->add_property (X_("name"), name);
3468                         }
3469
3470                 } else if ((*i)->name() == X_("Diskstream")) {
3471
3472                         (*i)->add_property (X_("playlist"), string_compose ("%1.1", name).c_str());
3473                         (*i)->add_property (X_("name"), name);
3474
3475                 }
3476         }
3477 }
3478
3479 boost::shared_ptr<Send>
3480 Route::internal_send_for (boost::shared_ptr<const Route> target) const
3481 {
3482         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3483
3484         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3485                 boost::shared_ptr<InternalSend> send;
3486
3487                 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
3488                         if (send->target_route() == target) {
3489                                 return send;
3490                         }
3491                 }
3492         }
3493
3494         return boost::shared_ptr<Send>();
3495 }
3496
3497 /** @param c Audio channel index.
3498  *  @param yn true to invert phase, otherwise false.
3499  */
3500 void
3501 Route::set_phase_invert (uint32_t c, bool yn)
3502 {
3503         if (_phase_invert[c] != yn) {
3504                 _phase_invert[c] = yn;
3505                 phase_invert_changed (); /* EMIT SIGNAL */
3506                 _session.set_dirty ();
3507         }
3508 }
3509
3510 void
3511 Route::set_phase_invert (boost::dynamic_bitset<> p)
3512 {
3513         if (_phase_invert != p) {
3514                 _phase_invert = p;
3515                 phase_invert_changed (); /* EMIT SIGNAL */
3516                 _session.set_dirty ();
3517         }
3518 }
3519
3520 bool
3521 Route::phase_invert (uint32_t c) const
3522 {
3523         return _phase_invert[c];
3524 }
3525
3526 boost::dynamic_bitset<>
3527 Route::phase_invert () const
3528 {
3529         return _phase_invert;
3530 }
3531
3532 void
3533 Route::set_denormal_protection (bool yn)
3534 {
3535         if (_denormal_protection != yn) {
3536                 _denormal_protection = yn;
3537                 denormal_protection_changed (); /* EMIT SIGNAL */
3538         }
3539 }
3540
3541 bool
3542 Route::denormal_protection () const
3543 {
3544         return _denormal_protection;
3545 }
3546
3547 void
3548 Route::set_active (bool yn, void* src)
3549 {
3550         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
3551                 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
3552                 return;
3553         }
3554
3555         if (_active != yn) {
3556                 _active = yn;
3557                 _input->set_active (yn);
3558                 _output->set_active (yn);
3559                 active_changed (); // EMIT SIGNAL
3560                 _session.set_dirty ();
3561         }
3562 }
3563
3564 void
3565 Route::meter ()
3566 {
3567         Glib::Threads::RWLock::ReaderLock rm (_processor_lock, Glib::Threads::TRY_LOCK);
3568
3569         assert (_meter);
3570
3571         _meter->meter ();
3572
3573         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3574
3575                 boost::shared_ptr<Send> s;
3576                 boost::shared_ptr<Return> r;
3577
3578                 if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
3579                         s->meter()->meter();
3580                 } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
3581                         r->meter()->meter ();
3582                 }
3583         }
3584 }
3585
3586 boost::shared_ptr<Pannable>
3587 Route::pannable() const
3588 {
3589         return _pannable;
3590 }
3591
3592 boost::shared_ptr<Panner>
3593 Route::panner() const
3594 {
3595         /* may be null ! */
3596         return _main_outs->panner_shell()->panner();
3597 }
3598
3599 boost::shared_ptr<PannerShell>
3600 Route::panner_shell() const
3601 {
3602         return _main_outs->panner_shell();
3603 }
3604
3605 boost::shared_ptr<AutomationControl>
3606 Route::gain_control() const
3607 {
3608         return _amp->gain_control();
3609 }
3610
3611 boost::shared_ptr<AutomationControl>
3612 Route::get_control (const Evoral::Parameter& param)
3613 {
3614         /* either we own the control or .... */
3615
3616         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
3617
3618         if (!c) {
3619
3620                 /* maybe one of our processors does or ... */
3621
3622                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock, Glib::Threads::TRY_LOCK);
3623                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3624                         if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
3625                                 break;
3626                         }
3627                 }
3628         }
3629
3630         if (!c) {
3631
3632                 /* nobody does so we'll make a new one */
3633
3634                 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
3635                 add_control(c);
3636         }
3637
3638         return c;
3639 }
3640
3641 boost::shared_ptr<Processor>
3642 Route::nth_plugin (uint32_t n)
3643 {
3644         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3645         ProcessorList::iterator i;
3646
3647         for (i = _processors.begin(); i != _processors.end(); ++i) {
3648                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
3649                         if (n-- == 0) {
3650                                 return *i;
3651                         }
3652                 }
3653         }
3654
3655         return boost::shared_ptr<Processor> ();
3656 }
3657
3658 boost::shared_ptr<Processor>
3659 Route::nth_send (uint32_t n)
3660 {
3661         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3662         ProcessorList::iterator i;
3663
3664         for (i = _processors.begin(); i != _processors.end(); ++i) {
3665                 if (boost::dynamic_pointer_cast<Send> (*i)) {
3666                         if (n-- == 0) {
3667                                 return *i;
3668                         }
3669                 }
3670         }
3671
3672         return boost::shared_ptr<Processor> ();
3673 }
3674
3675 bool
3676 Route::has_io_processor_named (const string& name)
3677 {
3678         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3679         ProcessorList::iterator i;
3680
3681         for (i = _processors.begin(); i != _processors.end(); ++i) {
3682                 if (boost::dynamic_pointer_cast<Send> (*i) ||
3683                     boost::dynamic_pointer_cast<PortInsert> (*i)) {
3684                         if ((*i)->name() == name) {
3685                                 return true;
3686                         }
3687                 }
3688         }
3689
3690         return false;
3691 }
3692
3693 MuteMaster::MutePoint
3694 Route::mute_points () const
3695 {
3696         return _mute_master->mute_points ();
3697 }
3698
3699 void
3700 Route::set_processor_positions ()
3701 {
3702         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3703
3704         bool had_amp = false;
3705         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3706                 (*i)->set_pre_fader (!had_amp);
3707                 if (boost::dynamic_pointer_cast<Amp> (*i)) {
3708                         had_amp = true;
3709                 }
3710         }
3711 }
3712
3713 /** Called when there is a proposed change to the input port count */
3714 bool
3715 Route::input_port_count_changing (ChanCount to)
3716 {
3717         list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
3718         if (c.empty()) {
3719                 /* The processors cannot be configured with the new input arrangement, so
3720                    block the change.
3721                 */
3722                 return true;
3723         }
3724
3725         /* The change is ok */
3726         return false;
3727 }
3728
3729 /** Called when there is a proposed change to the output port count */
3730 bool
3731 Route::output_port_count_changing (ChanCount to)
3732 {
3733         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
3734                 if (processor_out_streams.get(*t) > to.get(*t)) {
3735                         return true;
3736                 }
3737         }
3738         /* The change is ok */
3739         return false;
3740 }
3741
3742 list<string>
3743 Route::unknown_processors () const
3744 {
3745         list<string> p;
3746
3747         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3748         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3749                 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
3750                         p.push_back ((*i)->name ());
3751                 }
3752         }
3753
3754         return p;
3755 }
3756
3757
3758 framecnt_t
3759 Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecnt_t our_latency) const
3760 {
3761         /* we assume that all our input ports feed all our output ports. its not
3762            universally true, but the alternative is way too corner-case to worry about.
3763         */
3764
3765         LatencyRange all_connections;
3766
3767         if (from.empty()) {
3768                 all_connections.min = 0;
3769                 all_connections.max = 0;
3770         } else {
3771                 all_connections.min = ~((pframes_t) 0);
3772                 all_connections.max = 0;
3773
3774                 /* iterate over all "from" ports and determine the latency range for all of their
3775                    connections to the "outside" (outside of this Route).
3776                 */
3777
3778                 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
3779
3780                         LatencyRange range;
3781
3782                         p->get_connected_latency_range (range, playback);
3783
3784                         all_connections.min = min (all_connections.min, range.min);
3785                         all_connections.max = max (all_connections.max, range.max);
3786                 }
3787         }
3788
3789         /* set the "from" port latencies to the max/min range of all their connections */
3790
3791         for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
3792                 p->set_private_latency_range (all_connections, playback);
3793         }
3794
3795         /* set the ports "in the direction of the flow" to the same value as above plus our own signal latency */
3796
3797         all_connections.min += our_latency;
3798         all_connections.max += our_latency;
3799
3800         for (PortSet::iterator p = to.begin(); p != to.end(); ++p) {
3801                 p->set_private_latency_range (all_connections, playback);
3802         }
3803
3804         return all_connections.max;
3805 }
3806
3807 framecnt_t
3808 Route::set_private_port_latencies (bool playback) const
3809 {
3810         framecnt_t own_latency = 0;
3811
3812         /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD
3813            OR LATENCY CALLBACK.
3814
3815            This is called (early) from the latency callback. It computes the REAL
3816            latency associated with each port and stores the result as the "private"
3817            latency of the port. A later call to Route::set_public_port_latencies()
3818            sets all ports to the same value to reflect the fact that we do latency
3819            compensation and so all signals are delayed by the same amount as they
3820            flow through ardour.
3821         */
3822
3823         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3824                 if ((*i)->active ()) {
3825                         own_latency += (*i)->signal_latency ();
3826                 }
3827         }
3828
3829         if (playback) {
3830                 /* playback: propagate latency from "outside the route" to outputs to inputs */
3831                 return update_port_latencies (_output->ports (), _input->ports (), true, own_latency);
3832         } else {
3833                 /* capture: propagate latency from "outside the route" to inputs to outputs */
3834                 return update_port_latencies (_input->ports (), _output->ports (), false, own_latency);
3835         }
3836 }
3837
3838 void
3839 Route::set_public_port_latencies (framecnt_t value, bool playback) const
3840 {
3841         /* this is called to set the JACK-visible port latencies, which take
3842            latency compensation into account.
3843         */
3844
3845         LatencyRange range;
3846
3847         range.min = value;
3848         range.max = value;
3849
3850         {
3851                 const PortSet& ports (_input->ports());
3852                 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
3853                         p->set_public_latency_range (range, playback);
3854                 }
3855         }
3856
3857         {
3858                 const PortSet& ports (_output->ports());
3859                 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
3860                         p->set_public_latency_range (range, playback);
3861                 }
3862         }
3863 }
3864
3865 /** Put the invisible processors in the right place in _processors.
3866  *  Must be called with a writer lock on _processor_lock held.
3867  */
3868 void
3869 Route::setup_invisible_processors ()
3870 {
3871 #ifndef NDEBUG
3872         Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3873         assert (!lm.locked ());
3874 #endif
3875
3876         if (!_main_outs) {
3877                 /* too early to be doing this stuff */
3878                 return;
3879         }
3880
3881         /* we'll build this new list here and then use it */
3882
3883         ProcessorList new_processors;
3884
3885         /* find visible processors */
3886
3887         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3888                 if ((*i)->display_to_user ()) {
3889                         new_processors.push_back (*i);
3890                 }
3891         }
3892
3893         /* find the amp */
3894
3895         ProcessorList::iterator amp = new_processors.begin ();
3896         while (amp != new_processors.end() && boost::dynamic_pointer_cast<Amp> (*amp) == 0) {
3897                 ++amp;
3898         }
3899
3900         assert (amp != _processors.end ());
3901
3902         /* and the processor after the amp */
3903
3904         ProcessorList::iterator after_amp = amp;
3905         ++after_amp;
3906
3907         /* METER */
3908
3909         if (_meter) {
3910                 switch (_meter_point) {
3911                 case MeterInput:
3912                         assert (!_meter->display_to_user ());
3913                         new_processors.push_front (_meter);
3914                         break;
3915                 case MeterPreFader:
3916                         assert (!_meter->display_to_user ());
3917                         new_processors.insert (amp, _meter);
3918                         break;
3919                 case MeterPostFader:
3920                         /* do nothing here */
3921                         break;
3922                 case MeterOutput:
3923                         /* do nothing here */
3924                         break;
3925                 case MeterCustom:
3926                         /* the meter is visible, so we don't touch it here */
3927                         break;
3928                 }
3929         }
3930
3931         /* MAIN OUTS */
3932
3933         assert (_main_outs);
3934         assert (!_main_outs->display_to_user ());
3935         new_processors.push_back (_main_outs);
3936
3937         /* iterator for the main outs */
3938
3939         ProcessorList::iterator main = new_processors.end();
3940         --main;
3941
3942         /* OUTPUT METERING */
3943
3944         if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
3945                 assert (!_meter->display_to_user ());
3946
3947                 /* add the processor just before or just after the main outs */
3948
3949                 ProcessorList::iterator meter_point = main;
3950
3951                 if (_meter_point == MeterOutput) {
3952                         ++meter_point;
3953                 }
3954                 new_processors.insert (meter_point, _meter);
3955         }
3956
3957         /* MONITOR SEND */
3958
3959         if (_monitor_send && !is_monitor ()) {
3960                 assert (!_monitor_send->display_to_user ());
3961                 if (Config->get_solo_control_is_listen_control()) {
3962                         switch (Config->get_listen_position ()) {
3963                         case PreFaderListen:
3964                                 switch (Config->get_pfl_position ()) {
3965                                 case PFLFromBeforeProcessors:
3966                                         new_processors.push_front (_monitor_send);
3967                                         break;
3968                                 case PFLFromAfterProcessors:
3969                                         new_processors.insert (amp, _monitor_send);
3970                                         break;
3971                                 }
3972                                 _monitor_send->set_can_pan (false);
3973                                 break;
3974                         case AfterFaderListen:
3975                                 switch (Config->get_afl_position ()) {
3976                                 case AFLFromBeforeProcessors:
3977                                         new_processors.insert (after_amp, _monitor_send);
3978                                         break;
3979                                 case AFLFromAfterProcessors:
3980                                         new_processors.insert (new_processors.end(), _monitor_send);
3981                                         break;
3982                                 }
3983                                 _monitor_send->set_can_pan (true);
3984                                 break;
3985                         }
3986                 }  else {
3987                         new_processors.insert (new_processors.end(), _monitor_send);
3988                         _monitor_send->set_can_pan (false);
3989                 }
3990         }
3991
3992         /* MONITOR CONTROL */
3993
3994         if (_monitor_control && is_monitor ()) {
3995                 assert (!_monitor_control->display_to_user ());
3996                 new_processors.push_front (_monitor_control);
3997         }
3998
3999         /* INTERNAL RETURN */
4000
4001         /* doing this here means that any monitor control will come just after
4002            the return.
4003         */
4004
4005         if (_intreturn) {
4006                 assert (!_intreturn->display_to_user ());
4007                 new_processors.push_front (_intreturn);
4008         }
4009
4010         /* EXPORT PROCESSOR */
4011
4012         if (_capturing_processor) {
4013                 assert (!_capturing_processor->display_to_user ());
4014                 new_processors.push_front (_capturing_processor);
4015         }
4016
4017         _processors = new_processors;
4018
4019         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
4020         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4021                 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
4022         }
4023 }
4024
4025 void
4026 Route::unpan ()
4027 {
4028         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
4029         Glib::Threads::RWLock::ReaderLock lp (_processor_lock);
4030
4031         _pannable.reset ();
4032
4033         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4034                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery>(*i);
4035                 if (d) {
4036                         d->unpan ();
4037                 }
4038         }
4039 }
4040
4041 /** If the meter point is `Custom', make a note of where the meter is.
4042  *  This is so that if the meter point is subsequently set to something else,
4043  *  and then back to custom, we can put the meter back where it was last time
4044  *  custom was enabled.
4045  *
4046  *  Must be called with the _processor_lock held.
4047  */
4048 void
4049 Route::maybe_note_meter_position ()
4050 {
4051         if (_meter_point != MeterCustom) {
4052                 return;
4053         }
4054
4055         _custom_meter_position_noted = true;
4056         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4057                 if (boost::dynamic_pointer_cast<PeakMeter> (*i)) {
4058                         ProcessorList::iterator j = i;
4059                         ++j;
4060                         if (j != _processors.end ()) {
4061                                 _processor_after_last_custom_meter = *j;
4062                                 _last_custom_meter_was_at_end = false;
4063                         } else {
4064                                 _last_custom_meter_was_at_end = true;
4065                         }
4066                 }
4067         }
4068 }
4069
4070 boost::shared_ptr<Processor>
4071 Route::processor_by_id (PBD::ID id) const
4072 {
4073         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4074         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4075                 if ((*i)->id() == id) {
4076                         return *i;
4077                 }
4078         }
4079
4080         return boost::shared_ptr<Processor> ();
4081 }
4082
4083 /** @return the monitoring state, or in other words what data we are pushing
4084  *  into the route (data from the inputs, data from disk or silence)
4085  */
4086 MonitorState
4087 Route::monitoring_state () const
4088 {
4089         return MonitoringInput;
4090 }
4091
4092 /** @return what we should be metering; either the data coming from the input
4093  *  IO or the data that is flowing through the route.
4094  */
4095 MeterState
4096 Route::metering_state () const
4097 {
4098         return MeteringRoute;
4099 }
4100
4101 bool
4102 Route::has_external_redirects () const
4103 {
4104         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4105
4106                 /* ignore inactive processors and obviously ignore the main
4107                  * outs since everything has them and we don't care.
4108                  */
4109
4110                 if ((*i)->active() && (*i) != _main_outs && (*i)->does_routing()) {
4111                         return true;;
4112                 }
4113         }
4114
4115         return false;
4116 }
4117
4118 boost::shared_ptr<Processor>
4119 Route::the_instrument () const
4120 {
4121         Glib::Threads::RWLock::WriterLock lm (_processor_lock);
4122         return the_instrument_unlocked ();
4123 }
4124
4125 boost::shared_ptr<Processor>
4126 Route::the_instrument_unlocked () const
4127 {
4128         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4129                 if (boost::dynamic_pointer_cast<PluginInsert>(*i)) {
4130                         if ((*i)->input_streams().n_midi() > 0 &&
4131                             (*i)->output_streams().n_audio() > 0) {
4132                                 return (*i);
4133                         }
4134                 }
4135         }
4136         return boost::shared_ptr<Processor>();
4137 }
4138
4139
4140
4141 void
4142 Route::non_realtime_locate (framepos_t pos)
4143 {
4144         if (_pannable) {
4145                 _pannable->transport_located (pos);
4146         }
4147
4148         {
4149                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
4150
4151                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4152                         (*i)->transport_located (pos);
4153                 }
4154         }
4155 }
4156
4157 void
4158 Route::fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes)
4159 {
4160         size_t n_buffers;
4161         size_t i;
4162
4163         /* MIDI
4164          *
4165          * We don't currently mix MIDI input together, so we don't need the
4166          * complex logic of the audio case.
4167          */
4168
4169         n_buffers = bufs.count().n_midi ();
4170
4171         for (i = 0; i < n_buffers; ++i) {
4172
4173                 boost::shared_ptr<MidiPort> source_port = io->midi (i);
4174                 MidiBuffer& buf (bufs.get_midi (i));
4175
4176                 if (source_port) {
4177                         buf.copy (source_port->get_midi_buffer(nframes));
4178                 } else {
4179                         buf.silence (nframes);
4180                 }
4181         }
4182
4183         /* AUDIO */
4184
4185         n_buffers = bufs.count().n_audio();
4186
4187         size_t n_ports = io->n_ports().n_audio();
4188         float scaling = 1.0f;
4189
4190         if (n_ports > n_buffers) {
4191                 scaling = ((float) n_buffers) / n_ports;
4192         }
4193
4194         for (i = 0; i < n_ports; ++i) {
4195
4196                 /* if there are more ports than buffers, map them onto buffers
4197                  * in a round-robin fashion
4198                  */
4199
4200                 boost::shared_ptr<AudioPort> source_port = io->audio (i);
4201                 AudioBuffer& buf (bufs.get_audio (i%n_buffers));
4202
4203
4204                 if (i < n_buffers) {
4205
4206                         /* first time through just copy a channel into
4207                            the output buffer.
4208                         */
4209
4210                         buf.read_from (source_port->get_audio_buffer (nframes), nframes);
4211
4212                         if (scaling != 1.0f) {
4213                                 buf.apply_gain (scaling, nframes);
4214                         }
4215
4216                 } else {
4217
4218                         /* on subsequent times around, merge data from
4219                          * the port with what is already there
4220                          */
4221
4222                         if (scaling != 1.0f) {
4223                                 buf.accumulate_with_gain_from (source_port->get_audio_buffer (nframes), nframes, 0, scaling);
4224                         } else {
4225                                 buf.accumulate_from (source_port->get_audio_buffer (nframes), nframes);
4226                         }
4227                 }
4228         }
4229
4230         /* silence any remaining buffers */
4231
4232         for (; i < n_buffers; ++i) {
4233                 AudioBuffer& buf (bufs.get_audio (i));
4234                 buf.silence (nframes);
4235         }
4236
4237         /* establish the initial setup of the buffer set, reflecting what was
4238            copied into it. unless, of course, we are the auditioner, in which
4239            case nothing was fed into it from the inputs at all.
4240         */
4241
4242         if (!is_auditioner()) {
4243                 bufs.set_count (io->n_ports());
4244         }
4245 }