libs/ardour/route.cc

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