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