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 <sigc++/bind.h>
  26 #include "pbd/xml++.h"
  27 #include "pbd/enumwriter.h"
  28 #include "pbd/stacktrace.h"
  29 #include "pbd/memento_command.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/delivery.h"
  41 #include "ardour/dB.h"
  42 #include "ardour/internal_send.h"
  43 #include "ardour/internal_return.h"
  44 #include "ardour/ladspa_plugin.h"
  45 #include "ardour/meter.h"
  46 #include "ardour/mix.h"
  47 #include "ardour/panner.h"
  48 #include "ardour/plugin_insert.h"
  49 #include "ardour/port.h"
  50 #include "ardour/port_insert.h"
  51 #include "ardour/processor.h"
  52 #include "ardour/profile.h"
  53 #include "ardour/route.h"
  54 #include "ardour/route_group.h"
  55 #include "ardour/send.h"
  56 #include "ardour/session.h"
  57 #include "ardour/timestamps.h"
  58 #include "ardour/utils.h"
  59
  60 #include "i18n.h"
  61
  62 using namespace std;
  63 using namespace ARDOUR;
  64 using namespace PBD;
  65
  66 uint32_t Route::order_key_cnt = 0;
  67 sigc::signal<void, string const &> Route::SyncOrderKeys;
  68
  69 Route::Route (Session& sess, string name, Flag flg, DataType default_type)
  70         : SessionObject (sess, name)
  71         , AutomatableControls (sess)
  72         , _flags (flg)
  73         , _solo_control (new SoloControllable (X_("solo"), *this))
  74         , _mute_master (new MuteMaster (sess, name))
  75         , _default_type (default_type)
  76
  77 {
  78         init ();
  79
  80         /* add standard processors other than amp (added by ::init()) */
  81
  82         _meter.reset (new PeakMeter (_session));
  83         add_processor (_meter, PreFader);
  84
  85         if (_flags & ControlOut) {
  86                 /* where we listen to tracks */
  87                 _intreturn.reset (new InternalReturn (_session));
  88                 add_processor (_intreturn, PreFader);
  89         }
  90
  91         _main_outs.reset (new Delivery (_session, _output, _mute_master, _name, Delivery::Main));
  92         add_processor (_main_outs, PostFader);
  93
  94         /* now that we have _meter, its safe to connect to this */
  95
  96         _meter_connection = Metering::connect (mem_fun (*this, &Route::meter));
  97 }
  98
  99 Route::Route (Session& sess, const XMLNode& node, DataType default_type)
 100         : SessionObject (sess, "toBeReset")
 101         , AutomatableControls (sess)
 102         , _solo_control (new SoloControllable (X_("solo"), *this))
 103         , _mute_master (new MuteMaster (sess, "toBeReset"))
 104         , _default_type (default_type)
 105 {
 106         init ();
 107
 108         _set_state (node, false);
 109
 110         /* now that we have _meter, its safe to connect to this */
 111
 112         _meter_connection = Metering::connect (mem_fun (*this, &Route::meter));
 113 }
 114
 115 void
 116 Route::init ()
 117 {
 118         _solo_level = 0;
 119         _solo_isolated = false;
 120         _active = true;
 121         processor_max_streams.reset();
 122         _solo_safe = false;
 123         _recordable = true;
 124         order_keys[N_("signal")] = order_key_cnt++;
 125         _silent = false;
 126         _meter_point = MeterPostFader;
 127         _initial_delay = 0;
 128         _roll_delay = 0;
 129         _have_internal_generator = false;
 130         _declickable = false;
 131         _pending_declick = true;
 132         _remote_control_id = 0;
 133         _in_configure_processors = false;
 134
 135         _route_group = 0;
 136
 137         _phase_invert = 0;
 138         _denormal_protection = false;
 139
 140         /* add standard controls */
 141
 142         add_control (_solo_control);
 143         add_control (_mute_master);
 144
 145         /* input and output objects */
 146
 147         _input.reset (new IO (_session, _name, IO::Input, _default_type));
 148         _output.reset (new IO (_session, _name, IO::Output, _default_type));
 149
 150         _input->changed.connect (mem_fun (this, &Route::input_change_handler));
 151         _output->changed.connect (mem_fun (this, &Route::output_change_handler));
 152
 153         /* add amp processor  */
 154
 155         _amp.reset (new Amp (_session, _mute_master));
 156         add_processor (_amp, PostFader);
 157 }
 158
 159 Route::~Route ()
 160 {
 161         Metering::disconnect (_meter_connection);
 162
 163         clear_processors (PreFader);
 164         clear_processors (PostFader);
 165 }
 166
 167 void
 168 Route::set_remote_control_id (uint32_t id)
 169 {
 170         if (id != _remote_control_id) {
 171                 _remote_control_id = id;
 172                 RemoteControlIDChanged ();
 173         }
 174 }
 175
 176 uint32_t
 177 Route::remote_control_id() const
 178 {
 179         return _remote_control_id;
 180 }
 181
 182 long
 183 Route::order_key (std::string const & name) const
 184 {
 185         OrderKeys::const_iterator i = order_keys.find (name);
 186         if (i == order_keys.end()) {
 187                 return -1;
 188         }
 189
 190         return i->second;
 191 }
 192
 193 void
 194 Route::set_order_key (std::string const & name, long n)
 195 {
 196         order_keys[name] = n;
 197
 198         if (Config->get_sync_all_route_ordering()) {
 199                 for (OrderKeys::iterator x = order_keys.begin(); x != order_keys.end(); ++x) {
 200                         x->second = n;
 201                 }
 202         }
 203
 204         _session.set_dirty ();
 205 }
 206
 207 /** Set all order keys to be the same as that for `base', if such a key
 208  *  exists in this route.
 209  *  @param base Base key.
 210  */
 211 void
 212 Route::sync_order_keys (std::string const & base)
 213 {
 214         if (order_keys.empty()) {
 215                 return;
 216         }
 217
 218         OrderKeys::iterator i;
 219         uint32_t key;
 220
 221         if ((i = order_keys.find (base)) == order_keys.end()) {
 222                 /* key doesn't exist, use the first existing key (during session initialization) */
 223                 i = order_keys.begin();
 224                 key = i->second;
 225                 ++i;
 226         } else {
 227                 /* key exists - use it and reset all others (actually, itself included) */
 228                 key = i->second;
 229                 i = order_keys.begin();
 230         }
 231
 232         for (; i != order_keys.end(); ++i) {
 233                 i->second = key;
 234         }
 235 }
 236
 237 string
 238 Route::ensure_track_or_route_name(string name, Session &session)
 239 {
 240         string newname = name;
 241
 242         while (session.route_by_name (newname) != NULL) {
 243                 newname = bump_name_once (newname);
 244         }
 245
 246         return newname;
 247 }
 248
 249
 250 void
 251 Route::inc_gain (gain_t fraction, void *src)
 252 {
 253         _amp->inc_gain (fraction, src);
 254 }
 255
 256 void
 257 Route::set_gain (gain_t val, void *src)
 258 {
 259         if (src != 0 && _route_group && src != _route_group && _route_group->active_property (RouteGroup::Gain)) {
 260
 261                 if (_route_group->is_relative()) {
 262
 263                         gain_t usable_gain = _amp->gain();
 264                         if (usable_gain < 0.000001f) {
 265                                 usable_gain = 0.000001f;
 266                         }
 267
 268                         gain_t delta = val;
 269                         if (delta < 0.000001f) {
 270                                 delta = 0.000001f;
 271                         }
 272
 273                         delta -= usable_gain;
 274
 275                         if (delta == 0.0f)
 276                                 return;
 277
 278                         gain_t factor = delta / usable_gain;
 279
 280                         if (factor > 0.0f) {
 281                                 factor = _route_group->get_max_factor(factor);
 282                                 if (factor == 0.0f) {
 283                                         _amp->gain_control()->Changed(); /* EMIT SIGNAL */
 284                                         return;
 285                                 }
 286                         } else {
 287                                 factor = _route_group->get_min_factor(factor);
 288                                 if (factor == 0.0f) {
 289                                         _amp->gain_control()->Changed(); /* EMIT SIGNAL */
 290                                         return;
 291                                 }
 292                         }
 293
 294                         _route_group->apply (&Route::inc_gain, factor, _route_group);
 295
 296                 } else {
 297
 298                         _route_group->apply (&Route::set_gain, val, _route_group);
 299                 }
 300
 301                 return;
 302         }
 303
 304         if (val == _amp->gain()) {
 305                 return;
 306         }
 307
 308         _amp->set_gain (val, src);
 309 }
 310
 311 /** Process this route for one (sub) cycle (process thread)
 312  *
 313  * @param bufs Scratch buffers to use for the signal path
 314  * @param start_frame Initial transport frame
 315  * @param end_frame Final transport frame
 316  * @param nframes Number of frames to output (to ports)
 317  *
 318  * Note that (end_frame - start_frame) may not be equal to nframes when the
 319  * transport speed isn't 1.0 (eg varispeed).
 320  */
 321 void
 322 Route::process_output_buffers (BufferSet& bufs,
 323                                sframes_t start_frame, sframes_t end_frame, nframes_t nframes,
 324                                bool with_processors, int declick)
 325 {
 326         bool monitor;
 327
 328         bufs.is_silent (false);
 329
 330         switch (Config->get_monitoring_model()) {
 331         case HardwareMonitoring:
 332         case ExternalMonitoring:
 333                 monitor = !record_enabled() || (_session.config.get_auto_input() && !_session.actively_recording());
 334                 break;
 335         default:
 336                 monitor = true;
 337         }
 338
 339         if (!declick) {
 340                 declick = _pending_declick;
 341         }
 342
 343         /* figure out if we're going to use gain automation */
 344         _amp->setup_gain_automation (start_frame, end_frame, nframes);
 345
 346
 347         /* tell main outs what to do about monitoring */
 348         _main_outs->no_outs_cuz_we_no_monitor (!monitor);
 349
 350
 351         /* -------------------------------------------------------------------------------------------
 352            GLOBAL DECLICK (for transport changes etc.)
 353            ----------------------------------------------------------------------------------------- */
 354
 355         if (declick > 0) {
 356                 Amp::apply_gain (bufs, nframes, 0.0, 1.0);
 357         } else if (declick < 0) {
 358                 Amp::apply_gain (bufs, nframes, 1.0, 0.0);
 359         }
 360
 361         _pending_declick = 0;
 362
 363         /* -------------------------------------------------------------------------------------------
 364            DENORMAL CONTROL/PHASE INVERT
 365            ----------------------------------------------------------------------------------------- */
 366
 367         if (_phase_invert) {
 368
 369                 int chn = 0;
 370
 371                 if (_denormal_protection || Config->get_denormal_protection()) {
 372
 373                         for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
 374                                 Sample* const sp = i->data();
 375
 376                                 if (_phase_invert & chn) {
 377                                         for (nframes_t nx = 0; nx < nframes; ++nx) {
 378                                                 sp[nx]  = -sp[nx];
 379                                                 sp[nx] += 1.0e-27f;
 380                                         }
 381                                 } else {
 382                                         for (nframes_t nx = 0; nx < nframes; ++nx) {
 383                                                 sp[nx] += 1.0e-27f;
 384                                         }
 385                                 }
 386                         }
 387
 388                 } else {
 389
 390                         for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
 391                                 Sample* const sp = i->data();
 392
 393                                 if (_phase_invert & chn) {
 394                                         for (nframes_t nx = 0; nx < nframes; ++nx) {
 395                                                 sp[nx] = -sp[nx];
 396                                         }
 397                                 }
 398                         }
 399                 }
 400
 401         } else {
 402
 403                 if (_denormal_protection || Config->get_denormal_protection()) {
 404
 405                         for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
 406                                 Sample* const sp = i->data();
 407                                 for (nframes_t nx = 0; nx < nframes; ++nx) {
 408                                         sp[nx] += 1.0e-27f;
 409                                 }
 410                         }
 411
 412                 }
 413         }
 414
 415         /* -------------------------------------------------------------------------------------------
 416            and go ....
 417            ----------------------------------------------------------------------------------------- */
 418
 419         Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
 420
 421         if (rm.locked()) {
 422                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 423                         bufs.set_count (ChanCount::max(bufs.count(), (*i)->input_streams()));
 424                         (*i)->run (bufs, start_frame, end_frame, nframes);
 425                         bufs.set_count (ChanCount::max(bufs.count(), (*i)->output_streams()));
 426                 }
 427
 428                 if (!_processors.empty()) {
 429                         bufs.set_count (ChanCount::max (bufs.count(), _processors.back()->output_streams()));
 430                 }
 431         }
 432 }
 433
 434 ChanCount
 435 Route::n_process_buffers ()
 436 {
 437         return max (_input->n_ports(), processor_max_streams);
 438 }
 439
 440 void
 441 Route::passthru (sframes_t start_frame, sframes_t end_frame, nframes_t nframes, int declick)
 442 {
 443         BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers());
 444
 445         _silent = false;
 446
 447         assert (bufs.available() >= _input->n_ports());
 448
 449         if (_input->n_ports() == ChanCount::ZERO) {
 450                 silence (nframes);
 451         }
 452
 453         bufs.set_count (_input->n_ports());
 454
 455         if (is_control() && _session.listening()) {
 456
 457                 /* control/monitor bus ignores input ports when something is
 458                    feeding the listen "stream". data will "arrive" into the
 459                    route from the intreturn processor element.
 460                 */
 461
 462                 bufs.silence (nframes, 0);
 463
 464         } else {
 465
 466                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 467
 468                         BufferSet::iterator o = bufs.begin(*t);
 469                         PortSet& ports (_input->ports());
 470
 471                         for (PortSet::iterator i = ports.begin(*t); i != ports.end(*t); ++i, ++o) {
 472                                 o->read_from (i->get_buffer(nframes), nframes);
 473                         }
 474                 }
 475         }
 476
 477         process_output_buffers (bufs, start_frame, end_frame, nframes, true, declick);
 478 }
 479
 480 void
 481 Route::passthru_silence (sframes_t start_frame, sframes_t end_frame, nframes_t nframes, int declick)
 482 {
 483         process_output_buffers (_session.get_silent_buffers (n_process_buffers()), start_frame, end_frame, nframes, true, declick);
 484 }
 485
 486 void
 487 Route::set_listen (bool yn, void* src)
 488 {
 489         if (_control_outs) {
 490                 if (yn != _control_outs->active()) {
 491                         if (yn) {
 492                                 _control_outs->activate ();
 493                         } else {
 494                                 _control_outs->deactivate ();
 495                         }
 496
 497                         listen_changed (src); /* EMIT SIGNAL */
 498                 }
 499         }
 500 }
 501
 502 bool
 503 Route::listening () const
 504 {
 505         if (_control_outs) {
 506                 return _control_outs->active ();
 507         } else {
 508                 return false;
 509         }
 510 }
 511
 512 void
 513 Route::set_solo (bool yn, void *src)
 514 {
 515         if (_solo_safe || _solo_isolated) {
 516                 return;
 517         }
 518
 519         if (_route_group && src != _route_group && _route_group->active_property (RouteGroup::Solo)) {
 520                 _route_group->apply (&Route::set_solo, yn, _route_group);
 521                 return;
 522         }
 523
 524         if (soloed() != yn) {
 525                 mod_solo_level (yn ? 1 : -1);
 526                 solo_changed (src); /* EMIT SIGNAL */
 527                 _solo_control->Changed (); /* EMIT SIGNAL */
 528         }
 529 }
 530
 531 void
 532 Route::mod_solo_level (int32_t delta)
 533 {
 534         if (delta < 0) {
 535                 if (_solo_level >= (uint32_t) delta) {
 536                         _solo_level += delta;
 537                 } else {
 538                         _solo_level = 0;
 539                 }
 540         } else {
 541                 _solo_level += delta;
 542         }
 543
 544         /* tell main outs what the solo situation is
 545          */
 546
 547         _main_outs->set_solo_level (_solo_level);
 548         _main_outs->set_solo_isolated (_solo_isolated);
 549 }
 550
 551 void
 552 Route::set_solo_isolated (bool yn, void *src)
 553 {
 554         if (_route_group && src != _route_group && _route_group->active_property (RouteGroup::Solo)) {
 555                 _route_group->apply (&Route::set_solo_isolated, yn, _route_group);
 556                 return;
 557         }
 558
 559         if (yn != _solo_isolated) {
 560                 _solo_isolated = yn;
 561
 562                 /* tell main outs what the solo situation is
 563                  */
 564
 565                 _main_outs->set_solo_level (_solo_level);
 566                 _main_outs->set_solo_isolated (_solo_isolated);
 567
 568                 solo_isolated_changed (src);
 569         }
 570 }
 571
 572 bool
 573 Route::solo_isolated () const
 574 {
 575         return _solo_isolated;
 576 }
 577
 578 void
 579 Route::set_mute (bool yn, void *src)
 580 {
 581         if (_route_group && src != _route_group && _route_group->active_property (RouteGroup::Mute)) {
 582                 _route_group->apply (&Route::set_mute, yn, _route_group);
 583                 return;
 584         }
 585
 586         if (muted() != yn) {
 587                 _mute_master->mute (yn);
 588                 mute_changed (src);
 589         }
 590 }
 591
 592 bool
 593 Route::muted() const
 594 {
 595         return _mute_master->muted ();
 596 }
 597
 598 #if 0
 599 static void
 600 dump_processors(const string& name, const list<boost::shared_ptr<Processor> >& procs)
 601 {
 602         cerr << name << " {" << endl;
 603         for (list<boost::shared_ptr<Processor> >::const_iterator p = procs.begin();
 604                         p != procs.end(); ++p) {
 605                 cerr << "\t" << (*p)->name() << " ID = " << (*p)->id() << endl;
 606         }
 607         cerr << "}" << endl;
 608 }
 609 #endif
 610
 611 int
 612 Route::add_processor (boost::shared_ptr<Processor> processor, Placement placement, ProcessorStreams* err)
 613 {
 614         ProcessorList::iterator loc;
 615
 616         /* XXX this is not thread safe - we don't hold the lock across determining the iter
 617            to add before and actually doing the insertion. dammit.
 618         */
 619
 620         if (placement == PreFader) {
 621                 /* generic pre-fader: insert immediately before the amp */
 622                 loc = find(_processors.begin(), _processors.end(), _amp);
 623         } else {
 624                 /* generic post-fader: insert at end */
 625                 loc = _processors.end();
 626
 627                 if (processor->visible() && !_processors.empty()) {
 628                         /* check for invisible processors stacked at the end and leave them there */
 629                         ProcessorList::iterator p;
 630                         p = _processors.end();
 631                         --p;
 632                         while (!(*p)->visible() && p != _processors.begin()) {
 633                                 --p;
 634                         }
 635                         ++p;
 636                         loc = p;
 637                 }
 638         }
 639
 640         return add_processor (processor, loc, err);
 641 }
 642
 643
 644 /** Add a processor to the route.
 645  * If @a iter is not NULL, it must point to an iterator in _processors and the new
 646  * processor will be inserted immediately before this location.  Otherwise,
 647  * @a position is used.
 648  */
 649 int
 650 Route::add_processor (boost::shared_ptr<Processor> processor, ProcessorList::iterator iter, ProcessorStreams* err)
 651 {
 652         ChanCount old_pms = processor_max_streams;
 653
 654         if (!_session.engine().connected() || !processor) {
 655                 return 1;
 656         }
 657
 658         {
 659                 Glib::RWLock::WriterLock lm (_processor_lock);
 660
 661                 boost::shared_ptr<PluginInsert> pi;
 662                 boost::shared_ptr<PortInsert> porti;
 663
 664                 ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), processor);
 665
 666                 if (processor == _amp || processor == _meter || processor == _main_outs) {
 667                         // Ensure only one of these are in the list at any time
 668                         if (loc != _processors.end()) {
 669                                 if (iter == loc) { // Already in place, do nothing
 670                                         return 0;
 671                                 } else { // New position given, relocate
 672                                         _processors.erase (loc);
 673                                 }
 674                         }
 675
 676                 } else {
 677                         if (loc != _processors.end()) {
 678                                 cerr << "ERROR: Processor added to route twice!" << endl;
 679                                 return 1;
 680                         }
 681
 682                         loc = iter;
 683                 }
 684
 685                 _processors.insert (loc, processor);
 686
 687                 // Set up processor list channels.  This will set processor->[input|output]_streams(),
 688                 // configure redirect ports properly, etc.
 689
 690
 691                 if (configure_processors_unlocked (err)) {
 692                         ProcessorList::iterator ploc = loc;
 693                         --ploc;
 694                         _processors.erase(ploc);
 695                         configure_processors_unlocked (0); // it worked before we tried to add it ...
 696                         cerr << "configure failed\n";
 697                         return -1;
 698                 }
 699
 700                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(processor)) != 0) {
 701
 702                         if (pi->natural_input_streams() == ChanCount::ZERO) {
 703                                 /* generator plugin */
 704                                 _have_internal_generator = true;
 705                         }
 706
 707                 }
 708
 709                 // XXX: do we want to emit the signal here ? change call order.
 710                 if (!boost::dynamic_pointer_cast<InternalSend>(processor)) {
 711                         processor->activate ();
 712                 }
 713                 processor->ActiveChanged.connect (bind (mem_fun (_session, &Session::update_latency_compensation), false, false));
 714
 715                 _output->set_user_latency (0);
 716         }
 717
 718         processors_changed (); /* EMIT SIGNAL */
 719
 720         return 0;
 721 }
 722
 723 bool
 724 Route::add_processor_from_xml (const XMLNode& node, ProcessorList::iterator iter)
 725 {
 726         const XMLProperty *prop;
 727
 728         // legacy sessions use a different node name for sends
 729         if (node.name() == "Send") {
 730
 731                 try {
 732                         boost::shared_ptr<Send> send (new Send (_session, _mute_master, node));
 733                         add_processor (send, iter);
 734                         return true;
 735                 }
 736
 737                 catch (failed_constructor &err) {
 738                         error << _("Send construction failed") << endmsg;
 739                         return false;
 740                 }
 741
 742         } else if (node.name() == "Processor") {
 743
 744                 try {
 745                         if ((prop = node.property ("type")) != 0) {
 746
 747                                 boost::shared_ptr<Processor> processor;
 748
 749                                 if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
 750                                     prop->value() == "lv2" ||
 751                                     prop->value() == "vst" ||
 752                                     prop->value() == "audiounit") {
 753
 754                                         processor.reset (new PluginInsert(_session, node));
 755
 756                                 } else if (prop->value() == "port") {
 757
 758                                         processor.reset (new PortInsert (_session, _mute_master, node));
 759
 760                                 } else if (prop->value() == "send") {
 761
 762                                         processor.reset (new Send (_session, _mute_master, node));
 763
 764                                 } else if (prop->value() == "meter") {
 765
 766                                         if (_meter) {
 767                                                 if (_meter->set_state (node)) {
 768                                                         return false;
 769                                                 } else {
 770                                                         return true;
 771                                                 }
 772                                         }
 773
 774                                         _meter.reset (new PeakMeter (_session, node));
 775                                         processor = _meter;
 776
 777                                 } else if (prop->value() == "amp") {
 778
 779                                         /* amp always exists */
 780
 781                                         processor = _amp;
 782                                         if (processor->set_state (node)) {
 783                                                 return false;
 784                                         } else {
 785                                                 /* never any reason to add it */
 786                                                 return true;
 787                                         }
 788
 789                                 } else if (prop->value() == "listen" || prop->value() == "deliver") {
 790
 791                                         /* XXX need to generalize */
 792
 793                                 } else if (prop->value() == "intsend") {
 794
 795                                         processor.reset (new InternalSend (_session, _mute_master, node));
 796
 797                                 } else if (prop->value() == "intreturn") {
 798
 799                                         if (_intreturn) {
 800                                                 if (_intreturn->set_state (node)) {
 801                                                         return false;
 802                                                 } else {
 803                                                         return true;
 804                                                 }
 805                                         }
 806                                         _intreturn.reset (new InternalReturn (_session, node));
 807                                         processor = _intreturn;
 808
 809                                 } else if (prop->value() == "main-outs") {
 810
 811                                         if (_main_outs) {
 812                                                 if (_main_outs->set_state (node)) {
 813                                                         return false;
 814                                                 } else {
 815                                                         return true;
 816                                                 }
 817                                         }
 818
 819                                         _main_outs.reset (new Delivery (_session, _output, _mute_master, node));
 820                                         processor = _main_outs;
 821
 822                                 } else {
 823                                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
 824                                 }
 825
 826                                 if (iter == _processors.end() && processor->visible() && !_processors.empty()) {
 827                                         /* check for invisible processors stacked at the end and leave them there */
 828                                         ProcessorList::iterator p;
 829                                         p = _processors.end();
 830                                         --p;
 831                                         while (!(*p)->visible() && p != _processors.begin()) {
 832                                                 --p;
 833                                         }
 834                                         ++p;
 835                                         iter = p;
 836                                 }
 837
 838                                 return (add_processor (processor, iter) == 0);
 839
 840                         } else {
 841                                 error << _("Processor XML node has no type property") << endmsg;
 842                         }
 843                 }
 844
 845                 catch (failed_constructor &err) {
 846                         warning << _("processor could not be created. Ignored.") << endmsg;
 847                         return false;
 848                 }
 849         }
 850         return false;
 851 }
 852
 853 int
 854 Route::add_processors (const ProcessorList& others, Placement placement, ProcessorStreams* err)
 855 {
 856         ProcessorList::iterator loc;
 857         if (placement == PreFader) {
 858                 /* generic pre-fader: insert immediately before the amp */
 859                 loc = find(_processors.begin(), _processors.end(), _amp);
 860         } else {
 861                 /* generic post-fader: insert at end */
 862                 loc = _processors.end();
 863
 864                 if (!_processors.empty()) {
 865                         /* check for invisible processors stacked at the end and leave them there */
 866                         ProcessorList::iterator p;
 867                         p = _processors.end();
 868                         --p;
 869                         cerr << "Let's check " << (*p)->name() << " vis ? " << (*p)->visible() << endl;
 870                         while (!(*p)->visible() && p != _processors.begin()) {
 871                                 --p;
 872                         }
 873                         ++p;
 874                         loc = p;
 875                 }
 876         }
 877
 878         return add_processors (others, loc, err);
 879 }
 880
 881 int
 882 Route::add_processors (const ProcessorList& others, ProcessorList::iterator iter, ProcessorStreams* err)
 883 {
 884         /* NOTE: this is intended to be used ONLY when copying
 885            processors from another Route. Hence the subtle
 886            differences between this and ::add_processor()
 887         */
 888
 889         ChanCount old_pms = processor_max_streams;
 890
 891         if (!_session.engine().connected()) {
 892                 return 1;
 893         }
 894
 895         if (others.empty()) {
 896                 return 0;
 897         }
 898
 899         {
 900                 Glib::RWLock::WriterLock lm (_processor_lock);
 901                 ProcessorList::iterator existing_end = _processors.end();
 902                 --existing_end;
 903
 904                 ChanCount potential_max_streams = ChanCount::max (_input->n_ports(), _output->n_ports());
 905
 906                 for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
 907
 908                         // Ensure meter only appears in the list once
 909                         if (*i == _meter) {
 910                                 ProcessorList::iterator m = find(_processors.begin(), _processors.end(), *i);
 911                                 if (m != _processors.end()) {
 912                                         _processors.erase(m);
 913                                 }
 914                         }
 915
 916                         boost::shared_ptr<PluginInsert> pi;
 917
 918                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
 919                                 pi->set_count (1);
 920
 921                                 ChanCount m = max(pi->input_streams(), pi->output_streams());
 922                                 if (m > potential_max_streams)
 923                                         potential_max_streams = m;
 924                         }
 925
 926                         _processors.insert (iter, *i);
 927
 928                         if (configure_processors_unlocked (err)) {
 929                                 ++existing_end;
 930                                 _processors.erase (existing_end, _processors.end());
 931                                 configure_processors_unlocked (0); // it worked before we tried to add it ...
 932                                 return -1;
 933                         }
 934
 935                         (*i)->ActiveChanged.connect (bind (mem_fun (_session, &Session::update_latency_compensation), false, false));
 936                 }
 937
 938                 _output->set_user_latency (0);
 939         }
 940
 941         processors_changed (); /* EMIT SIGNAL */
 942
 943         return 0;
 944 }
 945
 946 void
 947 Route::placement_range(Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end)
 948 {
 949         if (p == PreFader) {
 950                 start = _processors.begin();
 951                 end = find(_processors.begin(), _processors.end(), _amp);
 952         } else {
 953                 start = find(_processors.begin(), _processors.end(), _amp);
 954                 ++start;
 955                 end = _processors.end();
 956         }
 957 }
 958
 959 /** Turn off all processors with a given placement
 960  * @param p Placement of processors to disable
 961  */
 962 void
 963 Route::disable_processors (Placement p)
 964 {
 965         Glib::RWLock::ReaderLock lm (_processor_lock);
 966
 967         ProcessorList::iterator start, end;
 968         placement_range(p, start, end);
 969
 970         for (ProcessorList::iterator i = start; i != end; ++i) {
 971                 (*i)->deactivate ();
 972         }
 973
 974         _session.set_dirty ();
 975 }
 976
 977 /** Turn off all redirects
 978  */
 979 void
 980 Route::disable_processors ()
 981 {
 982         Glib::RWLock::ReaderLock lm (_processor_lock);
 983
 984         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 985                 (*i)->deactivate ();
 986         }
 987
 988         _session.set_dirty ();
 989 }
 990
 991 /** Turn off all redirects with a given placement
 992  * @param p Placement of redirects to disable
 993  */
 994 void
 995 Route::disable_plugins (Placement p)
 996 {
 997         Glib::RWLock::ReaderLock lm (_processor_lock);
 998
 999         ProcessorList::iterator start, end;
1000         placement_range(p, start, end);
1001
1002         for (ProcessorList::iterator i = start; i != end; ++i) {
1003                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1004                         (*i)->deactivate ();
1005                 }
1006         }
1007
1008         _session.set_dirty ();
1009 }
1010
1011 /** Turn off all plugins
1012  */
1013 void
1014 Route::disable_plugins ()
1015 {
1016         Glib::RWLock::ReaderLock lm (_processor_lock);
1017
1018         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1019                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1020                         (*i)->deactivate ();
1021                 }
1022         }
1023
1024         _session.set_dirty ();
1025 }
1026
1027
1028 void
1029 Route::ab_plugins (bool forward)
1030 {
1031         Glib::RWLock::ReaderLock lm (_processor_lock);
1032
1033         if (forward) {
1034
1035                 /* forward = turn off all active redirects, and mark them so that the next time
1036                    we go the other way, we will revert them
1037                 */
1038
1039                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1040                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1041                                 continue;
1042                         }
1043
1044                         if ((*i)->active()) {
1045                                 (*i)->deactivate ();
1046                                 (*i)->set_next_ab_is_active (true);
1047                         } else {
1048                                 (*i)->set_next_ab_is_active (false);
1049                         }
1050                 }
1051
1052         } else {
1053
1054                 /* backward = if the redirect was marked to go active on the next ab, do so */
1055
1056                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1057
1058                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1059                                 continue;
1060                         }
1061
1062                         if ((*i)->get_next_ab_is_active()) {
1063                                 (*i)->activate ();
1064                         } else {
1065                                 (*i)->deactivate ();
1066                         }
1067                 }
1068         }
1069
1070         _session.set_dirty ();
1071 }
1072
1073
1074 /** Remove processors with a given placement.
1075  * @param p Placement of processors to remove.
1076  */
1077 void
1078 Route::clear_processors (Placement p)
1079 {
1080         const ChanCount old_pms = processor_max_streams;
1081
1082         if (!_session.engine().connected()) {
1083                 return;
1084         }
1085
1086         bool already_deleting = _session.deletion_in_progress();
1087         if (!already_deleting) {
1088                 _session.set_deletion_in_progress();
1089         }
1090
1091         {
1092                 Glib::RWLock::WriterLock lm (_processor_lock);
1093                 ProcessorList new_list;
1094                 ProcessorStreams err;
1095
1096                 ProcessorList::iterator amp_loc = find(_processors.begin(), _processors.end(), _amp);
1097                 if (p == PreFader) {
1098                         // Get rid of PreFader processors
1099                         for (ProcessorList::iterator i = _processors.begin(); i != amp_loc; ++i) {
1100                                 (*i)->drop_references ();
1101                         }
1102                         // Keep the rest
1103                         for (ProcessorList::iterator i = amp_loc; i != _processors.end(); ++i) {
1104                                 new_list.push_back (*i);
1105                         }
1106                 } else {
1107                         // Keep PreFader processors
1108                         for (ProcessorList::iterator i = _processors.begin(); i != amp_loc; ++i) {
1109                                 new_list.push_back (*i);
1110                         }
1111                         new_list.push_back (_amp);
1112                         // Get rid of PostFader processors
1113                         for (ProcessorList::iterator i = amp_loc; i != _processors.end(); ++i) {
1114                                 (*i)->drop_references ();
1115                         }
1116                 }
1117
1118                 _processors = new_list;
1119                 configure_processors_unlocked (&err); // this can't fail
1120         }
1121
1122         processor_max_streams.reset();
1123         _have_internal_generator = false;
1124         processors_changed (); /* EMIT SIGNAL */
1125
1126         if (!already_deleting) {
1127                 _session.clear_deletion_in_progress();
1128         }
1129 }
1130
1131 int
1132 Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err)
1133 {
1134         /* these can never be removed */
1135
1136         if (processor == _amp || processor == _meter || processor == _main_outs) {
1137                 return 0;
1138         }
1139
1140         ChanCount old_pms = processor_max_streams;
1141
1142         if (!_session.engine().connected()) {
1143                 return 1;
1144         }
1145
1146         processor_max_streams.reset();
1147
1148         {
1149                 Glib::RWLock::WriterLock lm (_processor_lock);
1150                 ProcessorList::iterator i;
1151                 bool removed = false;
1152
1153                 for (i = _processors.begin(); i != _processors.end(); ) {
1154                         if (*i == processor) {
1155
1156                                 /* move along, see failure case for configure_processors()
1157                                    where we may need to reconfigure the processor.
1158                                 */
1159
1160                                 /* stop redirects that send signals to JACK ports
1161                                    from causing noise as a result of no longer being
1162                                    run.
1163                                 */
1164
1165                                 boost::shared_ptr<IOProcessor> iop;
1166
1167                                 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (*i)) != 0) {
1168                                         if (iop->input()) {
1169                                                 iop->input()->disconnect (this);
1170                                         }
1171                                         if (iop->output()) {
1172                                                 iop->output()->disconnect (this);
1173                                         }
1174                                 }
1175
1176                                 i = _processors.erase (i);
1177                                 removed = true;
1178                                 break;
1179
1180                         } else {
1181                                 ++i;
1182                         }
1183
1184                         _output->set_user_latency (0);
1185                 }
1186
1187                 if (!removed) {
1188                         /* what? */
1189                         return 1;
1190                 }
1191
1192                 if (configure_processors_unlocked (err)) {
1193                         /* get back to where we where */
1194                         _processors.insert (i, processor);
1195                         /* we know this will work, because it worked before :) */
1196                         configure_processors_unlocked (0);
1197                         return -1;
1198                 }
1199
1200                 _have_internal_generator = false;
1201
1202                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1203                         boost::shared_ptr<PluginInsert> pi;
1204
1205                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1206                                 if (pi->is_generator()) {
1207                                         _have_internal_generator = true;
1208                                         break;
1209                                 }
1210                         }
1211                 }
1212         }
1213
1214         processor->drop_references ();
1215         processors_changed (); /* EMIT SIGNAL */
1216
1217         return 0;
1218 }
1219
1220 int
1221 Route::configure_processors (ProcessorStreams* err)
1222 {
1223         if (!_in_configure_processors) {
1224                 Glib::RWLock::WriterLock lm (_processor_lock);
1225                 return configure_processors_unlocked (err);
1226         }
1227         return 0;
1228 }
1229
1230 /** Configure the input/output configuration of each processor in the processors list.
1231  * Return 0 on success, otherwise configuration is impossible.
1232  */
1233 int
1234 Route::configure_processors_unlocked (ProcessorStreams* err)
1235 {
1236         if (_in_configure_processors) {
1237            return 0;
1238         }
1239
1240         _in_configure_processors = true;
1241
1242         // Check each processor in order to see if we can configure as requested
1243         ChanCount in = _input->n_ports ();
1244         ChanCount out;
1245         list< pair<ChanCount,ChanCount> > configuration;
1246         uint32_t index = 0;
1247
1248         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1249                 if ((*p)->can_support_io_configuration(in, out)) {
1250                         configuration.push_back(make_pair(in, out));
1251                         in = out;
1252                 } else {
1253                         if (err) {
1254                                 err->index = index;
1255                                 err->count = in;
1256                         }
1257                         _in_configure_processors = false;
1258                         return -1;
1259                 }
1260         }
1261
1262         // We can, so configure everything
1263         list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1264         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1265                 (*p)->configure_io(c->first, c->second);
1266                 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1267                 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1268                 out = c->second;
1269         }
1270
1271         // Ensure route outputs match last processor's outputs
1272         if (out != _output->n_ports ()) {
1273                 _output->ensure_io (out, false, this);
1274         }
1275
1276         _in_configure_processors = false;
1277         return 0;
1278 }
1279
1280 void
1281 Route::all_processors_flip ()
1282 {
1283         Glib::RWLock::ReaderLock lm (_processor_lock);
1284
1285         if (_processors.empty()) {
1286                 return;
1287         }
1288
1289         bool first_is_on = _processors.front()->active();
1290
1291         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1292                 if (first_is_on) {
1293                         (*i)->deactivate ();
1294                 } else {
1295                         (*i)->activate ();
1296                 }
1297         }
1298
1299         _session.set_dirty ();
1300 }
1301
1302 /** Set all processors with a given placement to a given active state.
1303  * @param p Placement of processors to change.
1304  * @param state New active state for those processors.
1305  */
1306 void
1307 Route::all_processors_active (Placement p, bool state)
1308 {
1309         Glib::RWLock::ReaderLock lm (_processor_lock);
1310
1311         if (_processors.empty()) {
1312                 return;
1313         }
1314         ProcessorList::iterator start, end;
1315         placement_range(p, start, end);
1316
1317         bool before_amp = true;
1318         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1319                 if ((*i) == _amp) {
1320                         before_amp = false;
1321                         continue;
1322                 }
1323                 if (p == PreFader && before_amp) {
1324                         if (state) {
1325                                 (*i)->activate ();
1326                         } else {
1327                                 (*i)->deactivate ();
1328                         }
1329                 }
1330         }
1331
1332         _session.set_dirty ();
1333 }
1334
1335 bool
1336 Route::processor_is_prefader (boost::shared_ptr<Processor> p)
1337 {
1338         bool pre_fader = true;
1339         Glib::RWLock::ReaderLock lm (_processor_lock);
1340
1341         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1342
1343                 /* semantic note: if p == amp, we want to return true, so test
1344                    for equality before checking if this is the amp
1345                 */
1346
1347                 if ((*i) == p) {
1348                         break;
1349                 }
1350
1351                 if ((*i) == _amp) {
1352                         pre_fader = false;
1353                         break;
1354                 }
1355         }
1356
1357         return pre_fader;
1358 }
1359
1360 int
1361 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
1362 {
1363         /* "new_order" is an ordered list of processors to be positioned according to "placement".
1364            NOTE: all processors in "new_order" MUST be marked as visible. There maybe additional
1365            processors in the current actual processor list that are hidden. Any visible processors
1366            in the current list but not in "new_order" will be assumed to be deleted.
1367         */
1368
1369         {
1370                 Glib::RWLock::WriterLock lm (_processor_lock);
1371                 ChanCount old_pms = processor_max_streams;
1372                 ProcessorList::iterator oiter;
1373                 ProcessorList::const_iterator niter;
1374                 ProcessorList as_it_was_before = _processors;
1375                 ProcessorList as_it_will_be;
1376
1377                 oiter = _processors.begin();
1378                 niter = new_order.begin();
1379
1380                 while (niter !=  new_order.end()) {
1381
1382                         /* if the next processor in the old list is invisible (i.e. should not be in the new order)
1383                            then append it to the temp list.
1384
1385                            Otherwise, see if the next processor in the old list is in the new list. if not,
1386                            its been deleted. If its there, append it to the temp list.
1387                         */
1388
1389                         if (oiter == _processors.end()) {
1390
1391                                 /* no more elements in the old list, so just stick the rest of
1392                                    the new order onto the temp list.
1393                                 */
1394
1395                                 as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
1396                                 while (niter != new_order.end()) {
1397                                         ++niter;
1398                                 }
1399                                 break;
1400
1401                         } else {
1402
1403                                 if (!(*oiter)->visible()) {
1404
1405                                         as_it_will_be.push_back (*oiter);
1406
1407                                 } else {
1408
1409                                         /* visible processor: check that its in the new order */
1410
1411                                         if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
1412                                                 /* deleted: do nothing, shared_ptr<> will clean up */
1413                                         } else {
1414                                                 /* ignore this one, and add the next item from the new order instead */
1415                                                 as_it_will_be.push_back (*niter);
1416                                                 ++niter;
1417                                         }
1418                                 }
1419
1420                                 /* now remove from old order - its taken care of no matter what */
1421                                 oiter = _processors.erase (oiter);
1422                         }
1423
1424                 }
1425
1426                 _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
1427
1428                 if (configure_processors_unlocked (err)) {
1429                         _processors = as_it_was_before;
1430                         processor_max_streams = old_pms;
1431                         return -1;
1432                 }
1433         }
1434
1435         processors_changed (); /* EMIT SIGNAL */
1436
1437         return 0;
1438 }
1439
1440 XMLNode&
1441 Route::get_state()
1442 {
1443         return state(true);
1444 }
1445
1446 XMLNode&
1447 Route::get_template()
1448 {
1449         return state(false);
1450 }
1451
1452 XMLNode&
1453 Route::state(bool full_state)
1454 {
1455         XMLNode *node = new XMLNode("Route");
1456         ProcessorList::iterator i;
1457         char buf[32];
1458
1459         id().print (buf, sizeof (buf));
1460         node->add_property("id", buf);
1461         node->add_property ("name", _name);
1462         node->add_property("default-type", _default_type.to_string());
1463
1464         if (_flags) {
1465                 node->add_property("flags", enum_2_string (_flags));
1466         }
1467
1468         node->add_property("active", _active?"yes":"no");
1469         node->add_property("phase-invert", _phase_invert?"yes":"no");
1470         node->add_property("denormal-protection", _denormal_protection?"yes":"no");
1471         node->add_property("meter-point", enum_2_string (_meter_point));
1472
1473         if (_route_group) {
1474                 node->add_property("route-group", _route_group->name());
1475         }
1476
1477         string order_string;
1478         OrderKeys::iterator x = order_keys.begin();
1479
1480         while (x != order_keys.end()) {
1481                 order_string += string ((*x).first);
1482                 order_string += '=';
1483                 snprintf (buf, sizeof(buf), "%ld", (*x).second);
1484                 order_string += buf;
1485
1486                 ++x;
1487
1488                 if (x == order_keys.end()) {
1489                         break;
1490                 }
1491
1492                 order_string += ':';
1493         }
1494         node->add_property ("order-keys", order_string);
1495
1496         node->add_child_nocopy (_input->state (full_state));
1497         node->add_child_nocopy (_output->state (full_state));
1498         node->add_child_nocopy (_solo_control->get_state ());
1499         node->add_child_nocopy (_mute_master->get_state ());
1500
1501         XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
1502         snprintf (buf, sizeof (buf), "%d", _remote_control_id);
1503         remote_control_node->add_property (X_("id"), buf);
1504         node->add_child_nocopy (*remote_control_node);
1505
1506         if (_comment.length()) {
1507                 XMLNode *cmt = node->add_child ("Comment");
1508                 cmt->add_content (_comment);
1509         }
1510
1511         for (i = _processors.begin(); i != _processors.end(); ++i) {
1512                 node->add_child_nocopy((*i)->state (full_state));
1513         }
1514
1515         if (_extra_xml){
1516                 node->add_child_copy (*_extra_xml);
1517         }
1518
1519         return *node;
1520 }
1521
1522 int
1523 Route::set_state (const XMLNode& node)
1524 {
1525         return _set_state (node, true);
1526 }
1527
1528 int
1529 Route::_set_state (const XMLNode& node, bool call_base)
1530 {
1531
1532         XMLNodeList nlist;
1533         XMLNodeConstIterator niter;
1534         XMLNode *child;
1535         XMLPropertyList plist;
1536         const XMLProperty *prop;
1537
1538         if (node.name() != "Route"){
1539                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1540                 return -1;
1541         }
1542
1543         if ((prop = node.property (X_("name"))) != 0) {
1544                 Route::set_name (prop->value());
1545         }
1546
1547         if ((prop = node.property ("id")) != 0) {
1548                 _id = prop->value ();
1549         }
1550
1551         if ((prop = node.property (X_("flags"))) != 0) {
1552                 _flags = Flag (string_2_enum (prop->value(), _flags));
1553         } else {
1554                 _flags = Flag (0);
1555         }
1556
1557         /* add all processors (except amp, which is always present) */
1558
1559         nlist = node.children();
1560         XMLNode processor_state (X_("processor_state"));
1561
1562         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1563
1564                 child = *niter;
1565
1566                 if (child->name() == IO::state_node_name) {
1567                         if ((prop = child->property (X_("direction"))) == 0) {
1568                                 continue;
1569                         }
1570
1571                         if (prop->value() == "Input") {
1572                                 _input->set_state (*child);
1573                         } else if (prop->value() == "Output") {
1574                                 _output->set_state (*child);
1575                         }
1576                 }
1577
1578                 if (child->name() == X_("Processor")) {
1579                         processor_state.add_child_copy (*child);
1580                 }
1581         }
1582
1583         set_processor_state (processor_state);
1584
1585         if ((prop = node.property ("solo_level")) != 0) {
1586                 _solo_level = 0; // needed for mod_solo_level() to work
1587                 mod_solo_level (atoi (prop->value()));
1588         }
1589
1590         if ((prop = node.property ("solo-isolated")) != 0) {
1591                 set_solo_isolated (prop->value() == "yes", this);
1592         }
1593
1594         if ((prop = node.property (X_("phase-invert"))) != 0) {
1595                 set_phase_invert (prop->value()=="yes"?true:false);
1596         }
1597
1598         if ((prop = node.property (X_("denormal-protection"))) != 0) {
1599                 set_denormal_protection (prop->value()=="yes"?true:false);
1600         }
1601
1602         if ((prop = node.property (X_("active"))) != 0) {
1603                 bool yn = (prop->value() == "yes");
1604                 _active = !yn; // force switch
1605                 set_active (yn);
1606         }
1607
1608         if ((prop = node.property (X_("soloed"))) != 0) {
1609                 bool yn = (prop->value()=="yes");
1610
1611                 /* XXX force reset of solo status */
1612
1613                 set_solo (yn, this);
1614         }
1615
1616         if ((prop = node.property (X_("meter-point"))) != 0) {
1617                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
1618         }
1619
1620         if ((prop = node.property (X_("route-group"))) != 0) {
1621                 RouteGroup* route_group = _session.route_group_by_name(prop->value());
1622                 if (route_group == 0) {
1623                         error << string_compose(_("Route %1: unknown route group \"%2 in saved state (ignored)"), _name, prop->value()) << endmsg;
1624                 } else {
1625                         set_route_group (route_group, this);
1626                 }
1627         }
1628
1629         if ((prop = node.property (X_("order-keys"))) != 0) {
1630
1631                 long n;
1632
1633                 string::size_type colon, equal;
1634                 string remaining = prop->value();
1635
1636                 while (remaining.length()) {
1637
1638                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
1639                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1640                                       << endmsg;
1641                         } else {
1642                                 if (sscanf (remaining.substr (equal+1).c_str(), "%ld", &n) != 1) {
1643                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1644                                               << endmsg;
1645                                 } else {
1646                                         set_order_key (remaining.substr (0, equal), n);
1647                                 }
1648                         }
1649
1650                         colon = remaining.find_first_of (':');
1651
1652                         if (colon != string::npos) {
1653                                 remaining = remaining.substr (colon+1);
1654                         } else {
1655                                 break;
1656                         }
1657                 }
1658         }
1659
1660         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1661                 child = *niter;
1662
1663                 if (child->name() == X_("Comment")) {
1664
1665                         /* XXX this is a terrible API design in libxml++ */
1666
1667                         XMLNode *cmt = *(child->children().begin());
1668                         _comment = cmt->content();
1669
1670                 } else if (child->name() == X_("Extra")) {
1671
1672                         _extra_xml = new XMLNode (*child);
1673
1674                 } else if (child->name() == X_("Controllable") && (prop = child->property("name")) != 0) {
1675
1676                         if (prop->value() == "solo") {
1677                                 _solo_control->set_state (*child);
1678                                 _session.add_controllable (_solo_control);
1679                         }
1680
1681                 } else if (child->name() == X_("RemoteControl")) {
1682                         if ((prop = child->property (X_("id"))) != 0) {
1683                                 int32_t x;
1684                                 sscanf (prop->value().c_str(), "%d", &x);
1685                                 set_remote_control_id (x);
1686                         }
1687
1688                 } else if (child->name() == X_("MuteMaster")) {
1689                         _mute_master->set_state (*child);
1690                 }
1691         }
1692
1693         return 0;
1694 }
1695
1696 XMLNode&
1697 Route::get_processor_state ()
1698 {
1699         XMLNode* root = new XMLNode (X_("redirects"));
1700         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1701                 root->add_child_nocopy ((*i)->state (true));
1702         }
1703
1704         return *root;
1705 }
1706
1707 void
1708 Route::set_processor_state (const XMLNode& node)
1709 {
1710         const XMLNodeList &nlist = node.children();
1711         XMLNodeConstIterator niter;
1712         ProcessorList::iterator i, o;
1713
1714         // Iterate through existing processors, remove those which are not in the state list
1715
1716         for (i = _processors.begin(); i != _processors.end(); ) {
1717
1718                 /* leave amp alone, always */
1719
1720                 if ((*i) == _amp) {
1721                         ++i;
1722                         continue;
1723                 }
1724
1725                 ProcessorList::iterator tmp = i;
1726                 ++tmp;
1727
1728                 bool processorInStateList = false;
1729
1730                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1731
1732                         XMLProperty* id_prop = (*niter)->property(X_("id"));
1733
1734                         if (id_prop && (*i)->id() == id_prop->value()) {
1735                                 processorInStateList = true;
1736                                 break;
1737                         }
1738                 }
1739
1740                 if (!processorInStateList) {
1741                         remove_processor (*i);
1742                 }
1743
1744                 i = tmp;
1745         }
1746
1747         // Iterate through state list and make sure all processors are on the track and in the correct order,
1748         // set the state of existing processors according to the new state on the same go
1749
1750         i = _processors.begin();
1751
1752         for (niter = nlist.begin(); niter != nlist.end(); ++niter, ++i) {
1753
1754                 XMLProperty* prop = (*niter)->property ("type");
1755
1756                 o = i;
1757
1758                 // Check whether the next processor in the list is the right one,
1759                 // except for "amp" which is always there and may not have the
1760                 // old ID since it is always created anew in every Route
1761
1762                 if (prop->value() != "amp") {
1763                         while (o != _processors.end()) {
1764                                 XMLProperty* id_prop = (*niter)->property(X_("id"));
1765                                 if (id_prop && (*o)->id() == id_prop->value()) {
1766                                         break;
1767                                 }
1768
1769                                 ++o;
1770                         }
1771                 }
1772
1773                 // If the processor (*niter) is not on the route,
1774                 // create it and move it to the correct location
1775
1776                 if (o == _processors.end()) {
1777
1778                         if (add_processor_from_xml (**niter, i)) {
1779                                 --i; // move iterator to the newly inserted processor
1780                         } else {
1781                                 cerr << "Error restoring route: unable to restore processor" << endl;
1782                         }
1783
1784                 } else {
1785
1786                         // Otherwise, the processor already exists; just
1787                         // ensure it is at the location provided in the XML state
1788
1789                         if (i != o) {
1790                                 boost::shared_ptr<Processor> tmp = (*o);
1791                                 _processors.erase (o); // remove the old copy
1792                                 _processors.insert (i, tmp); // insert the processor at the correct location
1793                                 --i; // move iterator to the correct processor
1794                         }
1795
1796                         // and make it (just) so
1797
1798                         (*i)->set_state (**niter);
1799                 }
1800         }
1801
1802         /* note: there is no configure_processors() call because we figure that
1803            the XML state represents a working signal route.
1804         */
1805
1806         processors_changed ();
1807 }
1808
1809 void
1810 Route::curve_reallocate ()
1811 {
1812 //      _gain_automation_curve.finish_resize ();
1813 //      _pan_automation_curve.finish_resize ();
1814 }
1815
1816 void
1817 Route::silence (nframes_t nframes)
1818 {
1819         if (!_silent) {
1820
1821                 _output->silence (nframes);
1822
1823                 {
1824                         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
1825
1826                         if (lm.locked()) {
1827                                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1828                                         boost::shared_ptr<PluginInsert> pi;
1829
1830                                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
1831                                                 // skip plugins, they don't need anything when we're not active
1832                                                 continue;
1833                                         }
1834
1835                                         (*i)->silence (nframes);
1836                                 }
1837
1838                                 if (nframes == _session.get_block_size()) {
1839                                         // _silent = true;
1840                                 }
1841                         }
1842                 }
1843
1844         }
1845 }
1846
1847 void
1848 Route::add_internal_return ()
1849 {
1850         if (!_intreturn) {
1851                 _intreturn.reset (new InternalReturn (_session));
1852                 add_processor (_intreturn, PreFader);
1853         }
1854 }
1855
1856 BufferSet*
1857 Route::get_return_buffer () const
1858 {
1859         Glib::RWLock::ReaderLock rm (_processor_lock);
1860
1861         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
1862                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
1863
1864                 if (d) {
1865                         BufferSet* bs = d->get_buffers ();
1866                         return bs;
1867                 }
1868         }
1869
1870         return 0;
1871 }
1872
1873 void
1874 Route::release_return_buffer () const
1875 {
1876         Glib::RWLock::ReaderLock rm (_processor_lock);
1877
1878         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
1879                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
1880
1881                 if (d) {
1882                         return d->release_buffers ();
1883                 }
1884         }
1885 }
1886
1887 int
1888 Route::listen_via (boost::shared_ptr<Route> route, bool active)
1889 {
1890         vector<string> ports;
1891         vector<string>::const_iterator i;
1892
1893         {
1894                 Glib::RWLock::ReaderLock rm (_processor_lock);
1895
1896                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
1897
1898                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
1899
1900                         if (d && d->target_route() == route) {
1901
1902                                 /* if the target is the control outs, then make sure
1903                                    we take note of which i-send is doing that.
1904                                 */
1905
1906                                 if (route == _session.control_out()) {
1907                                         _control_outs = boost::dynamic_pointer_cast<Delivery>(d);
1908                                 }
1909
1910                                 /* already listening via the specified IO: do nothing */
1911
1912                                 return 0;
1913                         }
1914                 }
1915         }
1916
1917         boost::shared_ptr<InternalSend> listener;
1918
1919         try {
1920                 listener.reset (new InternalSend (_session, _mute_master, route));
1921
1922         } catch (failed_constructor& err) {
1923                 return -1;
1924         }
1925
1926         if (route == _session.control_out()) {
1927                 _control_outs = listener;
1928         }
1929
1930         add_processor (listener, (Config->get_listen_position() == AfterFaderListen ? PostFader : PreFader));
1931
1932         return 0;
1933 }
1934
1935 void
1936 Route::drop_listen (boost::shared_ptr<Route> route)
1937 {
1938         ProcessorStreams err;
1939         ProcessorList::iterator tmp;
1940
1941         Glib::RWLock::ReaderLock rl(_processor_lock);
1942         rl.acquire ();
1943
1944   again:
1945         for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ) {
1946
1947                 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
1948
1949                 if (d && d->target_route() == route) {
1950                         rl.release ();
1951                         remove_processor (*x, &err);
1952                         rl.acquire ();
1953
1954                         /* list could have been demolished while we dropped the lock
1955                            so start over.
1956                         */
1957
1958                         goto again;
1959                 }
1960         }
1961
1962         rl.release ();
1963
1964         if (route == _session.control_out()) {
1965                 _control_outs.reset ();
1966         }
1967 }
1968
1969 void
1970 Route::set_route_group (RouteGroup *rg, void *src)
1971 {
1972         if (rg == _route_group) {
1973                 return;
1974         }
1975
1976         if (_route_group) {
1977                 _route_group->remove (this);
1978         }
1979
1980         if ((_route_group = rg) != 0) {
1981                 _route_group->add (this);
1982         }
1983
1984         _session.set_dirty ();
1985         route_group_changed (src); /* EMIT SIGNAL */
1986 }
1987
1988 void
1989 Route::drop_route_group (void *src)
1990 {
1991         _route_group = 0;
1992         _session.set_dirty ();
1993         route_group_changed (src); /* EMIT SIGNAL */
1994 }
1995
1996 void
1997 Route::set_comment (string cmt, void *src)
1998 {
1999         _comment = cmt;
2000         comment_changed (src);
2001         _session.set_dirty ();
2002 }
2003
2004 bool
2005 Route::feeds (boost::shared_ptr<Route> other)
2006 {
2007         // cerr << _name << endl;
2008
2009         if (_output->connected_to (other->input())) {
2010                 // cerr << "\tdirect FEEDS " << other->name() << endl;
2011                 return true;
2012         }
2013
2014         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); r++) {
2015
2016                 boost::shared_ptr<IOProcessor> iop;
2017
2018                 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
2019                         if (iop->feeds (other)) {
2020                                 // cerr << "\tIOP " << iop->name() << " feeds " << other->name() << endl;
2021                                 return true;
2022                         } else {
2023                                 // cerr << "\tIOP " << iop->name() << " does NOT feeds " << other->name() << endl;
2024                         }
2025                 }
2026         }
2027
2028         // cerr << "\tdoes NOT FEED " << other->name() << endl;
2029         return false;
2030 }
2031
2032 void
2033 Route::handle_transport_stopped (bool abort_ignored, bool did_locate, bool can_flush_processors)
2034 {
2035         nframes_t now = _session.transport_frame();
2036
2037         {
2038                 Glib::RWLock::ReaderLock lm (_processor_lock);
2039
2040                 if (!did_locate) {
2041                         automation_snapshot (now, true);
2042                 }
2043
2044                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2045
2046                         if (Config->get_plugins_stop_with_transport() && can_flush_processors) {
2047                                 (*i)->deactivate ();
2048                                 (*i)->activate ();
2049                         }
2050
2051                         (*i)->transport_stopped (now);
2052                 }
2053         }
2054
2055         _roll_delay = _initial_delay;
2056 }
2057
2058 void
2059 Route::input_change_handler (IOChange change, void *src)
2060 {
2061         if ((change & ConfigurationChanged)) {
2062                 configure_processors (0);
2063         }
2064 }
2065
2066 void
2067 Route::output_change_handler (IOChange change, void *src)
2068 {
2069         if ((change & ConfigurationChanged)) {
2070
2071                 /* XXX resize all listeners to match _main_outs? */
2072
2073                 // configure_processors (0);
2074         }
2075 }
2076
2077 uint32_t
2078 Route::pans_required () const
2079 {
2080         if (n_outputs().n_audio() < 2) {
2081                 return 0;
2082         }
2083
2084         return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
2085 }
2086
2087 int
2088 Route::no_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
2089                 bool session_state_changing, bool can_record, bool rec_monitors_input)
2090 {
2091         if (n_outputs().n_total() == 0) {
2092                 return 0;
2093         }
2094
2095         if (session_state_changing || !_active || n_inputs() == ChanCount::ZERO)  {
2096                 silence (nframes);
2097                 return 0;
2098         }
2099
2100         _amp->apply_gain_automation (false);
2101         passthru (start_frame, end_frame, nframes, 0);
2102
2103         return 0;
2104 }
2105
2106 nframes_t
2107 Route::check_initial_delay (nframes_t nframes, nframes_t& transport_frame)
2108 {
2109         if (_roll_delay > nframes) {
2110
2111                 _roll_delay -= nframes;
2112                 silence (nframes);
2113                 /* transport frame is not legal for caller to use */
2114                 return 0;
2115
2116         } else if (_roll_delay > 0) {
2117
2118                 nframes -= _roll_delay;
2119                 silence (_roll_delay);
2120                 /* we've written _roll_delay of samples into the
2121                    output ports, so make a note of that for
2122                    future reference.
2123                 */
2124                 _main_outs->increment_output_offset (_roll_delay);
2125                 transport_frame += _roll_delay;
2126
2127                 _roll_delay = 0;
2128         }
2129
2130         return nframes;
2131 }
2132
2133 int
2134 Route::roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame, int declick,
2135              bool can_record, bool rec_monitors_input)
2136 {
2137         {
2138                 // automation snapshot can also be called from the non-rt context
2139                 // and it uses the processor list, so we try to acquire the lock here
2140                 Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2141
2142                 if (lm.locked()) {
2143                         automation_snapshot (_session.transport_frame(), false);
2144                 }
2145         }
2146
2147         if (n_outputs().n_total() == 0) {
2148                 return 0;
2149         }
2150
2151         if (!_active || n_inputs().n_total() == 0) {
2152                 silence (nframes);
2153                 return 0;
2154         }
2155
2156         nframes_t unused = 0;
2157
2158         if ((nframes = check_initial_delay (nframes, unused)) == 0) {
2159                 return 0;
2160         }
2161
2162         _silent = false;
2163
2164         passthru (start_frame, end_frame, nframes, declick);
2165
2166         return 0;
2167 }
2168
2169 int
2170 Route::silent_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
2171                     bool can_record, bool rec_monitors_input)
2172 {
2173         silence (nframes);
2174         return 0;
2175 }
2176
2177 void
2178 Route::toggle_monitor_input ()
2179 {
2180         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
2181                 i->ensure_monitor_input( ! i->monitoring_input());
2182         }
2183 }
2184
2185 bool
2186 Route::has_external_redirects () const
2187 {
2188         // FIXME: what about sends? - they don't return a signal back to ardour?
2189
2190         boost::shared_ptr<const PortInsert> pi;
2191
2192         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2193
2194                 if ((pi = boost::dynamic_pointer_cast<const PortInsert>(*i)) != 0) {
2195
2196                         for (PortSet::const_iterator port = pi->output()->ports().begin(); port != pi->output()->ports().end(); ++port) {
2197
2198                                 string port_name = port->name();
2199                                 string client_name = port_name.substr (0, port_name.find(':'));
2200
2201                                 /* only say "yes" if the redirect is actually in use */
2202
2203                                 if (client_name != "ardour" && pi->active()) {
2204                                         return true;
2205                                 }
2206                         }
2207                 }
2208         }
2209
2210         return false;
2211 }
2212
2213 void
2214 Route::flush_processors ()
2215 {
2216         /* XXX shouldn't really try to take this lock, since
2217            this is called from the RT audio thread.
2218         */
2219
2220         Glib::RWLock::ReaderLock lm (_processor_lock);
2221
2222         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2223                 (*i)->deactivate ();
2224                 (*i)->activate ();
2225         }
2226 }
2227
2228 void
2229 Route::set_meter_point (MeterPoint p, void *src)
2230 {
2231         if (_meter_point != p) {
2232                 _meter_point = p;
2233
2234                 // Move meter in the processors list
2235                 ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), _meter);
2236                 _processors.erase(loc);
2237                 switch (p) {
2238                 case MeterInput:
2239                         loc = _processors.begin();
2240                         break;
2241                 case MeterPreFader:
2242                         loc = find(_processors.begin(), _processors.end(), _amp);
2243                         break;
2244                 case MeterPostFader:
2245                         loc = _processors.end();
2246                         break;
2247                 }
2248                 _processors.insert(loc, _meter);
2249
2250                  meter_change (src); /* EMIT SIGNAL */
2251                 processors_changed (); /* EMIT SIGNAL */
2252                 _session.set_dirty ();
2253         }
2254 }
2255 void
2256 Route::put_control_outs_at (Placement p)
2257 {
2258         if (!_control_outs) {
2259                 return;
2260         }
2261
2262         // Move meter in the processors list
2263         ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), _control_outs);
2264         _processors.erase(loc);
2265
2266         switch (p) {
2267         case PreFader:
2268                 loc = find(_processors.begin(), _processors.end(), _amp);
2269                 if (loc != _processors.begin()) {
2270                         --loc;
2271                 }
2272                 break;
2273         case PostFader:
2274                 loc = find(_processors.begin(), _processors.end(), _amp);
2275                 assert (loc != _processors.end());
2276                 loc++;
2277                 break;
2278         }
2279
2280         _processors.insert(loc, _control_outs);
2281
2282         processors_changed (); /* EMIT SIGNAL */
2283         _session.set_dirty ();
2284 }
2285
2286 nframes_t
2287 Route::update_total_latency ()
2288 {
2289         nframes_t old = _output->effective_latency();
2290         nframes_t own_latency = _output->user_latency();
2291
2292         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2293                 if ((*i)->active ()) {
2294                         own_latency += (*i)->signal_latency ();
2295                 }
2296         }
2297
2298 #undef DEBUG_LATENCY
2299 #ifdef DEBUG_LATENCY
2300         cerr << _name << ": internal redirect latency = " << own_latency << endl;
2301 #endif
2302
2303         _output->set_port_latency (own_latency);
2304
2305         if (_output->user_latency() == 0) {
2306
2307                 /* this (virtual) function is used for pure Routes,
2308                    not derived classes like AudioTrack.  this means
2309                    that the data processed here comes from an input
2310                    port, not prerecorded material, and therefore we
2311                    have to take into account any input latency.
2312                 */
2313
2314                 own_latency += _input->signal_latency ();
2315         }
2316
2317         if (old != own_latency) {
2318                 _output->set_latency_delay (own_latency);
2319                 signal_latency_changed (); /* EMIT SIGNAL */
2320         }
2321
2322 #ifdef DEBUG_LATENCY
2323         cerr << _name << ": input latency = " << _input->signal_latency() << " total = "
2324              << own_latency << endl;
2325 #endif
2326
2327         return _output->effective_latency ();
2328 }
2329
2330 void
2331 Route::set_user_latency (nframes_t nframes)
2332 {
2333         _output->set_user_latency (nframes);
2334         _session.update_latency_compensation (false, false);
2335 }
2336
2337 void
2338 Route::set_latency_delay (nframes_t longest_session_latency)
2339 {
2340         nframes_t old = _initial_delay;
2341
2342         if (_output->effective_latency() < longest_session_latency) {
2343                 _initial_delay = longest_session_latency - _output->effective_latency();
2344         } else {
2345                 _initial_delay = 0;
2346         }
2347
2348         if (_initial_delay != old) {
2349                 initial_delay_changed (); /* EMIT SIGNAL */
2350         }
2351
2352         if (_session.transport_stopped()) {
2353                 _roll_delay = _initial_delay;
2354         }
2355 }
2356
2357 void
2358 Route::automation_snapshot (nframes_t now, bool force)
2359 {
2360         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2361                 (*i)->automation_snapshot (now, force);
2362         }
2363 }
2364
2365 Route::SoloControllable::SoloControllable (std::string name, Route& r)
2366         : AutomationControl (r.session(), Evoral::Parameter (SoloAutomation),
2367                              boost::shared_ptr<AutomationList>(), name)
2368         , route (r)
2369 {
2370         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
2371         set_list (gl);
2372 }
2373
2374 void
2375 Route::SoloControllable::set_value (float val)
2376 {
2377         bool bval = ((val >= 0.5f) ? true: false);
2378
2379         route.set_solo (bval, this);
2380 }
2381
2382 float
2383 Route::SoloControllable::get_value (void) const
2384 {
2385         return route.soloed() ? 1.0f : 0.0f;
2386 }
2387
2388 void
2389 Route::set_block_size (nframes_t nframes)
2390 {
2391         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2392                 (*i)->set_block_size (nframes);
2393         }
2394         _session.ensure_buffers(processor_max_streams);
2395 }
2396
2397 void
2398 Route::protect_automation ()
2399 {
2400         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
2401                 (*i)->protect_automation();
2402 }
2403
2404 void
2405 Route::set_pending_declick (int declick)
2406 {
2407         if (_declickable) {
2408                 /* this call is not allowed to turn off a pending declick unless "force" is true */
2409                 if (declick) {
2410                         _pending_declick = declick;
2411                 }
2412                 // cerr << _name << ": after setting to " << declick << " pending declick = " << _pending_declick << endl;
2413         } else {
2414                 _pending_declick = 0;
2415         }
2416
2417 }
2418
2419 /** Shift automation forwards from a particular place, thereby inserting time.
2420  *  Adds undo commands for any shifts that are performed.
2421  *
2422  * @param pos Position to start shifting from.
2423  * @param frames Amount to shift forwards by.
2424  */
2425
2426 void
2427 Route::shift (nframes64_t pos, nframes64_t frames)
2428 {
2429 #ifdef THIS_NEEDS_FIXING_FOR_V3
2430
2431         /* gain automation */
2432         XMLNode &before = _gain_control->get_state ();
2433         _gain_control->shift (pos, frames);
2434         XMLNode &after = _gain_control->get_state ();
2435         _session.add_command (new MementoCommand<AutomationList> (_gain_automation_curve, &before, &after));
2436
2437         /* pan automation */
2438         for (std::vector<StreamPanner*>::iterator i = _panner->begin (); i != _panner->end (); ++i) {
2439                 Curve & c = (*i)->automation ();
2440                 XMLNode &before = c.get_state ();
2441                 c.shift (pos, frames);
2442                 XMLNode &after = c.get_state ();
2443                 _session.add_command (new MementoCommand<AutomationList> (c, &before, &after));
2444         }
2445
2446         /* redirect automation */
2447         {
2448                 Glib::RWLock::ReaderLock lm (redirect_lock);
2449                 for (RedirectList::iterator i = _redirects.begin (); i != _redirects.end (); ++i) {
2450
2451                         set<uint32_t> a;
2452                         (*i)->what_has_automation (a);
2453
2454                         for (set<uint32_t>::const_iterator j = a.begin (); j != a.end (); ++j) {
2455                                 AutomationList & al = (*i)->automation_list (*j);
2456                                 XMLNode &before = al.get_state ();
2457                                 al.shift (pos, frames);
2458                                 XMLNode &after = al.get_state ();
2459                                 _session.add_command (new MementoCommand<AutomationList> (al, &before, &after));
2460                         }
2461                 }
2462         }
2463 #endif
2464
2465 }
2466
2467
2468 int
2469 Route::save_as_template (const string& path, const string& name)
2470 {
2471         XMLNode& node (state (false));
2472         XMLTree tree;
2473
2474         IO::set_name_in_state (*node.children().front(), name);
2475
2476         tree.set_root (&node);
2477         return tree.write (path.c_str());
2478 }
2479
2480
2481 bool
2482 Route::set_name (const string& str)
2483 {
2484         bool ret;
2485         string ioproc_name;
2486         string name;
2487
2488         name = Route::ensure_track_or_route_name (str, _session);
2489         SessionObject::set_name (name);
2490
2491         ret = (_input->set_name(name) && _output->set_name(name));
2492
2493         if (ret) {
2494
2495                 Glib::RWLock::ReaderLock lm (_processor_lock);
2496
2497                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2498
2499                         /* rename all I/O processors that have inputs or outputs */
2500
2501                         boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
2502
2503                         if (iop && (iop->output() || iop->input())) {
2504                                 if (!iop->set_name (name)) {
2505                                         ret = false;
2506                                 }
2507                         }
2508                 }
2509
2510         }
2511
2512         return ret;
2513 }
2514
2515 boost::shared_ptr<Send>
2516 Route::internal_send_for (boost::shared_ptr<const Route> target) const
2517 {
2518         Glib::RWLock::ReaderLock lm (_processor_lock);
2519
2520         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2521                 boost::shared_ptr<InternalSend> send;
2522
2523                 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
2524                         if (send->target_route() == target) {
2525                                 return send;
2526                         }
2527                 }
2528         }
2529
2530         return boost::shared_ptr<Send>();
2531 }
2532
2533 void
2534 Route::set_phase_invert (bool yn)
2535 {
2536         if (_phase_invert != yn) {
2537                 _phase_invert = 0xffff; // XXX all channels
2538                 phase_invert_changed (); /* EMIT SIGNAL */
2539         }
2540 }
2541
2542 bool
2543 Route::phase_invert () const
2544 {
2545         return _phase_invert != 0;
2546 }
2547
2548 void
2549 Route::set_denormal_protection (bool yn)
2550 {
2551         if (_denormal_protection != yn) {
2552                 _denormal_protection = yn;
2553                 denormal_protection_changed (); /* EMIT SIGNAL */
2554         }
2555 }
2556
2557 bool
2558 Route::denormal_protection () const
2559 {
2560         return _denormal_protection;
2561 }
2562
2563 void
2564 Route::set_active (bool yn)
2565 {
2566         if (_active != yn) {
2567                 _active = yn;
2568                 _input->set_active (yn);
2569                 _output->set_active (yn);
2570                 active_changed (); // EMIT SIGNAL
2571         }
2572 }
2573
2574 void
2575 Route::meter ()
2576 {
2577         Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
2578         _meter->meter ();
2579 }
2580
2581 boost::shared_ptr<Panner>
2582 Route::panner() const
2583 {
2584
2585         return _main_outs->panner();
2586 }
2587
2588 boost::shared_ptr<AutomationControl>
2589 Route::gain_control() const
2590 {
2591
2592         return _amp->gain_control();
2593 }
2594
2595 boost::shared_ptr<AutomationControl>
2596 Route::get_control (const Evoral::Parameter& param)
2597 {
2598         /* either we own the control or .... */
2599
2600         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(data().control (param));
2601
2602         if (!c) {
2603
2604                 /* maybe one of our processors does or ... */
2605
2606                 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
2607                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2608                         if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->data().control (param))) != 0) {
2609                                 break;
2610                         }
2611                 }
2612         }
2613
2614         if (!c) {
2615
2616                 /* nobody does so we'll make a new one */
2617
2618                 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
2619                 add_control(c);
2620         }
2621
2622         return c;
2623 }