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