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                                sframes_t start_frame, sframes_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 (sframes_t start_frame, sframes_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 (sframes_t start_frame, sframes_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, ProcessorList::iterator iter)
 922 {
 923         const XMLProperty *prop;
 924
 925         try {
 926                 boost::shared_ptr<Processor> processor;
 927
 928                 if (node.name() == "Insert") {
 929
 930                         if ((prop = node.property ("type")) != 0) {
 931
 932                                 if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
 933                                                 prop->value() == "lv2" ||
 934                                                 prop->value() == "vst" ||
 935                                                 prop->value() == "audiounit") {
 936
 937                                         processor.reset (new PluginInsert (_session));
 938
 939                                 } else {
 940
 941                                         processor.reset (new PortInsert (_session, _mute_master));
 942                                 }
 943
 944                         }
 945
 946                 } else if (node.name() == "Send") {
 947
 948                         processor.reset (new Send (_session, _mute_master));
 949
 950                 } else {
 951
 952                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), node.name()) << endmsg;
 953                         return false;
 954                 }
 955
 956                 if (processor->set_state (node, version)) {
 957                         return false;
 958                 }
 959
 960                 if (iter == _processors.end() && processor->display_to_user() && !_processors.empty()) {
 961                         /* check for invisible processors stacked at the end and leave them there */
 962                         ProcessorList::iterator p;
 963                         p = _processors.end();
 964                         --p;
 965                         while (!(*p)->display_to_user() && p != _processors.begin()) {
 966                                 --p;
 967                         }
 968                         ++p;
 969                         iter = p;
 970                 }
 971
 972                 return (add_processor (processor, iter) == 0);
 973         }
 974
 975         catch (failed_constructor &err) {
 976                 warning << _("processor could not be created. Ignored.") << endmsg;
 977                 return false;
 978         }
 979 }
 980
 981 int
 982 Route::add_processors (const ProcessorList& others, boost::shared_ptr<Processor> before, ProcessorStreams* err)
 983 {
 984         ProcessorList::iterator loc;
 985
 986         if (before) {
 987                 loc = find(_processors.begin(), _processors.end(), before);
 988         } else {
 989                 /* nothing specified - at end but before main outs */
 990                 loc = find (_processors.begin(), _processors.end(), _main_outs);
 991         }
 992
 993         return add_processors (others, loc, err);
 994 }
 995
 996 int
 997 Route::add_processors (const ProcessorList& others, ProcessorList::iterator iter, ProcessorStreams* err)
 998 {
 999         /* NOTE: this is intended to be used ONLY when copying
1000            processors from another Route. Hence the subtle
1001            differences between this and ::add_processor()
1002         */
1003
1004         ChanCount old_pms = processor_max_streams;
1005
1006         if (!_session.engine().connected()) {
1007                 return 1;
1008         }
1009
1010         if (others.empty()) {
1011                 return 0;
1012         }
1013
1014         {
1015                 Glib::RWLock::WriterLock lm (_processor_lock);
1016
1017                 ChanCount potential_max_streams = ChanCount::max (_input->n_ports(), _output->n_ports());
1018
1019                 for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
1020
1021                         // Ensure meter only appears in the list once
1022                         if (*i == _meter) {
1023                                 ProcessorList::iterator m = find(_processors.begin(), _processors.end(), *i);
1024                                 if (m != _processors.end()) {
1025                                         _processors.erase(m);
1026                                 }
1027                         }
1028
1029                         boost::shared_ptr<PluginInsert> pi;
1030
1031                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1032                                 pi->set_count (1);
1033
1034                                 ChanCount m = max (pi->input_streams(), pi->output_streams());
1035
1036                                 if (m > potential_max_streams) {
1037                                         potential_max_streams = m;
1038                                 }
1039                         }
1040
1041                         ProcessorList::iterator inserted = _processors.insert (iter, *i);
1042
1043                         if ((*i)->active()) {
1044                                 (*i)->activate ();
1045                         }
1046
1047                         if (configure_processors_unlocked (err)) {
1048                                 _processors.erase (inserted);
1049                                 configure_processors_unlocked (0); // it worked before we tried to add it ...
1050                                 return -1;
1051                         }
1052
1053                         (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false, false));
1054                 }
1055
1056                 _output->set_user_latency (0);
1057         }
1058
1059         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1060         set_processor_positions ();
1061
1062         return 0;
1063 }
1064
1065 void
1066 Route::placement_range(Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end)
1067 {
1068         if (p == PreFader) {
1069                 start = _processors.begin();
1070                 end = find(_processors.begin(), _processors.end(), _amp);
1071         } else {
1072                 start = find(_processors.begin(), _processors.end(), _amp);
1073                 ++start;
1074                 end = _processors.end();
1075         }
1076 }
1077
1078 /** Turn off all processors with a given placement
1079  * @param p Placement of processors to disable
1080  */
1081 void
1082 Route::disable_processors (Placement p)
1083 {
1084         Glib::RWLock::ReaderLock lm (_processor_lock);
1085
1086         ProcessorList::iterator start, end;
1087         placement_range(p, start, end);
1088
1089         for (ProcessorList::iterator i = start; i != end; ++i) {
1090                 (*i)->deactivate ();
1091         }
1092
1093         _session.set_dirty ();
1094 }
1095
1096 /** Turn off all redirects
1097  */
1098 void
1099 Route::disable_processors ()
1100 {
1101         Glib::RWLock::ReaderLock lm (_processor_lock);
1102
1103         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1104                 (*i)->deactivate ();
1105         }
1106
1107         _session.set_dirty ();
1108 }
1109
1110 /** Turn off all redirects with a given placement
1111  * @param p Placement of redirects to disable
1112  */
1113 void
1114 Route::disable_plugins (Placement p)
1115 {
1116         Glib::RWLock::ReaderLock lm (_processor_lock);
1117
1118         ProcessorList::iterator start, end;
1119         placement_range(p, start, end);
1120
1121         for (ProcessorList::iterator i = start; i != end; ++i) {
1122                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1123                         (*i)->deactivate ();
1124                 }
1125         }
1126
1127         _session.set_dirty ();
1128 }
1129
1130 /** Turn off all plugins
1131  */
1132 void
1133 Route::disable_plugins ()
1134 {
1135         Glib::RWLock::ReaderLock lm (_processor_lock);
1136
1137         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1138                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1139                         (*i)->deactivate ();
1140                 }
1141         }
1142
1143         _session.set_dirty ();
1144 }
1145
1146
1147 void
1148 Route::ab_plugins (bool forward)
1149 {
1150         Glib::RWLock::ReaderLock lm (_processor_lock);
1151
1152         if (forward) {
1153
1154                 /* forward = turn off all active redirects, and mark them so that the next time
1155                    we go the other way, we will revert them
1156                 */
1157
1158                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1159                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1160                                 continue;
1161                         }
1162
1163                         if ((*i)->active()) {
1164                                 (*i)->deactivate ();
1165                                 (*i)->set_next_ab_is_active (true);
1166                         } else {
1167                                 (*i)->set_next_ab_is_active (false);
1168                         }
1169                 }
1170
1171         } else {
1172
1173                 /* backward = if the redirect was marked to go active on the next ab, do so */
1174
1175                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1176
1177                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1178                                 continue;
1179                         }
1180
1181                         if ((*i)->get_next_ab_is_active()) {
1182                                 (*i)->activate ();
1183                         } else {
1184                                 (*i)->deactivate ();
1185                         }
1186                 }
1187         }
1188
1189         _session.set_dirty ();
1190 }
1191
1192
1193 /** Remove processors with a given placement.
1194  * @param p Placement of processors to remove.
1195  */
1196 void
1197 Route::clear_processors (Placement p)
1198 {
1199         const ChanCount old_pms = processor_max_streams;
1200
1201         if (!_session.engine().connected()) {
1202                 return;
1203         }
1204
1205         bool already_deleting = _session.deletion_in_progress();
1206         if (!already_deleting) {
1207                 _session.set_deletion_in_progress();
1208         }
1209
1210         {
1211                 Glib::RWLock::WriterLock lm (_processor_lock);
1212                 ProcessorList new_list;
1213                 ProcessorStreams err;
1214                 bool seen_amp = false;
1215
1216                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1217
1218                         if (*i == _amp) {
1219                                 seen_amp = true;
1220                         }
1221
1222                         if ((*i) == _amp || (*i) == _meter || (*i) == _main_outs) {
1223
1224                                 /* you can't remove these */
1225
1226                                 new_list.push_back (*i);
1227
1228                         } else {
1229                                 if (seen_amp) {
1230
1231                                         switch (p) {
1232                                         case PreFader:
1233                                                 new_list.push_back (*i);
1234                                                 break;
1235                                         case PostFader:
1236                                                 (*i)->drop_references ();
1237                                                 break;
1238                                         }
1239
1240                                 } else {
1241
1242                                         switch (p) {
1243                                         case PreFader:
1244                                                 (*i)->drop_references ();
1245                                                 break;
1246                                         case PostFader:
1247                                                 new_list.push_back (*i);
1248                                                 break;
1249                                         }
1250                                 }
1251                         }
1252                 }
1253
1254                 _processors = new_list;
1255                 configure_processors_unlocked (&err); // this can't fail
1256         }
1257
1258         processor_max_streams.reset();
1259         _have_internal_generator = false;
1260         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1261         set_processor_positions ();
1262
1263         if (!already_deleting) {
1264                 _session.clear_deletion_in_progress();
1265         }
1266 }
1267
1268 int
1269 Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err)
1270 {
1271         /* these can never be removed */
1272
1273         if (processor == _amp || processor == _meter || processor == _main_outs) {
1274                 return 0;
1275         }
1276
1277         ChanCount old_pms = processor_max_streams;
1278
1279         if (!_session.engine().connected()) {
1280                 return 1;
1281         }
1282
1283         processor_max_streams.reset();
1284
1285         {
1286                 Glib::RWLock::WriterLock lm (_processor_lock);
1287                 ProcessorList::iterator i;
1288                 bool removed = false;
1289
1290                 for (i = _processors.begin(); i != _processors.end(); ) {
1291                         if (*i == processor) {
1292
1293                                 /* move along, see failure case for configure_processors()
1294                                    where we may need to reconfigure the processor.
1295                                 */
1296
1297                                 /* stop redirects that send signals to JACK ports
1298                                    from causing noise as a result of no longer being
1299                                    run.
1300                                 */
1301
1302                                 boost::shared_ptr<IOProcessor> iop;
1303
1304                                 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (*i)) != 0) {
1305                                         if (iop->input()) {
1306                                                 iop->input()->disconnect (this);
1307                                         }
1308                                         if (iop->output()) {
1309                                                 iop->output()->disconnect (this);
1310                                         }
1311                                 }
1312
1313                                 i = _processors.erase (i);
1314                                 removed = true;
1315                                 break;
1316
1317                         } else {
1318                                 ++i;
1319                         }
1320
1321                         _output->set_user_latency (0);
1322                 }
1323
1324                 if (!removed) {
1325                         /* what? */
1326                         return 1;
1327                 }
1328
1329                 if (configure_processors_unlocked (err)) {
1330                         /* get back to where we where */
1331                         _processors.insert (i, processor);
1332                         /* we know this will work, because it worked before :) */
1333                         configure_processors_unlocked (0);
1334                         return -1;
1335                 }
1336
1337                 _have_internal_generator = false;
1338
1339                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1340                         boost::shared_ptr<PluginInsert> pi;
1341
1342                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1343                                 if (pi->is_generator()) {
1344                                         _have_internal_generator = true;
1345                                         break;
1346                                 }
1347                         }
1348                 }
1349         }
1350
1351         processor->drop_references ();
1352         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1353         set_processor_positions ();
1354
1355         return 0;
1356 }
1357
1358 int
1359 Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
1360 {
1361         ProcessorList deleted;
1362
1363         if (!_session.engine().connected()) {
1364                 return 1;
1365         }
1366
1367         processor_max_streams.reset();
1368
1369         {
1370                 Glib::RWLock::WriterLock lm (_processor_lock);
1371                 ProcessorList::iterator i;
1372                 boost::shared_ptr<Processor> processor;
1373
1374                 ProcessorList as_we_were = _processors;
1375
1376                 for (i = _processors.begin(); i != _processors.end(); ) {
1377
1378                         processor = *i;
1379
1380                         /* these can never be removed */
1381
1382                         if (processor == _amp || processor == _meter || processor == _main_outs) {
1383                                 ++i;
1384                                 continue;
1385                         }
1386
1387                         /* see if its in the list of processors to delete */
1388
1389                         if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
1390                                 ++i;
1391                                 continue;
1392                         }
1393
1394                         /* stop IOProcessors that send to JACK ports
1395                            from causing noise as a result of no longer being
1396                            run.
1397                         */
1398
1399                         boost::shared_ptr<IOProcessor> iop;
1400
1401                         if ((iop = boost::dynamic_pointer_cast<IOProcessor> (processor)) != 0) {
1402                                 iop->disconnect ();
1403                         }
1404
1405                         deleted.push_back (processor);
1406                         i = _processors.erase (i);
1407                 }
1408
1409                 if (deleted.empty()) {
1410                         /* none of those in the requested list were found */
1411                         return 0;
1412                 }
1413
1414                 _output->set_user_latency (0);
1415
1416                 if (configure_processors_unlocked (err)) {
1417                         /* get back to where we where */
1418                         _processors = as_we_were;
1419                         /* we know this will work, because it worked before :) */
1420                         configure_processors_unlocked (0);
1421                         return -1;
1422                 }
1423
1424                 _have_internal_generator = false;
1425
1426                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1427                         boost::shared_ptr<PluginInsert> pi;
1428
1429                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1430                                 if (pi->is_generator()) {
1431                                         _have_internal_generator = true;
1432                                         break;
1433                                 }
1434                         }
1435                 }
1436         }
1437
1438         /* now try to do what we need to so that those that were removed will be deleted */
1439
1440         for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
1441                 (*i)->drop_references ();
1442         }
1443
1444         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1445         set_processor_positions ();
1446
1447         return 0;
1448 }
1449
1450
1451 int
1452 Route::configure_processors (ProcessorStreams* err)
1453 {
1454         if (!_in_configure_processors) {
1455                 Glib::RWLock::WriterLock lm (_processor_lock);
1456                 return configure_processors_unlocked (err);
1457         }
1458         return 0;
1459 }
1460
1461 ChanCount
1462 Route::input_streams () const
1463 {
1464         return _input->n_ports ();
1465 }
1466
1467 /** Configure the input/output configuration of each processor in the processors list.
1468  * Return 0 on success, otherwise configuration is impossible.
1469  */
1470 int
1471 Route::configure_processors_unlocked (ProcessorStreams* err)
1472 {
1473         if (_in_configure_processors) {
1474            return 0;
1475         }
1476
1477         _in_configure_processors = true;
1478
1479         // Check each processor in order to see if we can configure as requested
1480         ChanCount in = input_streams ();
1481         ChanCount out;
1482         list< pair<ChanCount,ChanCount> > configuration;
1483         uint32_t index = 0;
1484
1485         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
1486         DEBUG_TRACE (DEBUG::Processors, "{\n");
1487         for (list<boost::shared_ptr<Processor> >::const_iterator p = _processors.begin(); p != _processors.end(); ++p) {
1488                 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID = %2\n", (*p)->name(), (*p)->id()));
1489         }
1490         DEBUG_TRACE (DEBUG::Processors, "}\n");
1491
1492         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1493
1494                 if ((*p)->can_support_io_configuration(in, out)) {
1495                         DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 in = %2 out = %3\n",(*p)->name(), in, out));
1496                         configuration.push_back(make_pair(in, out));
1497                         in = out;
1498                 } else {
1499                         if (err) {
1500                                 err->index = index;
1501                                 err->count = in;
1502                         }
1503                         _in_configure_processors = false;
1504                         return -1;
1505                 }
1506         }
1507
1508         // We can, so configure everything
1509         list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1510         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1511                 (*p)->configure_io(c->first, c->second);
1512                 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1513                 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1514                 out = c->second;
1515         }
1516
1517         if (_meter) {
1518                 _meter->reset_max_channels (processor_max_streams);
1519         }
1520
1521         /* make sure we have sufficient scratch buffers to cope with the new processor
1522            configuration */
1523         {
1524                 Glib::Mutex::Lock em (_session.engine().process_lock ());
1525                 _session.ensure_buffers (n_process_buffers ());
1526         }
1527
1528         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
1529
1530         _in_configure_processors = false;
1531         return 0;
1532 }
1533
1534 void
1535 Route::all_processors_flip ()
1536 {
1537         Glib::RWLock::ReaderLock lm (_processor_lock);
1538
1539         if (_processors.empty()) {
1540                 return;
1541         }
1542
1543         bool first_is_on = _processors.front()->active();
1544
1545         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1546                 if (first_is_on) {
1547                         (*i)->deactivate ();
1548                 } else {
1549                         (*i)->activate ();
1550                 }
1551         }
1552
1553         _session.set_dirty ();
1554 }
1555
1556 /** Set all processors with a given placement to a given active state.
1557  * @param p Placement of processors to change.
1558  * @param state New active state for those processors.
1559  */
1560 void
1561 Route::all_processors_active (Placement p, bool state)
1562 {
1563         Glib::RWLock::ReaderLock lm (_processor_lock);
1564
1565         if (_processors.empty()) {
1566                 return;
1567         }
1568         ProcessorList::iterator start, end;
1569         placement_range(p, start, end);
1570
1571         bool before_amp = true;
1572         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1573                 if ((*i) == _amp) {
1574                         before_amp = false;
1575                         continue;
1576                 }
1577                 if (p == PreFader && before_amp) {
1578                         if (state) {
1579                                 (*i)->activate ();
1580                         } else {
1581                                 (*i)->deactivate ();
1582                         }
1583                 }
1584         }
1585
1586         _session.set_dirty ();
1587 }
1588
1589 bool
1590 Route::processor_is_prefader (boost::shared_ptr<Processor> p)
1591 {
1592         bool pre_fader = true;
1593         Glib::RWLock::ReaderLock lm (_processor_lock);
1594
1595         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1596
1597                 /* semantic note: if p == amp, we want to return true, so test
1598                    for equality before checking if this is the amp
1599                 */
1600
1601                 if ((*i) == p) {
1602                         break;
1603                 }
1604
1605                 if ((*i) == _amp) {
1606                         pre_fader = false;
1607                         break;
1608                 }
1609         }
1610
1611         return pre_fader;
1612 }
1613
1614 int
1615 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
1616 {
1617         /* "new_order" is an ordered list of processors to be positioned according to "placement".
1618            NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
1619            processors in the current actual processor list that are hidden. Any visible processors
1620            in the current list but not in "new_order" will be assumed to be deleted.
1621         */
1622
1623         {
1624                 Glib::RWLock::WriterLock lm (_processor_lock);
1625                 ChanCount old_pms = processor_max_streams;
1626                 ProcessorList::iterator oiter;
1627                 ProcessorList::const_iterator niter;
1628                 ProcessorList as_it_was_before = _processors;
1629                 ProcessorList as_it_will_be;
1630
1631                 oiter = _processors.begin();
1632                 niter = new_order.begin();
1633
1634                 while (niter !=  new_order.end()) {
1635
1636                         /* if the next processor in the old list is invisible (i.e. should not be in the new order)
1637                            then append it to the temp list.
1638
1639                            Otherwise, see if the next processor in the old list is in the new list. if not,
1640                            its been deleted. If its there, append it to the temp list.
1641                         */
1642
1643                         if (oiter == _processors.end()) {
1644
1645                                 /* no more elements in the old list, so just stick the rest of
1646                                    the new order onto the temp list.
1647                                 */
1648
1649                                 as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
1650                                 while (niter != new_order.end()) {
1651                                         ++niter;
1652                                 }
1653                                 break;
1654
1655                         } else {
1656
1657                                 if (!(*oiter)->display_to_user()) {
1658
1659                                         as_it_will_be.push_back (*oiter);
1660
1661                                 } else {
1662
1663                                         /* visible processor: check that its in the new order */
1664
1665                                         if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
1666                                                 /* deleted: do nothing, shared_ptr<> will clean up */
1667                                         } else {
1668                                                 /* ignore this one, and add the next item from the new order instead */
1669                                                 as_it_will_be.push_back (*niter);
1670                                                 ++niter;
1671                                         }
1672                                 }
1673
1674                                 /* now remove from old order - its taken care of no matter what */
1675                                 oiter = _processors.erase (oiter);
1676                         }
1677
1678                 }
1679
1680                 _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
1681
1682                 if (configure_processors_unlocked (err)) {
1683                         _processors = as_it_was_before;
1684                         processor_max_streams = old_pms;
1685                         return -1;
1686                 }
1687         }
1688
1689         if (true) {
1690                 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1691                 set_processor_positions ();
1692         }
1693
1694         return 0;
1695 }
1696
1697 XMLNode&
1698 Route::get_state()
1699 {
1700         return state(true);
1701 }
1702
1703 XMLNode&
1704 Route::get_template()
1705 {
1706         return state(false);
1707 }
1708
1709 XMLNode&
1710 Route::state(bool full_state)
1711 {
1712         XMLNode *node = new XMLNode("Route");
1713         ProcessorList::iterator i;
1714         char buf[32];
1715
1716         id().print (buf, sizeof (buf));
1717         node->add_property("id", buf);
1718         node->add_property ("name", _name);
1719         node->add_property("default-type", _default_type.to_string());
1720
1721         if (_flags) {
1722                 node->add_property("flags", enum_2_string (_flags));
1723         }
1724
1725         node->add_property("active", _active?"yes":"no");
1726         string p;
1727         boost::to_string (_phase_invert, p);
1728         node->add_property("phase-invert", p);
1729         node->add_property("denormal-protection", _denormal_protection?"yes":"no");
1730         node->add_property("meter-point", enum_2_string (_meter_point));
1731
1732         if (_route_group) {
1733                 node->add_property("route-group", _route_group->name());
1734         }
1735
1736         string order_string;
1737         OrderKeys::iterator x = order_keys.begin();
1738
1739         while (x != order_keys.end()) {
1740                 order_string += string ((*x).first);
1741                 order_string += '=';
1742                 snprintf (buf, sizeof(buf), "%ld", (*x).second);
1743                 order_string += buf;
1744
1745                 ++x;
1746
1747                 if (x == order_keys.end()) {
1748                         break;
1749                 }
1750
1751                 order_string += ':';
1752         }
1753         node->add_property ("order-keys", order_string);
1754         node->add_property ("self-solo", (_self_solo ? "yes" : "no"));
1755         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_upstream);
1756         node->add_property ("soloed-by-upstream", buf);
1757         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_downstream);
1758         node->add_property ("soloed-by-downstream", buf);
1759
1760         node->add_child_nocopy (_input->state (full_state));
1761         node->add_child_nocopy (_output->state (full_state));
1762         node->add_child_nocopy (_solo_control->get_state ());
1763         node->add_child_nocopy (_mute_master->get_state ());
1764
1765         XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
1766         snprintf (buf, sizeof (buf), "%d", _remote_control_id);
1767         remote_control_node->add_property (X_("id"), buf);
1768         node->add_child_nocopy (*remote_control_node);
1769
1770         if (_comment.length()) {
1771                 XMLNode *cmt = node->add_child ("Comment");
1772                 cmt->add_content (_comment);
1773         }
1774
1775         for (i = _processors.begin(); i != _processors.end(); ++i) {
1776                 node->add_child_nocopy((*i)->state (full_state));
1777         }
1778
1779         if (_extra_xml){
1780                 node->add_child_copy (*_extra_xml);
1781         }
1782
1783         return *node;
1784 }
1785
1786 int
1787 Route::set_state (const XMLNode& node, int version)
1788 {
1789         return _set_state (node, version, true);
1790 }
1791
1792 int
1793 Route::_set_state (const XMLNode& node, int version, bool /*call_base*/)
1794 {
1795         if (version < 3000) {
1796                 return _set_state_2X (node, version);
1797         }
1798
1799         XMLNodeList nlist;
1800         XMLNodeConstIterator niter;
1801         XMLNode *child;
1802         XMLPropertyList plist;
1803         const XMLProperty *prop;
1804
1805         if (node.name() != "Route"){
1806                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1807                 return -1;
1808         }
1809
1810         if ((prop = node.property (X_("name"))) != 0) {
1811                 Route::set_name (prop->value());
1812         }
1813
1814         if ((prop = node.property ("id")) != 0) {
1815                 _id = prop->value ();
1816         }
1817
1818         if ((prop = node.property (X_("flags"))) != 0) {
1819                 _flags = Flag (string_2_enum (prop->value(), _flags));
1820         } else {
1821                 _flags = Flag (0);
1822         }
1823
1824         if (is_master() || is_monitor() || is_hidden()) {
1825                 _mute_master->set_solo_ignore (true);
1826         }
1827
1828         /* add all processors (except amp, which is always present) */
1829
1830         nlist = node.children();
1831         XMLNode processor_state (X_("processor_state"));
1832
1833         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1834
1835                 child = *niter;
1836
1837                 if (child->name() == IO::state_node_name) {
1838                         if ((prop = child->property (X_("direction"))) == 0) {
1839                                 continue;
1840                         }
1841
1842                         if (prop->value() == "Input") {
1843                                 _input->set_state (*child, version);
1844                         } else if (prop->value() == "Output") {
1845                                 _output->set_state (*child, version);
1846                         }
1847                 }
1848
1849                 if (child->name() == X_("Processor")) {
1850                         processor_state.add_child_copy (*child);
1851                 }
1852         }
1853
1854         set_processor_state (processor_state);
1855
1856         if ((prop = node.property ("self-solo")) != 0) {
1857                 set_self_solo (string_is_affirmative (prop->value()));
1858         }
1859
1860         if ((prop = node.property ("soloed-by-upstream")) != 0) {
1861                 _soloed_by_others_upstream = 0; // needed for mod_.... () to work
1862                 mod_solo_by_others_upstream (atoi (prop->value()));
1863         }
1864
1865         if ((prop = node.property ("soloed-by-downstream")) != 0) {
1866                 _soloed_by_others_downstream = 0; // needed for mod_.... () to work
1867                 mod_solo_by_others_downstream (atoi (prop->value()));
1868         }
1869
1870         if ((prop = node.property ("solo-isolated")) != 0) {
1871                 set_solo_isolated (string_is_affirmative (prop->value()), this);
1872         }
1873
1874         if ((prop = node.property (X_("phase-invert"))) != 0) {
1875                 set_phase_invert (boost::dynamic_bitset<> (prop->value ()));
1876         }
1877
1878         if ((prop = node.property (X_("denormal-protection"))) != 0) {
1879                 set_denormal_protection (string_is_affirmative (prop->value()));
1880         }
1881
1882         if ((prop = node.property (X_("active"))) != 0) {
1883                 bool yn = string_is_affirmative (prop->value());
1884                 _active = !yn; // force switch
1885                 set_active (yn);
1886         }
1887
1888         if ((prop = node.property (X_("meter-point"))) != 0) {
1889                 MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
1890                 set_meter_point (mp);
1891                 if (_meter) {
1892                         _meter->set_display_to_user (_meter_point == MeterCustom);
1893                 }
1894         }
1895
1896         if ((prop = node.property (X_("order-keys"))) != 0) {
1897
1898                 int32_t n;
1899
1900                 string::size_type colon, equal;
1901                 string remaining = prop->value();
1902
1903                 while (remaining.length()) {
1904
1905                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
1906                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1907                                       << endmsg;
1908                         } else {
1909                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
1910                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1911                                               << endmsg;
1912                                 } else {
1913                                         set_order_key (remaining.substr (0, equal), n);
1914                                 }
1915                         }
1916
1917                         colon = remaining.find_first_of (':');
1918
1919                         if (colon != string::npos) {
1920                                 remaining = remaining.substr (colon+1);
1921                         } else {
1922                                 break;
1923                         }
1924                 }
1925         }
1926
1927         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1928                 child = *niter;
1929
1930                 if (child->name() == X_("Comment")) {
1931
1932                         /* XXX this is a terrible API design in libxml++ */
1933
1934                         XMLNode *cmt = *(child->children().begin());
1935                         _comment = cmt->content();
1936
1937                 } else if (child->name() == X_("Extra")) {
1938
1939                         _extra_xml = new XMLNode (*child);
1940
1941                 } else if (child->name() == X_("Controllable") && (prop = child->property("name")) != 0) {
1942
1943                         if (prop->value() == "solo") {
1944                                 _solo_control->set_state (*child, version);
1945                                 _session.add_controllable (_solo_control);
1946                         }
1947
1948                 } else if (child->name() == X_("RemoteControl")) {
1949                         if ((prop = child->property (X_("id"))) != 0) {
1950                                 int32_t x;
1951                                 sscanf (prop->value().c_str(), "%d", &x);
1952                                 set_remote_control_id (x);
1953                         }
1954
1955                 } else if (child->name() == X_("MuteMaster")) {
1956                         _mute_master->set_state (*child, version);
1957                 }
1958         }
1959
1960         return 0;
1961 }
1962
1963 int
1964 Route::_set_state_2X (const XMLNode& node, int version)
1965 {
1966         XMLNodeList nlist;
1967         XMLNodeConstIterator niter;
1968         XMLNode *child;
1969         XMLPropertyList plist;
1970         const XMLProperty *prop;
1971
1972         /* 2X things which still remain to be handled:
1973          * default-type
1974          * automation
1975          * controlouts
1976          */
1977
1978         if (node.name() != "Route") {
1979                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1980                 return -1;
1981         }
1982
1983         if ((prop = node.property (X_("flags"))) != 0) {
1984                 _flags = Flag (string_2_enum (prop->value(), _flags));
1985         } else {
1986                 _flags = Flag (0);
1987         }
1988
1989         if ((prop = node.property (X_("phase-invert"))) != 0) {
1990                 boost::dynamic_bitset<> p (_input->n_ports().n_audio ());
1991                 if (string_is_affirmative (prop->value ())) {
1992                         p.set ();
1993                 }
1994                 set_phase_invert (p);
1995         }
1996
1997         if ((prop = node.property (X_("denormal-protection"))) != 0) {
1998                 set_denormal_protection (string_is_affirmative (prop->value()));
1999         }
2000
2001         if ((prop = node.property (X_("soloed"))) != 0) {
2002                 bool yn = string_is_affirmative (prop->value());
2003
2004                 /* XXX force reset of solo status */
2005
2006                 set_solo (yn, this);
2007         }
2008
2009         if ((prop = node.property (X_("muted"))) != 0) {
2010
2011                 bool first = true;
2012                 bool muted = string_is_affirmative (prop->value());
2013
2014                 if (muted){
2015
2016                         string mute_point;
2017
2018                         if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
2019
2020                                 if (string_is_affirmative (prop->value())){
2021                                         mute_point = mute_point + "PreFader";
2022                                         first = false;
2023                                 }
2024                         }
2025
2026                         if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
2027
2028                                 if (string_is_affirmative (prop->value())){
2029
2030                                         if (!first) {
2031                                                 mute_point = mute_point + ",";
2032                                         }
2033
2034                                         mute_point = mute_point + "PostFader";
2035                                         first = false;
2036                                 }
2037                         }
2038
2039                         if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
2040
2041                                 if (string_is_affirmative (prop->value())){
2042
2043                                         if (!first) {
2044                                                 mute_point = mute_point + ",";
2045                                         }
2046
2047                                         mute_point = mute_point + "Listen";
2048                                         first = false;
2049                                 }
2050                         }
2051
2052                         if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
2053
2054                                 if (string_is_affirmative (prop->value())){
2055
2056                                         if (!first) {
2057                                                 mute_point = mute_point + ",";
2058                                         }
2059
2060                                         mute_point = mute_point + "Main";
2061                                 }
2062                         }
2063
2064                         _mute_master->set_mute_points (mute_point);
2065                 }
2066         }
2067
2068         if ((prop = node.property (X_("meter-point"))) != 0) {
2069                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2070         }
2071
2072         /* do not carry over edit/mix groups from 2.X because (a) its hard (b) they
2073            don't mean the same thing.
2074         */
2075
2076         if ((prop = node.property (X_("order-keys"))) != 0) {
2077
2078                 int32_t n;
2079
2080                 string::size_type colon, equal;
2081                 string remaining = prop->value();
2082
2083                 while (remaining.length()) {
2084
2085                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2086                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2087                                         << endmsg;
2088                         } else {
2089                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2090                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2091                                                 << endmsg;
2092                                 } else {
2093                                         set_order_key (remaining.substr (0, equal), n);
2094                                 }
2095                         }
2096
2097                         colon = remaining.find_first_of (':');
2098
2099                         if (colon != string::npos) {
2100                                 remaining = remaining.substr (colon+1);
2101                         } else {
2102                                 break;
2103                         }
2104                 }
2105         }
2106
2107         /* add standard processors */
2108
2109         //_meter.reset (new PeakMeter (_session));
2110         //add_processor (_meter, PreFader);
2111
2112         if (is_monitor()) {
2113                 /* where we listen to tracks */
2114                 _intreturn.reset (new InternalReturn (_session));
2115                 add_processor (_intreturn, PreFader);
2116
2117                 _monitor_control.reset (new MonitorProcessor (_session));
2118                 add_processor (_monitor_control, PostFader);
2119         }
2120
2121         _main_outs.reset (new Delivery (_session, _output, _mute_master, _name, Delivery::Main));
2122         add_processor (_main_outs, PostFader);
2123
2124         /* IOs */
2125
2126         nlist = node.children ();
2127         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2128
2129                 child = *niter;
2130
2131                 if (child->name() == IO::state_node_name) {
2132
2133                         /* there is a note in IO::set_state_2X() about why we have to call
2134                            this directly.
2135                            */
2136
2137                         _input->set_state_2X (*child, version, true);
2138                         _output->set_state_2X (*child, version, false);
2139
2140                         if ((prop = child->property (X_("name"))) != 0) {
2141                                 Route::set_name (prop->value ());
2142                         }
2143
2144                         if ((prop = child->property (X_("id"))) != 0) {
2145                                 _id = prop->value ();
2146                         }
2147
2148                         if ((prop = child->property (X_("active"))) != 0) {
2149                                 bool yn = string_is_affirmative (prop->value());
2150                                 _active = !yn; // force switch
2151                                 set_active (yn);
2152                         }
2153
2154                         if ((prop = child->property (X_("gain"))) != 0) {
2155                                 gain_t val;
2156
2157                                 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2158                                         _amp->gain_control()->set_value (val);
2159                                 }
2160                         }
2161
2162                         /* Set up Panners in the IO */
2163                         XMLNodeList io_nlist = child->children ();
2164
2165                         XMLNodeConstIterator io_niter;
2166                         XMLNode *io_child;
2167
2168                         for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2169
2170                                 io_child = *io_niter;
2171
2172                                 if (io_child->name() == X_("Panner")) {
2173                                         _main_outs->panner()->set_state(*io_child, version);
2174                                 }
2175                         }
2176                 }
2177         }
2178
2179         XMLNodeList redirect_nodes;
2180
2181         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2182
2183                 child = *niter;
2184
2185                 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2186                         redirect_nodes.push_back(child);
2187                 }
2188
2189         }
2190
2191         set_processor_state_2X (redirect_nodes, version);
2192
2193         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2194                 child = *niter;
2195
2196                 if (child->name() == X_("Comment")) {
2197
2198                         /* XXX this is a terrible API design in libxml++ */
2199
2200                         XMLNode *cmt = *(child->children().begin());
2201                         _comment = cmt->content();
2202
2203                 } else if (child->name() == X_("Extra")) {
2204
2205                         _extra_xml = new XMLNode (*child);
2206
2207                 } else if (child->name() == X_("Controllable") && (prop = child->property("name")) != 0) {
2208
2209                         if (prop->value() == "solo") {
2210                                 _solo_control->set_state (*child, version);
2211                                 _session.add_controllable (_solo_control);
2212                         }
2213
2214                 } else if (child->name() == X_("RemoteControl")) {
2215                         if ((prop = child->property (X_("id"))) != 0) {
2216                                 int32_t x;
2217                                 sscanf (prop->value().c_str(), "%d", &x);
2218                                 set_remote_control_id (x);
2219                         }
2220
2221                 }
2222         }
2223
2224         return 0;
2225 }
2226
2227 XMLNode&
2228 Route::get_processor_state ()
2229 {
2230         XMLNode* root = new XMLNode (X_("redirects"));
2231         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2232                 root->add_child_nocopy ((*i)->state (true));
2233         }
2234
2235         return *root;
2236 }
2237
2238 void
2239 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2240 {
2241         /* We don't bother removing existing processors not in nList, as this
2242            method will only be called when creating a Route from scratch, not
2243            for undo purposes.  Just put processors in at the appropriate place
2244            in the list.
2245         */
2246
2247         for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2248                 add_processor_from_xml_2X (**i, version, _processors.begin ());
2249         }
2250 }
2251
2252 void
2253 Route::set_processor_state (const XMLNode& node)
2254 {
2255         const XMLNodeList &nlist = node.children();
2256         XMLNodeConstIterator niter;
2257         ProcessorList new_order;
2258         bool must_configure = false;
2259
2260         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2261
2262                 XMLProperty* prop = (*niter)->property ("type");
2263
2264                 if (prop->value() == "amp") {
2265                         _amp->set_state (**niter, Stateful::current_state_version);
2266                         new_order.push_back (_amp);
2267                 } else if (prop->value() == "meter") {
2268                         _meter->set_state (**niter, Stateful::current_state_version);
2269                         new_order.push_back (_meter);
2270                 } else if (prop->value() == "main-outs") {
2271                         _main_outs->set_state (**niter, Stateful::current_state_version);
2272                         new_order.push_back (_main_outs);
2273                 } else if (prop->value() == "intreturn") {
2274                         if (!_intreturn) {
2275                                 _intreturn.reset (new InternalReturn (_session));
2276                                 must_configure = true;
2277                         }
2278                         _intreturn->set_state (**niter, Stateful::current_state_version);
2279                         new_order.push_back (_intreturn);
2280                 } else if (is_monitor() && prop->value() == "monitor") {
2281                         if (!_monitor_control) {
2282                                 _monitor_control.reset (new MonitorProcessor (_session));
2283                                 must_configure = true;
2284                         }
2285                         _monitor_control->set_state (**niter, Stateful::current_state_version);
2286                         new_order.push_back (_monitor_control);
2287                 } else {
2288                         ProcessorList::iterator o;
2289
2290                         for (o = _processors.begin(); o != _processors.end(); ++o) {
2291                                 XMLProperty* id_prop = (*niter)->property(X_("id"));
2292                                 if (id_prop && (*o)->id() == id_prop->value()) {
2293                                         (*o)->set_state (**niter, Stateful::current_state_version);
2294                                         new_order.push_back (*o);
2295                                         break;
2296                                 }
2297                         }
2298
2299                         // If the processor (*niter) is not on the route then create it
2300
2301                         if (o == _processors.end()) {
2302
2303                                 boost::shared_ptr<Processor> processor;
2304
2305                                 if (prop->value() == "intsend") {
2306
2307                                         processor.reset (new InternalSend (_session, _mute_master, boost::shared_ptr<Route>(), Delivery::Role (0)));
2308
2309                                 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2310                                            prop->value() == "lv2" ||
2311                                            prop->value() == "vst" ||
2312                                            prop->value() == "audiounit") {
2313
2314                                         processor.reset (new PluginInsert(_session));
2315
2316                                 } else if (prop->value() == "port") {
2317
2318                                         processor.reset (new PortInsert (_session, _mute_master));
2319
2320                                 } else if (prop->value() == "send") {
2321
2322                                         processor.reset (new Send (_session, _mute_master));
2323
2324                                 } else {
2325                                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2326                                         continue;
2327                                 }
2328
2329                                 processor->set_state (**niter, Stateful::current_state_version);
2330                                 new_order.push_back (processor);
2331                                 must_configure = true;
2332                         }
2333                 }
2334         }
2335
2336         {
2337                 Glib::RWLock::WriterLock lm (_processor_lock);
2338                 _processors = new_order;
2339                 if (must_configure) {
2340                         configure_processors_unlocked (0);
2341                 }
2342         }
2343
2344         processors_changed (RouteProcessorChange ());
2345         set_processor_positions ();
2346 }
2347
2348 void
2349 Route::curve_reallocate ()
2350 {
2351 //      _gain_automation_curve.finish_resize ();
2352 //      _pan_automation_curve.finish_resize ();
2353 }
2354
2355 void
2356 Route::silence (nframes_t nframes)
2357 {
2358         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2359         if (!lm.locked()) {
2360                 return;
2361         }
2362
2363         silence_unlocked (nframes);
2364 }
2365
2366 void
2367 Route::silence_unlocked (nframes_t nframes)
2368 {
2369         /* Must be called with the processor lock held */
2370
2371         if (!_silent) {
2372
2373                 _output->silence (nframes);
2374
2375                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2376                         boost::shared_ptr<PluginInsert> pi;
2377
2378                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2379                                 // skip plugins, they don't need anything when we're not active
2380                                 continue;
2381                         }
2382
2383                         (*i)->silence (nframes);
2384                 }
2385
2386                 if (nframes == _session.get_block_size()) {
2387                         // _silent = true;
2388                 }
2389         }
2390 }
2391
2392 void
2393 Route::add_internal_return ()
2394 {
2395         if (!_intreturn) {
2396                 _intreturn.reset (new InternalReturn (_session));
2397                 add_processor (_intreturn, PreFader);
2398         }
2399 }
2400
2401 BufferSet*
2402 Route::get_return_buffer () const
2403 {
2404         Glib::RWLock::ReaderLock rm (_processor_lock);
2405
2406         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2407                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2408
2409                 if (d) {
2410                         BufferSet* bs = d->get_buffers ();
2411                         return bs;
2412                 }
2413         }
2414
2415         return 0;
2416 }
2417
2418 void
2419 Route::release_return_buffer () const
2420 {
2421         Glib::RWLock::ReaderLock rm (_processor_lock);
2422
2423         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2424                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2425
2426                 if (d) {
2427                         return d->release_buffers ();
2428                 }
2429         }
2430 }
2431
2432 int
2433 Route::listen_via (boost::shared_ptr<Route> route, Placement placement, bool /*active*/, bool aux)
2434 {
2435         vector<string> ports;
2436         vector<string>::const_iterator i;
2437
2438         {
2439                 Glib::RWLock::ReaderLock rm (_processor_lock);
2440
2441                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2442
2443                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2444
2445                         if (d && d->target_route() == route) {
2446
2447                                 /* if the target is the control outs, then make sure
2448                                    we take note of which i-send is doing that.
2449                                 */
2450
2451                                 if (route == _session.monitor_out()) {
2452                                         _monitor_send = boost::dynamic_pointer_cast<Delivery>(d);
2453                                 }
2454
2455                                 /* already listening via the specified IO: do nothing */
2456
2457                                 return 0;
2458                         }
2459                 }
2460         }
2461
2462         boost::shared_ptr<InternalSend> listener;
2463
2464         try {
2465
2466                 if (is_master()) {
2467
2468                         if (route == _session.monitor_out()) {
2469                                 /* master never sends to control outs */
2470                                 return 0;
2471                         } else {
2472                                 listener.reset (new InternalSend (_session, _mute_master, route, (aux ? Delivery::Aux : Delivery::Listen)));
2473                         }
2474
2475                 } else {
2476                         listener.reset (new InternalSend (_session, _mute_master, route, (aux ? Delivery::Aux : Delivery::Listen)));
2477                 }
2478
2479         } catch (failed_constructor& err) {
2480                 return -1;
2481         }
2482
2483         if (route == _session.monitor_out()) {
2484                 _monitor_send = listener;
2485         }
2486
2487         if (placement == PostFader) {
2488                 /* put it *really* at the end, not just after the panner (main outs)
2489                  */
2490                 add_processor (listener, _processors.end());
2491         } else {
2492                 add_processor (listener, PreFader);
2493         }
2494
2495         return 0;
2496 }
2497
2498 void
2499 Route::drop_listen (boost::shared_ptr<Route> route)
2500 {
2501         ProcessorStreams err;
2502         ProcessorList::iterator tmp;
2503
2504         Glib::RWLock::ReaderLock rl(_processor_lock);
2505         rl.acquire ();
2506
2507   again:
2508         for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ) {
2509
2510                 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2511
2512                 if (d && d->target_route() == route) {
2513                         rl.release ();
2514                         remove_processor (*x, &err);
2515                         rl.acquire ();
2516
2517                         /* list could have been demolished while we dropped the lock
2518                            so start over.
2519                         */
2520
2521                         goto again;
2522                 }
2523         }
2524
2525         rl.release ();
2526
2527         if (route == _session.monitor_out()) {
2528                 _monitor_send.reset ();
2529         }
2530 }
2531
2532 void
2533 Route::set_comment (string cmt, void *src)
2534 {
2535         _comment = cmt;
2536         comment_changed (src);
2537         _session.set_dirty ();
2538 }
2539
2540 bool
2541 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
2542 {
2543         FeedRecord fr (other, via_sends_only);
2544
2545         pair<FedBy::iterator,bool> result =  _fed_by.insert (fr);
2546
2547         if (!result.second) {
2548
2549                 /* already a record for "other" - make sure sends-only information is correct */
2550                 if (!via_sends_only && result.first->sends_only) {
2551                         FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
2552                         frp->sends_only = false;
2553                 }
2554         }
2555
2556         return result.second;
2557 }
2558
2559 void
2560 Route::clear_fed_by ()
2561 {
2562         _fed_by.clear ();
2563 }
2564
2565 bool
2566 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
2567 {
2568         const FedBy& fed_by (other->fed_by());
2569
2570         for (FedBy::iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
2571                 boost::shared_ptr<Route> sr = f->r.lock();
2572
2573                 if (sr && (sr.get() == this)) {
2574
2575                         if (via_sends_only) {
2576                                 *via_sends_only = f->sends_only;
2577                         }
2578
2579                         return true;
2580                 }
2581         }
2582
2583         return false;
2584 }
2585
2586 bool
2587 Route::direct_feeds (boost::shared_ptr<Route> other, bool* only_send)
2588 {
2589         DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
2590
2591         if (_output->connected_to (other->input())) {
2592                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
2593                 if (only_send) {
2594                         *only_send = false;
2595                 }
2596
2597                 return true;
2598         }
2599
2600
2601         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
2602
2603                 boost::shared_ptr<IOProcessor> iop;
2604
2605                 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
2606                         if (iop->feeds (other)) {
2607                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
2608                                 if (only_send) {
2609                                         *only_send = true;
2610                                 }
2611                                 return true;
2612                         } else {
2613                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
2614                         }
2615                 } else {
2616                         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
2617                 }
2618
2619         }
2620
2621         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tdoes NOT feed %1\n", other->name()));
2622         return false;
2623 }
2624
2625 void
2626 Route::handle_transport_stopped (bool /*abort_ignored*/, bool did_locate, bool can_flush_processors)
2627 {
2628         framepos_t now = _session.transport_frame();
2629
2630         {
2631                 Glib::RWLock::ReaderLock lm (_processor_lock);
2632
2633                 if (!did_locate) {
2634                         automation_snapshot (now, true);
2635                 }
2636
2637                 Automatable::transport_stopped (now);
2638
2639                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2640
2641                         if (Config->get_plugins_stop_with_transport() && can_flush_processors) {
2642                                 (*i)->deactivate ();
2643                                 (*i)->activate ();
2644                                 (*i)->flush ();
2645                         }
2646
2647                         (*i)->transport_stopped (now);
2648                 }
2649         }
2650
2651         _roll_delay = _initial_delay;
2652 }
2653
2654 void
2655 Route::input_change_handler (IOChange change, void * /*src*/)
2656 {
2657         if ((change & ConfigurationChanged)) {
2658                 configure_processors (0);
2659                 _phase_invert.resize (_input->n_ports().n_audio ());
2660                 io_changed (); /* EMIT SIGNAL */
2661         }
2662 }
2663
2664 void
2665 Route::output_change_handler (IOChange change, void * /*src*/)
2666 {
2667         if ((change & ConfigurationChanged)) {
2668
2669                 /* XXX resize all listeners to match _main_outs? */
2670
2671                 // configure_processors (0);
2672         }
2673 }
2674
2675 uint32_t
2676 Route::pans_required () const
2677 {
2678         if (n_outputs().n_audio() < 2) {
2679                 return 0;
2680         }
2681
2682         return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
2683 }
2684
2685 int
2686 Route::no_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
2687                 bool session_state_changing, bool /*can_record*/, bool /*rec_monitors_input*/)
2688 {
2689         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2690         if (!lm.locked()) {
2691                 return 0;
2692         }
2693
2694         if (n_outputs().n_total() == 0) {
2695                 return 0;
2696         }
2697
2698         if (!_active || n_inputs() == ChanCount::ZERO)  {
2699                 silence_unlocked (nframes);
2700                 return 0;
2701         }
2702         if (session_state_changing) {
2703                 if (_session.transport_speed() != 0.0f) {
2704                         /* we're rolling but some state is changing (e.g. our diskstream contents)
2705                            so we cannot use them. Be silent till this is over.
2706
2707                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
2708                         */
2709                         silence_unlocked (nframes);
2710                         return 0;
2711                 }
2712                 /* we're really not rolling, so we're either delivery silence or actually
2713                    monitoring, both of which are safe to do while session_state_changing is true.
2714                 */
2715         }
2716
2717         _amp->apply_gain_automation (false);
2718         passthru (start_frame, end_frame, nframes, 0);
2719
2720         return 0;
2721 }
2722
2723 nframes_t
2724 Route::check_initial_delay (nframes_t nframes, nframes_t& transport_frame)
2725 {
2726         if (_roll_delay > nframes) {
2727
2728                 _roll_delay -= nframes;
2729                 silence_unlocked (nframes);
2730                 /* transport frame is not legal for caller to use */
2731                 return 0;
2732
2733         } else if (_roll_delay > 0) {
2734
2735                 nframes -= _roll_delay;
2736                 silence_unlocked (_roll_delay);
2737                 /* we've written _roll_delay of samples into the
2738                    output ports, so make a note of that for
2739                    future reference.
2740                 */
2741                 _main_outs->increment_output_offset (_roll_delay);
2742                 transport_frame += _roll_delay;
2743
2744                 _roll_delay = 0;
2745         }
2746
2747         return nframes;
2748 }
2749
2750 int
2751 Route::roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame, int declick,
2752              bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
2753 {
2754         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2755         if (!lm.locked()) {
2756                 return 0;
2757         }
2758
2759         automation_snapshot (_session.transport_frame(), false);
2760
2761         if (n_outputs().n_total() == 0) {
2762                 return 0;
2763         }
2764
2765         if (!_active || n_inputs().n_total() == 0) {
2766                 silence_unlocked (nframes);
2767                 return 0;
2768         }
2769
2770         nframes_t unused = 0;
2771
2772         if ((nframes = check_initial_delay (nframes, unused)) == 0) {
2773                 return 0;
2774         }
2775
2776         _silent = false;
2777
2778         passthru (start_frame, end_frame, nframes, declick);
2779
2780         return 0;
2781 }
2782
2783 int
2784 Route::silent_roll (nframes_t nframes, sframes_t /*start_frame*/, sframes_t /*end_frame*/,
2785                     bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
2786 {
2787         silence (nframes);
2788         return 0;
2789 }
2790
2791 void
2792 Route::toggle_monitor_input ()
2793 {
2794         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
2795                 i->ensure_monitor_input( ! i->monitoring_input());
2796         }
2797 }
2798
2799 bool
2800 Route::has_external_redirects () const
2801 {
2802         // FIXME: what about sends? - they don't return a signal back to ardour?
2803
2804         boost::shared_ptr<const PortInsert> pi;
2805
2806         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2807
2808                 if ((pi = boost::dynamic_pointer_cast<const PortInsert>(*i)) != 0) {
2809
2810                         for (PortSet::const_iterator port = pi->output()->ports().begin(); port != pi->output()->ports().end(); ++port) {
2811
2812                                 string port_name = port->name();
2813                                 string client_name = port_name.substr (0, port_name.find(':'));
2814
2815                                 /* only say "yes" if the redirect is actually in use */
2816
2817                                 if (client_name != "ardour" && pi->active()) {
2818                                         return true;
2819                                 }
2820                         }
2821                 }
2822         }
2823
2824         return false;
2825 }
2826
2827 void
2828 Route::flush_processors ()
2829 {
2830         /* XXX shouldn't really try to take this lock, since
2831            this is called from the RT audio thread.
2832         */
2833
2834         Glib::RWLock::ReaderLock lm (_processor_lock);
2835
2836         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2837                 (*i)->flush ();
2838         }
2839 }
2840
2841 void
2842 Route::set_meter_point (MeterPoint p)
2843 {
2844         /* CAN BE CALLED FROM PROCESS CONTEXT */
2845
2846         if (_meter_point == p) {
2847                 return;
2848         }
2849
2850         bool meter_was_visible_to_user = _meter->display_to_user ();
2851
2852         {
2853                 Glib::RWLock::WriterLock lm (_processor_lock);
2854
2855                 if (p != MeterCustom) {
2856                         // Move meter in the processors list to reflect the new position
2857                         ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
2858                         _processors.erase(loc);
2859                         switch (p) {
2860                         case MeterInput:
2861                                 loc = _processors.begin();
2862                                 break;
2863                         case MeterPreFader:
2864                                 loc = find (_processors.begin(), _processors.end(), _amp);
2865                                 break;
2866                         case MeterPostFader:
2867                                 loc = _processors.end();
2868                                 break;
2869                         default:
2870                                 break;
2871                         }
2872
2873                         ChanCount m_in;
2874
2875                         if (loc == _processors.begin()) {
2876                                 m_in = _input->n_ports();
2877                         } else {
2878                                 ProcessorList::iterator before = loc;
2879                                 --before;
2880                                 m_in = (*before)->output_streams ();
2881                         }
2882
2883                         _meter->reflect_inputs (m_in);
2884
2885                         _processors.insert (loc, _meter);
2886
2887                         /* we do not need to reconfigure the processors, because the meter
2888                            (a) is always ready to handle processor_max_streams
2889                            (b) is always an N-in/N-out processor, and thus moving
2890                            it doesn't require any changes to the other processors.
2891                         */
2892
2893                         _meter->set_display_to_user (false);
2894
2895                 } else {
2896
2897                         // just make it visible and let the user move it
2898
2899                         _meter->set_display_to_user (true);
2900                 }
2901         }
2902
2903         _meter_point = p;
2904         meter_change (); /* EMIT SIGNAL */
2905
2906         bool const meter_visibly_changed = (_meter->display_to_user() != meter_was_visible_to_user);
2907
2908         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
2909 }
2910
2911 void
2912 Route::put_monitor_send_at (Placement p)
2913 {
2914         if (!_monitor_send) {
2915                 return;
2916         }
2917
2918         {
2919                 Glib::RWLock::WriterLock lm (_processor_lock);
2920                 ProcessorList as_it_was (_processors);
2921                 ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), _monitor_send);
2922                 _processors.erase(loc);
2923
2924                 switch (p) {
2925                 case PreFader:
2926                         loc = find(_processors.begin(), _processors.end(), _amp);
2927                         if (loc != _processors.begin()) {
2928                                 --loc;
2929                         }
2930                         break;
2931                 case PostFader:
2932                         loc = _processors.end();
2933                         break;
2934                 }
2935
2936                 _processors.insert (loc, _monitor_send);
2937
2938                 if (configure_processors_unlocked (0)) {
2939                         _processors = as_it_was;
2940                         configure_processors_unlocked (0); // it worked before we tried to add it ...
2941                         return;
2942                 }
2943         }
2944
2945         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2946         _session.set_dirty ();
2947 }
2948
2949 nframes_t
2950 Route::update_total_latency ()
2951 {
2952         nframes_t old = _output->effective_latency();
2953         nframes_t own_latency = _output->user_latency();
2954
2955         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2956                 if ((*i)->active ()) {
2957                         own_latency += (*i)->signal_latency ();
2958                 }
2959         }
2960
2961         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal redirect latency = %2\n", _name, own_latency));
2962
2963         _output->set_port_latency (own_latency);
2964
2965         if (_output->user_latency() == 0) {
2966
2967                 /* this (virtual) function is used for pure Routes,
2968                    not derived classes like AudioTrack.  this means
2969                    that the data processed here comes from an input
2970                    port, not prerecorded material, and therefore we
2971                    have to take into account any input latency.
2972                 */
2973
2974                 own_latency += _input->signal_latency ();
2975         }
2976
2977         if (old != own_latency) {
2978                 _output->set_latency_delay (own_latency);
2979                 signal_latency_changed (); /* EMIT SIGNAL */
2980         }
2981
2982         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: input latency = %2 total = %3\n", _name, _input->signal_latency(), own_latency));
2983
2984         return _output->effective_latency ();
2985 }
2986
2987 void
2988 Route::set_user_latency (nframes_t nframes)
2989 {
2990         _output->set_user_latency (nframes);
2991         _session.update_latency_compensation (false, false);
2992 }
2993
2994 void
2995 Route::set_latency_delay (nframes_t longest_session_latency)
2996 {
2997         nframes_t old = _initial_delay;
2998
2999         if (_output->effective_latency() < longest_session_latency) {
3000                 _initial_delay = longest_session_latency - _output->effective_latency();
3001         } else {
3002                 _initial_delay = 0;
3003         }
3004
3005         if (_initial_delay != old) {
3006                 initial_delay_changed (); /* EMIT SIGNAL */
3007         }
3008
3009         if (_session.transport_stopped()) {
3010                 _roll_delay = _initial_delay;
3011         }
3012 }
3013
3014 void
3015 Route::automation_snapshot (nframes_t now, bool force)
3016 {
3017         panner()->automation_snapshot (now, force);
3018
3019         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3020                 (*i)->automation_snapshot (now, force);
3021         }
3022 }
3023
3024 Route::SoloControllable::SoloControllable (std::string name, Route& r)
3025         : AutomationControl (r.session(), Evoral::Parameter (SoloAutomation),
3026                              boost::shared_ptr<AutomationList>(), name)
3027         , route (r)
3028 {
3029         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
3030         set_list (gl);
3031 }
3032
3033 void
3034 Route::SoloControllable::set_value (double val)
3035 {
3036         bool bval = ((val >= 0.5f) ? true: false);
3037 # if 0
3038         this is how it should be done
3039
3040         boost::shared_ptr<RouteList> rl (new RouteList);
3041         rl->push_back (route);
3042
3043         if (Config->get_solo_control_is_listen_control()) {
3044                 _session.set_listen (rl, bval);
3045         } else {
3046                 _session.set_solo (rl, bval);
3047         }
3048 #else
3049         route.set_solo (bval, this);
3050 #endif
3051 }
3052
3053 double
3054 Route::SoloControllable::get_value (void) const
3055 {
3056         if (Config->get_solo_control_is_listen_control()) {
3057                 return route.listening() ? 1.0f : 0.0f;
3058         } else {
3059                 return route.self_soloed() ? 1.0f : 0.0f;
3060         }
3061 }
3062
3063 Route::MuteControllable::MuteControllable (std::string name, Route& r)
3064         : AutomationControl (r.session(), Evoral::Parameter (MuteAutomation),
3065                              boost::shared_ptr<AutomationList>(), name)
3066         , route (r)
3067 {
3068         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MuteAutomation)));
3069         set_list (gl);
3070 }
3071
3072 void
3073 Route::MuteControllable::set_value (double val)
3074 {
3075         bool bval = ((val >= 0.5f) ? true: false);
3076 # if 0
3077         this is how it should be done
3078
3079         boost::shared_ptr<RouteList> rl (new RouteList);
3080         rl->push_back (route);
3081         _session.set_mute (rl, bval);
3082 #else
3083         route.set_mute (bval, this);
3084 #endif
3085 }
3086
3087 double
3088 Route::MuteControllable::get_value (void) const
3089 {
3090         return route.muted() ? 1.0f : 0.0f;
3091 }
3092
3093 void
3094 Route::set_block_size (nframes_t nframes)
3095 {
3096         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3097                 (*i)->set_block_size (nframes);
3098         }
3099
3100         _session.ensure_buffers (n_process_buffers ());
3101 }
3102
3103 void
3104 Route::protect_automation ()
3105 {
3106         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3107                 (*i)->protect_automation();
3108 }
3109
3110 void
3111 Route::set_pending_declick (int declick)
3112 {
3113         if (_declickable) {
3114                 /* this call is not allowed to turn off a pending declick unless "force" is true */
3115                 if (declick) {
3116                         _pending_declick = declick;
3117                 }
3118                 // cerr << _name << ": after setting to " << declick << " pending declick = " << _pending_declick << endl;
3119         } else {
3120                 _pending_declick = 0;
3121         }
3122
3123 }
3124
3125 /** Shift automation forwards from a particular place, thereby inserting time.
3126  *  Adds undo commands for any shifts that are performed.
3127  *
3128  * @param pos Position to start shifting from.
3129  * @param frames Amount to shift forwards by.
3130  */
3131
3132 void
3133 Route::shift (nframes64_t /*pos*/, nframes64_t /*frames*/)
3134 {
3135 #ifdef THIS_NEEDS_FIXING_FOR_V3
3136
3137         /* gain automation */
3138         XMLNode &before = _gain_control->get_state ();
3139         _gain_control->shift (pos, frames);
3140         XMLNode &after = _gain_control->get_state ();
3141         _session.add_command (new MementoCommand<AutomationList> (_gain_automation_curve, &before, &after));
3142
3143         /* pan automation */
3144         for (std::vector<StreamPanner*>::iterator i = _panner->begin (); i != _panner->end (); ++i) {
3145                 Curve & c = (*i)->automation ();
3146                 XMLNode &before = c.get_state ();
3147                 c.shift (pos, frames);
3148                 XMLNode &after = c.get_state ();
3149                 _session.add_command (new MementoCommand<AutomationList> (c, &before, &after));
3150         }
3151
3152         /* redirect automation */
3153         {
3154                 Glib::RWLock::ReaderLock lm (redirect_lock);
3155                 for (RedirectList::iterator i = _redirects.begin (); i != _redirects.end (); ++i) {
3156
3157                         set<uint32_t> a;
3158                         (*i)->what_has_automation (a);
3159
3160                         for (set<uint32_t>::const_iterator j = a.begin (); j != a.end (); ++j) {
3161                                 AutomationList & al = (*i)->automation_list (*j);
3162                                 XMLNode &before = al.get_state ();
3163                                 al.shift (pos, frames);
3164                                 XMLNode &after = al.get_state ();
3165                                 _session.add_command (new MementoCommand<AutomationList> (al, &before, &after));
3166                         }
3167                 }
3168         }
3169 #endif
3170
3171 }
3172
3173
3174 int
3175 Route::save_as_template (const string& path, const string& name)
3176 {
3177         XMLNode& node (state (false));
3178         XMLTree tree;
3179
3180         IO::set_name_in_state (*node.children().front(), name);
3181
3182         tree.set_root (&node);
3183         return tree.write (path.c_str());
3184 }
3185
3186
3187 bool
3188 Route::set_name (const string& str)
3189 {
3190         bool ret;
3191         string ioproc_name;
3192         string name;
3193
3194         name = Route::ensure_track_or_route_name (str, _session);
3195         SessionObject::set_name (name);
3196
3197         ret = (_input->set_name(name) && _output->set_name(name));
3198
3199         if (ret) {
3200
3201                 Glib::RWLock::ReaderLock lm (_processor_lock);
3202
3203                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3204
3205                         /* rename all I/O processors that have inputs or outputs */
3206
3207                         boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
3208
3209                         if (iop && (iop->output() || iop->input())) {
3210                                 if (!iop->set_name (name)) {
3211                                         ret = false;
3212                                 }
3213                         }
3214                 }
3215
3216         }
3217
3218         return ret;
3219 }
3220
3221 boost::shared_ptr<Send>
3222 Route::internal_send_for (boost::shared_ptr<const Route> target) const
3223 {
3224         Glib::RWLock::ReaderLock lm (_processor_lock);
3225
3226         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3227                 boost::shared_ptr<InternalSend> send;
3228
3229                 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
3230                         if (send->target_route() == target) {
3231                                 return send;
3232                         }
3233                 }
3234         }
3235
3236         return boost::shared_ptr<Send>();
3237 }
3238
3239 /** @param c Audio channel index.
3240  *  @param yn true to invert phase, otherwise false.
3241  */
3242 void
3243 Route::set_phase_invert (uint32_t c, bool yn)
3244 {
3245         if (_phase_invert[c] != yn) {
3246                 _phase_invert[c] = yn;
3247                 phase_invert_changed (); /* EMIT SIGNAL */
3248                 _session.set_dirty ();
3249         }
3250 }
3251
3252 void
3253 Route::set_phase_invert (boost::dynamic_bitset<> p)
3254 {
3255         if (_phase_invert != p) {
3256                 _phase_invert = p;
3257                 phase_invert_changed (); /* EMIT SIGNAL */
3258                 _session.set_dirty ();
3259         }
3260 }
3261
3262 bool
3263 Route::phase_invert (uint32_t c) const
3264 {
3265         return _phase_invert[c];
3266 }
3267
3268 boost::dynamic_bitset<>
3269 Route::phase_invert () const
3270 {
3271         return _phase_invert;
3272 }
3273
3274 void
3275 Route::set_denormal_protection (bool yn)
3276 {
3277         if (_denormal_protection != yn) {
3278                 _denormal_protection = yn;
3279                 denormal_protection_changed (); /* EMIT SIGNAL */
3280         }
3281 }
3282
3283 bool
3284 Route::denormal_protection () const
3285 {
3286         return _denormal_protection;
3287 }
3288
3289 void
3290 Route::set_active (bool yn)
3291 {
3292         if (_active != yn) {
3293                 _active = yn;
3294                 _input->set_active (yn);
3295                 _output->set_active (yn);
3296                 active_changed (); // EMIT SIGNAL
3297         }
3298 }
3299
3300 void
3301 Route::meter ()
3302 {
3303         Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3304
3305         assert (_meter);
3306
3307         _meter->meter ();
3308
3309         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3310
3311                 boost::shared_ptr<Send> s;
3312                 boost::shared_ptr<Return> r;
3313
3314                 if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
3315                         s->meter()->meter();
3316                 } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
3317                         r->meter()->meter ();
3318                 }
3319         }
3320 }
3321
3322 boost::shared_ptr<Panner>
3323 Route::panner() const
3324 {
3325         return _main_outs->panner();
3326 }
3327
3328 boost::shared_ptr<AutomationControl>
3329 Route::gain_control() const
3330 {
3331         return _amp->gain_control();
3332 }
3333
3334 boost::shared_ptr<AutomationControl>
3335 Route::get_control (const Evoral::Parameter& param)
3336 {
3337         /* either we own the control or .... */
3338
3339         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
3340
3341         if (!c) {
3342
3343                 /* maybe one of our processors does or ... */
3344
3345                 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3346                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3347                         if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
3348                                 break;
3349                         }
3350                 }
3351         }
3352
3353         if (!c) {
3354
3355                 /* nobody does so we'll make a new one */
3356
3357                 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
3358                 add_control(c);
3359         }
3360
3361         return c;
3362 }
3363
3364 boost::shared_ptr<Processor>
3365 Route::nth_plugin (uint32_t n)
3366 {
3367         Glib::RWLock::ReaderLock lm (_processor_lock);
3368         ProcessorList::iterator i;
3369
3370         for (i = _processors.begin(); i != _processors.end(); ++i) {
3371                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
3372                         if (n-- == 0) {
3373                                 return *i;
3374                         }
3375                 }
3376         }
3377
3378         return boost::shared_ptr<Processor> ();
3379 }
3380
3381 boost::shared_ptr<Processor>
3382 Route::nth_send (uint32_t n)
3383 {
3384         Glib::RWLock::ReaderLock lm (_processor_lock);
3385         ProcessorList::iterator i;
3386
3387         for (i = _processors.begin(); i != _processors.end(); ++i) {
3388                 if (boost::dynamic_pointer_cast<Send> (*i)) {
3389                         if (n-- == 0) {
3390                                 return *i;
3391                         }
3392                 }
3393         }
3394
3395         return boost::shared_ptr<Processor> ();
3396 }
3397
3398 bool
3399 Route::has_io_processor_named (const string& name)
3400 {
3401         Glib::RWLock::ReaderLock lm (_processor_lock);
3402         ProcessorList::iterator i;
3403
3404         for (i = _processors.begin(); i != _processors.end(); ++i) {
3405                 if (boost::dynamic_pointer_cast<Send> (*i) ||
3406                     boost::dynamic_pointer_cast<PortInsert> (*i)) {
3407                         if ((*i)->name() == name) {
3408                                 return true;
3409                         }
3410                 }
3411         }
3412
3413         return false;
3414 }
3415
3416 MuteMaster::MutePoint
3417 Route::mute_points () const
3418 {
3419         return _mute_master->mute_points ();
3420 }
3421
3422 void
3423 Route::set_processor_positions ()
3424 {
3425         Glib::RWLock::ReaderLock lm (_processor_lock);
3426
3427         bool had_amp = false;
3428         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3429                 (*i)->set_pre_fader (!had_amp);
3430                 if (boost::dynamic_pointer_cast<Amp> (*i)) {
3431                         had_amp = true;
3432                 }
3433         }
3434 }
3435