libs/ardour/route.cc

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