libs/ardour/route.cc

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