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         XMLPropertyList plist;
1810         const XMLProperty *prop;
1811
1812         if (node.name() != "Route"){
1813                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1814                 return -1;
1815         }
1816
1817         if ((prop = node.property (X_("name"))) != 0) {
1818                 Route::set_name (prop->value());
1819         }
1820
1821         if ((prop = node.property ("id")) != 0) {
1822                 _id = prop->value ();
1823         }
1824
1825         if ((prop = node.property (X_("flags"))) != 0) {
1826                 _flags = Flag (string_2_enum (prop->value(), _flags));
1827         } else {
1828                 _flags = Flag (0);
1829         }
1830
1831         if (is_master() || is_monitor() || is_hidden()) {
1832                 _mute_master->set_solo_ignore (true);
1833         }
1834
1835         /* add all processors (except amp, which is always present) */
1836
1837         nlist = node.children();
1838         XMLNode processor_state (X_("processor_state"));
1839
1840         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1841
1842                 child = *niter;
1843
1844                 if (child->name() == IO::state_node_name) {
1845                         if ((prop = child->property (X_("direction"))) == 0) {
1846                                 continue;
1847                         }
1848
1849                         if (prop->value() == "Input") {
1850                                 _input->set_state (*child, version);
1851                         } else if (prop->value() == "Output") {
1852                                 _output->set_state (*child, version);
1853                         }
1854                 }
1855
1856                 if (child->name() == X_("Processor")) {
1857                         processor_state.add_child_copy (*child);
1858                 }
1859         }
1860
1861         set_processor_state (processor_state);
1862
1863         if ((prop = node.property ("self-solo")) != 0) {
1864                 set_self_solo (string_is_affirmative (prop->value()));
1865         }
1866
1867         if ((prop = node.property ("soloed-by-upstream")) != 0) {
1868                 _soloed_by_others_upstream = 0; // needed for mod_.... () to work
1869                 mod_solo_by_others_upstream (atoi (prop->value()));
1870         }
1871
1872         if ((prop = node.property ("soloed-by-downstream")) != 0) {
1873                 _soloed_by_others_downstream = 0; // needed for mod_.... () to work
1874                 mod_solo_by_others_downstream (atoi (prop->value()));
1875         }
1876
1877         if ((prop = node.property ("solo-isolated")) != 0) {
1878                 set_solo_isolated (string_is_affirmative (prop->value()), this);
1879         }
1880
1881         if ((prop = node.property (X_("phase-invert"))) != 0) {
1882                 set_phase_invert (boost::dynamic_bitset<> (prop->value ()));
1883         }
1884
1885         if ((prop = node.property (X_("denormal-protection"))) != 0) {
1886                 set_denormal_protection (string_is_affirmative (prop->value()));
1887         }
1888
1889         if ((prop = node.property (X_("active"))) != 0) {
1890                 bool yn = string_is_affirmative (prop->value());
1891                 _active = !yn; // force switch
1892                 set_active (yn);
1893         }
1894
1895         if ((prop = node.property (X_("meter-point"))) != 0) {
1896                 MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
1897                 set_meter_point (mp);
1898                 if (_meter) {
1899                         _meter->set_display_to_user (_meter_point == MeterCustom);
1900                 }
1901         }
1902
1903         if ((prop = node.property (X_("order-keys"))) != 0) {
1904
1905                 int32_t n;
1906
1907                 string::size_type colon, equal;
1908                 string remaining = prop->value();
1909
1910                 while (remaining.length()) {
1911
1912                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
1913                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1914                                       << endmsg;
1915                         } else {
1916                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
1917                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1918                                               << endmsg;
1919                                 } else {
1920                                         set_order_key (remaining.substr (0, equal), n);
1921                                 }
1922                         }
1923
1924                         colon = remaining.find_first_of (':');
1925
1926                         if (colon != string::npos) {
1927                                 remaining = remaining.substr (colon+1);
1928                         } else {
1929                                 break;
1930                         }
1931                 }
1932         }
1933
1934         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1935                 child = *niter;
1936
1937                 if (child->name() == X_("Comment")) {
1938
1939                         /* XXX this is a terrible API design in libxml++ */
1940
1941                         XMLNode *cmt = *(child->children().begin());
1942                         _comment = cmt->content();
1943
1944                 } else if (child->name() == X_("Extra")) {
1945
1946                         _extra_xml = new XMLNode (*child);
1947
1948                 } else if (child->name() == X_("Controllable") && (prop = child->property("name")) != 0) {
1949
1950                         if (prop->value() == "solo") {
1951                                 _solo_control->set_state (*child, version);
1952                                 _session.add_controllable (_solo_control);
1953                         }
1954
1955                 } else if (child->name() == X_("RemoteControl")) {
1956                         if ((prop = child->property (X_("id"))) != 0) {
1957                                 int32_t x;
1958                                 sscanf (prop->value().c_str(), "%d", &x);
1959                                 set_remote_control_id (x);
1960                         }
1961
1962                 } else if (child->name() == X_("MuteMaster")) {
1963                         _mute_master->set_state (*child, version);
1964                 }
1965         }
1966
1967         return 0;
1968 }
1969
1970 int
1971 Route::_set_state_2X (const XMLNode& node, int version)
1972 {
1973         XMLNodeList nlist;
1974         XMLNodeConstIterator niter;
1975         XMLNode *child;
1976         XMLPropertyList plist;
1977         const XMLProperty *prop;
1978
1979         /* 2X things which still remain to be handled:
1980          * default-type
1981          * automation
1982          * controlouts
1983          */
1984
1985         if (node.name() != "Route") {
1986                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1987                 return -1;
1988         }
1989
1990         if ((prop = node.property (X_("flags"))) != 0) {
1991                 _flags = Flag (string_2_enum (prop->value(), _flags));
1992         } else {
1993                 _flags = Flag (0);
1994         }
1995
1996         if ((prop = node.property (X_("phase-invert"))) != 0) {
1997                 boost::dynamic_bitset<> p (_input->n_ports().n_audio ());
1998                 if (string_is_affirmative (prop->value ())) {
1999                         p.set ();
2000                 }
2001                 set_phase_invert (p);
2002         }
2003
2004         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2005                 set_denormal_protection (string_is_affirmative (prop->value()));
2006         }
2007
2008         if ((prop = node.property (X_("soloed"))) != 0) {
2009                 bool yn = string_is_affirmative (prop->value());
2010
2011                 /* XXX force reset of solo status */
2012
2013                 set_solo (yn, this);
2014         }
2015
2016         if ((prop = node.property (X_("muted"))) != 0) {
2017
2018                 bool first = true;
2019                 bool muted = string_is_affirmative (prop->value());
2020
2021                 if (muted){
2022
2023                         string mute_point;
2024
2025                         if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
2026
2027                                 if (string_is_affirmative (prop->value())){
2028                                         mute_point = mute_point + "PreFader";
2029                                         first = false;
2030                                 }
2031                         }
2032
2033                         if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
2034
2035                                 if (string_is_affirmative (prop->value())){
2036
2037                                         if (!first) {
2038                                                 mute_point = mute_point + ",";
2039                                         }
2040
2041                                         mute_point = mute_point + "PostFader";
2042                                         first = false;
2043                                 }
2044                         }
2045
2046                         if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
2047
2048                                 if (string_is_affirmative (prop->value())){
2049
2050                                         if (!first) {
2051                                                 mute_point = mute_point + ",";
2052                                         }
2053
2054                                         mute_point = mute_point + "Listen";
2055                                         first = false;
2056                                 }
2057                         }
2058
2059                         if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
2060
2061                                 if (string_is_affirmative (prop->value())){
2062
2063                                         if (!first) {
2064                                                 mute_point = mute_point + ",";
2065                                         }
2066
2067                                         mute_point = mute_point + "Main";
2068                                 }
2069                         }
2070
2071                         _mute_master->set_mute_points (mute_point);
2072                 }
2073         }
2074
2075         if ((prop = node.property (X_("meter-point"))) != 0) {
2076                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2077         }
2078
2079         /* do not carry over edit/mix groups from 2.X because (a) its hard (b) they
2080            don't mean the same thing.
2081         */
2082
2083         if ((prop = node.property (X_("order-keys"))) != 0) {
2084
2085                 int32_t n;
2086
2087                 string::size_type colon, equal;
2088                 string remaining = prop->value();
2089
2090                 while (remaining.length()) {
2091
2092                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2093                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2094                                         << endmsg;
2095                         } else {
2096                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2097                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2098                                                 << endmsg;
2099                                 } else {
2100                                         set_order_key (remaining.substr (0, equal), n);
2101                                 }
2102                         }
2103
2104                         colon = remaining.find_first_of (':');
2105
2106                         if (colon != string::npos) {
2107                                 remaining = remaining.substr (colon+1);
2108                         } else {
2109                                 break;
2110                         }
2111                 }
2112         }
2113
2114         /* IOs */
2115
2116         nlist = node.children ();
2117         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2118
2119                 child = *niter;
2120
2121                 if (child->name() == IO::state_node_name) {
2122
2123                         /* there is a note in IO::set_state_2X() about why we have to call
2124                            this directly.
2125                            */
2126
2127                         _input->set_state_2X (*child, version, true);
2128                         _output->set_state_2X (*child, version, false);
2129
2130                         if ((prop = child->property (X_("name"))) != 0) {
2131                                 Route::set_name (prop->value ());
2132                         }
2133
2134                         if ((prop = child->property (X_("id"))) != 0) {
2135                                 _id = prop->value ();
2136                         }
2137
2138                         if ((prop = child->property (X_("active"))) != 0) {
2139                                 bool yn = string_is_affirmative (prop->value());
2140                                 _active = !yn; // force switch
2141                                 set_active (yn);
2142                         }
2143
2144                         if ((prop = child->property (X_("gain"))) != 0) {
2145                                 gain_t val;
2146
2147                                 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2148                                         _amp->gain_control()->set_value (val);
2149                                 }
2150                         }
2151
2152                         /* Set up Panners in the IO */
2153                         XMLNodeList io_nlist = child->children ();
2154
2155                         XMLNodeConstIterator io_niter;
2156                         XMLNode *io_child;
2157
2158                         for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2159
2160                                 io_child = *io_niter;
2161
2162                                 if (io_child->name() == X_("Panner")) {
2163                                         _main_outs->panner()->set_state(*io_child, version);
2164                                 } else if (io_child->name() == X_("Automation")) {
2165                                         /* IO's automation is for the fader */
2166                                         _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
2167                                 }
2168                         }
2169                 }
2170         }
2171
2172         XMLNodeList redirect_nodes;
2173
2174         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2175
2176                 child = *niter;
2177
2178                 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2179                         redirect_nodes.push_back(child);
2180                 }
2181
2182         }
2183
2184         set_processor_state_2X (redirect_nodes, version);
2185
2186         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2187                 child = *niter;
2188
2189                 if (child->name() == X_("Comment")) {
2190
2191                         /* XXX this is a terrible API design in libxml++ */
2192
2193                         XMLNode *cmt = *(child->children().begin());
2194                         _comment = cmt->content();
2195
2196                 } else if (child->name() == X_("extra")) {
2197
2198                         _extra_xml = new XMLNode (*child);
2199
2200                 } else if (child->name() == X_("Controllable") && (prop = child->property("name")) != 0) {
2201
2202                         if (prop->value() == "solo") {
2203                                 _solo_control->set_state (*child, version);
2204                                 _session.add_controllable (_solo_control);
2205                         }
2206
2207                 } else if (child->name() == X_("RemoteControl")) {
2208                         if ((prop = child->property (X_("id"))) != 0) {
2209                                 int32_t x;
2210                                 sscanf (prop->value().c_str(), "%d", &x);
2211                                 set_remote_control_id (x);
2212                         }
2213
2214                 }
2215         }
2216
2217         return 0;
2218 }
2219
2220 XMLNode&
2221 Route::get_processor_state ()
2222 {
2223         XMLNode* root = new XMLNode (X_("redirects"));
2224         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2225                 root->add_child_nocopy ((*i)->state (true));
2226         }
2227
2228         return *root;
2229 }
2230
2231 void
2232 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2233 {
2234         /* We don't bother removing existing processors not in nList, as this
2235            method will only be called when creating a Route from scratch, not
2236            for undo purposes.  Just put processors in at the appropriate place
2237            in the list.
2238         */
2239
2240         for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2241                 add_processor_from_xml_2X (**i, version);
2242         }
2243 }
2244
2245 void
2246 Route::set_processor_state (const XMLNode& node)
2247 {
2248         const XMLNodeList &nlist = node.children();
2249         XMLNodeConstIterator niter;
2250         ProcessorList new_order;
2251         bool must_configure = false;
2252
2253         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2254
2255                 XMLProperty* prop = (*niter)->property ("type");
2256
2257                 if (prop->value() == "amp") {
2258                         _amp->set_state (**niter, Stateful::current_state_version);
2259                         new_order.push_back (_amp);
2260                 } else if (prop->value() == "meter") {
2261                         _meter->set_state (**niter, Stateful::current_state_version);
2262                         new_order.push_back (_meter);
2263                 } else if (prop->value() == "main-outs") {
2264                         _main_outs->set_state (**niter, Stateful::current_state_version);
2265                         new_order.push_back (_main_outs);
2266                 } else if (prop->value() == "intreturn") {
2267                         if (!_intreturn) {
2268                                 _intreturn.reset (new InternalReturn (_session));
2269                                 must_configure = true;
2270                         }
2271                         _intreturn->set_state (**niter, Stateful::current_state_version);
2272                         new_order.push_back (_intreturn);
2273                 } else if (is_monitor() && prop->value() == "monitor") {
2274                         if (!_monitor_control) {
2275                                 _monitor_control.reset (new MonitorProcessor (_session));
2276                                 must_configure = true;
2277                         }
2278                         _monitor_control->set_state (**niter, Stateful::current_state_version);
2279                         new_order.push_back (_monitor_control);
2280                 } else {
2281                         ProcessorList::iterator o;
2282
2283                         for (o = _processors.begin(); o != _processors.end(); ++o) {
2284                                 XMLProperty* id_prop = (*niter)->property(X_("id"));
2285                                 if (id_prop && (*o)->id() == id_prop->value()) {
2286                                         (*o)->set_state (**niter, Stateful::current_state_version);
2287                                         new_order.push_back (*o);
2288                                         break;
2289                                 }
2290                         }
2291
2292                         // If the processor (*niter) is not on the route then create it
2293
2294                         if (o == _processors.end()) {
2295
2296                                 boost::shared_ptr<Processor> processor;
2297
2298                                 if (prop->value() == "intsend") {
2299
2300                                         processor.reset (new InternalSend (_session, _mute_master, boost::shared_ptr<Route>(), Delivery::Role (0)));
2301
2302                                 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2303                                            prop->value() == "lv2" ||
2304                                            prop->value() == "vst" ||
2305                                            prop->value() == "audiounit") {
2306
2307                                         processor.reset (new PluginInsert(_session));
2308
2309                                 } else if (prop->value() == "port") {
2310
2311                                         processor.reset (new PortInsert (_session, _mute_master));
2312
2313                                 } else if (prop->value() == "send") {
2314
2315                                         processor.reset (new Send (_session, _mute_master));
2316
2317                                 } else {
2318                                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2319                                         continue;
2320                                 }
2321
2322                                 processor->set_state (**niter, Stateful::current_state_version);
2323                                 new_order.push_back (processor);
2324                                 must_configure = true;
2325                         }
2326                 }
2327         }
2328
2329         {
2330                 Glib::RWLock::WriterLock lm (_processor_lock);
2331                 _processors = new_order;
2332                 if (must_configure) {
2333                         configure_processors_unlocked (0);
2334                 }
2335         }
2336
2337         processors_changed (RouteProcessorChange ());
2338         set_processor_positions ();
2339 }
2340
2341 void
2342 Route::curve_reallocate ()
2343 {
2344 //      _gain_automation_curve.finish_resize ();
2345 //      _pan_automation_curve.finish_resize ();
2346 }
2347
2348 void
2349 Route::silence (nframes_t nframes)
2350 {
2351         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2352         if (!lm.locked()) {
2353                 return;
2354         }
2355
2356         silence_unlocked (nframes);
2357 }
2358
2359 void
2360 Route::silence_unlocked (nframes_t nframes)
2361 {
2362         /* Must be called with the processor lock held */
2363
2364         if (!_silent) {
2365
2366                 _output->silence (nframes);
2367
2368                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2369                         boost::shared_ptr<PluginInsert> pi;
2370
2371                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2372                                 // skip plugins, they don't need anything when we're not active
2373                                 continue;
2374                         }
2375
2376                         (*i)->silence (nframes);
2377                 }
2378
2379                 if (nframes == _session.get_block_size()) {
2380                         // _silent = true;
2381                 }
2382         }
2383 }
2384
2385 void
2386 Route::add_internal_return ()
2387 {
2388         if (!_intreturn) {
2389                 _intreturn.reset (new InternalReturn (_session));
2390                 add_processor (_intreturn, PreFader);
2391         }
2392 }
2393
2394 BufferSet*
2395 Route::get_return_buffer () const
2396 {
2397         Glib::RWLock::ReaderLock rm (_processor_lock);
2398
2399         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2400                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2401
2402                 if (d) {
2403                         BufferSet* bs = d->get_buffers ();
2404                         return bs;
2405                 }
2406         }
2407
2408         return 0;
2409 }
2410
2411 void
2412 Route::release_return_buffer () const
2413 {
2414         Glib::RWLock::ReaderLock rm (_processor_lock);
2415
2416         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2417                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2418
2419                 if (d) {
2420                         return d->release_buffers ();
2421                 }
2422         }
2423 }
2424
2425 int
2426 Route::listen_via (boost::shared_ptr<Route> route, Placement placement, bool /*active*/, bool aux)
2427 {
2428         vector<string> ports;
2429         vector<string>::const_iterator i;
2430
2431         {
2432                 Glib::RWLock::ReaderLock rm (_processor_lock);
2433
2434                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2435
2436                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2437
2438                         if (d && d->target_route() == route) {
2439
2440                                 /* if the target is the control outs, then make sure
2441                                    we take note of which i-send is doing that.
2442                                 */
2443
2444                                 if (route == _session.monitor_out()) {
2445                                         _monitor_send = boost::dynamic_pointer_cast<Delivery>(d);
2446                                 }
2447
2448                                 /* already listening via the specified IO: do nothing */
2449
2450                                 return 0;
2451                         }
2452                 }
2453         }
2454
2455         boost::shared_ptr<InternalSend> listener;
2456
2457         try {
2458
2459                 if (is_master()) {
2460
2461                         if (route == _session.monitor_out()) {
2462                                 /* master never sends to control outs */
2463                                 return 0;
2464                         } else {
2465                                 listener.reset (new InternalSend (_session, _mute_master, route, (aux ? Delivery::Aux : Delivery::Listen)));
2466                         }
2467
2468                 } else {
2469                         listener.reset (new InternalSend (_session, _mute_master, route, (aux ? Delivery::Aux : Delivery::Listen)));
2470                 }
2471
2472         } catch (failed_constructor& err) {
2473                 return -1;
2474         }
2475
2476         if (route == _session.monitor_out()) {
2477                 _monitor_send = listener;
2478         }
2479
2480         if (placement == PostFader) {
2481                 /* put it *really* at the end, not just after the panner (main outs)
2482                  */
2483                 add_processor (listener, _processors.end());
2484         } else {
2485                 add_processor (listener, PreFader);
2486         }
2487
2488         return 0;
2489 }
2490
2491 void
2492 Route::drop_listen (boost::shared_ptr<Route> route)
2493 {
2494         ProcessorStreams err;
2495         ProcessorList::iterator tmp;
2496
2497         Glib::RWLock::ReaderLock rl(_processor_lock);
2498         rl.acquire ();
2499
2500   again:
2501         for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ) {
2502
2503                 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2504
2505                 if (d && d->target_route() == route) {
2506                         rl.release ();
2507                         remove_processor (*x, &err);
2508                         rl.acquire ();
2509
2510                         /* list could have been demolished while we dropped the lock
2511                            so start over.
2512                         */
2513
2514                         goto again;
2515                 }
2516         }
2517
2518         rl.release ();
2519
2520         if (route == _session.monitor_out()) {
2521                 _monitor_send.reset ();
2522         }
2523 }
2524
2525 void
2526 Route::set_comment (string cmt, void *src)
2527 {
2528         _comment = cmt;
2529         comment_changed (src);
2530         _session.set_dirty ();
2531 }
2532
2533 bool
2534 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
2535 {
2536         FeedRecord fr (other, via_sends_only);
2537
2538         pair<FedBy::iterator,bool> result =  _fed_by.insert (fr);
2539
2540         if (!result.second) {
2541
2542                 /* already a record for "other" - make sure sends-only information is correct */
2543                 if (!via_sends_only && result.first->sends_only) {
2544                         FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
2545                         frp->sends_only = false;
2546                 }
2547         }
2548
2549         return result.second;
2550 }
2551
2552 void
2553 Route::clear_fed_by ()
2554 {
2555         _fed_by.clear ();
2556 }
2557
2558 bool
2559 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
2560 {
2561         const FedBy& fed_by (other->fed_by());
2562
2563         for (FedBy::iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
2564                 boost::shared_ptr<Route> sr = f->r.lock();
2565
2566                 if (sr && (sr.get() == this)) {
2567
2568                         if (via_sends_only) {
2569                                 *via_sends_only = f->sends_only;
2570                         }
2571
2572                         return true;
2573                 }
2574         }
2575
2576         return false;
2577 }
2578
2579 bool
2580 Route::direct_feeds (boost::shared_ptr<Route> other, bool* only_send)
2581 {
2582         DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
2583
2584         if (_output->connected_to (other->input())) {
2585                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
2586                 if (only_send) {
2587                         *only_send = false;
2588                 }
2589
2590                 return true;
2591         }
2592
2593
2594         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
2595
2596                 boost::shared_ptr<IOProcessor> iop;
2597
2598                 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
2599                         if (iop->feeds (other)) {
2600                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
2601                                 if (only_send) {
2602                                         *only_send = true;
2603                                 }
2604                                 return true;
2605                         } else {
2606                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
2607                         }
2608                 } else {
2609                         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
2610                 }
2611
2612         }
2613
2614         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tdoes NOT feed %1\n", other->name()));
2615         return false;
2616 }
2617
2618 void
2619 Route::handle_transport_stopped (bool /*abort_ignored*/, bool did_locate, bool can_flush_processors)
2620 {
2621         framepos_t now = _session.transport_frame();
2622
2623         {
2624                 Glib::RWLock::ReaderLock lm (_processor_lock);
2625
2626                 if (!did_locate) {
2627                         automation_snapshot (now, true);
2628                 }
2629
2630                 Automatable::transport_stopped (now);
2631
2632                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2633
2634                         if (Config->get_plugins_stop_with_transport() && can_flush_processors) {
2635                                 (*i)->flush ();
2636                         }
2637
2638                         (*i)->transport_stopped (now);
2639                 }
2640         }
2641
2642         _roll_delay = _initial_delay;
2643 }
2644
2645 void
2646 Route::input_change_handler (IOChange change, void * /*src*/)
2647 {
2648         if ((change.type & IOChange::ConfigurationChanged)) {
2649                 configure_processors (0);
2650                 _phase_invert.resize (_input->n_ports().n_audio ());
2651                 io_changed (); /* EMIT SIGNAL */
2652         }
2653 }
2654
2655 void
2656 Route::output_change_handler (IOChange change, void * /*src*/)
2657 {
2658         if ((change.type & IOChange::ConfigurationChanged)) {
2659
2660                 /* XXX resize all listeners to match _main_outs? */
2661
2662                 /* Auto-connect newly-created outputs, unless we're auto-connecting to master
2663                    and we are master (as an auto-connect in this situation would cause a
2664                    feedback loop)
2665                 */
2666                 AutoConnectOption ac = Config->get_output_auto_connect ();
2667                 if (ac == AutoConnectPhysical || (ac == AutoConnectMaster && !is_master ())) {
2668
2669                         ChanCount start = change.before;
2670
2671                         for (DataType::iterator i = DataType::begin(); i != DataType::end(); ++i) {
2672                                 if (change.before.get(*i) < change.after.get(*i)) {
2673                                         /* the existing ChanCounts don't matter for this call as they are only
2674                                            to do with matching input and output indices, and we are only changing
2675                                            outputs here.
2676                                         */
2677                                         ChanCount dummy;
2678
2679                                         /* only auto-connect the newly-created outputs, not the ones that were
2680                                            already there
2681                                         */
2682                                         start.set (*i, start.get (*i) + 1);
2683
2684                                         _session.auto_connect_route (this, dummy, dummy, false, ChanCount(), change.before);
2685                                 }
2686                         }
2687                 }
2688
2689                 // configure_processors (0);
2690         }
2691 }
2692
2693 uint32_t
2694 Route::pans_required () const
2695 {
2696         if (n_outputs().n_audio() < 2) {
2697                 return 0;
2698         }
2699
2700         return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
2701 }
2702
2703 int
2704 Route::no_roll (nframes_t nframes, framepos_t start_frame, framepos_t end_frame,
2705                 bool session_state_changing, bool /*can_record*/, bool /*rec_monitors_input*/)
2706 {
2707         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2708         if (!lm.locked()) {
2709                 return 0;
2710         }
2711
2712         if (n_outputs().n_total() == 0) {
2713                 return 0;
2714         }
2715
2716         if (!_active || n_inputs() == ChanCount::ZERO)  {
2717                 silence_unlocked (nframes);
2718                 return 0;
2719         }
2720         if (session_state_changing) {
2721                 if (_session.transport_speed() != 0.0f) {
2722                         /* we're rolling but some state is changing (e.g. our diskstream contents)
2723                            so we cannot use them. Be silent till this is over.
2724
2725                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
2726                         */
2727                         silence_unlocked (nframes);
2728                         return 0;
2729                 }
2730                 /* we're really not rolling, so we're either delivery silence or actually
2731                    monitoring, both of which are safe to do while session_state_changing is true.
2732                 */
2733         }
2734
2735         _amp->apply_gain_automation (false);
2736         passthru (start_frame, end_frame, nframes, 0);
2737
2738         return 0;
2739 }
2740
2741 nframes_t
2742 Route::check_initial_delay (nframes_t nframes, nframes_t& transport_frame)
2743 {
2744         if (_roll_delay > nframes) {
2745
2746                 _roll_delay -= nframes;
2747                 silence_unlocked (nframes);
2748                 /* transport frame is not legal for caller to use */
2749                 return 0;
2750
2751         } else if (_roll_delay > 0) {
2752
2753                 nframes -= _roll_delay;
2754                 silence_unlocked (_roll_delay);
2755                 /* we've written _roll_delay of samples into the
2756                    output ports, so make a note of that for
2757                    future reference.
2758                 */
2759                 _main_outs->increment_output_offset (_roll_delay);
2760                 transport_frame += _roll_delay;
2761
2762                 _roll_delay = 0;
2763         }
2764
2765         return nframes;
2766 }
2767
2768 int
2769 Route::roll (nframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick,
2770              bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
2771 {
2772         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2773         if (!lm.locked()) {
2774                 return 0;
2775         }
2776
2777         automation_snapshot (_session.transport_frame(), false);
2778
2779         if (n_outputs().n_total() == 0) {
2780                 return 0;
2781         }
2782
2783         if (!_active || n_inputs().n_total() == 0) {
2784                 silence_unlocked (nframes);
2785                 return 0;
2786         }
2787
2788         nframes_t unused = 0;
2789
2790         if ((nframes = check_initial_delay (nframes, unused)) == 0) {
2791                 return 0;
2792         }
2793
2794         _silent = false;
2795
2796         passthru (start_frame, end_frame, nframes, declick);
2797
2798         return 0;
2799 }
2800
2801 int
2802 Route::silent_roll (nframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/,
2803                     bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
2804 {
2805         silence (nframes);
2806         return 0;
2807 }
2808
2809 void
2810 Route::toggle_monitor_input ()
2811 {
2812         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
2813                 i->ensure_monitor_input( ! i->monitoring_input());
2814         }
2815 }
2816
2817 bool
2818 Route::has_external_redirects () const
2819 {
2820         // FIXME: what about sends? - they don't return a signal back to ardour?
2821
2822         boost::shared_ptr<const PortInsert> pi;
2823
2824         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2825
2826                 if ((pi = boost::dynamic_pointer_cast<const PortInsert>(*i)) != 0) {
2827
2828                         for (PortSet::const_iterator port = pi->output()->ports().begin(); port != pi->output()->ports().end(); ++port) {
2829
2830                                 string port_name = port->name();
2831                                 string client_name = port_name.substr (0, port_name.find(':'));
2832
2833                                 /* only say "yes" if the redirect is actually in use */
2834
2835                                 if (client_name != "ardour" && pi->active()) {
2836                                         return true;
2837                                 }
2838                         }
2839                 }
2840         }
2841
2842         return false;
2843 }
2844
2845 void
2846 Route::flush_processors ()
2847 {
2848         /* XXX shouldn't really try to take this lock, since
2849            this is called from the RT audio thread.
2850         */
2851
2852         Glib::RWLock::ReaderLock lm (_processor_lock);
2853
2854         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2855                 (*i)->flush ();
2856         }
2857 }
2858
2859 void
2860 Route::set_meter_point (MeterPoint p)
2861 {
2862         /* CAN BE CALLED FROM PROCESS CONTEXT */
2863
2864         if (_meter_point == p) {
2865                 return;
2866         }
2867
2868         bool meter_was_visible_to_user = _meter->display_to_user ();
2869
2870         {
2871                 Glib::RWLock::WriterLock lm (_processor_lock);
2872
2873                 if (p != MeterCustom) {
2874                         // Move meter in the processors list to reflect the new position
2875                         ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
2876                         _processors.erase(loc);
2877                         switch (p) {
2878                         case MeterInput:
2879                                 loc = _processors.begin();
2880                                 break;
2881                         case MeterPreFader:
2882                                 loc = find (_processors.begin(), _processors.end(), _amp);
2883                                 break;
2884                         case MeterPostFader:
2885                                 loc = _processors.end();
2886                                 break;
2887                         default:
2888                                 break;
2889                         }
2890
2891                         ChanCount m_in;
2892
2893                         if (loc == _processors.begin()) {
2894                                 m_in = _input->n_ports();
2895                         } else {
2896                                 ProcessorList::iterator before = loc;
2897                                 --before;
2898                                 m_in = (*before)->output_streams ();
2899                         }
2900
2901                         _meter->reflect_inputs (m_in);
2902
2903                         _processors.insert (loc, _meter);
2904
2905                         /* we do not need to reconfigure the processors, because the meter
2906                            (a) is always ready to handle processor_max_streams
2907                            (b) is always an N-in/N-out processor, and thus moving
2908                            it doesn't require any changes to the other processors.
2909                         */
2910
2911                         _meter->set_display_to_user (false);
2912
2913                 } else {
2914
2915                         // just make it visible and let the user move it
2916
2917                         _meter->set_display_to_user (true);
2918                 }
2919         }
2920
2921         _meter_point = p;
2922         meter_change (); /* EMIT SIGNAL */
2923
2924         bool const meter_visibly_changed = (_meter->display_to_user() != meter_was_visible_to_user);
2925
2926         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
2927 }
2928
2929 void
2930 Route::put_monitor_send_at (Placement p)
2931 {
2932         if (!_monitor_send) {
2933                 return;
2934         }
2935
2936         {
2937                 Glib::RWLock::WriterLock lm (_processor_lock);
2938                 ProcessorList as_it_was (_processors);
2939                 ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), _monitor_send);
2940                 _processors.erase(loc);
2941
2942                 switch (p) {
2943                 case PreFader:
2944                         loc = find(_processors.begin(), _processors.end(), _amp);
2945                         if (loc != _processors.begin()) {
2946                                 --loc;
2947                         }
2948                         break;
2949                 case PostFader:
2950                         loc = _processors.end();
2951                         break;
2952                 }
2953
2954                 _processors.insert (loc, _monitor_send);
2955
2956                 if (configure_processors_unlocked (0)) {
2957                         _processors = as_it_was;
2958                         configure_processors_unlocked (0); // it worked before we tried to add it ...
2959                         return;
2960                 }
2961         }
2962
2963         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2964         _session.set_dirty ();
2965 }
2966
2967 nframes_t
2968 Route::update_total_latency ()
2969 {
2970         nframes_t old = _output->effective_latency();
2971         nframes_t own_latency = _output->user_latency();
2972
2973         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2974                 if ((*i)->active ()) {
2975                         own_latency += (*i)->signal_latency ();
2976                 }
2977         }
2978
2979         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal redirect latency = %2\n", _name, own_latency));
2980
2981         _output->set_port_latency (own_latency);
2982
2983         if (_output->user_latency() == 0) {
2984
2985                 /* this (virtual) function is used for pure Routes,
2986                    not derived classes like AudioTrack.  this means
2987                    that the data processed here comes from an input
2988                    port, not prerecorded material, and therefore we
2989                    have to take into account any input latency.
2990                 */
2991
2992                 own_latency += _input->signal_latency ();
2993         }
2994
2995         if (old != own_latency) {
2996                 _output->set_latency_delay (own_latency);
2997                 signal_latency_changed (); /* EMIT SIGNAL */
2998         }
2999
3000         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: input latency = %2 total = %3\n", _name, _input->signal_latency(), own_latency));
3001
3002         return _output->effective_latency ();
3003 }
3004
3005 void
3006 Route::set_user_latency (nframes_t nframes)
3007 {
3008         _output->set_user_latency (nframes);
3009         _session.update_latency_compensation (false, false);
3010 }
3011
3012 void
3013 Route::set_latency_delay (nframes_t longest_session_latency)
3014 {
3015         nframes_t old = _initial_delay;
3016
3017         if (_output->effective_latency() < longest_session_latency) {
3018                 _initial_delay = longest_session_latency - _output->effective_latency();
3019         } else {
3020                 _initial_delay = 0;
3021         }
3022
3023         if (_initial_delay != old) {
3024                 initial_delay_changed (); /* EMIT SIGNAL */
3025         }
3026
3027         if (_session.transport_stopped()) {
3028                 _roll_delay = _initial_delay;
3029         }
3030 }
3031
3032 void
3033 Route::automation_snapshot (nframes_t now, bool force)
3034 {
3035         panner()->automation_snapshot (now, force);
3036
3037         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3038                 (*i)->automation_snapshot (now, force);
3039         }
3040 }
3041
3042 Route::SoloControllable::SoloControllable (std::string name, Route& r)
3043         : AutomationControl (r.session(), Evoral::Parameter (SoloAutomation),
3044                              boost::shared_ptr<AutomationList>(), name)
3045         , route (r)
3046 {
3047         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
3048         set_list (gl);
3049 }
3050
3051 void
3052 Route::SoloControllable::set_value (double val)
3053 {
3054         bool bval = ((val >= 0.5f) ? true: false);
3055 # if 0
3056         this is how it should be done
3057
3058         boost::shared_ptr<RouteList> rl (new RouteList);
3059         rl->push_back (route);
3060
3061         if (Config->get_solo_control_is_listen_control()) {
3062                 _session.set_listen (rl, bval);
3063         } else {
3064                 _session.set_solo (rl, bval);
3065         }
3066 #else
3067         route.set_solo (bval, this);
3068 #endif
3069 }
3070
3071 double
3072 Route::SoloControllable::get_value (void) const
3073 {
3074         if (Config->get_solo_control_is_listen_control()) {
3075                 return route.listening() ? 1.0f : 0.0f;
3076         } else {
3077                 return route.self_soloed() ? 1.0f : 0.0f;
3078         }
3079 }
3080
3081 Route::MuteControllable::MuteControllable (std::string name, Route& r)
3082         : AutomationControl (r.session(), Evoral::Parameter (MuteAutomation),
3083                              boost::shared_ptr<AutomationList>(), name)
3084         , route (r)
3085 {
3086         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MuteAutomation)));
3087         set_list (gl);
3088 }
3089
3090 void
3091 Route::MuteControllable::set_value (double val)
3092 {
3093         bool bval = ((val >= 0.5f) ? true: false);
3094 # if 0
3095         this is how it should be done
3096
3097         boost::shared_ptr<RouteList> rl (new RouteList);
3098         rl->push_back (route);
3099         _session.set_mute (rl, bval);
3100 #else
3101         route.set_mute (bval, this);
3102 #endif
3103 }
3104
3105 double
3106 Route::MuteControllable::get_value (void) const
3107 {
3108         return route.muted() ? 1.0f : 0.0f;
3109 }
3110
3111 void
3112 Route::set_block_size (nframes_t nframes)
3113 {
3114         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3115                 (*i)->set_block_size (nframes);
3116         }
3117
3118         _session.ensure_buffers (n_process_buffers ());
3119 }
3120
3121 void
3122 Route::protect_automation ()
3123 {
3124         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3125                 (*i)->protect_automation();
3126 }
3127
3128 void
3129 Route::set_pending_declick (int declick)
3130 {
3131         if (_declickable) {
3132                 /* this call is not allowed to turn off a pending declick unless "force" is true */
3133                 if (declick) {
3134                         _pending_declick = declick;
3135                 }
3136                 // cerr << _name << ": after setting to " << declick << " pending declick = " << _pending_declick << endl;
3137         } else {
3138                 _pending_declick = 0;
3139         }
3140
3141 }
3142
3143 /** Shift automation forwards from a particular place, thereby inserting time.
3144  *  Adds undo commands for any shifts that are performed.
3145  *
3146  * @param pos Position to start shifting from.
3147  * @param frames Amount to shift forwards by.
3148  */
3149
3150 void
3151 Route::shift (framepos_t /*pos*/, framecnt_t /*frames*/)
3152 {
3153 #ifdef THIS_NEEDS_FIXING_FOR_V3
3154
3155         /* gain automation */
3156         XMLNode &before = _gain_control->get_state ();
3157         _gain_control->shift (pos, frames);
3158         XMLNode &after = _gain_control->get_state ();
3159         _session.add_command (new MementoCommand<AutomationList> (_gain_automation_curve, &before, &after));
3160
3161         /* pan automation */
3162         for (std::vector<StreamPanner*>::iterator i = _panner->begin (); i != _panner->end (); ++i) {
3163                 Curve & c = (*i)->automation ();
3164                 XMLNode &before = c.get_state ();
3165                 c.shift (pos, frames);
3166                 XMLNode &after = c.get_state ();
3167                 _session.add_command (new MementoCommand<AutomationList> (c, &before, &after));
3168         }
3169
3170         /* redirect automation */
3171         {
3172                 Glib::RWLock::ReaderLock lm (redirect_lock);
3173                 for (RedirectList::iterator i = _redirects.begin (); i != _redirects.end (); ++i) {
3174
3175                         set<uint32_t> a;
3176                         (*i)->what_has_automation (a);
3177
3178                         for (set<uint32_t>::const_iterator j = a.begin (); j != a.end (); ++j) {
3179                                 AutomationList & al = (*i)->automation_list (*j);
3180                                 XMLNode &before = al.get_state ();
3181                                 al.shift (pos, frames);
3182                                 XMLNode &after = al.get_state ();
3183                                 _session.add_command (new MementoCommand<AutomationList> (al, &before, &after));
3184                         }
3185                 }
3186         }
3187 #endif
3188
3189 }
3190
3191
3192 int
3193 Route::save_as_template (const string& path, const string& name)
3194 {
3195         XMLNode& node (state (false));
3196         XMLTree tree;
3197
3198         IO::set_name_in_state (*node.children().front(), name);
3199
3200         tree.set_root (&node);
3201         return tree.write (path.c_str());
3202 }
3203
3204
3205 bool
3206 Route::set_name (const string& str)
3207 {
3208         bool ret;
3209         string ioproc_name;
3210         string name;
3211
3212         name = Route::ensure_track_or_route_name (str, _session);
3213         SessionObject::set_name (name);
3214
3215         ret = (_input->set_name(name) && _output->set_name(name));
3216
3217         if (ret) {
3218
3219                 Glib::RWLock::ReaderLock lm (_processor_lock);
3220
3221                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3222
3223                         /* rename all I/O processors that have inputs or outputs */
3224
3225                         boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
3226
3227                         if (iop && (iop->output() || iop->input())) {
3228                                 if (!iop->set_name (name)) {
3229                                         ret = false;
3230                                 }
3231                         }
3232                 }
3233
3234         }
3235
3236         return ret;
3237 }
3238
3239 boost::shared_ptr<Send>
3240 Route::internal_send_for (boost::shared_ptr<const Route> target) const
3241 {
3242         Glib::RWLock::ReaderLock lm (_processor_lock);
3243
3244         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3245                 boost::shared_ptr<InternalSend> send;
3246
3247                 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
3248                         if (send->target_route() == target) {
3249                                 return send;
3250                         }
3251                 }
3252         }
3253
3254         return boost::shared_ptr<Send>();
3255 }
3256
3257 /** @param c Audio channel index.
3258  *  @param yn true to invert phase, otherwise false.
3259  */
3260 void
3261 Route::set_phase_invert (uint32_t c, bool yn)
3262 {
3263         if (_phase_invert[c] != yn) {
3264                 _phase_invert[c] = yn;
3265                 phase_invert_changed (); /* EMIT SIGNAL */
3266                 _session.set_dirty ();
3267         }
3268 }
3269
3270 void
3271 Route::set_phase_invert (boost::dynamic_bitset<> p)
3272 {
3273         if (_phase_invert != p) {
3274                 _phase_invert = p;
3275                 phase_invert_changed (); /* EMIT SIGNAL */
3276                 _session.set_dirty ();
3277         }
3278 }
3279
3280 bool
3281 Route::phase_invert (uint32_t c) const
3282 {
3283         return _phase_invert[c];
3284 }
3285
3286 boost::dynamic_bitset<>
3287 Route::phase_invert () const
3288 {
3289         return _phase_invert;
3290 }
3291
3292 void
3293 Route::set_denormal_protection (bool yn)
3294 {
3295         if (_denormal_protection != yn) {
3296                 _denormal_protection = yn;
3297                 denormal_protection_changed (); /* EMIT SIGNAL */
3298         }
3299 }
3300
3301 bool
3302 Route::denormal_protection () const
3303 {
3304         return _denormal_protection;
3305 }
3306
3307 void
3308 Route::set_active (bool yn)
3309 {
3310         if (_active != yn) {
3311                 _active = yn;
3312                 _input->set_active (yn);
3313                 _output->set_active (yn);
3314                 active_changed (); // EMIT SIGNAL
3315         }
3316 }
3317
3318 void
3319 Route::meter ()
3320 {
3321         Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3322
3323         assert (_meter);
3324
3325         _meter->meter ();
3326
3327         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3328
3329                 boost::shared_ptr<Send> s;
3330                 boost::shared_ptr<Return> r;
3331
3332                 if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
3333                         s->meter()->meter();
3334                 } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
3335                         r->meter()->meter ();
3336                 }
3337         }
3338 }
3339
3340 boost::shared_ptr<Panner>
3341 Route::panner() const
3342 {
3343         return _main_outs->panner();
3344 }
3345
3346 boost::shared_ptr<AutomationControl>
3347 Route::gain_control() const
3348 {
3349         return _amp->gain_control();
3350 }
3351
3352 boost::shared_ptr<AutomationControl>
3353 Route::get_control (const Evoral::Parameter& param)
3354 {
3355         /* either we own the control or .... */
3356
3357         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
3358
3359         if (!c) {
3360
3361                 /* maybe one of our processors does or ... */
3362
3363                 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3364                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3365                         if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
3366                                 break;
3367                         }
3368                 }
3369         }
3370
3371         if (!c) {
3372
3373                 /* nobody does so we'll make a new one */
3374
3375                 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
3376                 add_control(c);
3377         }
3378
3379         return c;
3380 }
3381
3382 boost::shared_ptr<Processor>
3383 Route::nth_plugin (uint32_t n)
3384 {
3385         Glib::RWLock::ReaderLock lm (_processor_lock);
3386         ProcessorList::iterator i;
3387
3388         for (i = _processors.begin(); i != _processors.end(); ++i) {
3389                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
3390                         if (n-- == 0) {
3391                                 return *i;
3392                         }
3393                 }
3394         }
3395
3396         return boost::shared_ptr<Processor> ();
3397 }
3398
3399 boost::shared_ptr<Processor>
3400 Route::nth_send (uint32_t n)
3401 {
3402         Glib::RWLock::ReaderLock lm (_processor_lock);
3403         ProcessorList::iterator i;
3404
3405         for (i = _processors.begin(); i != _processors.end(); ++i) {
3406                 if (boost::dynamic_pointer_cast<Send> (*i)) {
3407                         if (n-- == 0) {
3408                                 return *i;
3409                         }
3410                 }
3411         }
3412
3413         return boost::shared_ptr<Processor> ();
3414 }
3415
3416 bool
3417 Route::has_io_processor_named (const string& name)
3418 {
3419         Glib::RWLock::ReaderLock lm (_processor_lock);
3420         ProcessorList::iterator i;
3421
3422         for (i = _processors.begin(); i != _processors.end(); ++i) {
3423                 if (boost::dynamic_pointer_cast<Send> (*i) ||
3424                     boost::dynamic_pointer_cast<PortInsert> (*i)) {
3425                         if ((*i)->name() == name) {
3426                                 return true;
3427                         }
3428                 }
3429         }
3430
3431         return false;
3432 }
3433
3434 MuteMaster::MutePoint
3435 Route::mute_points () const
3436 {
3437         return _mute_master->mute_points ();
3438 }
3439
3440 void
3441 Route::set_processor_positions ()
3442 {
3443         Glib::RWLock::ReaderLock lm (_processor_lock);
3444
3445         bool had_amp = false;
3446         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3447                 (*i)->set_pre_fader (!had_amp);
3448                 if (boost::dynamic_pointer_cast<Amp> (*i)) {
3449                         had_amp = true;
3450                 }
3451         }
3452 }
3453