libs/ardour/route.cc

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