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->is_active() && _route_group->is_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->is_active() && _route_group->is_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->is_active() && _route_group->is_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->is_active() && _route_group->is_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
1372         if (!_session.engine().connected()) {
1373                 return 1;
1374         }
1375
1376         processor_max_streams.reset();
1377
1378         {
1379                 Glib::RWLock::WriterLock lm (_processor_lock);
1380                 ProcessorList::iterator i;
1381                 boost::shared_ptr<Processor> processor;
1382
1383                 ProcessorList as_we_were = _processors;
1384
1385                 for (i = _processors.begin(); i != _processors.end(); ) {
1386
1387                         processor = *i;
1388
1389                         /* these can never be removed */
1390
1391                         if (processor == _amp || processor == _meter || processor == _main_outs) {
1392                                 ++i;
1393                                 continue;
1394                         }
1395
1396                         /* see if its in the list of processors to delete */
1397
1398                         if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
1399                                 ++i;
1400                                 continue;
1401                         }
1402
1403                         /* stop IOProcessors that send to JACK ports
1404                            from causing noise as a result of no longer being
1405                            run.
1406                         */
1407
1408                         boost::shared_ptr<IOProcessor> iop;
1409
1410                         if ((iop = boost::dynamic_pointer_cast<IOProcessor> (processor)) != 0) {
1411                                 iop->disconnect ();
1412                         }
1413
1414                         deleted.push_back (processor);
1415                         i = _processors.erase (i);
1416                 }
1417
1418                 if (deleted.empty()) {
1419                         /* none of those in the requested list were found */
1420                         return 0;
1421                 }
1422
1423                 _output->set_user_latency (0);
1424
1425                 if (configure_processors_unlocked (err)) {
1426                         /* get back to where we where */
1427                         _processors = as_we_were;
1428                         /* we know this will work, because it worked before :) */
1429                         configure_processors_unlocked (0);
1430                         return -1;
1431                 }
1432
1433                 _have_internal_generator = false;
1434
1435                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1436                         boost::shared_ptr<PluginInsert> pi;
1437
1438                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1439                                 if (pi->is_generator()) {
1440                                         _have_internal_generator = true;
1441                                         break;
1442                                 }
1443                         }
1444                 }
1445         }
1446
1447         /* now try to do what we need to so that those that were removed will be deleted */
1448
1449         for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
1450                 (*i)->drop_references ();
1451         }
1452
1453         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1454
1455         return 0;
1456 }
1457
1458
1459 int
1460 Route::configure_processors (ProcessorStreams* err)
1461 {
1462         if (!_in_configure_processors) {
1463                 Glib::RWLock::WriterLock lm (_processor_lock);
1464                 return configure_processors_unlocked (err);
1465         }
1466         return 0;
1467 }
1468
1469 /** Configure the input/output configuration of each processor in the processors list.
1470  * Return 0 on success, otherwise configuration is impossible.
1471  */
1472 int
1473 Route::configure_processors_unlocked (ProcessorStreams* err)
1474 {
1475         if (_in_configure_processors) {
1476            return 0;
1477         }
1478
1479         _in_configure_processors = true;
1480
1481         // Check each processor in order to see if we can configure as requested
1482         ChanCount in = _input->n_ports ();
1483         ChanCount out;
1484         list< pair<ChanCount,ChanCount> > configuration;
1485         uint32_t index = 0;
1486
1487         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
1488 #ifndef NDEBUG
1489         DEBUG_TRACE (DEBUG::Processors, "{\n");
1490         for (list<boost::shared_ptr<Processor> >::const_iterator p = _processors.begin(); p != _processors.end(); ++p) {
1491                 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID = %2\n", (*p)->name(), (*p)->id()));
1492         }
1493         DEBUG_TRACE (DEBUG::Processors, "}\n");
1494 #endif
1495
1496         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1497
1498                 if ((*p)->can_support_io_configuration(in, out)) {
1499                         DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1in = %2 out = %3\n",(*p)->name(), in, out));
1500                         configuration.push_back(make_pair(in, out));
1501                         in = out;
1502                 } else {
1503                         if (err) {
1504                                 err->index = index;
1505                                 err->count = in;
1506                         }
1507                         _in_configure_processors = false;
1508                         return -1;
1509                 }
1510         }
1511
1512         // We can, so configure everything
1513         list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1514         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1515                 (*p)->configure_io(c->first, c->second);
1516                 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1517                 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1518                 out = c->second;
1519         }
1520
1521         if (_meter) {
1522                 _meter->reset_max_channels (processor_max_streams);
1523         }
1524
1525         /* make sure we have sufficient scratch buffers to cope with the new processor
1526            configuration */
1527         _session.ensure_buffers (n_process_buffers ());
1528
1529         _in_configure_processors = false;
1530         return 0;
1531 }
1532
1533 void
1534 Route::all_processors_flip ()
1535 {
1536         Glib::RWLock::ReaderLock lm (_processor_lock);
1537
1538         if (_processors.empty()) {
1539                 return;
1540         }
1541
1542         bool first_is_on = _processors.front()->active();
1543
1544         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1545                 if (first_is_on) {
1546                         (*i)->deactivate ();
1547                 } else {
1548                         (*i)->activate ();
1549                 }
1550         }
1551
1552         _session.set_dirty ();
1553 }
1554
1555 /** Set all processors with a given placement to a given active state.
1556  * @param p Placement of processors to change.
1557  * @param state New active state for those processors.
1558  */
1559 void
1560 Route::all_processors_active (Placement p, bool state)
1561 {
1562         Glib::RWLock::ReaderLock lm (_processor_lock);
1563
1564         if (_processors.empty()) {
1565                 return;
1566         }
1567         ProcessorList::iterator start, end;
1568         placement_range(p, start, end);
1569
1570         bool before_amp = true;
1571         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1572                 if ((*i) == _amp) {
1573                         before_amp = false;
1574                         continue;
1575                 }
1576                 if (p == PreFader && before_amp) {
1577                         if (state) {
1578                                 (*i)->activate ();
1579                         } else {
1580                                 (*i)->deactivate ();
1581                         }
1582                 }
1583         }
1584
1585         _session.set_dirty ();
1586 }
1587
1588 bool
1589 Route::processor_is_prefader (boost::shared_ptr<Processor> p)
1590 {
1591         bool pre_fader = true;
1592         Glib::RWLock::ReaderLock lm (_processor_lock);
1593
1594         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1595
1596                 /* semantic note: if p == amp, we want to return true, so test
1597                    for equality before checking if this is the amp
1598                 */
1599
1600                 if ((*i) == p) {
1601                         break;
1602                 }
1603
1604                 if ((*i) == _amp) {
1605                         pre_fader = false;
1606                         break;
1607                 }
1608         }
1609
1610         return pre_fader;
1611 }
1612
1613 int
1614 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
1615 {
1616         /* "new_order" is an ordered list of processors to be positioned according to "placement".
1617            NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
1618            processors in the current actual processor list that are hidden. Any visible processors
1619            in the current list but not in "new_order" will be assumed to be deleted.
1620         */
1621
1622         {
1623                 Glib::RWLock::WriterLock lm (_processor_lock);
1624                 ChanCount old_pms = processor_max_streams;
1625                 ProcessorList::iterator oiter;
1626                 ProcessorList::const_iterator niter;
1627                 ProcessorList as_it_was_before = _processors;
1628                 ProcessorList as_it_will_be;
1629
1630                 oiter = _processors.begin();
1631                 niter = new_order.begin();
1632
1633                 while (niter !=  new_order.end()) {
1634
1635                         /* if the next processor in the old list is invisible (i.e. should not be in the new order)
1636                            then append it to the temp list.
1637
1638                            Otherwise, see if the next processor in the old list is in the new list. if not,
1639                            its been deleted. If its there, append it to the temp list.
1640                         */
1641
1642                         if (oiter == _processors.end()) {
1643
1644                                 /* no more elements in the old list, so just stick the rest of
1645                                    the new order onto the temp list.
1646                                 */
1647
1648                                 as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
1649                                 while (niter != new_order.end()) {
1650                                         ++niter;
1651                                 }
1652                                 break;
1653
1654                         } else {
1655
1656                                 if (!(*oiter)->display_to_user()) {
1657
1658                                         as_it_will_be.push_back (*oiter);
1659
1660                                 } else {
1661
1662                                         /* visible processor: check that its in the new order */
1663
1664                                         if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
1665                                                 /* deleted: do nothing, shared_ptr<> will clean up */
1666                                         } else {
1667                                                 /* ignore this one, and add the next item from the new order instead */
1668                                                 as_it_will_be.push_back (*niter);
1669                                                 ++niter;
1670                                         }
1671                                 }
1672
1673                                 /* now remove from old order - its taken care of no matter what */
1674                                 oiter = _processors.erase (oiter);
1675                         }
1676
1677                 }
1678
1679                 _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
1680
1681                 if (configure_processors_unlocked (err)) {
1682                         _processors = as_it_was_before;
1683                         processor_max_streams = old_pms;
1684                         return -1;
1685                 }
1686         }
1687
1688         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1689
1690         return 0;
1691 }
1692
1693 XMLNode&
1694 Route::get_state()
1695 {
1696         return state(true);
1697 }
1698
1699 XMLNode&
1700 Route::get_template()
1701 {
1702         return state(false);
1703 }
1704
1705 XMLNode&
1706 Route::state(bool full_state)
1707 {
1708         XMLNode *node = new XMLNode("Route");
1709         ProcessorList::iterator i;
1710         char buf[32];
1711
1712         id().print (buf, sizeof (buf));
1713         node->add_property("id", buf);
1714         node->add_property ("name", _name);
1715         node->add_property("default-type", _default_type.to_string());
1716
1717         if (_flags) {
1718                 node->add_property("flags", enum_2_string (_flags));
1719         }
1720
1721         node->add_property("active", _active?"yes":"no");
1722         node->add_property("phase-invert", _phase_invert?"yes":"no");
1723         node->add_property("denormal-protection", _denormal_protection?"yes":"no");
1724         node->add_property("meter-point", enum_2_string (_meter_point));
1725
1726         if (_route_group) {
1727                 node->add_property("route-group", _route_group->name());
1728         }
1729
1730         string order_string;
1731         OrderKeys::iterator x = order_keys.begin();
1732
1733         while (x != order_keys.end()) {
1734                 order_string += string ((*x).first);
1735                 order_string += '=';
1736                 snprintf (buf, sizeof(buf), "%ld", (*x).second);
1737                 order_string += buf;
1738
1739                 ++x;
1740
1741                 if (x == order_keys.end()) {
1742                         break;
1743                 }
1744
1745                 order_string += ':';
1746         }
1747         node->add_property ("order-keys", order_string);
1748         node->add_property ("self-solo", (_self_solo ? "yes" : "no"));
1749         snprintf (buf, sizeof (buf), "%d", _soloed_by_others);
1750         node->add_property ("soloed-by-others", buf);
1751
1752         node->add_child_nocopy (_input->state (full_state));
1753         node->add_child_nocopy (_output->state (full_state));
1754         node->add_child_nocopy (_solo_control->get_state ());
1755         node->add_child_nocopy (_mute_master->get_state ());
1756
1757         XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
1758         snprintf (buf, sizeof (buf), "%d", _remote_control_id);
1759         remote_control_node->add_property (X_("id"), buf);
1760         node->add_child_nocopy (*remote_control_node);
1761
1762         if (_comment.length()) {
1763                 XMLNode *cmt = node->add_child ("Comment");
1764                 cmt->add_content (_comment);
1765         }
1766
1767         for (i = _processors.begin(); i != _processors.end(); ++i) {
1768                 node->add_child_nocopy((*i)->state (full_state));
1769         }
1770
1771         if (_extra_xml){
1772                 node->add_child_copy (*_extra_xml);
1773         }
1774
1775         return *node;
1776 }
1777
1778 int
1779 Route::set_state (const XMLNode& node, int version)
1780 {
1781         return _set_state (node, version, true);
1782 }
1783
1784 int
1785 Route::_set_state (const XMLNode& node, int version, bool /*call_base*/)
1786 {
1787         if (version < 3000) {
1788                 return _set_state_2X (node, version);
1789         }
1790
1791         XMLNodeList nlist;
1792         XMLNodeConstIterator niter;
1793         XMLNode *child;
1794         XMLPropertyList plist;
1795         const XMLProperty *prop;
1796
1797         if (node.name() != "Route"){
1798                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1799                 return -1;
1800         }
1801
1802         if ((prop = node.property (X_("name"))) != 0) {
1803                 Route::set_name (prop->value());
1804         }
1805
1806         if ((prop = node.property ("id")) != 0) {
1807                 _id = prop->value ();
1808         }
1809
1810         if ((prop = node.property (X_("flags"))) != 0) {
1811                 _flags = Flag (string_2_enum (prop->value(), _flags));
1812         } else {
1813                 _flags = Flag (0);
1814         }
1815
1816         /* add all processors (except amp, which is always present) */
1817
1818         nlist = node.children();
1819         XMLNode processor_state (X_("processor_state"));
1820
1821         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1822
1823                 child = *niter;
1824
1825                 if (child->name() == IO::state_node_name) {
1826                         if ((prop = child->property (X_("direction"))) == 0) {
1827                                 continue;
1828                         }
1829
1830                         if (prop->value() == "Input") {
1831                                 _input->set_state (*child, version);
1832                         } else if (prop->value() == "Output") {
1833                                 _output->set_state (*child, version);
1834                         }
1835                 }
1836
1837                 if (child->name() == X_("Processor")) {
1838                         processor_state.add_child_copy (*child);
1839                 }
1840         }
1841
1842         set_processor_state (processor_state);
1843
1844         if ((prop = node.property ("self-solo")) != 0) {
1845                 set_self_solo (string_is_affirmative (prop->value()));
1846         }
1847
1848         if ((prop = node.property ("soloed-by-others")) != 0) {
1849                 _soloed_by_others = 0; // needed for mod_solo_by_others () to work
1850                 mod_solo_by_others (atoi (prop->value()));
1851         }
1852
1853         if ((prop = node.property ("solo-isolated")) != 0) {
1854                 set_solo_isolated (string_is_affirmative (prop->value()), this);
1855         }
1856
1857         if ((prop = node.property (X_("phase-invert"))) != 0) {
1858                 set_phase_invert (string_is_affirmative (prop->value()));
1859         }
1860
1861         if ((prop = node.property (X_("denormal-protection"))) != 0) {
1862                 set_denormal_protection (string_is_affirmative (prop->value()));
1863         }
1864
1865         if ((prop = node.property (X_("active"))) != 0) {
1866                 bool yn = string_is_affirmative (prop->value());
1867                 _active = !yn; // force switch
1868                 set_active (yn);
1869         }
1870
1871         if ((prop = node.property (X_("meter-point"))) != 0) {
1872                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
1873                 if (_meter) {
1874                         _meter->set_display_to_user (_meter_point == MeterCustom);
1875                 }
1876         }
1877
1878         if ((prop = node.property (X_("order-keys"))) != 0) {
1879
1880                 long n;
1881
1882                 string::size_type colon, equal;
1883                 string remaining = prop->value();
1884
1885                 while (remaining.length()) {
1886
1887                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
1888                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1889                                       << endmsg;
1890                         } else {
1891                                 if (sscanf (remaining.substr (equal+1).c_str(), "%ld", &n) != 1) {
1892                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1893                                               << endmsg;
1894                                 } else {
1895                                         set_order_key (remaining.substr (0, equal), n);
1896                                 }
1897                         }
1898
1899                         colon = remaining.find_first_of (':');
1900
1901                         if (colon != string::npos) {
1902                                 remaining = remaining.substr (colon+1);
1903                         } else {
1904                                 break;
1905                         }
1906                 }
1907         }
1908
1909         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1910                 child = *niter;
1911
1912                 if (child->name() == X_("Comment")) {
1913
1914                         /* XXX this is a terrible API design in libxml++ */
1915
1916                         XMLNode *cmt = *(child->children().begin());
1917                         _comment = cmt->content();
1918
1919                 } else if (child->name() == X_("Extra")) {
1920
1921                         _extra_xml = new XMLNode (*child);
1922
1923                 } else if (child->name() == X_("Controllable") && (prop = child->property("name")) != 0) {
1924
1925                         if (prop->value() == "solo") {
1926                                 _solo_control->set_state (*child, version);
1927                                 _session.add_controllable (_solo_control);
1928                         }
1929
1930                 } else if (child->name() == X_("RemoteControl")) {
1931                         if ((prop = child->property (X_("id"))) != 0) {
1932                                 int32_t x;
1933                                 sscanf (prop->value().c_str(), "%d", &x);
1934                                 set_remote_control_id (x);
1935                         }
1936
1937                 } else if (child->name() == X_("MuteMaster")) {
1938                         _mute_master->set_state (*child, version);
1939                 }
1940         }
1941
1942         return 0;
1943 }
1944
1945 int
1946 Route::_set_state_2X (const XMLNode& node, int version)
1947 {
1948         XMLNodeList nlist;
1949         XMLNodeConstIterator niter;
1950         XMLNode *child;
1951         XMLPropertyList plist;
1952         const XMLProperty *prop;
1953
1954         /* 2X things which still remain to be handled:
1955          * default-type
1956          * muted
1957          * mute-affects-pre-fader
1958          * mute-affects-post-fader
1959          * mute-affects-control-outs
1960          * mute-affects-main-outs
1961          * automation
1962          * controlouts
1963          */
1964
1965         if (node.name() != "Route") {
1966                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1967                 return -1;
1968         }
1969
1970         if ((prop = node.property (X_("flags"))) != 0) {
1971                 _flags = Flag (string_2_enum (prop->value(), _flags));
1972         } else {
1973                 _flags = Flag (0);
1974         }
1975
1976         /* add standard processors */
1977
1978         _meter.reset (new PeakMeter (_session));
1979         add_processor (_meter, PreFader);
1980
1981         if (_flags & ControlOut) {
1982                 /* where we listen to tracks */
1983                 _intreturn.reset (new InternalReturn (_session));
1984                 add_processor (_intreturn, PreFader);
1985         }
1986
1987         _main_outs.reset (new Delivery (_session, _output, _mute_master, _name, Delivery::Main));
1988         add_processor (_main_outs, PostFader);
1989
1990         /* IOs */
1991
1992         nlist = node.children ();
1993         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1994
1995                 child = *niter;
1996
1997                 if (child->name() == IO::state_node_name) {
1998
1999                         /* there is a note in IO::set_state_2X() about why we have to call
2000                            this directly.
2001                            */
2002
2003                         _input->set_state_2X (*child, version, true);
2004                         _output->set_state_2X (*child, version, false);
2005
2006                         if ((prop = child->property (X_("name"))) != 0) {
2007                                 set_name (prop->value ());
2008                         }
2009
2010                         if ((prop = child->property (X_("id"))) != 0) {
2011                                 _id = prop->value ();
2012                         }
2013
2014                         if ((prop = child->property (X_("active"))) != 0) {
2015                                 bool yn = string_is_affirmative (prop->value());
2016                                 _active = !yn; // force switch
2017                                 set_active (yn);
2018                         }
2019                 }
2020
2021                 /* XXX: panners? */
2022         }
2023
2024         if ((prop = node.property (X_("phase-invert"))) != 0) {
2025                 set_phase_invert (string_is_affirmative (prop->value()));
2026         }
2027
2028         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2029                 set_denormal_protection (string_is_affirmative (prop->value()));
2030         }
2031
2032         if ((prop = node.property (X_("soloed"))) != 0) {
2033                 bool yn = string_is_affirmative (prop->value());
2034
2035                 /* XXX force reset of solo status */
2036
2037                 set_solo (yn, this);
2038         }
2039
2040         if ((prop = node.property (X_("meter-point"))) != 0) {
2041                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2042         }
2043
2044         /* do not carry over edit/mix groups from 2.X because (a) its hard (b) they
2045            don't mean the same thing.
2046         */
2047
2048         if ((prop = node.property (X_("order-keys"))) != 0) {
2049
2050                 long n;
2051
2052                 string::size_type colon, equal;
2053                 string remaining = prop->value();
2054
2055                 while (remaining.length()) {
2056
2057                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2058                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2059                                         << endmsg;
2060                         } else {
2061                                 if (sscanf (remaining.substr (equal+1).c_str(), "%ld", &n) != 1) {
2062                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2063                                                 << endmsg;
2064                                 } else {
2065                                         set_order_key (remaining.substr (0, equal), n);
2066                                 }
2067                         }
2068
2069                         colon = remaining.find_first_of (':');
2070
2071                         if (colon != string::npos) {
2072                                 remaining = remaining.substr (colon+1);
2073                         } else {
2074                                 break;
2075                         }
2076                 }
2077         }
2078
2079         XMLNodeList redirect_nodes;
2080
2081         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2082
2083                 child = *niter;
2084
2085                 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2086                         redirect_nodes.push_back(child);
2087                 }
2088
2089         }
2090
2091         set_processor_state_2X (redirect_nodes, version);
2092
2093         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2094                 child = *niter;
2095
2096                 if (child->name() == X_("Comment")) {
2097
2098                         /* XXX this is a terrible API design in libxml++ */
2099
2100                         XMLNode *cmt = *(child->children().begin());
2101                         _comment = cmt->content();
2102
2103                 } else if (child->name() == X_("Extra")) {
2104
2105                         _extra_xml = new XMLNode (*child);
2106
2107                 } else if (child->name() == X_("Controllable") && (prop = child->property("name")) != 0) {
2108
2109                         if (prop->value() == "solo") {
2110                                 _solo_control->set_state (*child, version);
2111                                 _session.add_controllable (_solo_control);
2112                         }
2113
2114                 } else if (child->name() == X_("RemoteControl")) {
2115                         if ((prop = child->property (X_("id"))) != 0) {
2116                                 int32_t x;
2117                                 sscanf (prop->value().c_str(), "%d", &x);
2118                                 set_remote_control_id (x);
2119                         }
2120
2121                 }
2122         }
2123
2124         return 0;
2125 }
2126
2127 XMLNode&
2128 Route::get_processor_state ()
2129 {
2130         XMLNode* root = new XMLNode (X_("redirects"));
2131         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2132                 root->add_child_nocopy ((*i)->state (true));
2133         }
2134
2135         return *root;
2136 }
2137
2138 void
2139 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2140 {
2141         /* We don't bother removing existing processors not in nList, as this
2142            method will only be called when creating a Route from scratch, not
2143            for undo purposes.  Just put processors in at the appropriate place
2144            in the list.
2145         */
2146
2147         for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2148                 add_processor_from_xml_2X (**i, version, _processors.begin ());
2149         }
2150 }
2151
2152 void
2153 Route::set_processor_state (const XMLNode& node)
2154 {
2155         const XMLNodeList &nlist = node.children();
2156         XMLNodeConstIterator niter;
2157         ProcessorList::iterator i, o;
2158
2159         // Iterate through existing processors, remove those which are not in the state list
2160
2161         for (i = _processors.begin(); i != _processors.end(); ) {
2162
2163                 /* leave amp alone, always */
2164
2165                 if ((*i) == _amp) {
2166                         ++i;
2167                         continue;
2168                 }
2169
2170                 ProcessorList::iterator tmp = i;
2171                 ++tmp;
2172
2173                 bool processorInStateList = false;
2174
2175                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2176
2177                         XMLProperty* id_prop = (*niter)->property(X_("id"));
2178
2179                         if (id_prop && (*i)->id() == id_prop->value()) {
2180                                 processorInStateList = true;
2181                                 break;
2182                         }
2183                 }
2184
2185                 if (!processorInStateList) {
2186                         remove_processor (*i);
2187                 }
2188
2189                 i = tmp;
2190         }
2191
2192         // Iterate through state list and make sure all processors are on the track and in the correct order,
2193         // set the state of existing processors according to the new state on the same go
2194
2195         i = _processors.begin();
2196
2197         for (niter = nlist.begin(); niter != nlist.end(); ++niter, ++i) {
2198
2199                 XMLProperty* prop = (*niter)->property ("type");
2200
2201                 o = i;
2202
2203                 // Check whether the next processor in the list is the right one,
2204                 // except for "amp" which is always there and may not have the
2205                 // old ID since it is always created anew in every Route
2206
2207                 if (prop->value() != "amp") {
2208                         while (o != _processors.end()) {
2209                                 XMLProperty* id_prop = (*niter)->property(X_("id"));
2210                                 if (id_prop && (*o)->id() == id_prop->value()) {
2211                                         break;
2212                                 }
2213
2214                                 ++o;
2215                         }
2216                 }
2217
2218                 // If the processor (*niter) is not on the route,
2219                 // create it and move it to the correct location
2220
2221                 if (o == _processors.end()) {
2222
2223                         if (add_processor_from_xml (**niter, i)) {
2224                                 --i; // move iterator to the newly inserted processor
2225                         } else {
2226                                 cerr << "Error restoring route: unable to restore processor" << endl;
2227                         }
2228
2229                 } else {
2230
2231                         // Otherwise, the processor already exists; just
2232                         // ensure it is at the location provided in the XML state
2233
2234                         if (i != o) {
2235                                 boost::shared_ptr<Processor> tmp = (*o);
2236                                 _processors.erase (o); // remove the old copy
2237                                 _processors.insert (i, tmp); // insert the processor at the correct location
2238                                 --i; // move iterator to the correct processor
2239                         }
2240
2241                         // and make it (just) so
2242
2243                         (*i)->set_state (**niter, Stateful::current_state_version);
2244                 }
2245         }
2246
2247         /* note: there is no configure_processors() call because we figure that
2248            the XML state represents a working signal route.
2249         */
2250
2251         processors_changed (RouteProcessorChange ());
2252 }
2253
2254 void
2255 Route::curve_reallocate ()
2256 {
2257 //      _gain_automation_curve.finish_resize ();
2258 //      _pan_automation_curve.finish_resize ();
2259 }
2260
2261 void
2262 Route::silence (nframes_t nframes)
2263 {
2264         if (!_silent) {
2265
2266                 _output->silence (nframes);
2267
2268                 {
2269                         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2270
2271                         if (lm.locked()) {
2272                                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2273                                         boost::shared_ptr<PluginInsert> pi;
2274
2275                                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2276                                                 // skip plugins, they don't need anything when we're not active
2277                                                 continue;
2278                                         }
2279
2280                                         (*i)->silence (nframes);
2281                                 }
2282
2283                                 if (nframes == _session.get_block_size()) {
2284                                         // _silent = true;
2285                                 }
2286                         }
2287                 }
2288
2289         }
2290 }
2291
2292 void
2293 Route::add_internal_return ()
2294 {
2295         if (!_intreturn) {
2296                 _intreturn.reset (new InternalReturn (_session));
2297                 add_processor (_intreturn, PreFader);
2298         }
2299 }
2300
2301 BufferSet*
2302 Route::get_return_buffer () const
2303 {
2304         Glib::RWLock::ReaderLock rm (_processor_lock);
2305
2306         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2307                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2308
2309                 if (d) {
2310                         BufferSet* bs = d->get_buffers ();
2311                         return bs;
2312                 }
2313         }
2314
2315         return 0;
2316 }
2317
2318 void
2319 Route::release_return_buffer () const
2320 {
2321         Glib::RWLock::ReaderLock rm (_processor_lock);
2322
2323         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2324                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2325
2326                 if (d) {
2327                         return d->release_buffers ();
2328                 }
2329         }
2330 }
2331
2332 int
2333 Route::listen_via (boost::shared_ptr<Route> route, Placement placement, bool /*active*/, bool aux)
2334 {
2335         vector<string> ports;
2336         vector<string>::const_iterator i;
2337
2338         {
2339                 Glib::RWLock::ReaderLock rm (_processor_lock);
2340
2341                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2342
2343                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2344
2345                         if (d && d->target_route() == route) {
2346
2347                                 /* if the target is the control outs, then make sure
2348                                    we take note of which i-send is doing that.
2349                                 */
2350
2351                                 if (route == _session.control_out()) {
2352                                         _control_outs = boost::dynamic_pointer_cast<Delivery>(d);
2353                                 }
2354
2355                                 /* already listening via the specified IO: do nothing */
2356
2357                                 return 0;
2358                         }
2359                 }
2360         }
2361
2362         boost::shared_ptr<InternalSend> listener;
2363
2364         try {
2365                 listener.reset (new InternalSend (_session, _mute_master, route, (aux ? Delivery::Aux : Delivery::Listen)));
2366
2367         } catch (failed_constructor& err) {
2368                 return -1;
2369         }
2370
2371         if (route == _session.control_out()) {
2372                 _control_outs = listener;
2373         }
2374
2375         add_processor (listener, placement);
2376
2377         return 0;
2378 }
2379
2380 void
2381 Route::drop_listen (boost::shared_ptr<Route> route)
2382 {
2383         ProcessorStreams err;
2384         ProcessorList::iterator tmp;
2385
2386         Glib::RWLock::ReaderLock rl(_processor_lock);
2387         rl.acquire ();
2388
2389   again:
2390         for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ) {
2391
2392                 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2393
2394                 if (d && d->target_route() == route) {
2395                         rl.release ();
2396                         remove_processor (*x, &err);
2397                         rl.acquire ();
2398
2399                         /* list could have been demolished while we dropped the lock
2400                            so start over.
2401                         */
2402
2403                         goto again;
2404                 }
2405         }
2406
2407         rl.release ();
2408
2409         if (route == _session.control_out()) {
2410                 _control_outs.reset ();
2411         }
2412 }
2413
2414 void
2415 Route::set_comment (string cmt, void *src)
2416 {
2417         _comment = cmt;
2418         comment_changed (src);
2419         _session.set_dirty ();
2420 }
2421
2422 bool
2423 Route::feeds (boost::shared_ptr<Route> other, bool* only_send)
2424 {
2425         DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
2426
2427         if (_output->connected_to (other->input())) {
2428                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
2429                 if (only_send) {
2430                         *only_send = false;
2431                 }
2432
2433                 return true;
2434         }
2435
2436
2437         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
2438
2439                 boost::shared_ptr<IOProcessor> iop;
2440
2441                 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
2442                         if (iop->feeds (other)) {
2443                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
2444                                 if (only_send) {
2445                                         *only_send = true;
2446                                 }
2447                                 return true;
2448                         } else {
2449                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
2450                         }
2451                 } else {
2452                         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
2453                 }
2454
2455         }
2456
2457         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tdoes NOT feed %1\n", other->name()));
2458         return false;
2459 }
2460
2461 void
2462 Route::handle_transport_stopped (bool /*abort_ignored*/, bool did_locate, bool can_flush_processors)
2463 {
2464         nframes_t now = _session.transport_frame();
2465
2466         {
2467                 Glib::RWLock::ReaderLock lm (_processor_lock);
2468
2469                 if (!did_locate) {
2470                         automation_snapshot (now, true);
2471                 }
2472
2473                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2474
2475                         if (Config->get_plugins_stop_with_transport() && can_flush_processors) {
2476                                 (*i)->deactivate ();
2477                                 (*i)->activate ();
2478                         }
2479
2480                         (*i)->transport_stopped (now);
2481                 }
2482         }
2483
2484         _roll_delay = _initial_delay;
2485 }
2486
2487 void
2488 Route::input_change_handler (IOChange change, void * /*src*/)
2489 {
2490         if ((change & ConfigurationChanged)) {
2491                 configure_processors (0);
2492         }
2493 }
2494
2495 void
2496 Route::output_change_handler (IOChange change, void * /*src*/)
2497 {
2498         if ((change & ConfigurationChanged)) {
2499
2500                 /* XXX resize all listeners to match _main_outs? */
2501
2502                 // configure_processors (0);
2503         }
2504 }
2505
2506 uint32_t
2507 Route::pans_required () const
2508 {
2509         if (n_outputs().n_audio() < 2) {
2510                 return 0;
2511         }
2512
2513         return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
2514 }
2515
2516 int
2517 Route::no_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
2518                 bool session_state_changing, bool /*can_record*/, bool /*rec_monitors_input*/)
2519 {
2520         if (n_outputs().n_total() == 0) {
2521                 return 0;
2522         }
2523
2524         if (!_active || n_inputs() == ChanCount::ZERO)  {
2525                 silence (nframes);
2526                 return 0;
2527         }
2528         if (session_state_changing) {
2529                 if (_session.transport_speed() != 0.0f) {
2530                         /* we're rolling but some state is changing (e.g. our diskstream contents)
2531                            so we cannot use them. Be silent till this is over.
2532
2533                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
2534                         */
2535                         silence (nframes);
2536                         return 0;
2537                 }
2538                 /* we're really not rolling, so we're either delivery silence or actually
2539                    monitoring, both of which are safe to do while session_state_changing is true.
2540                 */
2541         }
2542
2543         _amp->apply_gain_automation (false);
2544         passthru (start_frame, end_frame, nframes, 0);
2545
2546         return 0;
2547 }
2548
2549 nframes_t
2550 Route::check_initial_delay (nframes_t nframes, nframes_t& transport_frame)
2551 {
2552         if (_roll_delay > nframes) {
2553
2554                 _roll_delay -= nframes;
2555                 silence (nframes);
2556                 /* transport frame is not legal for caller to use */
2557                 return 0;
2558
2559         } else if (_roll_delay > 0) {
2560
2561                 nframes -= _roll_delay;
2562                 silence (_roll_delay);
2563                 /* we've written _roll_delay of samples into the
2564                    output ports, so make a note of that for
2565                    future reference.
2566                 */
2567                 _main_outs->increment_output_offset (_roll_delay);
2568                 transport_frame += _roll_delay;
2569
2570                 _roll_delay = 0;
2571         }
2572
2573         return nframes;
2574 }
2575
2576 int
2577 Route::roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame, int declick,
2578              bool /*can_record*/, bool /*rec_monitors_input*/)
2579 {
2580         {
2581                 // automation snapshot can also be called from the non-rt context
2582                 // and it uses the processor list, so we try to acquire the lock here
2583                 Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2584
2585                 if (lm.locked()) {
2586                         automation_snapshot (_session.transport_frame(), false);
2587                 }
2588         }
2589
2590         if (n_outputs().n_total() == 0) {
2591                 return 0;
2592         }
2593
2594         if (!_active || n_inputs().n_total() == 0) {
2595                 silence (nframes);
2596                 return 0;
2597         }
2598
2599         nframes_t unused = 0;
2600
2601         if ((nframes = check_initial_delay (nframes, unused)) == 0) {
2602                 return 0;
2603         }
2604
2605         _silent = false;
2606
2607         passthru (start_frame, end_frame, nframes, declick);
2608
2609         return 0;
2610 }
2611
2612 int
2613 Route::silent_roll (nframes_t nframes, sframes_t /*start_frame*/, sframes_t /*end_frame*/,
2614                     bool /*can_record*/, bool /*rec_monitors_input*/)
2615 {
2616         silence (nframes);
2617         return 0;
2618 }
2619
2620 void
2621 Route::toggle_monitor_input ()
2622 {
2623         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
2624                 i->ensure_monitor_input( ! i->monitoring_input());
2625         }
2626 }
2627
2628 bool
2629 Route::has_external_redirects () const
2630 {
2631         // FIXME: what about sends? - they don't return a signal back to ardour?
2632
2633         boost::shared_ptr<const PortInsert> pi;
2634
2635         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2636
2637                 if ((pi = boost::dynamic_pointer_cast<const PortInsert>(*i)) != 0) {
2638
2639                         for (PortSet::const_iterator port = pi->output()->ports().begin(); port != pi->output()->ports().end(); ++port) {
2640
2641                                 string port_name = port->name();
2642                                 string client_name = port_name.substr (0, port_name.find(':'));
2643
2644                                 /* only say "yes" if the redirect is actually in use */
2645
2646                                 if (client_name != "ardour" && pi->active()) {
2647                                         return true;
2648                                 }
2649                         }
2650                 }
2651         }
2652
2653         return false;
2654 }
2655
2656 void
2657 Route::flush_processors ()
2658 {
2659         /* XXX shouldn't really try to take this lock, since
2660            this is called from the RT audio thread.
2661         */
2662
2663         Glib::RWLock::ReaderLock lm (_processor_lock);
2664
2665         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2666                 (*i)->deactivate ();
2667                 (*i)->activate ();
2668         }
2669 }
2670
2671 void
2672 Route::set_meter_point (MeterPoint p, void *src)
2673 {
2674         /* CAN BE CALLED FROM PROCESS CONTEXT */
2675
2676         if (_meter_point == p) {
2677                 return;
2678         }
2679
2680         bool meter_was_visible_to_user = _meter->display_to_user ();
2681
2682         {
2683                 Glib::RWLock::WriterLock lm (_processor_lock);
2684
2685                 if (p != MeterCustom) {
2686                         // Move meter in the processors list to reflect the new position
2687                         ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
2688                         _processors.erase(loc);
2689                         switch (p) {
2690                         case MeterInput:
2691                                 loc = _processors.begin();
2692                                 break;
2693                         case MeterPreFader:
2694                                 loc = find (_processors.begin(), _processors.end(), _amp);
2695                                 break;
2696                         case MeterPostFader:
2697                                 loc = _processors.end();
2698                                 break;
2699                         default:
2700                                 break;
2701                         }
2702
2703                         ChanCount m_in;
2704
2705                         if (loc == _processors.begin()) {
2706                                 m_in = _input->n_ports();
2707                         } else {
2708                                 ProcessorList::iterator before = loc;
2709                                 --before;
2710                                 m_in = (*before)->output_streams ();
2711                         }
2712
2713                         _meter->reflect_inputs (m_in);
2714
2715                         _processors.insert (loc, _meter);
2716
2717                         /* we do not need to reconfigure the processors, because the meter
2718                            (a) is always ready to handle processor_max_streams
2719                            (b) is always an N-in/N-out processor, and thus moving
2720                            it doesn't require any changes to the other processors.
2721                         */
2722
2723                         _meter->set_display_to_user (false);
2724
2725                 } else {
2726
2727                         // just make it visible and let the user move it
2728
2729                         _meter->set_display_to_user (true);
2730                 }
2731         }
2732
2733         _meter_point = p;
2734         meter_change (src); /* EMIT SIGNAL */
2735
2736         bool const meter_visibly_changed = (_meter->display_to_user() != meter_was_visible_to_user);
2737
2738         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
2739 }
2740
2741 void
2742 Route::put_control_outs_at (Placement p)
2743 {
2744         if (!_control_outs) {
2745                 return;
2746         }
2747
2748         {
2749                 Glib::RWLock::WriterLock lm (_processor_lock);
2750                 ProcessorList as_it_was (_processors);
2751                 // Move meter in the processors list
2752                 ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), _control_outs);
2753                 _processors.erase(loc);
2754
2755                 switch (p) {
2756                 case PreFader:
2757                         loc = find(_processors.begin(), _processors.end(), _amp);
2758                         if (loc != _processors.begin()) {
2759                                 --loc;
2760                         }
2761                         break;
2762                 case PostFader:
2763                         loc = find(_processors.begin(), _processors.end(), _amp);
2764                         assert (loc != _processors.end());
2765                         loc++;
2766                         break;
2767                 }
2768
2769                 _processors.insert(loc, _control_outs);
2770
2771                 if (configure_processors_unlocked (0)) {
2772                         _processors = as_it_was;
2773                         configure_processors_unlocked (0); // it worked before we tried to add it ...
2774                         return;
2775                 }
2776         }
2777
2778         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2779         _session.set_dirty ();
2780 }
2781
2782 nframes_t
2783 Route::update_total_latency ()
2784 {
2785         nframes_t old = _output->effective_latency();
2786         nframes_t own_latency = _output->user_latency();
2787
2788         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2789                 if ((*i)->active ()) {
2790                         own_latency += (*i)->signal_latency ();
2791                 }
2792         }
2793
2794         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal redirect latency = %2\n", _name, own_latency));
2795
2796         _output->set_port_latency (own_latency);
2797
2798         if (_output->user_latency() == 0) {
2799
2800                 /* this (virtual) function is used for pure Routes,
2801                    not derived classes like AudioTrack.  this means
2802                    that the data processed here comes from an input
2803                    port, not prerecorded material, and therefore we
2804                    have to take into account any input latency.
2805                 */
2806
2807                 own_latency += _input->signal_latency ();
2808         }
2809
2810         if (old != own_latency) {
2811                 _output->set_latency_delay (own_latency);
2812                 signal_latency_changed (); /* EMIT SIGNAL */
2813         }
2814
2815         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: input latency = %2 total = %3\n", _name, _input->signal_latency(), own_latency));
2816
2817         return _output->effective_latency ();
2818 }
2819
2820 void
2821 Route::set_user_latency (nframes_t nframes)
2822 {
2823         _output->set_user_latency (nframes);
2824         _session.update_latency_compensation (false, false);
2825 }
2826
2827 void
2828 Route::set_latency_delay (nframes_t longest_session_latency)
2829 {
2830         nframes_t old = _initial_delay;
2831
2832         if (_output->effective_latency() < longest_session_latency) {
2833                 _initial_delay = longest_session_latency - _output->effective_latency();
2834         } else {
2835                 _initial_delay = 0;
2836         }
2837
2838         if (_initial_delay != old) {
2839                 initial_delay_changed (); /* EMIT SIGNAL */
2840         }
2841
2842         if (_session.transport_stopped()) {
2843                 _roll_delay = _initial_delay;
2844         }
2845 }
2846
2847 void
2848 Route::automation_snapshot (nframes_t now, bool force)
2849 {
2850         panner()->automation_snapshot (now, force);
2851
2852         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2853                 (*i)->automation_snapshot (now, force);
2854         }
2855 }
2856
2857 Route::SoloControllable::SoloControllable (std::string name, Route& r)
2858         : AutomationControl (r.session(), Evoral::Parameter (SoloAutomation),
2859                              boost::shared_ptr<AutomationList>(), name)
2860         , route (r)
2861 {
2862         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
2863         set_list (gl);
2864 }
2865
2866 void
2867 Route::SoloControllable::set_value (float val)
2868 {
2869         bool bval = ((val >= 0.5f) ? true: false);
2870 # if 0
2871         this is how it should be done
2872
2873         boost::shared_ptr<RouteList> rl (new RouteList);
2874         rl->push_back (route);
2875
2876         if (Config->get_solo_control_is_listen_control()) {
2877                 _session.set_listen (rl, bval);
2878         } else {
2879                 _session.set_solo (rl, bval);
2880         }
2881 #else
2882         route.set_solo (bval, this);
2883 #endif
2884 }
2885
2886 float
2887 Route::SoloControllable::get_value (void) const
2888 {
2889         if (Config->get_solo_control_is_listen_control()) {
2890                 return route.listening() ? 1.0f : 0.0f;
2891         } else {
2892                 return route.self_soloed() ? 1.0f : 0.0f;
2893         }
2894 }
2895
2896 Route::MuteControllable::MuteControllable (std::string name, Route& r)
2897         : AutomationControl (r.session(), Evoral::Parameter (MuteAutomation),
2898                              boost::shared_ptr<AutomationList>(), name)
2899         , route (r)
2900 {
2901         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MuteAutomation)));
2902         set_list (gl);
2903 }
2904
2905 void
2906 Route::MuteControllable::set_value (float val)
2907 {
2908         bool bval = ((val >= 0.5f) ? true: false);
2909 # if 0
2910         this is how it should be done
2911
2912         boost::shared_ptr<RouteList> rl (new RouteList);
2913         rl->push_back (route);
2914         _session.set_mute (rl, bval);
2915 #else
2916         route.set_mute (bval, this);
2917 #endif
2918 }
2919
2920 float
2921 Route::MuteControllable::get_value (void) const
2922 {
2923         return route.muted() ? 1.0f : 0.0f;
2924 }
2925
2926 void
2927 Route::set_block_size (nframes_t nframes)
2928 {
2929         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2930                 (*i)->set_block_size (nframes);
2931         }
2932
2933         _session.ensure_buffers (n_process_buffers ());
2934 }
2935
2936 void
2937 Route::protect_automation ()
2938 {
2939         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
2940                 (*i)->protect_automation();
2941 }
2942
2943 void
2944 Route::set_pending_declick (int declick)
2945 {
2946         if (_declickable) {
2947                 /* this call is not allowed to turn off a pending declick unless "force" is true */
2948                 if (declick) {
2949                         _pending_declick = declick;
2950                 }
2951                 // cerr << _name << ": after setting to " << declick << " pending declick = " << _pending_declick << endl;
2952         } else {
2953                 _pending_declick = 0;
2954         }
2955
2956 }
2957
2958 /** Shift automation forwards from a particular place, thereby inserting time.
2959  *  Adds undo commands for any shifts that are performed.
2960  *
2961  * @param pos Position to start shifting from.
2962  * @param frames Amount to shift forwards by.
2963  */
2964
2965 void
2966 Route::shift (nframes64_t /*pos*/, nframes64_t /*frames*/)
2967 {
2968 #ifdef THIS_NEEDS_FIXING_FOR_V3
2969
2970         /* gain automation */
2971         XMLNode &before = _gain_control->get_state ();
2972         _gain_control->shift (pos, frames);
2973         XMLNode &after = _gain_control->get_state ();
2974         _session.add_command (new MementoCommand<AutomationList> (_gain_automation_curve, &before, &after));
2975
2976         /* pan automation */
2977         for (std::vector<StreamPanner*>::iterator i = _panner->begin (); i != _panner->end (); ++i) {
2978                 Curve & c = (*i)->automation ();
2979                 XMLNode &before = c.get_state ();
2980                 c.shift (pos, frames);
2981                 XMLNode &after = c.get_state ();
2982                 _session.add_command (new MementoCommand<AutomationList> (c, &before, &after));
2983         }
2984
2985         /* redirect automation */
2986         {
2987                 Glib::RWLock::ReaderLock lm (redirect_lock);
2988                 for (RedirectList::iterator i = _redirects.begin (); i != _redirects.end (); ++i) {
2989
2990                         set<uint32_t> a;
2991                         (*i)->what_has_automation (a);
2992
2993                         for (set<uint32_t>::const_iterator j = a.begin (); j != a.end (); ++j) {
2994                                 AutomationList & al = (*i)->automation_list (*j);
2995                                 XMLNode &before = al.get_state ();
2996                                 al.shift (pos, frames);
2997                                 XMLNode &after = al.get_state ();
2998                                 _session.add_command (new MementoCommand<AutomationList> (al, &before, &after));
2999                         }
3000                 }
3001         }
3002 #endif
3003
3004 }
3005
3006
3007 int
3008 Route::save_as_template (const string& path, const string& name)
3009 {
3010         XMLNode& node (state (false));
3011         XMLTree tree;
3012
3013         IO::set_name_in_state (*node.children().front(), name);
3014
3015         tree.set_root (&node);
3016         return tree.write (path.c_str());
3017 }
3018
3019
3020 bool
3021 Route::set_name (const string& str)
3022 {
3023         bool ret;
3024         string ioproc_name;
3025         string name;
3026
3027         name = Route::ensure_track_or_route_name (str, _session);
3028         SessionObject::set_name (name);
3029
3030         ret = (_input->set_name(name) && _output->set_name(name));
3031
3032         if (ret) {
3033
3034                 Glib::RWLock::ReaderLock lm (_processor_lock);
3035
3036                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3037
3038                         /* rename all I/O processors that have inputs or outputs */
3039
3040                         boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
3041
3042                         if (iop && (iop->output() || iop->input())) {
3043                                 if (!iop->set_name (name)) {
3044                                         ret = false;
3045                                 }
3046                         }
3047                 }
3048
3049         }
3050
3051         return ret;
3052 }
3053
3054 boost::shared_ptr<Send>
3055 Route::internal_send_for (boost::shared_ptr<const Route> target) const
3056 {
3057         Glib::RWLock::ReaderLock lm (_processor_lock);
3058
3059         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3060                 boost::shared_ptr<InternalSend> send;
3061
3062                 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
3063                         if (send->target_route() == target) {
3064                                 return send;
3065                         }
3066                 }
3067         }
3068
3069         return boost::shared_ptr<Send>();
3070 }
3071
3072 void
3073 Route::set_phase_invert (bool yn)
3074 {
3075         if (_phase_invert != yn) {
3076                 _phase_invert = 0xffff; // XXX all channels
3077                 phase_invert_changed (); /* EMIT SIGNAL */
3078         }
3079 }
3080
3081 bool
3082 Route::phase_invert () const
3083 {
3084         return _phase_invert != 0;
3085 }
3086
3087 void
3088 Route::set_denormal_protection (bool yn)
3089 {
3090         if (_denormal_protection != yn) {
3091                 _denormal_protection = yn;
3092                 denormal_protection_changed (); /* EMIT SIGNAL */
3093         }
3094 }
3095
3096 bool
3097 Route::denormal_protection () const
3098 {
3099         return _denormal_protection;
3100 }
3101
3102 void
3103 Route::set_active (bool yn)
3104 {
3105         if (_active != yn) {
3106                 _active = yn;
3107                 _input->set_active (yn);
3108                 _output->set_active (yn);
3109                 active_changed (); // EMIT SIGNAL
3110         }
3111 }
3112
3113 void
3114 Route::meter ()
3115 {
3116         Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3117
3118         assert (_meter);
3119
3120         _meter->meter ();
3121
3122         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3123
3124                 boost::shared_ptr<Send> s;
3125                 boost::shared_ptr<Return> r;
3126
3127                 if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
3128                         s->meter()->meter();
3129                 } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
3130                         r->meter()->meter ();
3131                 }
3132         }
3133 }
3134
3135 boost::shared_ptr<Panner>
3136 Route::panner() const
3137 {
3138         return _main_outs->panner();
3139 }
3140
3141 boost::shared_ptr<AutomationControl>
3142 Route::gain_control() const
3143 {
3144         return _amp->gain_control();
3145 }
3146
3147 boost::shared_ptr<AutomationControl>
3148 Route::get_control (const Evoral::Parameter& param)
3149 {
3150         /* either we own the control or .... */
3151
3152         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
3153
3154         if (!c) {
3155
3156                 /* maybe one of our processors does or ... */
3157
3158                 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3159                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3160                         if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
3161                                 break;
3162                         }
3163                 }
3164         }
3165
3166         if (!c) {
3167
3168                 /* nobody does so we'll make a new one */
3169
3170                 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
3171                 add_control(c);
3172         }
3173
3174         return c;
3175 }
3176
3177 boost::shared_ptr<Processor>
3178 Route::nth_plugin (uint32_t n)
3179 {
3180         Glib::RWLock::ReaderLock lm (_processor_lock);
3181         ProcessorList::iterator i;
3182
3183         for (i = _processors.begin(); i != _processors.end(); ++i) {
3184                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
3185                         if (n-- == 0) {
3186                                 return *i;
3187                         }
3188                 }
3189         }
3190
3191         return boost::shared_ptr<Processor> ();
3192 }
3193
3194 boost::shared_ptr<Processor>
3195 Route::nth_send (uint32_t n)
3196 {
3197         Glib::RWLock::ReaderLock lm (_processor_lock);
3198         ProcessorList::iterator i;
3199
3200         for (i = _processors.begin(); i != _processors.end(); ++i) {
3201                 cerr << "check " << (*i)->name() << endl;
3202                 if (boost::dynamic_pointer_cast<Send> (*i)) {
3203                         if (n-- == 0) {
3204                                 return *i;
3205                         }
3206                 } else {
3207                         cerr << "\tnot a send\n";
3208                 }
3209         }
3210
3211         return boost::shared_ptr<Processor> ();
3212 }