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