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