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