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,const char*> 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[strdup (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         for (OrderKeys::iterator i = order_keys.begin(); i != order_keys.end(); ++i) {
 167                 free ((void*)(i->first));
 168         }
 169 }
 170
 171 void
 172 Route::set_remote_control_id (uint32_t id)
 173 {
 174         if (id != _remote_control_id) {
 175                 _remote_control_id = id;
 176                 RemoteControlIDChanged ();
 177         }
 178 }
 179
 180 uint32_t
 181 Route::remote_control_id() const
 182 {
 183         return _remote_control_id;
 184 }
 185
 186 long
 187 Route::order_key (const char* name) const
 188 {
 189         OrderKeys::const_iterator i;
 190
 191         for (i = order_keys.begin(); i != order_keys.end(); ++i) {
 192                 if (!strcmp (name, i->first)) {
 193                         return i->second;
 194                 }
 195         }
 196
 197         return -1;
 198 }
 199
 200 void
 201 Route::set_order_key (const char* name, long n)
 202 {
 203         order_keys[strdup(name)] = n;
 204
 205         if (Config->get_sync_all_route_ordering()) {
 206                 for (OrderKeys::iterator x = order_keys.begin(); x != order_keys.end(); ++x) {
 207                         x->second = n;
 208                 }
 209         }
 210
 211         _session.set_dirty ();
 212 }
 213
 214 void
 215 Route::sync_order_keys (const char* base)
 216 {
 217         if (order_keys.empty()) {
 218                 return;
 219         }
 220
 221         OrderKeys::iterator i;
 222         uint32_t key;
 223
 224         if ((i = order_keys.find (base)) == order_keys.end()) {
 225                 /* key doesn't exist, use the first existing key (during session initialization) */
 226                 i = order_keys.begin();
 227                 key = i->second;
 228                 ++i;
 229         } else {
 230                 /* key exists - use it and reset all others (actually, itself included) */
 231                 key = i->second;
 232                 i = order_keys.begin();
 233         }
 234
 235         for (; i != order_keys.end(); ++i) {
 236                 i->second = key;
 237         }
 238 }
 239
 240 string
 241 Route::ensure_track_or_route_name(string name, Session &session)
 242 {
 243         string newname = name;
 244
 245         while (session.route_by_name (newname) != NULL) {
 246                 newname = bump_name_once (newname);
 247         }
 248
 249         return newname;
 250 }
 251
 252
 253 void
 254 Route::inc_gain (gain_t fraction, void *src)
 255 {
 256         _amp->inc_gain (fraction, src);
 257 }
 258
 259 void
 260 Route::set_gain (gain_t val, void *src)
 261 {
 262         if (src != 0 && _route_group && src != _route_group && _route_group->active_property (RouteGroup::Gain)) {
 263
 264                 if (_route_group->is_relative()) {
 265
 266                         gain_t usable_gain = _amp->gain();
 267                         if (usable_gain < 0.000001f) {
 268                                 usable_gain = 0.000001f;
 269                         }
 270
 271                         gain_t delta = val;
 272                         if (delta < 0.000001f) {
 273                                 delta = 0.000001f;
 274                         }
 275
 276                         delta -= usable_gain;
 277
 278                         if (delta == 0.0f)
 279                                 return;
 280
 281                         gain_t factor = delta / usable_gain;
 282
 283                         if (factor > 0.0f) {
 284                                 factor = _route_group->get_max_factor(factor);
 285                                 if (factor == 0.0f) {
 286                                         _amp->gain_control()->Changed(); /* EMIT SIGNAL */
 287                                         return;
 288                                 }
 289                         } else {
 290                                 factor = _route_group->get_min_factor(factor);
 291                                 if (factor == 0.0f) {
 292                                         _amp->gain_control()->Changed(); /* EMIT SIGNAL */
 293                                         return;
 294                                 }
 295                         }
 296
 297                         _route_group->apply (&Route::inc_gain, factor, _route_group);
 298
 299                 } else {
 300
 301                         _route_group->apply (&Route::set_gain, val, _route_group);
 302                 }
 303
 304                 return;
 305         }
 306
 307         if (val == _amp->gain()) {
 308                 return;
 309         }
 310
 311         _amp->set_gain (val, src);
 312 }
 313
 314 /** Process this route for one (sub) cycle (process thread)
 315  *
 316  * @param bufs Scratch buffers to use for the signal path
 317  * @param start_frame Initial transport frame
 318  * @param end_frame Final transport frame
 319  * @param nframes Number of frames to output (to ports)
 320  *
 321  * Note that (end_frame - start_frame) may not be equal to nframes when the
 322  * transport speed isn't 1.0 (eg varispeed).
 323  */
 324 void
 325 Route::process_output_buffers (BufferSet& bufs,
 326                                sframes_t start_frame, sframes_t end_frame, nframes_t nframes,
 327                                bool with_processors, int declick)
 328 {
 329         bool monitor;
 330
 331         bufs.is_silent (false);
 332
 333         switch (Config->get_monitoring_model()) {
 334         case HardwareMonitoring:
 335         case ExternalMonitoring:
 336                 monitor = !record_enabled() || (_session.config.get_auto_input() && !_session.actively_recording());
 337                 break;
 338         default:
 339                 monitor = true;
 340         }
 341
 342         if (!declick) {
 343                 declick = _pending_declick;
 344         }
 345
 346         /* figure out if we're going to use gain automation */
 347         _amp->setup_gain_automation (start_frame, end_frame, nframes);
 348
 349
 350         /* tell main outs what to do about monitoring */
 351         _main_outs->no_outs_cuz_we_no_monitor (!monitor);
 352
 353
 354         /* -------------------------------------------------------------------------------------------
 355            GLOBAL DECLICK (for transport changes etc.)
 356            ----------------------------------------------------------------------------------------- */
 357
 358         if (declick > 0) {
 359                 Amp::apply_gain (bufs, nframes, 0.0, 1.0);
 360         } else if (declick < 0) {
 361                 Amp::apply_gain (bufs, nframes, 1.0, 0.0);
 362         }
 363
 364         _pending_declick = 0;
 365
 366         /* -------------------------------------------------------------------------------------------
 367            DENORMAL CONTROL/PHASE INVERT
 368            ----------------------------------------------------------------------------------------- */
 369
 370         if (_phase_invert) {
 371
 372                 int chn = 0;
 373
 374                 if (_denormal_protection || Config->get_denormal_protection()) {
 375
 376                         for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
 377                                 Sample* const sp = i->data();
 378
 379                                 if (_phase_invert & chn) {
 380                                         for (nframes_t nx = 0; nx < nframes; ++nx) {
 381                                                 sp[nx]  = -sp[nx];
 382                                                 sp[nx] += 1.0e-27f;
 383                                         }
 384                                 } else {
 385                                         for (nframes_t nx = 0; nx < nframes; ++nx) {
 386                                                 sp[nx] += 1.0e-27f;
 387                                         }
 388                                 }
 389                         }
 390
 391                 } else {
 392
 393                         for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
 394                                 Sample* const sp = i->data();
 395
 396                                 if (_phase_invert & chn) {
 397                                         for (nframes_t nx = 0; nx < nframes; ++nx) {
 398                                                 sp[nx] = -sp[nx];
 399                                         }
 400                                 }
 401                         }
 402                 }
 403
 404         } else {
 405
 406                 if (_denormal_protection || Config->get_denormal_protection()) {
 407
 408                         for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
 409                                 Sample* const sp = i->data();
 410                                 for (nframes_t nx = 0; nx < nframes; ++nx) {
 411                                         sp[nx] += 1.0e-27f;
 412                                 }
 413                         }
 414
 415                 }
 416         }
 417
 418         /* -------------------------------------------------------------------------------------------
 419            and go ....
 420            ----------------------------------------------------------------------------------------- */
 421
 422         Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
 423
 424         if (rm.locked()) {
 425                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 426                         bufs.set_count (ChanCount::max(bufs.count(), (*i)->input_streams()));
 427                         (*i)->run (bufs, start_frame, end_frame, nframes);
 428                         bufs.set_count (ChanCount::max(bufs.count(), (*i)->output_streams()));
 429                 }
 430
 431                 if (!_processors.empty()) {
 432                         bufs.set_count (ChanCount::max (bufs.count(), _processors.back()->output_streams()));
 433                 }
 434         }
 435 }
 436
 437 ChanCount
 438 Route::n_process_buffers ()
 439 {
 440         return max (_input->n_ports(), processor_max_streams);
 441 }
 442
 443 void
 444 Route::passthru (sframes_t start_frame, sframes_t end_frame, nframes_t nframes, int declick)
 445 {
 446         BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers());
 447
 448         _silent = false;
 449
 450         assert (bufs.available() >= _input->n_ports());
 451
 452         if (_input->n_ports() == ChanCount::ZERO) {
 453                 silence (nframes);
 454         }
 455
 456         bufs.set_count (_input->n_ports());
 457
 458         if (is_control() && _session.listening()) {
 459
 460                 /* control/monitor bus ignores input ports when something is
 461                    feeding the listen "stream". data will "arrive" into the
 462                    route from the intreturn processor element.
 463                 */
 464
 465                 bufs.silence (nframes, 0);
 466
 467         } else {
 468
 469                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 470
 471                         BufferSet::iterator o = bufs.begin(*t);
 472                         PortSet& ports (_input->ports());
 473
 474                         for (PortSet::iterator i = ports.begin(*t); i != ports.end(*t); ++i, ++o) {
 475                                 o->read_from (i->get_buffer(nframes), nframes);
 476                         }
 477                 }
 478         }
 479
 480         process_output_buffers (bufs, start_frame, end_frame, nframes, true, declick);
 481 }
 482
 483 void
 484 Route::passthru_silence (sframes_t start_frame, sframes_t end_frame, nframes_t nframes, int declick)
 485 {
 486         process_output_buffers (_session.get_silent_buffers (n_process_buffers()), start_frame, end_frame, nframes, true, declick);
 487 }
 488
 489 void
 490 Route::set_listen (bool yn, void* src)
 491 {
 492         if (_control_outs) {
 493                 if (yn != _control_outs->active()) {
 494                         if (yn) {
 495                                 _control_outs->activate ();
 496                         } else {
 497                                 _control_outs->deactivate ();
 498                         }
 499
 500                         listen_changed (src); /* EMIT SIGNAL */
 501                 }
 502         }
 503 }
 504
 505 bool
 506 Route::listening () const
 507 {
 508         if (_control_outs) {
 509                 return _control_outs->active ();
 510         } else {
 511                 return false;
 512         }
 513 }
 514
 515 void
 516 Route::set_solo (bool yn, void *src)
 517 {
 518         if (_solo_safe || _solo_isolated) {
 519                 return;
 520         }
 521
 522         if (_route_group && src != _route_group && _route_group->active_property (RouteGroup::Solo)) {
 523                 _route_group->apply (&Route::set_solo, yn, _route_group);
 524                 return;
 525         }
 526
 527         if (soloed() != yn) {
 528                 mod_solo_level (yn ? 1 : -1);
 529                 solo_changed (src); /* EMIT SIGNAL */
 530                 _solo_control->Changed (); /* EMIT SIGNAL */
 531         }
 532 }
 533
 534 void
 535 Route::mod_solo_level (int32_t delta)
 536 {
 537         if (delta < 0) {
 538                 if (_solo_level >= (uint32_t) delta) {
 539                         _solo_level += delta;
 540                 } else {
 541                         _solo_level = 0;
 542                 }
 543         } else {
 544                 _solo_level += delta;
 545         }
 546
 547         /* tell main outs what the solo situation is
 548          */
 549
 550         _main_outs->set_solo_level (_solo_level);
 551         _main_outs->set_solo_isolated (_solo_isolated);
 552 }
 553
 554 void
 555 Route::set_solo_isolated (bool yn, void *src)
 556 {
 557         if (_route_group && src != _route_group && _route_group->active_property (RouteGroup::Solo)) {
 558                 _route_group->apply (&Route::set_solo_isolated, yn, _route_group);
 559                 return;
 560         }
 561
 562         if (yn != _solo_isolated) {
 563                 _solo_isolated = yn;
 564
 565                 /* tell main outs what the solo situation is
 566                  */
 567
 568                 _main_outs->set_solo_level (_solo_level);
 569                 _main_outs->set_solo_isolated (_solo_isolated);
 570
 571                 solo_isolated_changed (src);
 572         }
 573 }
 574
 575 bool
 576 Route::solo_isolated () const
 577 {
 578         return _solo_isolated;
 579 }
 580
 581 void
 582 Route::set_mute (bool yn, void *src)
 583 {
 584         if (_route_group && src != _route_group && _route_group->active_property (RouteGroup::Mute)) {
 585                 _route_group->apply (&Route::set_mute, yn, _route_group);
 586                 return;
 587         }
 588
 589         if (muted() != yn) {
 590                 _mute_master->mute (yn);
 591                 mute_changed (src);
 592         }
 593 }
 594
 595 bool
 596 Route::muted() const
 597 {
 598         return _mute_master->muted ();
 599 }
 600
 601 #if 0
 602 static void
 603 dump_processors(const string& name, const list<boost::shared_ptr<Processor> >& procs)
 604 {
 605         cerr << name << " {" << endl;
 606         for (list<boost::shared_ptr<Processor> >::const_iterator p = procs.begin();
 607                         p != procs.end(); ++p) {
 608                 cerr << "\t" << (*p)->name() << " ID = " << (*p)->id() << endl;
 609         }
 610         cerr << "}" << endl;
 611 }
 612 #endif
 613
 614 int
 615 Route::add_processor (boost::shared_ptr<Processor> processor, Placement placement, ProcessorStreams* err)
 616 {
 617         ProcessorList::iterator loc;
 618
 619         /* XXX this is not thread safe - we don't hold the lock across determining the iter
 620            to add before and actually doing the insertion. dammit.
 621         */
 622
 623         if (placement == PreFader) {
 624                 /* generic pre-fader: insert immediately before the amp */
 625                 loc = find(_processors.begin(), _processors.end(), _amp);
 626         } else {
 627                 /* generic post-fader: insert at end */
 628                 loc = _processors.end();
 629
 630                 if (processor->visible() && !_processors.empty()) {
 631                         /* check for invisible processors stacked at the end and leave them there */
 632                         ProcessorList::iterator p;
 633                         p = _processors.end();
 634                         --p;
 635                         while (!(*p)->visible() && p != _processors.begin()) {
 636                                 --p;
 637                         }
 638                         ++p;
 639                         loc = p;
 640                 }
 641         }
 642
 643         return add_processor (processor, loc, err);
 644 }
 645
 646
 647 /** Add a processor to the route.
 648  * If @a iter is not NULL, it must point to an iterator in _processors and the new
 649  * processor will be inserted immediately before this location.  Otherwise,
 650  * @a position is used.
 651  */
 652 int
 653 Route::add_processor (boost::shared_ptr<Processor> processor, ProcessorList::iterator iter, ProcessorStreams* err)
 654 {
 655         ChanCount old_pms = processor_max_streams;
 656
 657         if (!_session.engine().connected() || !processor) {
 658                 return 1;
 659         }
 660
 661         {
 662                 Glib::RWLock::WriterLock lm (_processor_lock);
 663
 664                 boost::shared_ptr<PluginInsert> pi;
 665                 boost::shared_ptr<PortInsert> porti;
 666
 667                 ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), processor);
 668
 669                 if (processor == _amp || processor == _meter || processor == _main_outs) {
 670                         // Ensure only one of these are in the list at any time
 671                         if (loc != _processors.end()) {
 672                                 if (iter == loc) { // Already in place, do nothing
 673                                         return 0;
 674                                 } else { // New position given, relocate
 675                                         _processors.erase (loc);
 676                                 }
 677                         }
 678
 679                 } else {
 680                         if (loc != _processors.end()) {
 681                                 cerr << "ERROR: Processor added to route twice!" << endl;
 682                                 return 1;
 683                         }
 684
 685                         loc = iter;
 686                 }
 687
 688                 _processors.insert (loc, processor);
 689
 690                 // Set up processor list channels.  This will set processor->[input|output]_streams(),
 691                 // configure redirect ports properly, etc.
 692
 693
 694                 if (configure_processors_unlocked (err)) {
 695                         ProcessorList::iterator ploc = loc;
 696                         --ploc;
 697                         _processors.erase(ploc);
 698                         configure_processors_unlocked (0); // it worked before we tried to add it ...
 699                         cerr << "configure failed\n";
 700                         return -1;
 701                 }
 702
 703                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(processor)) != 0) {
 704
 705                         if (pi->natural_input_streams() == ChanCount::ZERO) {
 706                                 /* generator plugin */
 707                                 _have_internal_generator = true;
 708                         }
 709
 710                 }
 711
 712                 // XXX: do we want to emit the signal here ? change call order.
 713                 if (!boost::dynamic_pointer_cast<InternalSend>(processor)) {
 714                         processor->activate ();
 715                 }
 716                 processor->ActiveChanged.connect (bind (mem_fun (_session, &Session::update_latency_compensation), false, false));
 717
 718                 _output->set_user_latency (0);
 719         }
 720
 721         processors_changed (); /* EMIT SIGNAL */
 722
 723         return 0;
 724 }
 725
 726 bool
 727 Route::add_processor_from_xml (const XMLNode& node, Placement placement)
 728 {
 729         ProcessorList::iterator loc;
 730
 731         if (placement == PreFader) {
 732                 /* generic pre-fader: insert immediately before the amp */
 733                 loc = find(_processors.begin(), _processors.end(), _amp);
 734         } else {
 735                 /* generic post-fader: insert at end */
 736                 loc = _processors.end();
 737         }
 738
 739         return add_processor_from_xml (node, loc);
 740 }
 741
 742 bool
 743 Route::add_processor_from_xml (const XMLNode& node, ProcessorList::iterator iter)
 744 {
 745         const XMLProperty *prop;
 746
 747         // legacy sessions use a different node name for sends
 748         if (node.name() == "Send") {
 749
 750                 try {
 751                         boost::shared_ptr<Send> send (new Send (_session, _mute_master, node));
 752                         add_processor (send, iter);
 753                         return true;
 754                 }
 755
 756                 catch (failed_constructor &err) {
 757                         error << _("Send construction failed") << endmsg;
 758                         return false;
 759                 }
 760
 761         } else if (node.name() == "Processor") {
 762
 763                 try {
 764                         if ((prop = node.property ("type")) != 0) {
 765
 766                                 boost::shared_ptr<Processor> processor;
 767
 768                                 if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
 769                                     prop->value() == "lv2" ||
 770                                     prop->value() == "vst" ||
 771                                     prop->value() == "audiounit") {
 772
 773                                         processor.reset (new PluginInsert(_session, node));
 774
 775                                 } else if (prop->value() == "port") {
 776
 777                                         processor.reset (new PortInsert (_session, _mute_master, node));
 778
 779                                 } else if (prop->value() == "send") {
 780
 781                                         processor.reset (new Send (_session, _mute_master, node));
 782
 783                                 } else if (prop->value() == "meter") {
 784
 785                                         if (_meter) {
 786                                                 if (_meter->set_state (node)) {
 787                                                         return false;
 788                                                 } else {
 789                                                         return true;
 790                                                 }
 791                                         }
 792
 793                                         _meter.reset (new PeakMeter (_session, node));
 794                                         processor = _meter;
 795
 796                                 } else if (prop->value() == "amp") {
 797
 798                                         /* amp always exists */
 799
 800                                         processor = _amp;
 801                                         if (processor->set_state (node)) {
 802                                                 return false;
 803                                         } else {
 804                                                 /* never any reason to add it */
 805                                                 return true;
 806                                         }
 807
 808                                 } else if (prop->value() == "listen" || prop->value() == "deliver") {
 809
 810                                         /* XXX need to generalize */
 811
 812                                 } else if (prop->value() == "intsend") {
 813
 814                                         processor.reset (new InternalSend (_session, _mute_master, node));
 815
 816                                 } else if (prop->value() == "intreturn") {
 817
 818                                         if (_intreturn) {
 819                                                 if (_intreturn->set_state (node)) {
 820                                                         return false;
 821                                                 } else {
 822                                                         return true;
 823                                                 }
 824                                         }
 825                                         _intreturn.reset (new InternalReturn (_session, node));
 826                                         processor = _intreturn;
 827
 828                                 } else if (prop->value() == "main-outs") {
 829
 830                                         if (_main_outs) {
 831                                                 if (_main_outs->set_state (node)) {
 832                                                         return false;
 833                                                 } else {
 834                                                         return true;
 835                                                 }
 836                                         }
 837
 838                                         _main_outs.reset (new Delivery (_session, _output, _mute_master, node));
 839                                         processor = _main_outs;
 840
 841                                 } else {
 842                                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
 843                                 }
 844
 845                                 if (iter == _processors.end() && processor->visible() && !_processors.empty()) {
 846                                         /* check for invisible processors stacked at the end and leave them there */
 847                                         ProcessorList::iterator p;
 848                                         p = _processors.end();
 849                                         --p;
 850                                         while (!(*p)->visible() && p != _processors.begin()) {
 851                                                 --p;
 852                                         }
 853                                         ++p;
 854                                         iter = p;
 855                                 }
 856
 857                                 return (add_processor (processor, iter) == 0);
 858
 859                         } else {
 860                                 error << _("Processor XML node has no type property") << endmsg;
 861                         }
 862                 }
 863
 864                 catch (failed_constructor &err) {
 865                         warning << _("processor could not be created. Ignored.") << endmsg;
 866                         return false;
 867                 }
 868         }
 869         return false;
 870 }
 871
 872 int
 873 Route::add_processors (const ProcessorList& others, Placement placement, ProcessorStreams* err)
 874 {
 875         ProcessorList::iterator loc;
 876         if (placement == PreFader) {
 877                 /* generic pre-fader: insert immediately before the amp */
 878                 loc = find(_processors.begin(), _processors.end(), _amp);
 879         } else {
 880                 /* generic post-fader: insert at end */
 881                 loc = _processors.end();
 882
 883                 if (!_processors.empty()) {
 884                         /* check for invisible processors stacked at the end and leave them there */
 885                         ProcessorList::iterator p;
 886                         p = _processors.end();
 887                         --p;
 888                         cerr << "Let's check " << (*p)->name() << " vis ? " << (*p)->visible() << endl;
 889                         while (!(*p)->visible() && p != _processors.begin()) {
 890                                 --p;
 891                         }
 892                         ++p;
 893                         loc = p;
 894                 }
 895         }
 896
 897         return add_processors (others, loc, err);
 898 }
 899
 900 int
 901 Route::add_processors (const ProcessorList& others, ProcessorList::iterator iter, ProcessorStreams* err)
 902 {
 903         /* NOTE: this is intended to be used ONLY when copying
 904            processors from another Route. Hence the subtle
 905            differences between this and ::add_processor()
 906         */
 907
 908         ChanCount old_pms = processor_max_streams;
 909
 910         if (!_session.engine().connected()) {
 911                 return 1;
 912         }
 913
 914         if (others.empty()) {
 915                 return 0;
 916         }
 917
 918         {
 919                 Glib::RWLock::WriterLock lm (_processor_lock);
 920                 ProcessorList::iterator existing_end = _processors.end();
 921                 --existing_end;
 922
 923                 ChanCount potential_max_streams = ChanCount::max (_input->n_ports(), _output->n_ports());
 924
 925                 for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
 926
 927                         // Ensure meter only appears in the list once
 928                         if (*i == _meter) {
 929                                 ProcessorList::iterator m = find(_processors.begin(), _processors.end(), *i);
 930                                 if (m != _processors.end()) {
 931                                         _processors.erase(m);
 932                                 }
 933                         }
 934
 935                         boost::shared_ptr<PluginInsert> pi;
 936
 937                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
 938                                 pi->set_count (1);
 939
 940                                 ChanCount m = max(pi->input_streams(), pi->output_streams());
 941                                 if (m > potential_max_streams)
 942                                         potential_max_streams = m;
 943                         }
 944
 945                         _processors.insert (iter, *i);
 946
 947                         if (configure_processors_unlocked (err)) {
 948                                 ++existing_end;
 949                                 _processors.erase (existing_end, _processors.end());
 950                                 configure_processors_unlocked (0); // it worked before we tried to add it ...
 951                                 return -1;
 952                         }
 953
 954                         (*i)->ActiveChanged.connect (bind (mem_fun (_session, &Session::update_latency_compensation), false, false));
 955                 }
 956
 957                 _output->set_user_latency (0);
 958         }
 959
 960         processors_changed (); /* EMIT SIGNAL */
 961
 962         return 0;
 963 }
 964
 965 void
 966 Route::placement_range(Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end)
 967 {
 968         if (p == PreFader) {
 969                 start = _processors.begin();
 970                 end = find(_processors.begin(), _processors.end(), _amp);
 971         } else {
 972                 start = find(_processors.begin(), _processors.end(), _amp);
 973                 ++start;
 974                 end = _processors.end();
 975         }
 976 }
 977
 978 /** Turn off all processors with a given placement
 979  * @param p Placement of processors to disable
 980  */
 981 void
 982 Route::disable_processors (Placement p)
 983 {
 984         Glib::RWLock::ReaderLock lm (_processor_lock);
 985
 986         ProcessorList::iterator start, end;
 987         placement_range(p, start, end);
 988
 989         for (ProcessorList::iterator i = start; i != end; ++i) {
 990                 (*i)->deactivate ();
 991         }
 992
 993         _session.set_dirty ();
 994 }
 995
 996 /** Turn off all redirects
 997  */
 998 void
 999 Route::disable_processors ()
1000 {
1001         Glib::RWLock::ReaderLock lm (_processor_lock);
1002
1003         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1004                 (*i)->deactivate ();
1005         }
1006
1007         _session.set_dirty ();
1008 }
1009
1010 /** Turn off all redirects with a given placement
1011  * @param p Placement of redirects to disable
1012  */
1013 void
1014 Route::disable_plugins (Placement p)
1015 {
1016         Glib::RWLock::ReaderLock lm (_processor_lock);
1017
1018         ProcessorList::iterator start, end;
1019         placement_range(p, start, end);
1020
1021         for (ProcessorList::iterator i = start; i != end; ++i) {
1022                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1023                         (*i)->deactivate ();
1024                 }
1025         }
1026
1027         _session.set_dirty ();
1028 }
1029
1030 /** Turn off all plugins
1031  */
1032 void
1033 Route::disable_plugins ()
1034 {
1035         Glib::RWLock::ReaderLock lm (_processor_lock);
1036
1037         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1038                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1039                         (*i)->deactivate ();
1040                 }
1041         }
1042
1043         _session.set_dirty ();
1044 }
1045
1046
1047 void
1048 Route::ab_plugins (bool forward)
1049 {
1050         Glib::RWLock::ReaderLock lm (_processor_lock);
1051
1052         if (forward) {
1053
1054                 /* forward = turn off all active redirects, and mark them so that the next time
1055                    we go the other way, we will revert them
1056                 */
1057
1058                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1059                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1060                                 continue;
1061                         }
1062
1063                         if ((*i)->active()) {
1064                                 (*i)->deactivate ();
1065                                 (*i)->set_next_ab_is_active (true);
1066                         } else {
1067                                 (*i)->set_next_ab_is_active (false);
1068                         }
1069                 }
1070
1071         } else {
1072
1073                 /* backward = if the redirect was marked to go active on the next ab, do so */
1074
1075                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1076
1077                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1078                                 continue;
1079                         }
1080
1081                         if ((*i)->get_next_ab_is_active()) {
1082                                 (*i)->activate ();
1083                         } else {
1084                                 (*i)->deactivate ();
1085                         }
1086                 }
1087         }
1088
1089         _session.set_dirty ();
1090 }
1091
1092
1093 /** Remove processors with a given placement.
1094  * @param p Placement of processors to remove.
1095  */
1096 void
1097 Route::clear_processors (Placement p)
1098 {
1099         const ChanCount old_pms = processor_max_streams;
1100
1101         if (!_session.engine().connected()) {
1102                 return;
1103         }
1104
1105         bool already_deleting = _session.deletion_in_progress();
1106         if (!already_deleting) {
1107                 _session.set_deletion_in_progress();
1108         }
1109
1110         {
1111                 Glib::RWLock::WriterLock lm (_processor_lock);
1112                 ProcessorList new_list;
1113                 ProcessorStreams err;
1114
1115                 ProcessorList::iterator amp_loc = find(_processors.begin(), _processors.end(), _amp);
1116                 if (p == PreFader) {
1117                         // Get rid of PreFader processors
1118                         for (ProcessorList::iterator i = _processors.begin(); i != amp_loc; ++i) {
1119                                 (*i)->drop_references ();
1120                         }
1121                         // Keep the rest
1122                         for (ProcessorList::iterator i = amp_loc; i != _processors.end(); ++i) {
1123                                 new_list.push_back (*i);
1124                         }
1125                 } else {
1126                         // Keep PreFader processors
1127                         for (ProcessorList::iterator i = _processors.begin(); i != amp_loc; ++i) {
1128                                 new_list.push_back (*i);
1129                         }
1130                         new_list.push_back (_amp);
1131                         // Get rid of PostFader processors
1132                         for (ProcessorList::iterator i = amp_loc; i != _processors.end(); ++i) {
1133                                 (*i)->drop_references ();
1134                         }
1135                 }
1136
1137                 _processors = new_list;
1138                 configure_processors_unlocked (&err); // this can't fail
1139         }
1140
1141         processor_max_streams.reset();
1142         _have_internal_generator = false;
1143         processors_changed (); /* EMIT SIGNAL */
1144
1145         if (!already_deleting) {
1146                 _session.clear_deletion_in_progress();
1147         }
1148 }
1149
1150 int
1151 Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err)
1152 {
1153         /* these can never be removed */
1154
1155         if (processor == _amp || processor == _meter || processor == _main_outs) {
1156                 return 0;
1157         }
1158
1159         ChanCount old_pms = processor_max_streams;
1160
1161         if (!_session.engine().connected()) {
1162                 return 1;
1163         }
1164
1165         processor_max_streams.reset();
1166
1167         {
1168                 Glib::RWLock::WriterLock lm (_processor_lock);
1169                 ProcessorList::iterator i;
1170                 bool removed = false;
1171
1172                 for (i = _processors.begin(); i != _processors.end(); ) {
1173                         if (*i == processor) {
1174
1175                                 /* move along, see failure case for configure_processors()
1176                                    where we may need to reconfigure the processor.
1177                                 */
1178
1179                                 /* stop redirects that send signals to JACK ports
1180                                    from causing noise as a result of no longer being
1181                                    run.
1182                                 */
1183
1184                                 boost::shared_ptr<IOProcessor> iop;
1185
1186                                 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (*i)) != 0) {
1187                                         if (iop->input()) {
1188                                                 iop->input()->disconnect (this);
1189                                         }
1190                                         if (iop->output()) {
1191                                                 iop->output()->disconnect (this);
1192                                         }
1193                                 }
1194
1195                                 i = _processors.erase (i);
1196                                 removed = true;
1197                                 break;
1198
1199                         } else {
1200                                 ++i;
1201                         }
1202
1203                         _output->set_user_latency (0);
1204                 }
1205
1206                 if (!removed) {
1207                         /* what? */
1208                         return 1;
1209                 }
1210
1211                 if (configure_processors_unlocked (err)) {
1212                         /* get back to where we where */
1213                         _processors.insert (i, processor);
1214                         /* we know this will work, because it worked before :) */
1215                         configure_processors_unlocked (0);
1216                         return -1;
1217                 }
1218
1219                 _have_internal_generator = false;
1220
1221                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1222                         boost::shared_ptr<PluginInsert> pi;
1223
1224                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1225                                 if (pi->is_generator()) {
1226                                         _have_internal_generator = true;
1227                                         break;
1228                                 }
1229                         }
1230                 }
1231         }
1232
1233         processor->drop_references ();
1234         processors_changed (); /* EMIT SIGNAL */
1235
1236         return 0;
1237 }
1238
1239 int
1240 Route::configure_processors (ProcessorStreams* err)
1241 {
1242         if (!_in_configure_processors) {
1243                 Glib::RWLock::WriterLock lm (_processor_lock);
1244                 return configure_processors_unlocked (err);
1245         }
1246         return 0;
1247 }
1248
1249 /** Configure the input/output configuration of each processor in the processors list.
1250  * Return 0 on success, otherwise configuration is impossible.
1251  */
1252 int
1253 Route::configure_processors_unlocked (ProcessorStreams* err)
1254 {
1255         if (_in_configure_processors) {
1256            return 0;
1257         }
1258
1259         _in_configure_processors = true;
1260
1261         // Check each processor in order to see if we can configure as requested
1262         ChanCount in = _input->n_ports ();
1263         ChanCount out;
1264         list< pair<ChanCount,ChanCount> > configuration;
1265         uint32_t index = 0;
1266
1267         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1268                 if ((*p)->can_support_io_configuration(in, out)) {
1269                         configuration.push_back(make_pair(in, out));
1270                         in = out;
1271                 } else {
1272                         if (err) {
1273                                 err->index = index;
1274                                 err->count = in;
1275                         }
1276                         _in_configure_processors = false;
1277                         return -1;
1278                 }
1279         }
1280
1281         // We can, so configure everything
1282         list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1283         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1284                 (*p)->configure_io(c->first, c->second);
1285                 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1286                 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1287                 out = c->second;
1288         }
1289
1290         // Ensure route outputs match last processor's outputs
1291         if (out != _output->n_ports ()) {
1292                 _output->ensure_io (out, false, this);
1293         }
1294
1295         _in_configure_processors = false;
1296         return 0;
1297 }
1298
1299 void
1300 Route::all_processors_flip ()
1301 {
1302         Glib::RWLock::ReaderLock lm (_processor_lock);
1303
1304         if (_processors.empty()) {
1305                 return;
1306         }
1307
1308         bool first_is_on = _processors.front()->active();
1309
1310         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1311                 if (first_is_on) {
1312                         (*i)->deactivate ();
1313                 } else {
1314                         (*i)->activate ();
1315                 }
1316         }
1317
1318         _session.set_dirty ();
1319 }
1320
1321 /** Set all processors with a given placement to a given active state.
1322  * @param p Placement of processors to change.
1323  * @param state New active state for those processors.
1324  */
1325 void
1326 Route::all_processors_active (Placement p, bool state)
1327 {
1328         Glib::RWLock::ReaderLock lm (_processor_lock);
1329
1330         if (_processors.empty()) {
1331                 return;
1332         }
1333         ProcessorList::iterator start, end;
1334         placement_range(p, start, end);
1335
1336         bool before_amp = true;
1337         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1338                 if ((*i) == _amp) {
1339                         before_amp = false;
1340                         continue;
1341                 }
1342                 if (p == PreFader && before_amp) {
1343                         if (state) {
1344                                 (*i)->activate ();
1345                         } else {
1346                                 (*i)->deactivate ();
1347                         }
1348                 }
1349         }
1350
1351         _session.set_dirty ();
1352 }
1353
1354 int
1355 Route::reorder_processors (const ProcessorList& new_order, Placement placement, ProcessorStreams* err)
1356 {
1357         /* "new_order" is an ordered list of processors to be positioned according to "placement".
1358            NOTE: all processors in "new_order" MUST be marked as visible. There maybe additional
1359            processors in the current actual processor list that are hidden. Any visible processors
1360            in the current list but not in "new_order" will be assumed to be deleted.
1361         */
1362
1363         {
1364                 Glib::RWLock::WriterLock lm (_processor_lock);
1365                 ChanCount old_pms = processor_max_streams;
1366                 ProcessorList::iterator oiter;
1367                 ProcessorList::const_iterator niter;
1368                 ProcessorList as_it_was_before = _processors;
1369                 ProcessorList as_it_will_be;
1370                 ProcessorList::iterator start, end;
1371
1372                 placement_range (placement, start, end);
1373
1374                 oiter = start;
1375                 niter = new_order.begin();
1376
1377                 while (niter !=  new_order.end()) {
1378
1379                         /* if the next processor in the old list is invisible (i.e. should not be in the new order)
1380                            then append it to the temp list.
1381
1382                            Otherwise, see if the next processor in the old list is in the new list. if not,
1383                            its been deleted. If its there, append it to the temp list.
1384                         */
1385
1386                         if (oiter == end) {
1387
1388                                 /* no more elements in the old list, so just stick the rest of
1389                                    the new order onto the temp list.
1390                                 */
1391
1392                                 as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
1393                                 while (niter != new_order.end()) {
1394                                         (*niter)->set_placement (placement);
1395                                         ++niter;
1396                                 }
1397                                 break;
1398
1399                         } else {
1400
1401                                 if (!(*oiter)->visible()) {
1402
1403                                         as_it_will_be.push_back (*oiter);
1404                                         (*oiter)->set_placement (placement);
1405
1406                                 } else {
1407
1408                                         /* visible processor: check that its in the new order */
1409
1410                                         if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
1411                                                 /* deleted: do nothing, shared_ptr<> will clean up */
1412                                         } else {
1413                                                 /* ignore this one, and add the next item from the new order instead */
1414                                                 as_it_will_be.push_back (*niter);
1415                                                 (*niter)->set_placement (placement);
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).c_str(), 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 }