libs/ardour/route.cc

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