libs/ardour/route.cc

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