libs/ardour/route.cc

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