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