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 #include <cmath>
  21 #include <fstream>
  22 #include <cassert>
  23 #include <algorithm>
  24
  25 #include "pbd/xml++.h"
  26 #include "pbd/enumwriter.h"
  27 #include "pbd/memento_command.h"
  28 #include "pbd/stacktrace.h"
  29 #include "pbd/convert.h"
  30
  31 #include "evoral/Curve.hpp"
  32
  33 #include "ardour/amp.h"
  34 #include "ardour/audio_port.h"
  35 #include "ardour/audioengine.h"
  36 #include "ardour/buffer.h"
  37 #include "ardour/buffer_set.h"
  38 #include "ardour/configuration.h"
  39 #include "ardour/cycle_timer.h"
  40 #include "ardour/debug.h"
  41 #include "ardour/delivery.h"
  42 #include "ardour/dB.h"
  43 #include "ardour/internal_send.h"
  44 #include "ardour/internal_return.h"
  45 #include "ardour/ladspa_plugin.h"
  46 #include "ardour/meter.h"
  47 #include "ardour/mix.h"
  48 #include "ardour/monitor_processor.h"
  49 #include "ardour/panner.h"
  50 #include "ardour/plugin_insert.h"
  51 #include "ardour/port.h"
  52 #include "ardour/port_insert.h"
  53 #include "ardour/processor.h"
  54 #include "ardour/profile.h"
  55 #include "ardour/route.h"
  56 #include "ardour/route_group.h"
  57 #include "ardour/send.h"
  58 #include "ardour/session.h"
  59 #include "ardour/timestamps.h"
  60 #include "ardour/utils.h"
  61 #include "ardour/graph.h"
  62 #include "ardour/unknown_processor.h"
  63 #include "ardour/capturing_processor.h"
  64
  65 #include "i18n.h"
  66
  67 using namespace std;
  68 using namespace ARDOUR;
  69 using namespace PBD;
  70
  71 uint32_t Route::order_key_cnt = 0;
  72 PBD::Signal1<void,string const&> Route::SyncOrderKeys;
  73 PBD::Signal0<void> Route::RemoteControlIDChange;
  74
  75 Route::Route (Session& sess, string name, Flag flg, DataType default_type)
  76         : SessionObject (sess, name)
  77         , Automatable (sess)
  78         , GraphNode( sess.route_graph )
  79         , _active (true)
  80         , _initial_delay (0)
  81         , _roll_delay (0)
  82         , _flags (flg)
  83         , _pending_declick (true)
  84         , _meter_point (MeterPostFader)
  85         , _self_solo (false)
  86         , _soloed_by_others_upstream (0)
  87         , _soloed_by_others_downstream (0)
  88         , _solo_isolated (0)
  89         , _denormal_protection (false)
  90         , _recordable (true)
  91         , _silent (false)
  92         , _declickable (false)
  93         , _solo_control (new SoloControllable (X_("solo"), *this))
  94         , _mute_control (new MuteControllable (X_("mute"), *this))
  95         , _mute_master (new MuteMaster (sess, name))
  96         , _have_internal_generator (false)
  97         , _solo_safe (false)
  98         , _default_type (default_type)
  99         , _remote_control_id (0)
 100         , _in_configure_processors (false)
 101 {
 102         processor_max_streams.reset();
 103         order_keys[N_("signal")] = order_key_cnt++;
 104 }
 105
 106 int
 107 Route::init ()
 108 {
 109         /* add standard controls */
 110
 111         _solo_control->set_flags (Controllable::Flag (_solo_control->flags() | Controllable::Toggle));
 112         _mute_control->set_flags (Controllable::Flag (_mute_control->flags() | Controllable::Toggle));
 113
 114         add_control (_solo_control);
 115         add_control (_mute_control);
 116
 117         /* input and output objects */
 118
 119         _input.reset (new IO (_session, _name, IO::Input, _default_type));
 120         _output.reset (new IO (_session, _name, IO::Output, _default_type));
 121
 122         _input->changed.connect_same_thread (*this, boost::bind (&Route::input_change_handler, this, _1, _2));
 123         _output->changed.connect_same_thread (*this, boost::bind (&Route::output_change_handler, this, _1, _2));
 124
 125         _input->PortCountChanging.connect_same_thread (*this, boost::bind (&Route::input_port_count_changing, this, _1));
 126
 127         /* add amp processor  */
 128
 129         _amp.reset (new Amp (_session));
 130         add_processor (_amp, PostFader);
 131
 132         /* add standard processors: meter, main outs, monitor out */
 133
 134         _meter.reset (new PeakMeter (_session));
 135         _meter->set_display_to_user (false);
 136
 137         add_processor (_meter, PostFader);
 138
 139         _main_outs.reset (new Delivery (_session, _output, _mute_master, _name, Delivery::Main));
 140
 141         add_processor (_main_outs, PostFader);
 142
 143         if (is_monitor()) {
 144                 /* where we listen to tracks */
 145                 _intreturn.reset (new InternalReturn (_session));
 146                 add_processor (_intreturn, PreFader);
 147
 148                 ProcessorList::iterator i;
 149
 150                 for (i = _processors.begin(); i != _processors.end(); ++i) {
 151                         if (*i == _intreturn) {
 152                                 ++i;
 153                                 break;
 154                         }
 155                 }
 156
 157                 /* the thing that provides proper control over a control/monitor/listen bus
 158                    (such as per-channel cut, dim, solo, invert, etc).
 159                    It always goes right after the internal return;
 160                  */
 161                 _monitor_control.reset (new MonitorProcessor (_session));
 162                 add_processor (_monitor_control, i);
 163
 164                 /* no panning on the monitor main outs */
 165
 166                 _main_outs->panner()->set_bypassed (true);
 167         }
 168
 169         if (is_master() || is_monitor() || is_hidden()) {
 170                 _mute_master->set_solo_ignore (true);
 171         }
 172
 173         /* now that we have _meter, its safe to connect to this */
 174
 175         Metering::Meter.connect_same_thread (*this, (boost::bind (&Route::meter, this)));
 176
 177         return 0;
 178 }
 179
 180 Route::~Route ()
 181 {
 182         DEBUG_TRACE (DEBUG::Destruction, string_compose ("route %1 destructor\n", _name));
 183
 184         /* do this early so that we don't get incoming signals as we are going through destruction
 185          */
 186
 187         drop_connections ();
 188
 189         /* don't use clear_processors here, as it depends on the session which may
 190            be half-destroyed by now
 191         */
 192
 193         Glib::RWLock::WriterLock lm (_processor_lock);
 194         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 195                 (*i)->drop_references ();
 196         }
 197
 198         _processors.clear ();
 199 }
 200
 201 void
 202 Route::set_remote_control_id (uint32_t id, bool notify_class_listeners)
 203 {
 204         if (id != _remote_control_id) {
 205                 _remote_control_id = id;
 206                 RemoteControlIDChanged ();
 207                 if (notify_class_listeners) {
 208                         RemoteControlIDChange ();
 209                 }
 210         }
 211 }
 212
 213 uint32_t
 214 Route::remote_control_id() const
 215 {
 216         return _remote_control_id;
 217 }
 218
 219 int32_t
 220 Route::order_key (std::string const & name) const
 221 {
 222         OrderKeys::const_iterator i = order_keys.find (name);
 223         if (i == order_keys.end()) {
 224                 return -1;
 225         }
 226
 227         return i->second;
 228 }
 229
 230 void
 231 Route::set_order_key (std::string const & name, int32_t n)
 232 {
 233         bool changed = false;
 234
 235         /* This method looks more complicated than it should, but
 236            it's important that we don't emit order_key_changed unless
 237            it actually has, as expensive things happen on receipt of that
 238            signal.
 239         */
 240
 241         if (order_keys.find(name) == order_keys.end() || order_keys[name] != n) {
 242                 order_keys[name] = n;
 243                 changed = true;
 244         }
 245
 246         if (Config->get_sync_all_route_ordering()) {
 247                 for (OrderKeys::iterator x = order_keys.begin(); x != order_keys.end(); ++x) {
 248                         if (x->second != n) {
 249                                 x->second = n;
 250                                 changed = true;
 251                         }
 252                 }
 253         }
 254
 255         if (changed) {
 256                 order_key_changed (); /* EMIT SIGNAL */
 257                 _session.set_dirty ();
 258         }
 259 }
 260
 261 /** Set all order keys to be the same as that for `base', if such a key
 262  *  exists in this route.
 263  *  @param base Base key.
 264  */
 265 void
 266 Route::sync_order_keys (std::string const & base)
 267 {
 268         if (order_keys.empty()) {
 269                 return;
 270         }
 271
 272         OrderKeys::iterator i;
 273         int32_t key;
 274
 275         if ((i = order_keys.find (base)) == order_keys.end()) {
 276                 /* key doesn't exist, use the first existing key (during session initialization) */
 277                 i = order_keys.begin();
 278                 key = i->second;
 279                 ++i;
 280         } else {
 281                 /* key exists - use it and reset all others (actually, itself included) */
 282                 key = i->second;
 283                 i = order_keys.begin();
 284         }
 285
 286         bool changed = false;
 287
 288         for (; i != order_keys.end(); ++i) {
 289                 if (i->second != key) {
 290                         i->second = key;
 291                         changed = true;
 292                 }
 293         }
 294
 295         if (changed) {
 296                 order_key_changed (); /* EMIT SIGNAL */
 297         }
 298 }
 299
 300 string
 301 Route::ensure_track_or_route_name(string name, Session &session)
 302 {
 303         string newname = name;
 304
 305         while (!session.io_name_is_legal (newname)) {
 306                 newname = bump_name_once (newname, '.');
 307         }
 308
 309         return newname;
 310 }
 311
 312
 313 void
 314 Route::inc_gain (gain_t fraction, void *src)
 315 {
 316         _amp->inc_gain (fraction, src);
 317 }
 318
 319 void
 320 Route::set_gain (gain_t val, void *src)
 321 {
 322         if (src != 0 && _route_group && src != _route_group && _route_group->is_active() && _route_group->is_gain()) {
 323
 324                 if (_route_group->is_relative()) {
 325
 326                         gain_t usable_gain = _amp->gain();
 327                         if (usable_gain < 0.000001f) {
 328                                 usable_gain = 0.000001f;
 329                         }
 330
 331                         gain_t delta = val;
 332                         if (delta < 0.000001f) {
 333                                 delta = 0.000001f;
 334                         }
 335
 336                         delta -= usable_gain;
 337
 338                         if (delta == 0.0f)
 339                                 return;
 340
 341                         gain_t factor = delta / usable_gain;
 342
 343                         if (factor > 0.0f) {
 344                                 factor = _route_group->get_max_factor(factor);
 345                                 if (factor == 0.0f) {
 346                                         _amp->gain_control()->Changed(); /* EMIT SIGNAL */
 347                                         return;
 348                                 }
 349                         } else {
 350                                 factor = _route_group->get_min_factor(factor);
 351                                 if (factor == 0.0f) {
 352                                         _amp->gain_control()->Changed(); /* EMIT SIGNAL */
 353                                         return;
 354                                 }
 355                         }
 356
 357                         _route_group->foreach_route (boost::bind (&Route::inc_gain, _1, factor, _route_group));
 358
 359                 } else {
 360
 361                         _route_group->foreach_route (boost::bind (&Route::set_gain, _1, val, _route_group));
 362                 }
 363
 364                 return;
 365         }
 366
 367         if (val == _amp->gain()) {
 368                 return;
 369         }
 370
 371         _amp->set_gain (val, src);
 372 }
 373
 374 /** Process this route for one (sub) cycle (process thread)
 375  *
 376  * @param bufs Scratch buffers to use for the signal path
 377  * @param start_frame Initial transport frame
 378  * @param end_frame Final transport frame
 379  * @param nframes Number of frames to output (to ports)
 380  *
 381  * Note that (end_frame - start_frame) may not be equal to nframes when the
 382  * transport speed isn't 1.0 (eg varispeed).
 383  */
 384 void
 385 Route::process_output_buffers (BufferSet& bufs,
 386                                framepos_t start_frame, framepos_t end_frame, pframes_t nframes,
 387                                bool /*with_processors*/, int declick,
 388                                bool gain_automation_ok)
 389 {
 390         bool monitor;
 391
 392         bufs.is_silent (false);
 393
 394         switch (Config->get_monitoring_model()) {
 395         case HardwareMonitoring:
 396         case ExternalMonitoring:
 397                 monitor = !record_enabled() || (_session.config.get_auto_input() && !_session.actively_recording());
 398                 break;
 399         default:
 400                 monitor = true;
 401         }
 402
 403         if (!declick) {
 404                 declick = _pending_declick;
 405         }
 406
 407         /* figure out if we're going to use gain automation */
 408         if (gain_automation_ok) {
 409                 _amp->setup_gain_automation (start_frame, end_frame, nframes);
 410         } else {
 411                 _amp->apply_gain_automation (false);
 412         }
 413
 414         /* tell main outs what to do about monitoring */
 415         _main_outs->no_outs_cuz_we_no_monitor (!monitor);
 416
 417
 418         /* -------------------------------------------------------------------------------------------
 419            GLOBAL DECLICK (for transport changes etc.)
 420            ----------------------------------------------------------------------------------------- */
 421
 422         if (declick > 0) {
 423                 Amp::declick (bufs, nframes, 1);
 424         } else if (declick < 0) {
 425                 Amp::declick (bufs, nframes, -1);
 426         }
 427
 428         _pending_declick = 0;
 429
 430         /* -------------------------------------------------------------------------------------------
 431            DENORMAL CONTROL/PHASE INVERT
 432            ----------------------------------------------------------------------------------------- */
 433
 434         if (_phase_invert.any ()) {
 435
 436                 int chn = 0;
 437
 438                 if (_denormal_protection || Config->get_denormal_protection()) {
 439
 440                         for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
 441                                 Sample* const sp = i->data();
 442
 443                                 if (_phase_invert[chn]) {
 444                                         for (pframes_t nx = 0; nx < nframes; ++nx) {
 445                                                 sp[nx]  = -sp[nx];
 446                                                 sp[nx] += 1.0e-27f;
 447                                         }
 448                                 } else {
 449                                         for (pframes_t nx = 0; nx < nframes; ++nx) {
 450                                                 sp[nx] += 1.0e-27f;
 451                                         }
 452                                 }
 453                         }
 454
 455                 } else {
 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                                         }
 464                                 }
 465                         }
 466                 }
 467
 468         } else {
 469
 470                 if (_denormal_protection || Config->get_denormal_protection()) {
 471
 472                         for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
 473                                 Sample* const sp = i->data();
 474                                 for (pframes_t nx = 0; nx < nframes; ++nx) {
 475                                         sp[nx] += 1.0e-27f;
 476                                 }
 477                         }
 478
 479                 }
 480         }
 481
 482         /* -------------------------------------------------------------------------------------------
 483            and go ....
 484            ----------------------------------------------------------------------------------------- */
 485
 486         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 487
 488                 if (boost::dynamic_pointer_cast<UnknownProcessor> (*i)) {
 489                         break;
 490                 }
 491
 492                 if (bufs.count() != (*i)->input_streams()) {
 493                         cerr << _name << " bufs = " << bufs.count()
 494                              << " input for " << (*i)->name() << " = " << (*i)->input_streams()
 495                              << endl;
 496                 }
 497                 assert (bufs.count() == (*i)->input_streams());
 498
 499                 /* should we NOT run plugins here if the route is inactive?
 500                    do we catch route != active somewhere higher?
 501                 */
 502
 503                 (*i)->run (bufs, start_frame, end_frame, nframes, *i != _processors.back());
 504                 bufs.set_count ((*i)->output_streams());
 505         }
 506 }
 507
 508 ChanCount
 509 Route::n_process_buffers ()
 510 {
 511         return max (_input->n_ports(), processor_max_streams);
 512 }
 513
 514 void
 515 Route::passthru (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
 516 {
 517         BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers());
 518
 519         _silent = false;
 520
 521         assert (bufs.available() >= input_streams());
 522
 523         if (_input->n_ports() == ChanCount::ZERO) {
 524                 silence_unlocked (nframes);
 525         }
 526
 527         bufs.set_count (input_streams());
 528
 529         if (is_monitor() && _session.listening() && !_session.is_auditioning()) {
 530
 531                 /* control/monitor bus ignores input ports when something is
 532                    feeding the listen "stream". data will "arrive" into the
 533                    route from the intreturn processor element.
 534                 */
 535                 bufs.silence (nframes, 0);
 536
 537         } else {
 538
 539                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 540
 541                         BufferSet::iterator o = bufs.begin(*t);
 542                         PortSet& ports (_input->ports());
 543
 544                         for (PortSet::iterator i = ports.begin(*t); i != ports.end(*t); ++i, ++o) {
 545                                 o->read_from (i->get_buffer(nframes), nframes);
 546                         }
 547                 }
 548         }
 549
 550         write_out_of_band_data (bufs, start_frame, end_frame, nframes);
 551         process_output_buffers (bufs, start_frame, end_frame, nframes, true, declick, true);
 552 }
 553
 554 void
 555 Route::passthru_silence (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
 556 {
 557         BufferSet& bufs (_session.get_silent_buffers (n_process_buffers()));
 558         bufs.set_count (_input->n_ports());
 559         write_out_of_band_data (bufs, start_frame, end_frame, nframes);
 560         process_output_buffers (bufs, start_frame, end_frame, nframes, true, declick, false);
 561 }
 562
 563 void
 564 Route::set_listen (bool yn, void* src)
 565 {
 566         if (_solo_safe) {
 567                 return;
 568         }
 569
 570         if (_monitor_send) {
 571                 if (yn != _monitor_send->active()) {
 572                         if (yn) {
 573                                 _monitor_send->activate ();
 574                                 _mute_master->set_soloed (true);
 575                         } else {
 576                                 _monitor_send->deactivate ();
 577                                 _mute_master->set_soloed (false);
 578                         }
 579
 580                         listen_changed (src); /* EMIT SIGNAL */
 581                 }
 582         }
 583 }
 584
 585 bool
 586 Route::listening () const
 587 {
 588         if (_monitor_send) {
 589                 return _monitor_send->active ();
 590         } else {
 591                 return false;
 592         }
 593 }
 594
 595 void
 596 Route::set_solo_safe (bool yn, void *src)
 597 {
 598         if (_solo_safe != yn) {
 599                 _solo_safe = yn;
 600                 solo_safe_changed (src);
 601         }
 602 }
 603
 604 bool
 605 Route::solo_safe() const
 606 {
 607         return _solo_safe;
 608 }
 609
 610 void
 611 Route::set_solo (bool yn, void *src)
 612 {
 613         if (_solo_safe) {
 614                 return;
 615         }
 616
 617         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
 618                 _route_group->foreach_route (boost::bind (&Route::set_solo, _1, yn, _route_group));
 619                 return;
 620         }
 621
 622         if (self_soloed() != yn) {
 623                 set_self_solo (yn);
 624                 set_mute_master_solo ();
 625                 solo_changed (true, src); /* EMIT SIGNAL */
 626                 _solo_control->Changed (); /* EMIT SIGNAL */
 627         }
 628 }
 629
 630 void
 631 Route::set_self_solo (bool yn)
 632 {
 633         _self_solo = yn;
 634 }
 635
 636 void
 637 Route::mod_solo_by_others_upstream (int32_t delta)
 638 {
 639         if (_solo_safe) {
 640                 return;
 641         }
 642
 643         uint32_t old_sbu = _soloed_by_others_upstream;
 644
 645         if (delta < 0) {
 646                 if (_soloed_by_others_upstream >= (uint32_t) abs (delta)) {
 647                         _soloed_by_others_upstream += delta;
 648                 } else {
 649                         _soloed_by_others_upstream = 0;
 650                 }
 651         } else {
 652                 _soloed_by_others_upstream += delta;
 653         }
 654
 655         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 SbU delta %2 = %3 old = %4 sbd %5 ss %6 exclusive %7\n",
 656                                                   name(), delta, _soloed_by_others_upstream, old_sbu,
 657                                                   _soloed_by_others_downstream, _self_solo, Config->get_exclusive_solo()));
 658
 659         /* push the inverse solo change to everything that feeds us.
 660
 661            This is important for solo-within-group. When we solo 1 track out of N that
 662            feed a bus, that track will cause mod_solo_by_upstream (+1) to be called
 663            on the bus. The bus then needs to call mod_solo_by_downstream (-1) on all
 664            tracks that feed it. This will silence them if they were audible because
 665            of a bus solo, but the newly soloed track will still be audible (because
 666            it is self-soloed).
 667
 668            but .. do this only when we are being told to solo-by-upstream (i.e delta = +1),
 669            not in reverse.
 670          */
 671
 672         if ((_self_solo || _soloed_by_others_downstream) &&
 673             ((old_sbu == 0 && _soloed_by_others_upstream > 0) ||
 674              (old_sbu > 0 && _soloed_by_others_upstream == 0))) {
 675
 676                 if (delta > 0 || !Config->get_exclusive_solo()) {
 677                         DEBUG_TRACE (DEBUG::Solo, "\t ... INVERT push\n");
 678                         for (FedBy::iterator i = _fed_by.begin(); i != _fed_by.end(); ++i) {
 679                                 boost::shared_ptr<Route> sr = i->r.lock();
 680                                 if (sr) {
 681                                         sr->mod_solo_by_others_downstream (-delta);
 682                                 }
 683                         }
 684                 }
 685         }
 686
 687         set_mute_master_solo ();
 688         solo_changed (false, this);
 689 }
 690
 691 void
 692 Route::mod_solo_by_others_downstream (int32_t delta)
 693 {
 694         if (_solo_safe) {
 695                 return;
 696         }
 697
 698         if (delta < 0) {
 699                 if (_soloed_by_others_downstream >= (uint32_t) abs (delta)) {
 700                         _soloed_by_others_downstream += delta;
 701                 } else {
 702                         _soloed_by_others_downstream = 0;
 703                 }
 704         } else {
 705                 _soloed_by_others_downstream += delta;
 706         }
 707
 708         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 SbD delta %2 = %3\n", name(), delta, _soloed_by_others_downstream));
 709
 710         set_mute_master_solo ();
 711         solo_changed (false, this);
 712 }
 713
 714 void
 715 Route::set_mute_master_solo ()
 716 {
 717         _mute_master->set_soloed (self_soloed() || soloed_by_others_downstream() || soloed_by_others_upstream());
 718 }
 719
 720 void
 721 Route::set_solo_isolated (bool yn, void *src)
 722 {
 723         if (is_master() || is_monitor() || is_hidden()) {
 724                 return;
 725         }
 726
 727         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
 728                 _route_group->foreach_route (boost::bind (&Route::set_solo_isolated, _1, yn, _route_group));
 729                 return;
 730         }
 731
 732         /* forward propagate solo-isolate status to everything fed by this route, but not those via sends only */
 733
 734         boost::shared_ptr<RouteList> routes = _session.get_routes ();
 735         for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
 736
 737                 if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) {
 738                         continue;
 739                 }
 740
 741                 bool sends_only;
 742                 bool does_feed = direct_feeds (*i, &sends_only); // we will recurse anyway, so don't use ::feeds()
 743
 744                 if (does_feed && !sends_only) {
 745                         (*i)->set_solo_isolated (yn, (*i)->route_group());
 746                 }
 747         }
 748
 749         /* XXX should we back-propagate as well? (April 2010: myself and chris goddard think not) */
 750
 751         bool changed = false;
 752
 753         if (yn) {
 754                 if (_solo_isolated == 0) {
 755                         _mute_master->set_solo_ignore (true);
 756                         changed = true;
 757                 }
 758                 _solo_isolated++;
 759         } else {
 760                 if (_solo_isolated > 0) {
 761                         _solo_isolated--;
 762                         if (_solo_isolated == 0) {
 763                                 _mute_master->set_solo_ignore (false);
 764                                 changed = true;
 765                         }
 766                 }
 767         }
 768
 769         if (changed) {
 770                 solo_isolated_changed (src);
 771         }
 772 }
 773
 774 bool
 775 Route::solo_isolated () const
 776 {
 777         return _solo_isolated > 0;
 778 }
 779
 780 void
 781 Route::set_mute_points (MuteMaster::MutePoint mp)
 782 {
 783         _mute_master->set_mute_points (mp);
 784         mute_points_changed (); /* EMIT SIGNAL */
 785
 786         if (_mute_master->muted_by_self()) {
 787                 mute_changed (this); /* EMIT SIGNAL */
 788                 _mute_control->Changed (); /* EMIT SIGNAL */
 789         }
 790 }
 791
 792 void
 793 Route::set_mute (bool yn, void *src)
 794 {
 795         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_mute()) {
 796                 _route_group->foreach_route (boost::bind (&Route::set_mute, _1, yn, _route_group));
 797                 return;
 798         }
 799
 800         if (muted() != yn) {
 801                 _mute_master->set_muted_by_self (yn);
 802                 mute_changed (src); /* EMIT SIGNAL */
 803                 _mute_control->Changed (); /* EMIT SIGNAL */
 804         }
 805 }
 806
 807 bool
 808 Route::muted () const
 809 {
 810         return _mute_master->muted_by_self();
 811 }
 812
 813 #if 0
 814 static void
 815 dump_processors(const string& name, const list<boost::shared_ptr<Processor> >& procs)
 816 {
 817         cerr << name << " {" << endl;
 818         for (list<boost::shared_ptr<Processor> >::const_iterator p = procs.begin();
 819                         p != procs.end(); ++p) {
 820                 cerr << "\t" << (*p)->name() << " ID = " << (*p)->id() << endl;
 821         }
 822         cerr << "}" << endl;
 823 }
 824 #endif
 825
 826 int
 827 Route::add_processor (boost::shared_ptr<Processor> processor, Placement placement, ProcessorStreams* err)
 828 {
 829         ProcessorList::iterator loc;
 830
 831         /* XXX this is not thread safe - we don't hold the lock across determining the iter
 832            to add before and actually doing the insertion. dammit.
 833         */
 834
 835         if (placement == PreFader) {
 836                 /* generic pre-fader: insert immediately before the amp */
 837                 loc = find (_processors.begin(), _processors.end(), _amp);
 838         } else {
 839                 /* generic post-fader: insert right before the main outs */
 840                 loc = find (_processors.begin(), _processors.end(), _main_outs);
 841         }
 842
 843         return add_processor (processor, loc, err);
 844 }
 845
 846
 847 /** Add a processor to the route.
 848  * @a iter must point to an iterator in _processors and the new
 849  * processor will be inserted immediately before this location.  Otherwise,
 850  * @a position is used.
 851  */
 852 int
 853 Route::add_processor (boost::shared_ptr<Processor> processor, ProcessorList::iterator iter, ProcessorStreams* err, bool activation_allowed)
 854 {
 855         ChanCount old_pms = processor_max_streams;
 856
 857         if (!_session.engine().connected() || !processor) {
 858                 return 1;
 859         }
 860
 861         {
 862                 Glib::RWLock::WriterLock lm (_processor_lock);
 863
 864                 boost::shared_ptr<PluginInsert> pi;
 865                 boost::shared_ptr<PortInsert> porti;
 866
 867                 ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), processor);
 868
 869                 if (processor == _amp || processor == _meter || processor == _main_outs) {
 870                         // Ensure only one of these are in the list at any time
 871                         if (loc != _processors.end()) {
 872                                 if (iter == loc) { // Already in place, do nothing
 873                                         return 0;
 874                                 } else { // New position given, relocate
 875                                         _processors.erase (loc);
 876                                 }
 877                         }
 878
 879                 } else {
 880                         if (loc != _processors.end()) {
 881                                 cerr << "ERROR: Processor added to route twice!" << endl;
 882                                 return 1;
 883                         }
 884
 885                         loc = iter;
 886                 }
 887
 888                 _processors.insert (loc, processor);
 889
 890                 // Set up processor list channels.  This will set processor->[input|output]_streams(),
 891                 // configure redirect ports properly, etc.
 892
 893                 {
 894                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
 895
 896                         if (configure_processors_unlocked (err)) {
 897                                 ProcessorList::iterator ploc = loc;
 898                                 --ploc;
 899                                 _processors.erase(ploc);
 900                                 configure_processors_unlocked (0); // it worked before we tried to add it ...
 901                                 cerr << "configure failed\n";
 902                                 return -1;
 903                         }
 904                 }
 905
 906                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(processor)) != 0) {
 907
 908                         if (pi->natural_input_streams() == ChanCount::ZERO) {
 909                                 /* generator plugin */
 910                                 _have_internal_generator = true;
 911                         }
 912
 913                 }
 914
 915                 /* is this the monitor send ? if so, make sure we keep track of it */
 916
 917                 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
 918
 919                 if (isend && _session.monitor_out() && (isend->target_id() == _session.monitor_out()->id())) {
 920                         _monitor_send = isend;
 921                 }
 922
 923                 if (activation_allowed && (processor != _monitor_send)) {
 924                         processor->activate ();
 925                 }
 926
 927                 processor->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false, false));
 928
 929                 _output->set_user_latency (0);
 930         }
 931
 932         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
 933         set_processor_positions ();
 934
 935         return 0;
 936 }
 937
 938 bool
 939 Route::add_processor_from_xml_2X (const XMLNode& node, int version)
 940 {
 941         const XMLProperty *prop;
 942
 943         try {
 944                 boost::shared_ptr<Processor> processor;
 945
 946                 /* bit of a hack: get the `placement' property from the <Redirect> tag here
 947                    so that we can add the processor in the right place (pre/post-fader)
 948                 */
 949
 950                 XMLNodeList const & children = node.children ();
 951                 XMLNodeList::const_iterator i = children.begin ();
 952
 953                 while (i != children.end() && (*i)->name() != X_("Redirect")) {
 954                         ++i;
 955                 }
 956
 957                 Placement placement = PreFader;
 958
 959                 if (i != children.end()) {
 960                         if ((prop = (*i)->property (X_("placement"))) != 0) {
 961                                 placement = Placement (string_2_enum (prop->value(), placement));
 962                         }
 963                 }
 964
 965                 if (node.name() == "Insert") {
 966
 967                         if ((prop = node.property ("type")) != 0) {
 968
 969                                 if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
 970                                                 prop->value() == "lv2" ||
 971                                                 prop->value() == "vst" ||
 972                                                 prop->value() == "audiounit") {
 973
 974                                         processor.reset (new PluginInsert (_session));
 975
 976                                 } else {
 977
 978                                         processor.reset (new PortInsert (_session, _mute_master));
 979                                 }
 980
 981                         }
 982
 983                 } else if (node.name() == "Send") {
 984
 985                         processor.reset (new Send (_session, _mute_master));
 986
 987                 } else {
 988
 989                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), node.name()) << endmsg;
 990                         return false;
 991                 }
 992
 993                 if (processor->set_state (node, version)) {
 994                         return false;
 995                 }
 996
 997                 return (add_processor (processor, placement) == 0);
 998         }
 999
1000         catch (failed_constructor &err) {
1001                 warning << _("processor could not be created. Ignored.") << endmsg;
1002                 return false;
1003         }
1004 }
1005
1006 int
1007 Route::add_processors (const ProcessorList& others, boost::shared_ptr<Processor> before, ProcessorStreams* err)
1008 {
1009         ProcessorList::iterator loc;
1010
1011         if (before) {
1012                 loc = find(_processors.begin(), _processors.end(), before);
1013         } else {
1014                 /* nothing specified - at end but before main outs */
1015                 loc = find (_processors.begin(), _processors.end(), _main_outs);
1016         }
1017
1018         return add_processors (others, loc, err);
1019 }
1020
1021 int
1022 Route::add_processors (const ProcessorList& others, ProcessorList::iterator iter, ProcessorStreams* err)
1023 {
1024         /* NOTE: this is intended to be used ONLY when copying
1025            processors from another Route. Hence the subtle
1026            differences between this and ::add_processor()
1027         */
1028
1029         ChanCount old_pms = processor_max_streams;
1030
1031         if (!_session.engine().connected()) {
1032                 return 1;
1033         }
1034
1035         if (others.empty()) {
1036                 return 0;
1037         }
1038
1039         {
1040                 Glib::RWLock::WriterLock lm (_processor_lock);
1041
1042                 ChanCount potential_max_streams = ChanCount::max (_input->n_ports(), _output->n_ports());
1043
1044                 for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
1045
1046                         // Ensure meter only appears in the list once
1047                         if (*i == _meter) {
1048                                 ProcessorList::iterator m = find(_processors.begin(), _processors.end(), *i);
1049                                 if (m != _processors.end()) {
1050                                         _processors.erase(m);
1051                                 }
1052                         }
1053
1054                         boost::shared_ptr<PluginInsert> pi;
1055
1056                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1057                                 pi->set_count (1);
1058
1059                                 ChanCount m = max (pi->input_streams(), pi->output_streams());
1060
1061                                 if (m > potential_max_streams) {
1062                                         potential_max_streams = m;
1063                                 }
1064                         }
1065
1066                         ProcessorList::iterator inserted = _processors.insert (iter, *i);
1067
1068                         if ((*i)->active()) {
1069                                 (*i)->activate ();
1070                         }
1071
1072                         {
1073                                 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1074                                 if (configure_processors_unlocked (err)) {
1075                                         _processors.erase (inserted);
1076                                         configure_processors_unlocked (0); // it worked before we tried to add it ...
1077                                         return -1;
1078                                 }
1079                         }
1080
1081                         (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false, false));
1082                 }
1083
1084                 _output->set_user_latency (0);
1085         }
1086
1087         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1088         set_processor_positions ();
1089
1090         return 0;
1091 }
1092
1093 void
1094 Route::placement_range(Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end)
1095 {
1096         if (p == PreFader) {
1097                 start = _processors.begin();
1098                 end = find(_processors.begin(), _processors.end(), _amp);
1099         } else {
1100                 start = find(_processors.begin(), _processors.end(), _amp);
1101                 ++start;
1102                 end = _processors.end();
1103         }
1104 }
1105
1106 /** Turn off all processors with a given placement
1107  * @param p Placement of processors to disable
1108  */
1109 void
1110 Route::disable_processors (Placement p)
1111 {
1112         Glib::RWLock::ReaderLock lm (_processor_lock);
1113
1114         ProcessorList::iterator start, end;
1115         placement_range(p, start, end);
1116
1117         for (ProcessorList::iterator i = start; i != end; ++i) {
1118                 (*i)->deactivate ();
1119         }
1120
1121         _session.set_dirty ();
1122 }
1123
1124 /** Turn off all redirects
1125  */
1126 void
1127 Route::disable_processors ()
1128 {
1129         Glib::RWLock::ReaderLock lm (_processor_lock);
1130
1131         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1132                 (*i)->deactivate ();
1133         }
1134
1135         _session.set_dirty ();
1136 }
1137
1138 /** Turn off all redirects with a given placement
1139  * @param p Placement of redirects to disable
1140  */
1141 void
1142 Route::disable_plugins (Placement p)
1143 {
1144         Glib::RWLock::ReaderLock lm (_processor_lock);
1145
1146         ProcessorList::iterator start, end;
1147         placement_range(p, start, end);
1148
1149         for (ProcessorList::iterator i = start; i != end; ++i) {
1150                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1151                         (*i)->deactivate ();
1152                 }
1153         }
1154
1155         _session.set_dirty ();
1156 }
1157
1158 /** Turn off all plugins
1159  */
1160 void
1161 Route::disable_plugins ()
1162 {
1163         Glib::RWLock::ReaderLock lm (_processor_lock);
1164
1165         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1166                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1167                         (*i)->deactivate ();
1168                 }
1169         }
1170
1171         _session.set_dirty ();
1172 }
1173
1174
1175 void
1176 Route::ab_plugins (bool forward)
1177 {
1178         Glib::RWLock::ReaderLock lm (_processor_lock);
1179
1180         if (forward) {
1181
1182                 /* forward = turn off all active redirects, and mark them so that the next time
1183                    we go the other way, we will revert them
1184                 */
1185
1186                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1187                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1188                                 continue;
1189                         }
1190
1191                         if ((*i)->active()) {
1192                                 (*i)->deactivate ();
1193                                 (*i)->set_next_ab_is_active (true);
1194                         } else {
1195                                 (*i)->set_next_ab_is_active (false);
1196                         }
1197                 }
1198
1199         } else {
1200
1201                 /* backward = if the redirect was marked to go active on the next ab, do so */
1202
1203                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1204
1205                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1206                                 continue;
1207                         }
1208
1209                         if ((*i)->get_next_ab_is_active()) {
1210                                 (*i)->activate ();
1211                         } else {
1212                                 (*i)->deactivate ();
1213                         }
1214                 }
1215         }
1216
1217         _session.set_dirty ();
1218 }
1219
1220
1221 /** Remove processors with a given placement.
1222  * @param p Placement of processors to remove.
1223  */
1224 void
1225 Route::clear_processors (Placement p)
1226 {
1227         const ChanCount old_pms = processor_max_streams;
1228
1229         if (!_session.engine().connected()) {
1230                 return;
1231         }
1232
1233         bool already_deleting = _session.deletion_in_progress();
1234         if (!already_deleting) {
1235                 _session.set_deletion_in_progress();
1236         }
1237
1238         {
1239                 Glib::RWLock::WriterLock lm (_processor_lock);
1240                 ProcessorList new_list;
1241                 ProcessorStreams err;
1242                 bool seen_amp = false;
1243
1244                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1245
1246                         if (*i == _amp) {
1247                                 seen_amp = true;
1248                         }
1249
1250                         if ((*i) == _amp || (*i) == _meter || (*i) == _main_outs) {
1251
1252                                 /* you can't remove these */
1253
1254                                 new_list.push_back (*i);
1255
1256                         } else {
1257                                 if (seen_amp) {
1258
1259                                         switch (p) {
1260                                         case PreFader:
1261                                                 new_list.push_back (*i);
1262                                                 break;
1263                                         case PostFader:
1264                                                 (*i)->drop_references ();
1265                                                 break;
1266                                         }
1267
1268                                 } else {
1269
1270                                         switch (p) {
1271                                         case PreFader:
1272                                                 (*i)->drop_references ();
1273                                                 break;
1274                                         case PostFader:
1275                                                 new_list.push_back (*i);
1276                                                 break;
1277                                         }
1278                                 }
1279                         }
1280                 }
1281
1282                 _processors = new_list;
1283
1284                 {
1285                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1286                         configure_processors_unlocked (&err); // this can't fail
1287                 }
1288         }
1289
1290         processor_max_streams.reset();
1291         _have_internal_generator = false;
1292         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1293         set_processor_positions ();
1294
1295         if (!already_deleting) {
1296                 _session.clear_deletion_in_progress();
1297         }
1298 }
1299
1300 int
1301 Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err)
1302 {
1303         /* these can never be removed */
1304
1305         if (processor == _amp || processor == _meter || processor == _main_outs) {
1306                 return 0;
1307         }
1308
1309         ChanCount old_pms = processor_max_streams;
1310
1311         if (!_session.engine().connected()) {
1312                 return 1;
1313         }
1314
1315         processor_max_streams.reset();
1316
1317         {
1318                 Glib::RWLock::WriterLock lm (_processor_lock);
1319                 ProcessorList::iterator i;
1320                 bool removed = false;
1321
1322                 for (i = _processors.begin(); i != _processors.end(); ) {
1323                         if (*i == processor) {
1324
1325                                 /* move along, see failure case for configure_processors()
1326                                    where we may need to reconfigure the processor.
1327                                 */
1328
1329                                 /* stop redirects that send signals to JACK ports
1330                                    from causing noise as a result of no longer being
1331                                    run.
1332                                 */
1333
1334                                 boost::shared_ptr<IOProcessor> iop;
1335
1336                                 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (*i)) != 0) {
1337                                         if (iop->input()) {
1338                                                 iop->input()->disconnect (this);
1339                                         }
1340                                         if (iop->output()) {
1341                                                 iop->output()->disconnect (this);
1342                                         }
1343                                 }
1344
1345                                 i = _processors.erase (i);
1346                                 removed = true;
1347                                 break;
1348
1349                         } else {
1350                                 ++i;
1351                         }
1352
1353                         _output->set_user_latency (0);
1354                 }
1355
1356                 if (!removed) {
1357                         /* what? */
1358                         return 1;
1359                 }
1360
1361                 {
1362                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1363
1364                         if (configure_processors_unlocked (err)) {
1365                                 /* get back to where we where */
1366                                 _processors.insert (i, processor);
1367                                 /* we know this will work, because it worked before :) */
1368                                 configure_processors_unlocked (0);
1369                                 return -1;
1370                         }
1371                 }
1372
1373                 _have_internal_generator = false;
1374
1375                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1376                         boost::shared_ptr<PluginInsert> pi;
1377
1378                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1379                                 if (pi->is_generator()) {
1380                                         _have_internal_generator = true;
1381                                         break;
1382                                 }
1383                         }
1384                 }
1385         }
1386
1387         processor->drop_references ();
1388         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1389         set_processor_positions ();
1390
1391         return 0;
1392 }
1393
1394 int
1395 Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
1396 {
1397         ProcessorList deleted;
1398
1399         if (!_session.engine().connected()) {
1400                 return 1;
1401         }
1402
1403         processor_max_streams.reset();
1404
1405         {
1406                 Glib::RWLock::WriterLock lm (_processor_lock);
1407                 ProcessorList::iterator i;
1408                 boost::shared_ptr<Processor> processor;
1409
1410                 ProcessorList as_we_were = _processors;
1411
1412                 for (i = _processors.begin(); i != _processors.end(); ) {
1413
1414                         processor = *i;
1415
1416                         /* these can never be removed */
1417
1418                         if (processor == _amp || processor == _meter || processor == _main_outs) {
1419                                 ++i;
1420                                 continue;
1421                         }
1422
1423                         /* see if its in the list of processors to delete */
1424
1425                         if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
1426                                 ++i;
1427                                 continue;
1428                         }
1429
1430                         /* stop IOProcessors that send to JACK ports
1431                            from causing noise as a result of no longer being
1432                            run.
1433                         */
1434
1435                         boost::shared_ptr<IOProcessor> iop;
1436
1437                         if ((iop = boost::dynamic_pointer_cast<IOProcessor> (processor)) != 0) {
1438                                 iop->disconnect ();
1439                         }
1440
1441                         deleted.push_back (processor);
1442                         i = _processors.erase (i);
1443                 }
1444
1445                 if (deleted.empty()) {
1446                         /* none of those in the requested list were found */
1447                         return 0;
1448                 }
1449
1450                 _output->set_user_latency (0);
1451
1452                 {
1453                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1454
1455                         if (configure_processors_unlocked (err)) {
1456                                 /* get back to where we where */
1457                                 _processors = as_we_were;
1458                                 /* we know this will work, because it worked before :) */
1459                                 configure_processors_unlocked (0);
1460                                 return -1;
1461                         }
1462                 }
1463
1464                 _have_internal_generator = false;
1465
1466                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1467                         boost::shared_ptr<PluginInsert> pi;
1468
1469                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1470                                 if (pi->is_generator()) {
1471                                         _have_internal_generator = true;
1472                                         break;
1473                                 }
1474                         }
1475                 }
1476         }
1477
1478         /* now try to do what we need to so that those that were removed will be deleted */
1479
1480         for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
1481                 (*i)->drop_references ();
1482         }
1483
1484         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1485         set_processor_positions ();
1486
1487         return 0;
1488 }
1489
1490 /** Caller must hold process lock */
1491 int
1492 Route::configure_processors (ProcessorStreams* err)
1493 {
1494         assert (!AudioEngine::instance()->process_lock().trylock());
1495
1496         if (!_in_configure_processors) {
1497                 Glib::RWLock::WriterLock lm (_processor_lock);
1498                 return configure_processors_unlocked (err);
1499         }
1500         return 0;
1501 }
1502
1503 ChanCount
1504 Route::input_streams () const
1505 {
1506         return _input->n_ports ();
1507 }
1508
1509 list<pair<ChanCount, ChanCount> >
1510 Route::try_configure_processors (ChanCount in, ProcessorStreams* err)
1511 {
1512         Glib::RWLock::ReaderLock lm (_processor_lock);
1513
1514         return try_configure_processors_unlocked (in, err);
1515 }
1516
1517 list<pair<ChanCount, ChanCount> >
1518 Route::try_configure_processors_unlocked (ChanCount in, ProcessorStreams* err)
1519 {
1520         // Check each processor in order to see if we can configure as requested
1521         ChanCount out;
1522         list<pair<ChanCount, ChanCount> > configuration;
1523         uint32_t index = 0;
1524
1525         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
1526         DEBUG_TRACE (DEBUG::Processors, "{\n");
1527
1528         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1529
1530                 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1531                         DEBUG_TRACE (DEBUG::Processors, "--- CONFIGURE ABORTED due to unknown processor.\n");
1532                         break;
1533                 }
1534
1535                 if ((*p)->can_support_io_configuration(in, out)) {
1536                         DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID=%2 in=%3 out=%4\n",(*p)->name(), (*p)->id(), in, out));
1537                         configuration.push_back(make_pair(in, out));
1538                         in = out;
1539                 } else {
1540                         if (err) {
1541                                 err->index = index;
1542                                 err->count = in;
1543                         }
1544                         DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
1545                         DEBUG_TRACE (DEBUG::Processors, string_compose ("---- %1 cannot support in=%2 out=%3\n", (*p)->name(), in, out));
1546                         DEBUG_TRACE (DEBUG::Processors, "}\n");
1547                         return list<pair<ChanCount, ChanCount> > ();
1548                 }
1549         }
1550
1551         DEBUG_TRACE (DEBUG::Processors, "}\n");
1552
1553         return configuration;
1554 }
1555
1556 /** Set the input/output configuration of each processor in the processors list.
1557  *  Caller must hold process lock.
1558  *  Return 0 on success, otherwise configuration is impossible.
1559  */
1560 int
1561 Route::configure_processors_unlocked (ProcessorStreams* err)
1562 {
1563         assert (!AudioEngine::instance()->process_lock().trylock());
1564
1565         if (_in_configure_processors) {
1566                 return 0;
1567         }
1568
1569         _in_configure_processors = true;
1570
1571         list<pair<ChanCount, ChanCount> > configuration = try_configure_processors_unlocked (input_streams (), err);
1572
1573         if (configuration.empty ()) {
1574                 _in_configure_processors = false;
1575                 return -1;
1576         }
1577
1578         ChanCount out;
1579
1580         list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1581         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1582
1583                 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1584                         break;
1585                 }
1586
1587                 (*p)->configure_io(c->first, c->second);
1588                 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1589                 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1590                 out = c->second;
1591         }
1592
1593         if (_meter) {
1594                 _meter->reset_max_channels (processor_max_streams);
1595         }
1596
1597         /* make sure we have sufficient scratch buffers to cope with the new processor
1598            configuration */
1599         _session.ensure_buffers (n_process_buffers ());
1600
1601         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
1602
1603         _in_configure_processors = false;
1604         return 0;
1605 }
1606
1607 void
1608 Route::all_processors_flip ()
1609 {
1610         Glib::RWLock::ReaderLock lm (_processor_lock);
1611
1612         if (_processors.empty()) {
1613                 return;
1614         }
1615
1616         bool first_is_on = _processors.front()->active();
1617
1618         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1619                 if (first_is_on) {
1620                         (*i)->deactivate ();
1621                 } else {
1622                         (*i)->activate ();
1623                 }
1624         }
1625
1626         _session.set_dirty ();
1627 }
1628
1629 /** Set all processors with a given placement to a given active state.
1630  * @param p Placement of processors to change.
1631  * @param state New active state for those processors.
1632  */
1633 void
1634 Route::all_processors_active (Placement p, bool state)
1635 {
1636         Glib::RWLock::ReaderLock lm (_processor_lock);
1637
1638         if (_processors.empty()) {
1639                 return;
1640         }
1641         ProcessorList::iterator start, end;
1642         placement_range(p, start, end);
1643
1644         bool before_amp = true;
1645         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1646                 if ((*i) == _amp) {
1647                         before_amp = false;
1648                         continue;
1649                 }
1650                 if (p == PreFader && before_amp) {
1651                         if (state) {
1652                                 (*i)->activate ();
1653                         } else {
1654                                 (*i)->deactivate ();
1655                         }
1656                 }
1657         }
1658
1659         _session.set_dirty ();
1660 }
1661
1662 bool
1663 Route::processor_is_prefader (boost::shared_ptr<Processor> p)
1664 {
1665         bool pre_fader = true;
1666         Glib::RWLock::ReaderLock lm (_processor_lock);
1667
1668         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1669
1670                 /* semantic note: if p == amp, we want to return true, so test
1671                    for equality before checking if this is the amp
1672                 */
1673
1674                 if ((*i) == p) {
1675                         break;
1676                 }
1677
1678                 if ((*i) == _amp) {
1679                         pre_fader = false;
1680                         break;
1681                 }
1682         }
1683
1684         return pre_fader;
1685 }
1686
1687 int
1688 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
1689 {
1690         /* "new_order" is an ordered list of processors to be positioned according to "placement".
1691            NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
1692            processors in the current actual processor list that are hidden. Any visible processors
1693            in the current list but not in "new_order" will be assumed to be deleted.
1694         */
1695
1696         {
1697                 Glib::RWLock::WriterLock lm (_processor_lock);
1698                 ChanCount old_pms = processor_max_streams;
1699                 ProcessorList::iterator oiter;
1700                 ProcessorList::const_iterator niter;
1701                 ProcessorList as_it_was_before = _processors;
1702                 ProcessorList as_it_will_be;
1703
1704                 oiter = _processors.begin();
1705                 niter = new_order.begin();
1706
1707                 while (niter !=  new_order.end()) {
1708
1709                         /* if the next processor in the old list is invisible (i.e. should not be in the new order)
1710                            then append it to the temp list.
1711
1712                            Otherwise, see if the next processor in the old list is in the new list. if not,
1713                            its been deleted. If its there, append it to the temp list.
1714                         */
1715
1716                         if (oiter == _processors.end()) {
1717
1718                                 /* no more elements in the old list, so just stick the rest of
1719                                    the new order onto the temp list.
1720                                 */
1721
1722                                 as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
1723                                 while (niter != new_order.end()) {
1724                                         ++niter;
1725                                 }
1726                                 break;
1727
1728                         } else {
1729
1730                                 if (!(*oiter)->display_to_user()) {
1731
1732                                         as_it_will_be.push_back (*oiter);
1733
1734                                 } else {
1735
1736                                         /* visible processor: check that its in the new order */
1737
1738                                         if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
1739                                                 /* deleted: do nothing, shared_ptr<> will clean up */
1740                                         } else {
1741                                                 /* ignore this one, and add the next item from the new order instead */
1742                                                 as_it_will_be.push_back (*niter);
1743                                                 ++niter;
1744                                         }
1745                                 }
1746
1747                                 /* now remove from old order - its taken care of no matter what */
1748                                 oiter = _processors.erase (oiter);
1749                         }
1750
1751                 }
1752
1753                 _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
1754
1755                 {
1756                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1757
1758                         if (configure_processors_unlocked (err)) {
1759                                 _processors = as_it_was_before;
1760                                 processor_max_streams = old_pms;
1761                                 return -1;
1762                         }
1763                 }
1764         }
1765
1766         if (true) {
1767                 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1768                 set_processor_positions ();
1769         }
1770
1771         return 0;
1772 }
1773
1774 XMLNode&
1775 Route::get_state()
1776 {
1777         return state(true);
1778 }
1779
1780 XMLNode&
1781 Route::get_template()
1782 {
1783         return state(false);
1784 }
1785
1786 XMLNode&
1787 Route::state(bool full_state)
1788 {
1789         XMLNode *node = new XMLNode("Route");
1790         ProcessorList::iterator i;
1791         char buf[32];
1792
1793         id().print (buf, sizeof (buf));
1794         node->add_property("id", buf);
1795         node->add_property ("name", _name);
1796         node->add_property("default-type", _default_type.to_string());
1797
1798         if (_flags) {
1799                 node->add_property("flags", enum_2_string (_flags));
1800         }
1801
1802         node->add_property("active", _active?"yes":"no");
1803         string p;
1804         boost::to_string (_phase_invert, p);
1805         node->add_property("phase-invert", p);
1806         node->add_property("denormal-protection", _denormal_protection?"yes":"no");
1807         node->add_property("meter-point", enum_2_string (_meter_point));
1808
1809         if (_route_group) {
1810                 node->add_property("route-group", _route_group->name());
1811         }
1812
1813         string order_string;
1814         OrderKeys::iterator x = order_keys.begin();
1815
1816         while (x != order_keys.end()) {
1817                 order_string += string ((*x).first);
1818                 order_string += '=';
1819                 snprintf (buf, sizeof(buf), "%ld", (*x).second);
1820                 order_string += buf;
1821
1822                 ++x;
1823
1824                 if (x == order_keys.end()) {
1825                         break;
1826                 }
1827
1828                 order_string += ':';
1829         }
1830         node->add_property ("order-keys", order_string);
1831         node->add_property ("self-solo", (_self_solo ? "yes" : "no"));
1832         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_upstream);
1833         node->add_property ("soloed-by-upstream", buf);
1834         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_downstream);
1835         node->add_property ("soloed-by-downstream", buf);
1836         node->add_property ("solo-isolated", solo_isolated() ? "yes" : "no");
1837         node->add_property ("solo-safe", _solo_safe ? "yes" : "no");
1838
1839         node->add_child_nocopy (_input->state (full_state));
1840         node->add_child_nocopy (_output->state (full_state));
1841         node->add_child_nocopy (_solo_control->get_state ());
1842         node->add_child_nocopy (_mute_control->get_state ());
1843         node->add_child_nocopy (_mute_master->get_state ());
1844
1845         XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
1846         snprintf (buf, sizeof (buf), "%d", _remote_control_id);
1847         remote_control_node->add_property (X_("id"), buf);
1848         node->add_child_nocopy (*remote_control_node);
1849
1850         if (_comment.length()) {
1851                 XMLNode *cmt = node->add_child ("Comment");
1852                 cmt->add_content (_comment);
1853         }
1854
1855         for (i = _processors.begin(); i != _processors.end(); ++i) {
1856                 node->add_child_nocopy((*i)->state (full_state));
1857         }
1858
1859         if (_extra_xml){
1860                 node->add_child_copy (*_extra_xml);
1861         }
1862
1863         return *node;
1864 }
1865
1866 int
1867 Route::set_state (const XMLNode& node, int version)
1868 {
1869         return _set_state (node, version, true);
1870 }
1871
1872 int
1873 Route::_set_state (const XMLNode& node, int version, bool /*call_base*/)
1874 {
1875         if (version < 3000) {
1876                 return _set_state_2X (node, version);
1877         }
1878
1879         XMLNodeList nlist;
1880         XMLNodeConstIterator niter;
1881         XMLNode *child;
1882         const XMLProperty *prop;
1883
1884         if (node.name() != "Route"){
1885                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1886                 return -1;
1887         }
1888
1889         if ((prop = node.property (X_("name"))) != 0) {
1890                 Route::set_name (prop->value());
1891         }
1892
1893         if ((prop = node.property ("id")) != 0) {
1894                 _id = prop->value ();
1895         }
1896
1897         if ((prop = node.property (X_("flags"))) != 0) {
1898                 _flags = Flag (string_2_enum (prop->value(), _flags));
1899         } else {
1900                 _flags = Flag (0);
1901         }
1902
1903         if (is_master() || is_monitor() || is_hidden()) {
1904                 _mute_master->set_solo_ignore (true);
1905         }
1906
1907         /* add all processors (except amp, which is always present) */
1908
1909         nlist = node.children();
1910         XMLNode processor_state (X_("processor_state"));
1911
1912         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1913
1914                 child = *niter;
1915
1916                 if (child->name() == IO::state_node_name) {
1917                         if ((prop = child->property (X_("direction"))) == 0) {
1918                                 continue;
1919                         }
1920
1921                         if (prop->value() == "Input") {
1922                                 _input->set_state (*child, version);
1923                         } else if (prop->value() == "Output") {
1924                                 _output->set_state (*child, version);
1925                         }
1926                 }
1927
1928                 if (child->name() == X_("Processor")) {
1929                         processor_state.add_child_copy (*child);
1930                 }
1931         }
1932
1933         set_processor_state (processor_state);
1934
1935         if ((prop = node.property ("self-solo")) != 0) {
1936                 set_self_solo (string_is_affirmative (prop->value()));
1937         }
1938
1939         if ((prop = node.property ("soloed-by-upstream")) != 0) {
1940                 _soloed_by_others_upstream = 0; // needed for mod_.... () to work
1941                 mod_solo_by_others_upstream (atoi (prop->value()));
1942         }
1943
1944         if ((prop = node.property ("soloed-by-downstream")) != 0) {
1945                 _soloed_by_others_downstream = 0; // needed for mod_.... () to work
1946                 mod_solo_by_others_downstream (atoi (prop->value()));
1947         }
1948
1949         if ((prop = node.property ("solo-isolated")) != 0) {
1950                 set_solo_isolated (string_is_affirmative (prop->value()), this);
1951         }
1952
1953         if ((prop = node.property ("solo-safe")) != 0) {
1954                 set_solo_safe (string_is_affirmative (prop->value()), this);
1955         }
1956
1957         if ((prop = node.property (X_("phase-invert"))) != 0) {
1958                 set_phase_invert (boost::dynamic_bitset<> (prop->value ()));
1959         }
1960
1961         if ((prop = node.property (X_("denormal-protection"))) != 0) {
1962                 set_denormal_protection (string_is_affirmative (prop->value()));
1963         }
1964
1965         if ((prop = node.property (X_("active"))) != 0) {
1966                 bool yn = string_is_affirmative (prop->value());
1967                 _active = !yn; // force switch
1968                 set_active (yn, this);
1969         }
1970
1971         if ((prop = node.property (X_("meter-point"))) != 0) {
1972                 MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
1973                 set_meter_point (mp, true);
1974                 if (_meter) {
1975                         _meter->set_display_to_user (_meter_point == MeterCustom);
1976                 }
1977         }
1978
1979         if ((prop = node.property (X_("order-keys"))) != 0) {
1980
1981                 int32_t n;
1982
1983                 string::size_type colon, equal;
1984                 string remaining = prop->value();
1985
1986                 while (remaining.length()) {
1987
1988                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
1989                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1990                                       << endmsg;
1991                         } else {
1992                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
1993                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1994                                               << endmsg;
1995                                 } else {
1996                                         set_order_key (remaining.substr (0, equal), n);
1997                                 }
1998                         }
1999
2000                         colon = remaining.find_first_of (':');
2001
2002                         if (colon != string::npos) {
2003                                 remaining = remaining.substr (colon+1);
2004                         } else {
2005                                 break;
2006                         }
2007                 }
2008         }
2009
2010         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2011                 child = *niter;
2012
2013                 if (child->name() == X_("Comment")) {
2014
2015                         /* XXX this is a terrible API design in libxml++ */
2016
2017                         XMLNode *cmt = *(child->children().begin());
2018                         _comment = cmt->content();
2019
2020                 } else if (child->name() == X_("Extra")) {
2021
2022                         _extra_xml = new XMLNode (*child);
2023
2024                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2025                         if (prop->value() == "solo") {
2026                                 _solo_control->set_state (*child, version);
2027                         }
2028
2029                 } else if (child->name() == X_("RemoteControl")) {
2030                         if ((prop = child->property (X_("id"))) != 0) {
2031                                 int32_t x;
2032                                 sscanf (prop->value().c_str(), "%d", &x);
2033                                 set_remote_control_id (x);
2034                         }
2035
2036                 } else if (child->name() == X_("MuteMaster")) {
2037                         _mute_master->set_state (*child, version);
2038                 }
2039         }
2040
2041         return 0;
2042 }
2043
2044 int
2045 Route::_set_state_2X (const XMLNode& node, int version)
2046 {
2047         XMLNodeList nlist;
2048         XMLNodeConstIterator niter;
2049         XMLNode *child;
2050         const XMLProperty *prop;
2051
2052         /* 2X things which still remain to be handled:
2053          * default-type
2054          * automation
2055          * controlouts
2056          */
2057
2058         if (node.name() != "Route") {
2059                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2060                 return -1;
2061         }
2062
2063         if ((prop = node.property (X_("flags"))) != 0) {
2064                 _flags = Flag (string_2_enum (prop->value(), _flags));
2065         } else {
2066                 _flags = Flag (0);
2067         }
2068
2069         if ((prop = node.property (X_("phase-invert"))) != 0) {
2070                 boost::dynamic_bitset<> p (_input->n_ports().n_audio ());
2071                 if (string_is_affirmative (prop->value ())) {
2072                         p.set ();
2073                 }
2074                 set_phase_invert (p);
2075         }
2076
2077         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2078                 set_denormal_protection (string_is_affirmative (prop->value()));
2079         }
2080
2081         if ((prop = node.property (X_("soloed"))) != 0) {
2082                 bool yn = string_is_affirmative (prop->value());
2083
2084                 /* XXX force reset of solo status */
2085
2086                 set_solo (yn, this);
2087         }
2088
2089         if ((prop = node.property (X_("muted"))) != 0) {
2090
2091                 bool first = true;
2092                 bool muted = string_is_affirmative (prop->value());
2093
2094                 if (muted){
2095
2096                         string mute_point;
2097
2098                         if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
2099
2100                                 if (string_is_affirmative (prop->value())){
2101                                         mute_point = mute_point + "PreFader";
2102                                         first = false;
2103                                 }
2104                         }
2105
2106                         if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
2107
2108                                 if (string_is_affirmative (prop->value())){
2109
2110                                         if (!first) {
2111                                                 mute_point = mute_point + ",";
2112                                         }
2113
2114                                         mute_point = mute_point + "PostFader";
2115                                         first = false;
2116                                 }
2117                         }
2118
2119                         if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
2120
2121                                 if (string_is_affirmative (prop->value())){
2122
2123                                         if (!first) {
2124                                                 mute_point = mute_point + ",";
2125                                         }
2126
2127                                         mute_point = mute_point + "Listen";
2128                                         first = false;
2129                                 }
2130                         }
2131
2132                         if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
2133
2134                                 if (string_is_affirmative (prop->value())){
2135
2136                                         if (!first) {
2137                                                 mute_point = mute_point + ",";
2138                                         }
2139
2140                                         mute_point = mute_point + "Main";
2141                                 }
2142                         }
2143
2144                         _mute_master->set_mute_points (mute_point);
2145                 }
2146         }
2147
2148         if ((prop = node.property (X_("meter-point"))) != 0) {
2149                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2150         }
2151
2152         /* do not carry over edit/mix groups from 2.X because (a) its hard (b) they
2153            don't mean the same thing.
2154         */
2155
2156         if ((prop = node.property (X_("order-keys"))) != 0) {
2157
2158                 int32_t n;
2159
2160                 string::size_type colon, equal;
2161                 string remaining = prop->value();
2162
2163                 while (remaining.length()) {
2164
2165                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2166                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2167                                         << endmsg;
2168                         } else {
2169                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2170                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2171                                                 << endmsg;
2172                                 } else {
2173                                         set_order_key (remaining.substr (0, equal), n);
2174                                 }
2175                         }
2176
2177                         colon = remaining.find_first_of (':');
2178
2179                         if (colon != string::npos) {
2180                                 remaining = remaining.substr (colon+1);
2181                         } else {
2182                                 break;
2183                         }
2184                 }
2185         }
2186
2187         /* IOs */
2188
2189         nlist = node.children ();
2190         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2191
2192                 child = *niter;
2193
2194                 if (child->name() == IO::state_node_name) {
2195
2196                         /* there is a note in IO::set_state_2X() about why we have to call
2197                            this directly.
2198                            */
2199
2200                         _input->set_state_2X (*child, version, true);
2201                         _output->set_state_2X (*child, version, false);
2202
2203                         if ((prop = child->property (X_("name"))) != 0) {
2204                                 Route::set_name (prop->value ());
2205                         }
2206
2207                         if ((prop = child->property (X_("id"))) != 0) {
2208                                 _id = prop->value ();
2209                         }
2210
2211                         if ((prop = child->property (X_("active"))) != 0) {
2212                                 bool yn = string_is_affirmative (prop->value());
2213                                 _active = !yn; // force switch
2214                                 set_active (yn, this);
2215                         }
2216
2217                         if ((prop = child->property (X_("gain"))) != 0) {
2218                                 gain_t val;
2219
2220                                 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2221                                         _amp->gain_control()->set_value (val);
2222                                 }
2223                         }
2224
2225                         /* Set up Panners in the IO */
2226                         XMLNodeList io_nlist = child->children ();
2227
2228                         XMLNodeConstIterator io_niter;
2229                         XMLNode *io_child;
2230
2231                         for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2232
2233                                 io_child = *io_niter;
2234
2235                                 if (io_child->name() == X_("Panner")) {
2236                                         _main_outs->panner()->set_state(*io_child, version);
2237                                 } else if (io_child->name() == X_("Automation")) {
2238                                         /* IO's automation is for the fader */
2239                                         _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
2240                                 }
2241                         }
2242                 }
2243         }
2244
2245         XMLNodeList redirect_nodes;
2246
2247         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2248
2249                 child = *niter;
2250
2251                 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2252                         redirect_nodes.push_back(child);
2253                 }
2254
2255         }
2256
2257         set_processor_state_2X (redirect_nodes, version);
2258
2259         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2260                 child = *niter;
2261
2262                 if (child->name() == X_("Comment")) {
2263
2264                         /* XXX this is a terrible API design in libxml++ */
2265
2266                         XMLNode *cmt = *(child->children().begin());
2267                         _comment = cmt->content();
2268
2269                 } else if (child->name() == X_("extra")) {
2270
2271                         _extra_xml = new XMLNode (*child);
2272
2273                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2274                         if (prop->value() == X_("solo")) {
2275                                 _solo_control->set_state (*child, version);
2276                         } else if (prop->value() == X_("mute")) {
2277                                 _mute_control->set_state (*child, version);
2278                         }
2279
2280                 } else if (child->name() == X_("RemoteControl")) {
2281                         if ((prop = child->property (X_("id"))) != 0) {
2282                                 int32_t x;
2283                                 sscanf (prop->value().c_str(), "%d", &x);
2284                                 set_remote_control_id (x);
2285                         }
2286
2287                 }
2288         }
2289
2290         return 0;
2291 }
2292
2293 XMLNode&
2294 Route::get_processor_state ()
2295 {
2296         XMLNode* root = new XMLNode (X_("redirects"));
2297         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2298                 root->add_child_nocopy ((*i)->state (true));
2299         }
2300
2301         return *root;
2302 }
2303
2304 void
2305 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2306 {
2307         /* We don't bother removing existing processors not in nList, as this
2308            method will only be called when creating a Route from scratch, not
2309            for undo purposes.  Just put processors in at the appropriate place
2310            in the list.
2311         */
2312
2313         for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2314                 add_processor_from_xml_2X (**i, version);
2315         }
2316 }
2317
2318 void
2319 Route::set_processor_state (const XMLNode& node)
2320 {
2321         const XMLNodeList &nlist = node.children();
2322         XMLNodeConstIterator niter;
2323         ProcessorList new_order;
2324         bool must_configure = false;
2325
2326         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2327
2328                 XMLProperty* prop = (*niter)->property ("type");
2329
2330                 if (prop->value() == "amp") {
2331                         _amp->set_state (**niter, Stateful::current_state_version);
2332                         new_order.push_back (_amp);
2333                 } else if (prop->value() == "meter") {
2334                         _meter->set_state (**niter, Stateful::current_state_version);
2335                         new_order.push_back (_meter);
2336                 } else if (prop->value() == "main-outs") {
2337                         _main_outs->set_state (**niter, Stateful::current_state_version);
2338                         new_order.push_back (_main_outs);
2339                 } else if (prop->value() == "intreturn") {
2340                         if (!_intreturn) {
2341                                 _intreturn.reset (new InternalReturn (_session));
2342                                 must_configure = true;
2343                         }
2344                         _intreturn->set_state (**niter, Stateful::current_state_version);
2345                         new_order.push_back (_intreturn);
2346                 } else if (is_monitor() && prop->value() == "monitor") {
2347                         if (!_monitor_control) {
2348                                 _monitor_control.reset (new MonitorProcessor (_session));
2349                                 must_configure = true;
2350                         }
2351                         _monitor_control->set_state (**niter, Stateful::current_state_version);
2352                         new_order.push_back (_monitor_control);
2353                 } else {
2354                         ProcessorList::iterator o;
2355
2356                         for (o = _processors.begin(); o != _processors.end(); ++o) {
2357                                 XMLProperty* id_prop = (*niter)->property(X_("id"));
2358                                 if (id_prop && (*o)->id() == id_prop->value()) {
2359                                         (*o)->set_state (**niter, Stateful::current_state_version);
2360                                         new_order.push_back (*o);
2361                                         break;
2362                                 }
2363                         }
2364
2365                         // If the processor (*niter) is not on the route then create it
2366
2367                         if (o == _processors.end()) {
2368
2369                                 boost::shared_ptr<Processor> processor;
2370
2371                                 if (prop->value() == "intsend") {
2372
2373                                         processor.reset (new InternalSend (_session, _mute_master, boost::shared_ptr<Route>(), Delivery::Role (0)));
2374
2375                                 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2376                                            prop->value() == "lv2" ||
2377                                            prop->value() == "vst" ||
2378                                            prop->value() == "audiounit") {
2379
2380                                         processor.reset (new PluginInsert(_session));
2381
2382                                 } else if (prop->value() == "port") {
2383
2384                                         processor.reset (new PortInsert (_session, _mute_master));
2385
2386                                 } else if (prop->value() == "send") {
2387
2388                                         processor.reset (new Send (_session, _mute_master));
2389
2390                                 } else {
2391                                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2392                                         continue;
2393                                 }
2394
2395                                 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2396                                         /* This processor could not be configured.  Turn it into a UnknownProcessor */
2397                                         processor.reset (new UnknownProcessor (_session, **niter));
2398                                 }
2399
2400                                 new_order.push_back (processor);
2401                                 must_configure = true;
2402                         }
2403                 }
2404         }
2405
2406         {
2407                 Glib::RWLock::WriterLock lm (_processor_lock);
2408                 _processors = new_order;
2409                 if (must_configure) {
2410                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2411                         configure_processors_unlocked (0);
2412                 }
2413         }
2414
2415         processors_changed (RouteProcessorChange ());
2416         set_processor_positions ();
2417 }
2418
2419 void
2420 Route::curve_reallocate ()
2421 {
2422 //      _gain_automation_curve.finish_resize ();
2423 //      _pan_automation_curve.finish_resize ();
2424 }
2425
2426 void
2427 Route::silence (framecnt_t nframes)
2428 {
2429         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2430         if (!lm.locked()) {
2431                 return;
2432         }
2433
2434         silence_unlocked (nframes);
2435 }
2436
2437 void
2438 Route::silence_unlocked (framecnt_t nframes)
2439 {
2440         /* Must be called with the processor lock held */
2441
2442         if (!_silent) {
2443
2444                 _output->silence (nframes);
2445
2446                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2447                         boost::shared_ptr<PluginInsert> pi;
2448
2449                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2450                                 // skip plugins, they don't need anything when we're not active
2451                                 continue;
2452                         }
2453
2454                         (*i)->silence (nframes);
2455                 }
2456
2457                 if (nframes == _session.get_block_size()) {
2458                         // _silent = true;
2459                 }
2460         }
2461 }
2462
2463 void
2464 Route::add_internal_return ()
2465 {
2466         if (!_intreturn) {
2467                 _intreturn.reset (new InternalReturn (_session));
2468                 add_processor (_intreturn, PreFader);
2469         }
2470 }
2471
2472 BufferSet*
2473 Route::get_return_buffer () const
2474 {
2475         Glib::RWLock::ReaderLock rm (_processor_lock);
2476
2477         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2478                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2479
2480                 if (d) {
2481                         BufferSet* bs = d->get_buffers ();
2482                         return bs;
2483                 }
2484         }
2485
2486         return 0;
2487 }
2488
2489 void
2490 Route::release_return_buffer () const
2491 {
2492         Glib::RWLock::ReaderLock rm (_processor_lock);
2493
2494         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2495                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2496
2497                 if (d) {
2498                         return d->release_buffers ();
2499                 }
2500         }
2501 }
2502
2503 int
2504 Route::listen_via (boost::shared_ptr<Route> route, Placement placement, bool /*active*/, bool aux)
2505 {
2506         vector<string> ports;
2507         vector<string>::const_iterator i;
2508
2509         {
2510                 Glib::RWLock::ReaderLock rm (_processor_lock);
2511
2512                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2513
2514                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2515
2516                         if (d && d->target_route() == route) {
2517
2518                                 /* if the target is the control outs, then make sure
2519                                    we take note of which i-send is doing that.
2520                                 */
2521
2522                                 if (route == _session.monitor_out()) {
2523                                         _monitor_send = boost::dynamic_pointer_cast<Delivery>(d);
2524                                 }
2525
2526                                 /* already listening via the specified IO: do nothing */
2527
2528                                 return 0;
2529                         }
2530                 }
2531         }
2532
2533         boost::shared_ptr<InternalSend> listener;
2534
2535         try {
2536
2537                 if (is_master()) {
2538
2539                         if (route == _session.monitor_out()) {
2540                                 /* master never sends to control outs */
2541                                 return 0;
2542                         } else {
2543                                 listener.reset (new InternalSend (_session, _mute_master, route, (aux ? Delivery::Aux : Delivery::Listen)));
2544                         }
2545
2546                 } else {
2547                         listener.reset (new InternalSend (_session, _mute_master, route, (aux ? Delivery::Aux : Delivery::Listen)));
2548                 }
2549
2550         } catch (failed_constructor& err) {
2551                 return -1;
2552         }
2553
2554         if (route == _session.monitor_out()) {
2555                 _monitor_send = listener;
2556         }
2557
2558
2559         if (aux) {
2560
2561                 add_processor (listener, placement);
2562
2563         } else {
2564
2565                 if (placement == PostFader) {
2566                         /* put it *really* at the end, not just after the panner (main outs)
2567                          */
2568                         add_processor (listener, _processors.end());
2569                 } else {
2570                         add_processor (listener, PreFader);
2571                 }
2572
2573         }
2574
2575         return 0;
2576 }
2577
2578 void
2579 Route::drop_listen (boost::shared_ptr<Route> route)
2580 {
2581         ProcessorStreams err;
2582         ProcessorList::iterator tmp;
2583
2584         Glib::RWLock::ReaderLock rl(_processor_lock);
2585         rl.acquire ();
2586
2587   again:
2588         for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ) {
2589
2590                 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2591
2592                 if (d && d->target_route() == route) {
2593                         rl.release ();
2594                         remove_processor (*x, &err);
2595                         rl.acquire ();
2596
2597                         /* list could have been demolished while we dropped the lock
2598                            so start over.
2599                         */
2600
2601                         goto again;
2602                 }
2603         }
2604
2605         rl.release ();
2606
2607         if (route == _session.monitor_out()) {
2608                 _monitor_send.reset ();
2609         }
2610 }
2611
2612 void
2613 Route::set_comment (string cmt, void *src)
2614 {
2615         _comment = cmt;
2616         comment_changed (src);
2617         _session.set_dirty ();
2618 }
2619
2620 bool
2621 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
2622 {
2623         FeedRecord fr (other, via_sends_only);
2624
2625         pair<FedBy::iterator,bool> result =  _fed_by.insert (fr);
2626
2627         if (!result.second) {
2628
2629                 /* already a record for "other" - make sure sends-only information is correct */
2630                 if (!via_sends_only && result.first->sends_only) {
2631                         FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
2632                         frp->sends_only = false;
2633                 }
2634         }
2635
2636         return result.second;
2637 }
2638
2639 void
2640 Route::clear_fed_by ()
2641 {
2642         _fed_by.clear ();
2643 }
2644
2645 bool
2646 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
2647 {
2648         const FedBy& fed_by (other->fed_by());
2649
2650         for (FedBy::iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
2651                 boost::shared_ptr<Route> sr = f->r.lock();
2652
2653                 if (sr && (sr.get() == this)) {
2654
2655                         if (via_sends_only) {
2656                                 *via_sends_only = f->sends_only;
2657                         }
2658
2659                         return true;
2660                 }
2661         }
2662
2663         return false;
2664 }
2665
2666 bool
2667 Route::direct_feeds (boost::shared_ptr<Route> other, bool* only_send)
2668 {
2669         DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
2670
2671         if (_output->connected_to (other->input())) {
2672                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
2673                 if (only_send) {
2674                         *only_send = false;
2675                 }
2676
2677                 return true;
2678         }
2679
2680
2681         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
2682
2683                 boost::shared_ptr<IOProcessor> iop;
2684
2685                 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
2686                         if (iop->feeds (other)) {
2687                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
2688                                 if (only_send) {
2689                                         *only_send = true;
2690                                 }
2691                                 return true;
2692                         } else {
2693                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
2694                         }
2695                 } else {
2696                         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
2697                 }
2698
2699         }
2700
2701         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tdoes NOT feed %1\n", other->name()));
2702         return false;
2703 }
2704
2705 /** Called from the (non-realtime) butler thread when the transport is stopped */
2706 void
2707 Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool did_locate, bool can_flush_processors)
2708 {
2709         framepos_t now = _session.transport_frame();
2710
2711         {
2712                 Glib::RWLock::ReaderLock lm (_processor_lock);
2713
2714                 if (!did_locate) {
2715                         automation_snapshot (now, true);
2716                 }
2717
2718                 Automatable::transport_stopped (now);
2719
2720                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2721
2722                         if (Config->get_plugins_stop_with_transport() && can_flush_processors) {
2723                                 (*i)->flush ();
2724                         }
2725
2726                         (*i)->transport_stopped (now);
2727                 }
2728         }
2729
2730         _roll_delay = _initial_delay;
2731 }
2732
2733 /** Called with the process lock held if change contains ConfigurationChanged */
2734 void
2735 Route::input_change_handler (IOChange change, void * /*src*/)
2736 {
2737         if ((change.type & IOChange::ConfigurationChanged)) {
2738                 configure_processors (0);
2739                 _phase_invert.resize (_input->n_ports().n_audio ());
2740                 io_changed (); /* EMIT SIGNAL */
2741         }
2742 }
2743
2744 /** Called with the process lock held if change contains ConfigurationChanged */
2745 void
2746 Route::output_change_handler (IOChange change, void * /*src*/)
2747 {
2748         if ((change.type & IOChange::ConfigurationChanged)) {
2749
2750                 /* XXX resize all listeners to match _main_outs? */
2751
2752                 /* Auto-connect newly-created outputs, unless we're auto-connecting to master
2753                    and we are master (as an auto-connect in this situation would cause a
2754                    feedback loop)
2755                 */
2756                 AutoConnectOption ac = Config->get_output_auto_connect ();
2757                 if (ac == AutoConnectPhysical || (ac == AutoConnectMaster && !is_master ())) {
2758
2759                         ChanCount start = change.before;
2760
2761                         for (DataType::iterator i = DataType::begin(); i != DataType::end(); ++i) {
2762                                 if (change.before.get(*i) < change.after.get(*i)) {
2763                                         /* the existing ChanCounts don't matter for this call as they are only
2764                                            to do with matching input and output indices, and we are only changing
2765                                            outputs here.
2766                                         */
2767                                         ChanCount dummy;
2768
2769                                         /* only auto-connect the newly-created outputs, not the ones that were
2770                                            already there
2771                                         */
2772                                         start.set (*i, start.get (*i) + 1);
2773
2774                                         _session.auto_connect_route (this, dummy, dummy, false, ChanCount(), change.before);
2775                                 }
2776                         }
2777                 }
2778
2779                 // configure_processors (0);
2780         }
2781 }
2782
2783 uint32_t
2784 Route::pans_required () const
2785 {
2786         if (n_outputs().n_audio() < 2) {
2787                 return 0;
2788         }
2789
2790         return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
2791 }
2792
2793 int
2794 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
2795                 bool session_state_changing, bool /*can_record*/, bool /*rec_monitors_input*/)
2796 {
2797         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2798         if (!lm.locked()) {
2799                 return 0;
2800         }
2801
2802         if (n_outputs().n_total() == 0) {
2803                 return 0;
2804         }
2805
2806         if (!_active || n_inputs() == ChanCount::ZERO)  {
2807                 silence_unlocked (nframes);
2808                 return 0;
2809         }
2810         if (session_state_changing) {
2811                 if (_session.transport_speed() != 0.0f) {
2812                         /* we're rolling but some state is changing (e.g. our diskstream contents)
2813                            so we cannot use them. Be silent till this is over.
2814
2815                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
2816                         */
2817                         silence_unlocked (nframes);
2818                         return 0;
2819                 }
2820                 /* we're really not rolling, so we're either delivery silence or actually
2821                    monitoring, both of which are safe to do while session_state_changing is true.
2822                 */
2823         }
2824
2825         _amp->apply_gain_automation (false);
2826         passthru (start_frame, end_frame, nframes, 0);
2827
2828         return 0;
2829 }
2830
2831 framecnt_t
2832 Route::check_initial_delay (framecnt_t nframes, framecnt_t& transport_frame)
2833 {
2834         if (_roll_delay > nframes) {
2835
2836                 _roll_delay -= nframes;
2837                 silence_unlocked (nframes);
2838                 /* transport frame is not legal for caller to use */
2839                 return 0;
2840
2841         } else if (_roll_delay > 0) {
2842
2843                 nframes -= _roll_delay;
2844                 silence_unlocked (_roll_delay);
2845                 /* we've written _roll_delay of samples into the
2846                    output ports, so make a note of that for
2847                    future reference.
2848                 */
2849                 _main_outs->increment_output_offset (_roll_delay);
2850                 transport_frame += _roll_delay;
2851
2852                 _roll_delay = 0;
2853         }
2854
2855         return nframes;
2856 }
2857
2858 int
2859 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick,
2860              bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
2861 {
2862         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2863         if (!lm.locked()) {
2864                 return 0;
2865         }
2866
2867         automation_snapshot (_session.transport_frame(), false);
2868
2869         if (n_outputs().n_total() == 0) {
2870                 return 0;
2871         }
2872
2873         if (!_active || n_inputs().n_total() == 0) {
2874                 silence_unlocked (nframes);
2875                 return 0;
2876         }
2877
2878         framecnt_t unused = 0;
2879
2880         if ((nframes = check_initial_delay (nframes, unused)) == 0) {
2881                 return 0;
2882         }
2883
2884         _silent = false;
2885
2886         passthru (start_frame, end_frame, nframes, declick);
2887
2888         return 0;
2889 }
2890
2891 int
2892 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/,
2893                     bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
2894 {
2895         silence (nframes);
2896         return 0;
2897 }
2898
2899 void
2900 Route::toggle_monitor_input ()
2901 {
2902         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
2903                 i->ensure_monitor_input( ! i->monitoring_input());
2904         }
2905 }
2906
2907 bool
2908 Route::has_external_redirects () const
2909 {
2910         // FIXME: what about sends? - they don't return a signal back to ardour?
2911
2912         boost::shared_ptr<const PortInsert> pi;
2913
2914         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2915
2916                 if ((pi = boost::dynamic_pointer_cast<const PortInsert>(*i)) != 0) {
2917
2918                         for (PortSet::const_iterator port = pi->output()->ports().begin(); port != pi->output()->ports().end(); ++port) {
2919
2920                                 string port_name = port->name();
2921                                 string client_name = port_name.substr (0, port_name.find(':'));
2922
2923                                 /* only say "yes" if the redirect is actually in use */
2924
2925                                 if (client_name != "ardour" && pi->active()) {
2926                                         return true;
2927                                 }
2928                         }
2929                 }
2930         }
2931
2932         return false;
2933 }
2934
2935 void
2936 Route::flush_processors ()
2937 {
2938         /* XXX shouldn't really try to take this lock, since
2939            this is called from the RT audio thread.
2940         */
2941
2942         Glib::RWLock::ReaderLock lm (_processor_lock);
2943
2944         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2945                 (*i)->flush ();
2946         }
2947 }
2948
2949 void
2950 Route::set_meter_point (MeterPoint p, bool force)
2951 {
2952         /* CAN BE CALLED FROM PROCESS CONTEXT */
2953
2954         if (_meter_point == p && !force) {
2955                 return;
2956         }
2957
2958         bool meter_was_visible_to_user = _meter->display_to_user ();
2959
2960         {
2961                 Glib::RWLock::WriterLock lm (_processor_lock);
2962
2963                 if (p != MeterCustom) {
2964                         // Move meter in the processors list to reflect the new position
2965                         ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
2966                         _processors.erase(loc);
2967                         switch (p) {
2968                         case MeterInput:
2969                                 loc = _processors.begin();
2970                                 break;
2971                         case MeterPreFader:
2972                                 loc = find (_processors.begin(), _processors.end(), _amp);
2973                                 break;
2974                         case MeterPostFader:
2975                                 loc = _processors.end();
2976                                 break;
2977                         default:
2978                                 break;
2979                         }
2980
2981                         ChanCount m_in;
2982
2983                         if (loc == _processors.begin()) {
2984                                 m_in = _input->n_ports();
2985                         } else {
2986                                 ProcessorList::iterator before = loc;
2987                                 --before;
2988                                 m_in = (*before)->output_streams ();
2989                         }
2990
2991                         _meter->reflect_inputs (m_in);
2992
2993                         _processors.insert (loc, _meter);
2994
2995                         /* we do not need to reconfigure the processors, because the meter
2996                            (a) is always ready to handle processor_max_streams
2997                            (b) is always an N-in/N-out processor, and thus moving
2998                            it doesn't require any changes to the other processors.
2999                         */
3000
3001                         _meter->set_display_to_user (false);
3002
3003                 } else {
3004
3005                         // just make it visible and let the user move it
3006
3007                         _meter->set_display_to_user (true);
3008                 }
3009         }
3010
3011         _meter_point = p;
3012         meter_change (); /* EMIT SIGNAL */
3013
3014         bool const meter_visibly_changed = (_meter->display_to_user() != meter_was_visible_to_user);
3015
3016         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
3017 }
3018
3019 void
3020 Route::put_monitor_send_at (Placement p)
3021 {
3022         if (!_monitor_send) {
3023                 return;
3024         }
3025
3026         {
3027                 Glib::RWLock::WriterLock lm (_processor_lock);
3028                 ProcessorList as_it_was (_processors);
3029                 ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), _monitor_send);
3030                 _processors.erase(loc);
3031
3032                 switch (p) {
3033                 case PreFader:
3034                         loc = find(_processors.begin(), _processors.end(), _amp);
3035                         if (loc != _processors.begin()) {
3036                                 --loc;
3037                         }
3038                         break;
3039                 case PostFader:
3040                         loc = _processors.end();
3041                         break;
3042                 }
3043
3044                 _processors.insert (loc, _monitor_send);
3045
3046                 {
3047                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3048
3049                         if (configure_processors_unlocked (0)) {
3050                                 _processors = as_it_was;
3051                                 configure_processors_unlocked (0); // it worked before we tried to add it ...
3052                                 return;
3053                         }
3054                 }
3055         }
3056
3057         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
3058         _session.set_dirty ();
3059 }
3060
3061 boost::shared_ptr<CapturingProcessor>
3062 Route::add_export_point()
3063 {
3064         // Check if it exists already
3065         boost::shared_ptr<CapturingProcessor> processor;
3066         if ((processor = boost::dynamic_pointer_cast<CapturingProcessor> (*_processors.begin()))) {
3067                 return processor;
3068         }
3069
3070         // ...else add it
3071         processor.reset (new CapturingProcessor (_session));
3072         add_processor (processor, _processors.begin());
3073         return processor;
3074 }
3075
3076 framecnt_t
3077 Route::update_total_latency ()
3078 {
3079         framecnt_t old = _output->effective_latency();
3080         framecnt_t own_latency = _output->user_latency();
3081
3082         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3083                 if ((*i)->active ()) {
3084                         own_latency += (*i)->signal_latency ();
3085                 }
3086         }
3087
3088         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal redirect latency = %2\n", _name, own_latency));
3089
3090         _output->set_port_latency (own_latency);
3091
3092         if (_output->user_latency() == 0) {
3093
3094                 /* this (virtual) function is used for pure Routes,
3095                    not derived classes like AudioTrack.  this means
3096                    that the data processed here comes from an input
3097                    port, not prerecorded material, and therefore we
3098                    have to take into account any input latency.
3099                 */
3100
3101                 own_latency += _input->signal_latency ();
3102         }
3103
3104         if (old != own_latency) {
3105                 _output->set_latency_delay (own_latency);
3106                 signal_latency_changed (); /* EMIT SIGNAL */
3107         }
3108
3109         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: input latency = %2 total = %3\n", _name, _input->signal_latency(), own_latency));
3110
3111         return _output->effective_latency ();
3112 }
3113
3114 void
3115 Route::set_user_latency (framecnt_t nframes)
3116 {
3117         _output->set_user_latency (nframes);
3118         _session.update_latency_compensation (false, false);
3119 }
3120
3121 void
3122 Route::set_latency_delay (framecnt_t longest_session_latency)
3123 {
3124         framecnt_t old = _initial_delay;
3125
3126         if (_output->effective_latency() < longest_session_latency) {
3127                 _initial_delay = longest_session_latency - _output->effective_latency();
3128         } else {
3129                 _initial_delay = 0;
3130         }
3131
3132         if (_initial_delay != old) {
3133                 initial_delay_changed (); /* EMIT SIGNAL */
3134         }
3135
3136         if (_session.transport_stopped()) {
3137                 _roll_delay = _initial_delay;
3138         }
3139 }
3140
3141 void
3142 Route::automation_snapshot (framepos_t now, bool force)
3143 {
3144         panner()->automation_snapshot (now, force);
3145
3146         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3147                 (*i)->automation_snapshot (now, force);
3148         }
3149 }
3150
3151 Route::SoloControllable::SoloControllable (std::string name, Route& r)
3152         : AutomationControl (r.session(), Evoral::Parameter (SoloAutomation),
3153                              boost::shared_ptr<AutomationList>(), name)
3154         , route (r)
3155 {
3156         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
3157         set_list (gl);
3158 }
3159
3160 void
3161 Route::SoloControllable::set_value (double val)
3162 {
3163         bool bval = ((val >= 0.5f) ? true: false);
3164 # if 0
3165         this is how it should be done
3166
3167         boost::shared_ptr<RouteList> rl (new RouteList);
3168         rl->push_back (route);
3169
3170         if (Config->get_solo_control_is_listen_control()) {
3171                 _session.set_listen (rl, bval);
3172         } else {
3173                 _session.set_solo (rl, bval);
3174         }
3175 #else
3176         route.set_solo (bval, this);
3177 #endif
3178 }
3179
3180 double
3181 Route::SoloControllable::get_value (void) const
3182 {
3183         if (Config->get_solo_control_is_listen_control()) {
3184                 return route.listening() ? 1.0f : 0.0f;
3185         } else {
3186                 return route.self_soloed() ? 1.0f : 0.0f;
3187         }
3188 }
3189
3190 Route::MuteControllable::MuteControllable (std::string name, Route& r)
3191         : AutomationControl (r.session(), Evoral::Parameter (MuteAutomation),
3192                              boost::shared_ptr<AutomationList>(), name)
3193         , route (r)
3194 {
3195         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MuteAutomation)));
3196         set_list (gl);
3197 }
3198
3199 void
3200 Route::MuteControllable::set_value (double val)
3201 {
3202         bool bval = ((val >= 0.5f) ? true: false);
3203 # if 0
3204         this is how it should be done
3205
3206         boost::shared_ptr<RouteList> rl (new RouteList);
3207         rl->push_back (route);
3208         _session.set_mute (rl, bval);
3209 #else
3210         route.set_mute (bval, this);
3211 #endif
3212 }
3213
3214 double
3215 Route::MuteControllable::get_value (void) const
3216 {
3217         return route.muted() ? 1.0f : 0.0f;
3218 }
3219
3220 void
3221 Route::set_block_size (pframes_t nframes)
3222 {
3223         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3224                 (*i)->set_block_size (nframes);
3225         }
3226
3227         _session.ensure_buffers (n_process_buffers ());
3228 }
3229
3230 void
3231 Route::protect_automation ()
3232 {
3233         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3234                 (*i)->protect_automation();
3235 }
3236
3237 void
3238 Route::set_pending_declick (int declick)
3239 {
3240         if (_declickable) {
3241                 /* this call is not allowed to turn off a pending declick unless "force" is true */
3242                 if (declick) {
3243                         _pending_declick = declick;
3244                 }
3245                 // cerr << _name << ": after setting to " << declick << " pending declick = " << _pending_declick << endl;
3246         } else {
3247                 _pending_declick = 0;
3248         }
3249
3250 }
3251
3252 /** Shift automation forwards from a particular place, thereby inserting time.
3253  *  Adds undo commands for any shifts that are performed.
3254  *
3255  * @param pos Position to start shifting from.
3256  * @param frames Amount to shift forwards by.
3257  */
3258
3259 void
3260 Route::shift (framepos_t pos, framecnt_t frames)
3261 {
3262         /* gain automation */
3263         {
3264                 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
3265
3266                 XMLNode &before = gc->alist()->get_state ();
3267                 gc->alist()->shift (pos, frames);
3268                 XMLNode &after = gc->alist()->get_state ();
3269                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3270         }
3271
3272         /* pan automation */
3273         {
3274                 boost::shared_ptr<AutomationControl> pc;
3275                 uint32_t npans = _main_outs->panner()->npanners();
3276
3277                 for (uint32_t p = 0; p < npans; ++p) {
3278                         pc = _main_outs->panner()->pan_control (0, p);
3279                         if (pc) {
3280                                 boost::shared_ptr<AutomationList> al = pc->alist();
3281                                 XMLNode& before = al->get_state ();
3282                                 al->shift (pos, frames);
3283                                 XMLNode& after = al->get_state ();
3284                                 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3285                         }
3286                 }
3287         }
3288
3289         /* redirect automation */
3290         {
3291                 Glib::RWLock::ReaderLock lm (_processor_lock);
3292                 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
3293
3294                         set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
3295
3296                         for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
3297                                 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
3298                                 if (ac) {
3299                                         boost::shared_ptr<AutomationList> al = ac->alist();
3300                                         XMLNode &before = al->get_state ();
3301                                         al->shift (pos, frames);
3302                                         XMLNode &after = al->get_state ();
3303                                         _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3304                                 }
3305                         }
3306                 }
3307         }
3308 }
3309
3310
3311 int
3312 Route::save_as_template (const string& path, const string& name)
3313 {
3314         XMLNode& node (state (false));
3315         XMLTree tree;
3316
3317         IO::set_name_in_state (*node.children().front(), name);
3318
3319         tree.set_root (&node);
3320         return tree.write (path.c_str());
3321 }
3322
3323
3324 bool
3325 Route::set_name (const string& str)
3326 {
3327         bool ret;
3328         string ioproc_name;
3329         string name;
3330
3331         name = Route::ensure_track_or_route_name (str, _session);
3332         SessionObject::set_name (name);
3333
3334         ret = (_input->set_name(name) && _output->set_name(name));
3335
3336         if (ret) {
3337
3338                 Glib::RWLock::ReaderLock lm (_processor_lock);
3339
3340                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3341
3342                         /* rename all I/O processors that have inputs or outputs */
3343
3344                         boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
3345
3346                         if (iop && (iop->output() || iop->input())) {
3347                                 if (!iop->set_name (name)) {
3348                                         ret = false;
3349                                 }
3350                         }
3351                 }
3352
3353         }
3354
3355         return ret;
3356 }
3357
3358 boost::shared_ptr<Send>
3359 Route::internal_send_for (boost::shared_ptr<const Route> target) const
3360 {
3361         Glib::RWLock::ReaderLock lm (_processor_lock);
3362
3363         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3364                 boost::shared_ptr<InternalSend> send;
3365
3366                 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
3367                         if (send->target_route() == target) {
3368                                 return send;
3369                         }
3370                 }
3371         }
3372
3373         return boost::shared_ptr<Send>();
3374 }
3375
3376 /** @param c Audio channel index.
3377  *  @param yn true to invert phase, otherwise false.
3378  */
3379 void
3380 Route::set_phase_invert (uint32_t c, bool yn)
3381 {
3382         if (_phase_invert[c] != yn) {
3383                 _phase_invert[c] = yn;
3384                 phase_invert_changed (); /* EMIT SIGNAL */
3385                 _session.set_dirty ();
3386         }
3387 }
3388
3389 void
3390 Route::set_phase_invert (boost::dynamic_bitset<> p)
3391 {
3392         if (_phase_invert != p) {
3393                 _phase_invert = p;
3394                 phase_invert_changed (); /* EMIT SIGNAL */
3395                 _session.set_dirty ();
3396         }
3397 }
3398
3399 bool
3400 Route::phase_invert (uint32_t c) const
3401 {
3402         return _phase_invert[c];
3403 }
3404
3405 boost::dynamic_bitset<>
3406 Route::phase_invert () const
3407 {
3408         return _phase_invert;
3409 }
3410
3411 void
3412 Route::set_denormal_protection (bool yn)
3413 {
3414         if (_denormal_protection != yn) {
3415                 _denormal_protection = yn;
3416                 denormal_protection_changed (); /* EMIT SIGNAL */
3417         }
3418 }
3419
3420 bool
3421 Route::denormal_protection () const
3422 {
3423         return _denormal_protection;
3424 }
3425
3426 void
3427 Route::set_active (bool yn, void* src)
3428 {
3429         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
3430                 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
3431                 return;
3432         }
3433
3434         if (_active != yn) {
3435                 _active = yn;
3436                 _input->set_active (yn);
3437                 _output->set_active (yn);
3438                 active_changed (); // EMIT SIGNAL
3439         }
3440 }
3441
3442 void
3443 Route::meter ()
3444 {
3445         Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3446
3447         assert (_meter);
3448
3449         _meter->meter ();
3450
3451         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3452
3453                 boost::shared_ptr<Send> s;
3454                 boost::shared_ptr<Return> r;
3455
3456                 if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
3457                         s->meter()->meter();
3458                 } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
3459                         r->meter()->meter ();
3460                 }
3461         }
3462 }
3463
3464 boost::shared_ptr<Panner>
3465 Route::panner() const
3466 {
3467         return _main_outs->panner();
3468 }
3469
3470 boost::shared_ptr<AutomationControl>
3471 Route::gain_control() const
3472 {
3473         return _amp->gain_control();
3474 }
3475
3476 boost::shared_ptr<AutomationControl>
3477 Route::get_control (const Evoral::Parameter& param)
3478 {
3479         /* either we own the control or .... */
3480
3481         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
3482
3483         if (!c) {
3484
3485                 /* maybe one of our processors does or ... */
3486
3487                 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3488                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3489                         if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
3490                                 break;
3491                         }
3492                 }
3493         }
3494
3495         if (!c) {
3496
3497                 /* nobody does so we'll make a new one */
3498
3499                 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
3500                 add_control(c);
3501         }
3502
3503         return c;
3504 }
3505
3506 boost::shared_ptr<Processor>
3507 Route::nth_plugin (uint32_t n)
3508 {
3509         Glib::RWLock::ReaderLock lm (_processor_lock);
3510         ProcessorList::iterator i;
3511
3512         for (i = _processors.begin(); i != _processors.end(); ++i) {
3513                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
3514                         if (n-- == 0) {
3515                                 return *i;
3516                         }
3517                 }
3518         }
3519
3520         return boost::shared_ptr<Processor> ();
3521 }
3522
3523 boost::shared_ptr<Processor>
3524 Route::nth_send (uint32_t n)
3525 {
3526         Glib::RWLock::ReaderLock lm (_processor_lock);
3527         ProcessorList::iterator i;
3528
3529         for (i = _processors.begin(); i != _processors.end(); ++i) {
3530                 if (boost::dynamic_pointer_cast<Send> (*i)) {
3531                         if (n-- == 0) {
3532                                 return *i;
3533                         }
3534                 }
3535         }
3536
3537         return boost::shared_ptr<Processor> ();
3538 }
3539
3540 bool
3541 Route::has_io_processor_named (const string& name)
3542 {
3543         Glib::RWLock::ReaderLock lm (_processor_lock);
3544         ProcessorList::iterator i;
3545
3546         for (i = _processors.begin(); i != _processors.end(); ++i) {
3547                 if (boost::dynamic_pointer_cast<Send> (*i) ||
3548                     boost::dynamic_pointer_cast<PortInsert> (*i)) {
3549                         if ((*i)->name() == name) {
3550                                 return true;
3551                         }
3552                 }
3553         }
3554
3555         return false;
3556 }
3557
3558 MuteMaster::MutePoint
3559 Route::mute_points () const
3560 {
3561         return _mute_master->mute_points ();
3562 }
3563
3564 void
3565 Route::set_processor_positions ()
3566 {
3567         Glib::RWLock::ReaderLock lm (_processor_lock);
3568
3569         bool had_amp = false;
3570         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3571                 (*i)->set_pre_fader (!had_amp);
3572                 if (boost::dynamic_pointer_cast<Amp> (*i)) {
3573                         had_amp = true;
3574                 }
3575         }
3576 }
3577
3578 /** Called when there is a proposed change to the input port count */
3579 bool
3580 Route::input_port_count_changing (ChanCount to)
3581 {
3582         list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
3583         if (c.empty()) {
3584                 /* The processors cannot be configured with the new input arrangement, so
3585                    block the change.
3586                 */
3587                 return true;
3588         }
3589
3590         /* The change is ok */
3591         return false;
3592 }
3593
3594 list<string>
3595 Route::unknown_processors () const
3596 {
3597         list<string> p;
3598
3599         Glib::RWLock::ReaderLock lm (_processor_lock);
3600         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3601                 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
3602                         p.push_back ((*i)->name ());
3603                 }
3604         }
3605
3606         return p;
3607 }