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, Stateful::loading_state_version, 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                         if (bufs.count() != (*i)->input_streams()) {
 424                                 cerr << _name << " bufs = " << bufs.count()
 425                                      << " input for " << (*i)->name() << " = " << (*i)->input_streams()
 426                                      << endl;
 427                         }
 428                         assert (bufs.count() == (*i)->input_streams());
 429                         (*i)->run (bufs, start_frame, end_frame, nframes);
 430                         bufs.set_count (ChanCount::max(bufs.count(), (*i)->output_streams()));
 431                 }
 432
 433                 if (!_processors.empty()) {
 434                         bufs.set_count (ChanCount::max (bufs.count(), _processors.back()->output_streams()));
 435                 }
 436         }
 437 }
 438
 439 ChanCount
 440 Route::n_process_buffers ()
 441 {
 442         return max (_input->n_ports(), processor_max_streams);
 443 }
 444
 445 void
 446 Route::passthru (sframes_t start_frame, sframes_t end_frame, nframes_t nframes, int declick)
 447 {
 448         BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers());
 449
 450         _silent = false;
 451
 452         assert (bufs.available() >= _input->n_ports());
 453
 454         if (_input->n_ports() == ChanCount::ZERO) {
 455                 silence (nframes);
 456         }
 457
 458         bufs.set_count (_input->n_ports());
 459
 460         if (is_control() && _session.listening()) {
 461
 462                 /* control/monitor bus ignores input ports when something is
 463                    feeding the listen "stream". data will "arrive" into the
 464                    route from the intreturn processor element.
 465                 */
 466
 467                 bufs.silence (nframes, 0);
 468
 469         } else {
 470
 471                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 472
 473                         BufferSet::iterator o = bufs.begin(*t);
 474                         PortSet& ports (_input->ports());
 475
 476                         for (PortSet::iterator i = ports.begin(*t); i != ports.end(*t); ++i, ++o) {
 477                                 o->read_from (i->get_buffer(nframes), nframes);
 478                         }
 479                 }
 480         }
 481
 482         write_out_of_band_data (bufs, start_frame, end_frame, nframes);
 483         process_output_buffers (bufs, start_frame, end_frame, nframes, true, declick);
 484 }
 485
 486 void
 487 Route::passthru_silence (sframes_t start_frame, sframes_t end_frame, nframes_t nframes, int declick)
 488 {
 489         BufferSet& bufs (_session.get_silent_buffers (n_process_buffers()));
 490         bufs.set_count (_input->n_ports());
 491         write_out_of_band_data (bufs, start_frame, end_frame, nframes);
 492         process_output_buffers (bufs, start_frame, end_frame, nframes, true, declick);
 493 }
 494
 495 void
 496 Route::set_listen (bool yn, void* src)
 497 {
 498         if (_control_outs) {
 499                 if (yn != _control_outs->active()) {
 500                         if (yn) {
 501                                 _control_outs->activate ();
 502                         } else {
 503                                 _control_outs->deactivate ();
 504                         }
 505
 506                         listen_changed (src); /* EMIT SIGNAL */
 507                 }
 508         }
 509 }
 510
 511 bool
 512 Route::listening () const
 513 {
 514         if (_control_outs) {
 515                 return _control_outs->active ();
 516         } else {
 517                 return false;
 518         }
 519 }
 520
 521 void
 522 Route::set_solo (bool yn, void *src)
 523 {
 524         if (_solo_safe || _solo_isolated) {
 525                 return;
 526         }
 527
 528         if (_route_group && src != _route_group && _route_group->active_property (RouteGroup::Solo)) {
 529                 _route_group->apply (&Route::set_solo, yn, _route_group);
 530                 return;
 531         }
 532
 533         if (soloed() != yn) {
 534                 mod_solo_level (yn ? 1 : -1);
 535                 solo_changed (src); /* EMIT SIGNAL */
 536                 _solo_control->Changed (); /* EMIT SIGNAL */
 537         }
 538 }
 539
 540 void
 541 Route::mod_solo_level (int32_t delta)
 542 {
 543         if (delta < 0) {
 544                 if (_solo_level >= (uint32_t) delta) {
 545                         _solo_level += delta;
 546                 } else {
 547                         _solo_level = 0;
 548                 }
 549         } else {
 550                 _solo_level += delta;
 551         }
 552
 553         /* tell main outs what the solo situation is
 554          */
 555
 556         _main_outs->set_solo_level (_solo_level);
 557         _main_outs->set_solo_isolated (_solo_isolated);
 558 }
 559
 560 void
 561 Route::set_solo_isolated (bool yn, void *src)
 562 {
 563         if (_route_group && src != _route_group && _route_group->active_property (RouteGroup::Solo)) {
 564                 _route_group->apply (&Route::set_solo_isolated, yn, _route_group);
 565                 return;
 566         }
 567
 568         if (yn != _solo_isolated) {
 569                 _solo_isolated = yn;
 570
 571                 /* tell main outs what the solo situation is
 572                  */
 573
 574                 _main_outs->set_solo_level (_solo_level);
 575                 _main_outs->set_solo_isolated (_solo_isolated);
 576
 577                 solo_isolated_changed (src);
 578         }
 579 }
 580
 581 bool
 582 Route::solo_isolated () const
 583 {
 584         return _solo_isolated;
 585 }
 586
 587 void
 588 Route::set_mute (bool yn, void *src)
 589 {
 590         if (_route_group && src != _route_group && _route_group->active_property (RouteGroup::Mute)) {
 591                 _route_group->apply (&Route::set_mute, yn, _route_group);
 592                 return;
 593         }
 594
 595         if (muted() != yn) {
 596                 _mute_master->mute (yn);
 597                 mute_changed (src);
 598         }
 599 }
 600
 601 bool
 602 Route::muted() const
 603 {
 604         return _mute_master->muted ();
 605 }
 606
 607 #if 0
 608 static void
 609 dump_processors(const string& name, const list<boost::shared_ptr<Processor> >& procs)
 610 {
 611         cerr << name << " {" << endl;
 612         for (list<boost::shared_ptr<Processor> >::const_iterator p = procs.begin();
 613                         p != procs.end(); ++p) {
 614                 cerr << "\t" << (*p)->name() << " ID = " << (*p)->id() << endl;
 615         }
 616         cerr << "}" << endl;
 617 }
 618 #endif
 619
 620 int
 621 Route::add_processor (boost::shared_ptr<Processor> processor, Placement placement, ProcessorStreams* err)
 622 {
 623         ProcessorList::iterator loc;
 624
 625         /* XXX this is not thread safe - we don't hold the lock across determining the iter
 626            to add before and actually doing the insertion. dammit.
 627         */
 628
 629         if (placement == PreFader) {
 630                 /* generic pre-fader: insert immediately before the amp */
 631                 loc = find (_processors.begin(), _processors.end(), _amp);
 632         } else {
 633                 /* generic post-fader: insert right before the main outs */
 634                 loc = find (_processors.begin(), _processors.end(), _main_outs);
 635         }
 636
 637         return add_processor (processor, loc, err);
 638 }
 639
 640
 641 /** Add a processor to the route.
 642  * If @a iter is not NULL, it must point to an iterator in _processors and the new
 643  * processor will be inserted immediately before this location.  Otherwise,
 644  * @a position is used.
 645  */
 646 int
 647 Route::add_processor (boost::shared_ptr<Processor> processor, ProcessorList::iterator iter, ProcessorStreams* err)
 648 {
 649         ChanCount old_pms = processor_max_streams;
 650
 651         if (!_session.engine().connected() || !processor) {
 652                 return 1;
 653         }
 654
 655         {
 656                 Glib::RWLock::WriterLock lm (_processor_lock);
 657
 658                 boost::shared_ptr<PluginInsert> pi;
 659                 boost::shared_ptr<PortInsert> porti;
 660
 661                 ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), processor);
 662
 663                 if (processor == _amp || processor == _meter || processor == _main_outs) {
 664                         // Ensure only one of these are in the list at any time
 665                         if (loc != _processors.end()) {
 666                                 if (iter == loc) { // Already in place, do nothing
 667                                         return 0;
 668                                 } else { // New position given, relocate
 669                                         _processors.erase (loc);
 670                                 }
 671                         }
 672
 673                 } else {
 674                         if (loc != _processors.end()) {
 675                                 cerr << "ERROR: Processor added to route twice!" << endl;
 676                                 return 1;
 677                         }
 678
 679                         loc = iter;
 680                 }
 681
 682                 _processors.insert (loc, processor);
 683
 684                 // Set up processor list channels.  This will set processor->[input|output]_streams(),
 685                 // configure redirect ports properly, etc.
 686
 687                 if (configure_processors_unlocked (err)) {
 688                         ProcessorList::iterator ploc = loc;
 689                         --ploc;
 690                         _processors.erase(ploc);
 691                         configure_processors_unlocked (0); // it worked before we tried to add it ...
 692                         cerr << "configure failed\n";
 693                         return -1;
 694                 }
 695
 696                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(processor)) != 0) {
 697
 698                         if (pi->natural_input_streams() == ChanCount::ZERO) {
 699                                 /* generator plugin */
 700                                 _have_internal_generator = true;
 701                         }
 702
 703                 }
 704
 705                 if (_control_outs != processor) {
 706                         // XXX: do we want to emit the signal here ? change call order.
 707                         processor->activate ();
 708                 }
 709                 processor->ActiveChanged.connect (bind (mem_fun (_session, &Session::update_latency_compensation), false, false));
 710
 711                 _output->set_user_latency (0);
 712         }
 713
 714         processors_changed (); /* EMIT SIGNAL */
 715
 716         return 0;
 717 }
 718
 719 bool
 720 Route::add_processor_from_xml (const XMLNode& node, ProcessorList::iterator iter)
 721 {
 722         const XMLProperty *prop;
 723
 724         if (node.name() != "Processor") {
 725                 return false;
 726         }
 727
 728         try {
 729                 if ((prop = node.property ("type")) != 0) {
 730
 731                         boost::shared_ptr<Processor> processor;
 732
 733                         if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
 734                             prop->value() == "lv2" ||
 735                             prop->value() == "vst" ||
 736                             prop->value() == "audiounit") {
 737
 738                                 processor.reset (new PluginInsert(_session, node));
 739
 740                         } else if (prop->value() == "port") {
 741
 742                                 processor.reset (new PortInsert (_session, _mute_master, node));
 743
 744                         } else if (prop->value() == "send") {
 745
 746                                 processor.reset (new Send (_session, _mute_master, node));
 747
 748                         } else if (prop->value() == "meter") {
 749
 750                                 if (_meter) {
 751                                         if (_meter->set_state (node, Stateful::loading_state_version)) {
 752                                                 return false;
 753                                         } else {
 754                                                 return true;
 755                                         }
 756                                 }
 757
 758                                 _meter.reset (new PeakMeter (_session, node));
 759                                 processor = _meter;
 760
 761                         } else if (prop->value() == "amp") {
 762
 763                                 /* amp always exists */
 764
 765                                 processor = _amp;
 766                                 if (processor->set_state (node, Stateful::loading_state_version)) {
 767                                         return false;
 768                                 } else {
 769                                         /* never any reason to add it */
 770                                         return true;
 771                                 }
 772
 773                         } else if (prop->value() == "intsend") {
 774
 775                                 processor.reset (new InternalSend (_session, _mute_master, node));
 776
 777                         } else if (prop->value() == "intreturn") {
 778
 779                                 if (_intreturn) {
 780                                         if (_intreturn->set_state (node, Stateful::loading_state_version)) {
 781                                                 return false;
 782                                         } else {
 783                                                 return true;
 784                                         }
 785                                 }
 786                                 _intreturn.reset (new InternalReturn (_session, node));
 787                                 processor = _intreturn;
 788
 789                         } else if (prop->value() == "main-outs") {
 790
 791                                 if (_main_outs) {
 792                                         if (_main_outs->set_state (node, Stateful::loading_state_version)) {
 793                                                 return false;
 794                                         } else {
 795                                                 return true;
 796                                         }
 797                                 }
 798
 799                                 _main_outs.reset (new Delivery (_session, _output, _mute_master, node));
 800                                 processor = _main_outs;
 801
 802                         } else {
 803                                 error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
 804                                 return false;
 805                         }
 806
 807                         if (iter == _processors.end() && processor->visible() && !_processors.empty()) {
 808                                 /* check for invisible processors stacked at the end and leave them there */
 809                                 ProcessorList::iterator p;
 810                                 p = _processors.end();
 811                                 --p;
 812                                 while (!(*p)->visible() && p != _processors.begin()) {
 813                                         --p;
 814                                 }
 815                                 ++p;
 816                                 iter = p;
 817                         }
 818
 819                         return (add_processor (processor, iter) == 0);
 820
 821                 } else {
 822                         error << _("Processor XML node has no type property") << endmsg;
 823                         return false;
 824                 }
 825         }
 826
 827         catch (failed_constructor &err) {
 828                 warning << _("processor could not be created. Ignored.") << endmsg;
 829                 return false;
 830         }
 831 }
 832
 833
 834 bool
 835 Route::add_processor_from_xml_2X (const XMLNode& node, int version, ProcessorList::iterator iter)
 836 {
 837         const XMLProperty *prop;
 838
 839         try {
 840                 boost::shared_ptr<Processor> processor;
 841
 842                 if (node.name() == "Insert") {
 843
 844                         if ((prop = node.property ("type")) != 0) {
 845
 846                                 if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
 847                                                 prop->value() == "lv2" ||
 848                                                 prop->value() == "vst" ||
 849                                                 prop->value() == "audiounit") {
 850
 851                                         processor.reset (new PluginInsert (_session, node));
 852
 853                                 } else {
 854
 855                                         processor.reset (new PortInsert (_session, _mute_master, node));
 856                                 }
 857
 858                         }
 859
 860                 } else if (node.name() == "Send") {
 861
 862                         processor.reset (new Send (_session, _mute_master, node, version));
 863
 864                 } else {
 865
 866                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), node.name()) << endmsg;
 867                         return false;
 868                 }
 869
 870                 if (iter == _processors.end() && processor->visible() && !_processors.empty()) {
 871                         /* check for invisible processors stacked at the end and leave them there */
 872                         ProcessorList::iterator p;
 873                         p = _processors.end();
 874                         --p;
 875                         while (!(*p)->visible() && p != _processors.begin()) {
 876                                 --p;
 877                         }
 878                         ++p;
 879                         iter = p;
 880                 }
 881
 882                 return (add_processor (processor, iter) == 0);
 883         }
 884
 885         catch (failed_constructor &err) {
 886                 warning << _("processor could not be created. Ignored.") << endmsg;
 887                 return false;
 888         }
 889 }
 890
 891 int
 892 Route::add_processors (const ProcessorList& others, boost::shared_ptr<Processor> before, ProcessorStreams* err)
 893 {
 894         ProcessorList::iterator loc;
 895
 896         if (before) {
 897                 loc = find(_processors.begin(), _processors.end(), before);
 898         } else {
 899                 /* nothing specified - at end but before main outs */
 900                 loc = find (_processors.begin(), _processors.end(), _main_outs);
 901         }
 902
 903         return add_processors (others, loc, err);
 904 }
 905
 906 int
 907 Route::add_processors (const ProcessorList& others, ProcessorList::iterator iter, ProcessorStreams* err)
 908 {
 909         /* NOTE: this is intended to be used ONLY when copying
 910            processors from another Route. Hence the subtle
 911            differences between this and ::add_processor()
 912         */
 913
 914         ChanCount old_pms = processor_max_streams;
 915
 916         if (!_session.engine().connected()) {
 917                 return 1;
 918         }
 919
 920         if (others.empty()) {
 921                 return 0;
 922         }
 923
 924         {
 925                 Glib::RWLock::WriterLock lm (_processor_lock);
 926                 ProcessorList::iterator existing_end = _processors.end();
 927                 --existing_end;
 928
 929                 ChanCount potential_max_streams = ChanCount::max (_input->n_ports(), _output->n_ports());
 930
 931                 for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
 932
 933                         // Ensure meter only appears in the list once
 934                         if (*i == _meter) {
 935                                 ProcessorList::iterator m = find(_processors.begin(), _processors.end(), *i);
 936                                 if (m != _processors.end()) {
 937                                         _processors.erase(m);
 938                                 }
 939                         }
 940
 941                         boost::shared_ptr<PluginInsert> pi;
 942
 943                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
 944                                 pi->set_count (1);
 945
 946                                 ChanCount m = max (pi->input_streams(), pi->output_streams());
 947
 948                                 if (m > potential_max_streams) {
 949                                         potential_max_streams = m;
 950                                 }
 951                         }
 952
 953                         _processors.insert (iter, *i);
 954
 955                         if (configure_processors_unlocked (err)) {
 956                                 ++existing_end;
 957                                 _processors.erase (existing_end, _processors.end());
 958                                 configure_processors_unlocked (0); // it worked before we tried to add it ...
 959                                 return -1;
 960                         }
 961
 962                         (*i)->ActiveChanged.connect (bind (mem_fun (_session, &Session::update_latency_compensation), false, false));
 963                 }
 964
 965                 _output->set_user_latency (0);
 966         }
 967
 968         processors_changed (); /* EMIT SIGNAL */
 969
 970         return 0;
 971 }
 972
 973 void
 974 Route::placement_range(Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end)
 975 {
 976         if (p == PreFader) {
 977                 start = _processors.begin();
 978                 end = find(_processors.begin(), _processors.end(), _amp);
 979         } else {
 980                 start = find(_processors.begin(), _processors.end(), _amp);
 981                 ++start;
 982                 end = _processors.end();
 983         }
 984 }
 985
 986 /** Turn off all processors with a given placement
 987  * @param p Placement of processors to disable
 988  */
 989 void
 990 Route::disable_processors (Placement p)
 991 {
 992         Glib::RWLock::ReaderLock lm (_processor_lock);
 993
 994         ProcessorList::iterator start, end;
 995         placement_range(p, start, end);
 996
 997         for (ProcessorList::iterator i = start; i != end; ++i) {
 998                 (*i)->deactivate ();
 999         }
1000
1001         _session.set_dirty ();
1002 }
1003
1004 /** Turn off all redirects
1005  */
1006 void
1007 Route::disable_processors ()
1008 {
1009         Glib::RWLock::ReaderLock lm (_processor_lock);
1010
1011         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1012                 (*i)->deactivate ();
1013         }
1014
1015         _session.set_dirty ();
1016 }
1017
1018 /** Turn off all redirects with a given placement
1019  * @param p Placement of redirects to disable
1020  */
1021 void
1022 Route::disable_plugins (Placement p)
1023 {
1024         Glib::RWLock::ReaderLock lm (_processor_lock);
1025
1026         ProcessorList::iterator start, end;
1027         placement_range(p, start, end);
1028
1029         for (ProcessorList::iterator i = start; i != end; ++i) {
1030                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1031                         (*i)->deactivate ();
1032                 }
1033         }
1034
1035         _session.set_dirty ();
1036 }
1037
1038 /** Turn off all plugins
1039  */
1040 void
1041 Route::disable_plugins ()
1042 {
1043         Glib::RWLock::ReaderLock lm (_processor_lock);
1044
1045         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1046                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1047                         (*i)->deactivate ();
1048                 }
1049         }
1050
1051         _session.set_dirty ();
1052 }
1053
1054
1055 void
1056 Route::ab_plugins (bool forward)
1057 {
1058         Glib::RWLock::ReaderLock lm (_processor_lock);
1059
1060         if (forward) {
1061
1062                 /* forward = turn off all active redirects, and mark them so that the next time
1063                    we go the other way, we will revert them
1064                 */
1065
1066                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1067                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1068                                 continue;
1069                         }
1070
1071                         if ((*i)->active()) {
1072                                 (*i)->deactivate ();
1073                                 (*i)->set_next_ab_is_active (true);
1074                         } else {
1075                                 (*i)->set_next_ab_is_active (false);
1076                         }
1077                 }
1078
1079         } else {
1080
1081                 /* backward = if the redirect was marked to go active on the next ab, do so */
1082
1083                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1084
1085                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1086                                 continue;
1087                         }
1088
1089                         if ((*i)->get_next_ab_is_active()) {
1090                                 (*i)->activate ();
1091                         } else {
1092                                 (*i)->deactivate ();
1093                         }
1094                 }
1095         }
1096
1097         _session.set_dirty ();
1098 }
1099
1100
1101 /** Remove processors with a given placement.
1102  * @param p Placement of processors to remove.
1103  */
1104 void
1105 Route::clear_processors (Placement p)
1106 {
1107         const ChanCount old_pms = processor_max_streams;
1108
1109         if (!_session.engine().connected()) {
1110                 return;
1111         }
1112
1113         bool already_deleting = _session.deletion_in_progress();
1114         if (!already_deleting) {
1115                 _session.set_deletion_in_progress();
1116         }
1117
1118         {
1119                 Glib::RWLock::WriterLock lm (_processor_lock);
1120                 ProcessorList new_list;
1121                 ProcessorStreams err;
1122                 bool seen_amp = false;
1123
1124                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1125
1126                         if (*i == _amp) {
1127                                 seen_amp = true;
1128                         }
1129
1130                         if ((*i) == _amp || (*i) == _meter || (*i) == _main_outs) {
1131
1132                                 /* you can't remove these */
1133
1134                                 new_list.push_back (*i);
1135
1136                         } else {
1137                                 if (seen_amp) {
1138
1139                                         switch (p) {
1140                                         case PreFader:
1141                                                 new_list.push_back (*i);
1142                                                 break;
1143                                         case PostFader:
1144                                                 (*i)->drop_references ();
1145                                                 break;
1146                                         }
1147
1148                                 } else {
1149
1150                                         switch (p) {
1151                                         case PreFader:
1152                                                 (*i)->drop_references ();
1153                                                 break;
1154                                         case PostFader:
1155                                                 new_list.push_back (*i);
1156                                                 break;
1157                                         }
1158                                 }
1159                         }
1160                 }
1161
1162                 _processors = new_list;
1163                 configure_processors_unlocked (&err); // this can't fail
1164         }
1165
1166         processor_max_streams.reset();
1167         _have_internal_generator = false;
1168         processors_changed (); /* EMIT SIGNAL */
1169
1170         if (!already_deleting) {
1171                 _session.clear_deletion_in_progress();
1172         }
1173 }
1174
1175 int
1176 Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err)
1177 {
1178         /* these can never be removed */
1179
1180         if (processor == _amp || processor == _meter || processor == _main_outs) {
1181                 return 0;
1182         }
1183
1184         ChanCount old_pms = processor_max_streams;
1185
1186         if (!_session.engine().connected()) {
1187                 return 1;
1188         }
1189
1190         processor_max_streams.reset();
1191
1192         {
1193                 Glib::RWLock::WriterLock lm (_processor_lock);
1194                 ProcessorList::iterator i;
1195                 bool removed = false;
1196
1197                 for (i = _processors.begin(); i != _processors.end(); ) {
1198                         if (*i == processor) {
1199
1200                                 /* move along, see failure case for configure_processors()
1201                                    where we may need to reconfigure the processor.
1202                                 */
1203
1204                                 /* stop redirects that send signals to JACK ports
1205                                    from causing noise as a result of no longer being
1206                                    run.
1207                                 */
1208
1209                                 boost::shared_ptr<IOProcessor> iop;
1210
1211                                 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (*i)) != 0) {
1212                                         if (iop->input()) {
1213                                                 iop->input()->disconnect (this);
1214                                         }
1215                                         if (iop->output()) {
1216                                                 iop->output()->disconnect (this);
1217                                         }
1218                                 }
1219
1220                                 i = _processors.erase (i);
1221                                 removed = true;
1222                                 break;
1223
1224                         } else {
1225                                 ++i;
1226                         }
1227
1228                         _output->set_user_latency (0);
1229                 }
1230
1231                 if (!removed) {
1232                         /* what? */
1233                         return 1;
1234                 }
1235
1236                 if (configure_processors_unlocked (err)) {
1237                         /* get back to where we where */
1238                         _processors.insert (i, processor);
1239                         /* we know this will work, because it worked before :) */
1240                         configure_processors_unlocked (0);
1241                         return -1;
1242                 }
1243
1244                 _have_internal_generator = false;
1245
1246                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1247                         boost::shared_ptr<PluginInsert> pi;
1248
1249                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1250                                 if (pi->is_generator()) {
1251                                         _have_internal_generator = true;
1252                                         break;
1253                                 }
1254                         }
1255                 }
1256         }
1257
1258         processor->drop_references ();
1259         processors_changed (); /* EMIT SIGNAL */
1260
1261         return 0;
1262 }
1263
1264 int
1265 Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
1266 {
1267         ProcessorList deleted;
1268         ProcessorList as_we_were;
1269
1270         if (!_session.engine().connected()) {
1271                 return 1;
1272         }
1273
1274         processor_max_streams.reset();
1275
1276         {
1277                 Glib::RWLock::WriterLock lm (_processor_lock);
1278                 ProcessorList::iterator i;
1279                 boost::shared_ptr<Processor> processor;
1280
1281                 as_we_were = _processors;
1282
1283                 for (i = _processors.begin(); i != _processors.end(); ) {
1284
1285                         processor = *i;
1286
1287                         /* these can never be removed */
1288
1289                         if (processor == _amp || processor == _meter || processor == _main_outs) {
1290                                 ++i;
1291                                 continue;
1292                         }
1293
1294                         /* see if its in the list of processors to delete */
1295
1296                         if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
1297                                 ++i;
1298                                 continue;
1299                         }
1300
1301                         /* stop IOProcessors that send to JACK ports
1302                            from causing noise as a result of no longer being
1303                            run.
1304                         */
1305
1306                         boost::shared_ptr<IOProcessor> iop;
1307
1308                         if ((iop = boost::dynamic_pointer_cast<IOProcessor> (processor)) != 0) {
1309                                 iop->disconnect ();
1310                         }
1311
1312                         deleted.push_back (processor);
1313                         i = _processors.erase (i);
1314                 }
1315
1316                 if (deleted.empty()) {
1317                         /* none of those in the requested list were found */
1318                         return 0;
1319                 }
1320
1321                 _output->set_user_latency (0);
1322
1323                 if (configure_processors_unlocked (err)) {
1324                         /* get back to where we where */
1325                         _processors = as_we_were;
1326                         /* we know this will work, because it worked before :) */
1327                         configure_processors_unlocked (0);
1328                         return -1;
1329                 }
1330
1331                 _have_internal_generator = false;
1332
1333                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1334                         boost::shared_ptr<PluginInsert> pi;
1335
1336                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1337                                 if (pi->is_generator()) {
1338                                         _have_internal_generator = true;
1339                                         break;
1340                                 }
1341                         }
1342                 }
1343         }
1344
1345         /* now try to do what we need to so that those that were removed will be deleted */
1346
1347         for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
1348                 (*i)->drop_references ();
1349         }
1350
1351         processors_changed (); /* EMIT SIGNAL */
1352
1353         return 0;
1354 }
1355
1356
1357 int
1358 Route::configure_processors (ProcessorStreams* err)
1359 {
1360         if (!_in_configure_processors) {
1361                 Glib::RWLock::WriterLock lm (_processor_lock);
1362                 return configure_processors_unlocked (err);
1363         }
1364         return 0;
1365 }
1366
1367 /** Configure the input/output configuration of each processor in the processors list.
1368  * Return 0 on success, otherwise configuration is impossible.
1369  */
1370 int
1371 Route::configure_processors_unlocked (ProcessorStreams* err)
1372 {
1373         if (_in_configure_processors) {
1374            return 0;
1375         }
1376
1377         _in_configure_processors = true;
1378
1379         // Check each processor in order to see if we can configure as requested
1380         ChanCount in = _input->n_ports ();
1381         ChanCount out;
1382         list< pair<ChanCount,ChanCount> > configuration;
1383         uint32_t index = 0;
1384
1385         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1386
1387                 if ((*p)->can_support_io_configuration(in, out)) {
1388                         configuration.push_back(make_pair(in, out));
1389                         in = out;
1390                 } else {
1391                         if (err) {
1392                                 err->index = index;
1393                                 err->count = in;
1394                         }
1395                         _in_configure_processors = false;
1396                         return -1;
1397                 }
1398         }
1399
1400         /* Take the process lock so that if we add a processor which increases the required
1401            number of scratch buffers, we create those scratch buffers before the process
1402            thread has a chance to ask for them.
1403            XXX: in an ideal world we'd perhaps use some RCU magic to avoid having to take
1404            the lock here.
1405         */
1406
1407         Glib::Mutex::Lock pl (_session.engine().process_lock ());
1408
1409         // We can, so configure everything
1410         list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1411         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1412                 (*p)->configure_io(c->first, c->second);
1413                 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1414                 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1415                 out = c->second;
1416         }
1417
1418         /* make sure we have sufficient scratch buffers to cope with the new processor
1419            configuration */
1420         _session.ensure_buffers (n_process_buffers ());
1421
1422         _session.ensure_buffers (n_process_buffers ());
1423
1424         _in_configure_processors = false;
1425         return 0;
1426 }
1427
1428 void
1429 Route::all_processors_flip ()
1430 {
1431         Glib::RWLock::ReaderLock lm (_processor_lock);
1432
1433         if (_processors.empty()) {
1434                 return;
1435         }
1436
1437         bool first_is_on = _processors.front()->active();
1438
1439         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1440                 if (first_is_on) {
1441                         (*i)->deactivate ();
1442                 } else {
1443                         (*i)->activate ();
1444                 }
1445         }
1446
1447         _session.set_dirty ();
1448 }
1449
1450 /** Set all processors with a given placement to a given active state.
1451  * @param p Placement of processors to change.
1452  * @param state New active state for those processors.
1453  */
1454 void
1455 Route::all_processors_active (Placement p, bool state)
1456 {
1457         Glib::RWLock::ReaderLock lm (_processor_lock);
1458
1459         if (_processors.empty()) {
1460                 return;
1461         }
1462         ProcessorList::iterator start, end;
1463         placement_range(p, start, end);
1464
1465         bool before_amp = true;
1466         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1467                 if ((*i) == _amp) {
1468                         before_amp = false;
1469                         continue;
1470                 }
1471                 if (p == PreFader && before_amp) {
1472                         if (state) {
1473                                 (*i)->activate ();
1474                         } else {
1475                                 (*i)->deactivate ();
1476                         }
1477                 }
1478         }
1479
1480         _session.set_dirty ();
1481 }
1482
1483 bool
1484 Route::processor_is_prefader (boost::shared_ptr<Processor> p)
1485 {
1486         bool pre_fader = true;
1487         Glib::RWLock::ReaderLock lm (_processor_lock);
1488
1489         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1490
1491                 /* semantic note: if p == amp, we want to return true, so test
1492                    for equality before checking if this is the amp
1493                 */
1494
1495                 if ((*i) == p) {
1496                         break;
1497                 }
1498
1499                 if ((*i) == _amp) {
1500                         pre_fader = false;
1501                         break;
1502                 }
1503         }
1504
1505         return pre_fader;
1506 }
1507
1508 int
1509 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
1510 {
1511         /* "new_order" is an ordered list of processors to be positioned according to "placement".
1512            NOTE: all processors in "new_order" MUST be marked as visible. There maybe additional
1513            processors in the current actual processor list that are hidden. Any visible processors
1514            in the current list but not in "new_order" will be assumed to be deleted.
1515         */
1516
1517         {
1518                 Glib::RWLock::WriterLock lm (_processor_lock);
1519                 ChanCount old_pms = processor_max_streams;
1520                 ProcessorList::iterator oiter;
1521                 ProcessorList::const_iterator niter;
1522                 ProcessorList as_it_was_before = _processors;
1523                 ProcessorList as_it_will_be;
1524
1525                 oiter = _processors.begin();
1526                 niter = new_order.begin();
1527
1528                 while (niter !=  new_order.end()) {
1529
1530                         /* if the next processor in the old list is invisible (i.e. should not be in the new order)
1531                            then append it to the temp list.
1532
1533                            Otherwise, see if the next processor in the old list is in the new list. if not,
1534                            its been deleted. If its there, append it to the temp list.
1535                         */
1536
1537                         if (oiter == _processors.end()) {
1538
1539                                 /* no more elements in the old list, so just stick the rest of
1540                                    the new order onto the temp list.
1541                                 */
1542
1543                                 as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
1544                                 while (niter != new_order.end()) {
1545                                         ++niter;
1546                                 }
1547                                 break;
1548
1549                         } else {
1550
1551                                 if (!(*oiter)->visible()) {
1552
1553                                         as_it_will_be.push_back (*oiter);
1554
1555                                 } else {
1556
1557                                         /* visible processor: check that its in the new order */
1558
1559                                         if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
1560                                                 /* deleted: do nothing, shared_ptr<> will clean up */
1561                                         } else {
1562                                                 /* ignore this one, and add the next item from the new order instead */
1563                                                 as_it_will_be.push_back (*niter);
1564                                                 ++niter;
1565                                         }
1566                                 }
1567
1568                                 /* now remove from old order - its taken care of no matter what */
1569                                 oiter = _processors.erase (oiter);
1570                         }
1571
1572                 }
1573
1574                 _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
1575
1576                 if (configure_processors_unlocked (err)) {
1577                         _processors = as_it_was_before;
1578                         processor_max_streams = old_pms;
1579                         return -1;
1580                 }
1581         }
1582
1583         processors_changed (); /* EMIT SIGNAL */
1584
1585         return 0;
1586 }
1587
1588 XMLNode&
1589 Route::get_state()
1590 {
1591         return state(true);
1592 }
1593
1594 XMLNode&
1595 Route::get_template()
1596 {
1597         return state(false);
1598 }
1599
1600 XMLNode&
1601 Route::state(bool full_state)
1602 {
1603         XMLNode *node = new XMLNode("Route");
1604         ProcessorList::iterator i;
1605         char buf[32];
1606
1607         id().print (buf, sizeof (buf));
1608         node->add_property("id", buf);
1609         node->add_property ("name", _name);
1610         node->add_property("default-type", _default_type.to_string());
1611
1612         if (_flags) {
1613                 node->add_property("flags", enum_2_string (_flags));
1614         }
1615
1616         node->add_property("active", _active?"yes":"no");
1617         node->add_property("phase-invert", _phase_invert?"yes":"no");
1618         node->add_property("denormal-protection", _denormal_protection?"yes":"no");
1619         node->add_property("meter-point", enum_2_string (_meter_point));
1620
1621         if (_route_group) {
1622                 node->add_property("route-group", _route_group->name());
1623         }
1624
1625         string order_string;
1626         OrderKeys::iterator x = order_keys.begin();
1627
1628         while (x != order_keys.end()) {
1629                 order_string += string ((*x).first);
1630                 order_string += '=';
1631                 snprintf (buf, sizeof(buf), "%ld", (*x).second);
1632                 order_string += buf;
1633
1634                 ++x;
1635
1636                 if (x == order_keys.end()) {
1637                         break;
1638                 }
1639
1640                 order_string += ':';
1641         }
1642         node->add_property ("order-keys", order_string);
1643
1644         node->add_child_nocopy (_input->state (full_state));
1645         node->add_child_nocopy (_output->state (full_state));
1646         node->add_child_nocopy (_solo_control->get_state ());
1647         node->add_child_nocopy (_mute_master->get_state ());
1648
1649         XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
1650         snprintf (buf, sizeof (buf), "%d", _remote_control_id);
1651         remote_control_node->add_property (X_("id"), buf);
1652         node->add_child_nocopy (*remote_control_node);
1653
1654         if (_comment.length()) {
1655                 XMLNode *cmt = node->add_child ("Comment");
1656                 cmt->add_content (_comment);
1657         }
1658
1659         for (i = _processors.begin(); i != _processors.end(); ++i) {
1660                 node->add_child_nocopy((*i)->state (full_state));
1661         }
1662
1663         if (_extra_xml){
1664                 node->add_child_copy (*_extra_xml);
1665         }
1666
1667         return *node;
1668 }
1669
1670 int
1671 Route::set_state (const XMLNode& node, int version)
1672 {
1673         return _set_state (node, version, true);
1674 }
1675
1676 int
1677 Route::_set_state (const XMLNode& node, int version, bool /*call_base*/)
1678 {
1679         if (version < 3000) {
1680                 return _set_state_2X (node, version);
1681         }
1682
1683         XMLNodeList nlist;
1684         XMLNodeConstIterator niter;
1685         XMLNode *child;
1686         XMLPropertyList plist;
1687         const XMLProperty *prop;
1688
1689         if (node.name() != "Route"){
1690                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1691                 return -1;
1692         }
1693
1694         if ((prop = node.property (X_("name"))) != 0) {
1695                 Route::set_name (prop->value());
1696         }
1697
1698         if ((prop = node.property ("id")) != 0) {
1699                 _id = prop->value ();
1700         }
1701
1702         if ((prop = node.property (X_("flags"))) != 0) {
1703                 _flags = Flag (string_2_enum (prop->value(), _flags));
1704         } else {
1705                 _flags = Flag (0);
1706         }
1707
1708         /* add all processors (except amp, which is always present) */
1709
1710         nlist = node.children();
1711         XMLNode processor_state (X_("processor_state"));
1712
1713         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1714
1715                 child = *niter;
1716
1717                 if (child->name() == IO::state_node_name) {
1718                         if ((prop = child->property (X_("direction"))) == 0) {
1719                                 continue;
1720                         }
1721
1722                         if (prop->value() == "Input") {
1723                                 _input->set_state (*child, version);
1724                         } else if (prop->value() == "Output") {
1725                                 _output->set_state (*child, version);
1726                         }
1727                 }
1728
1729                 if (child->name() == X_("Processor")) {
1730                         processor_state.add_child_copy (*child);
1731                 }
1732         }
1733
1734         set_processor_state (processor_state);
1735
1736         if ((prop = node.property ("solo_level")) != 0) {
1737                 _solo_level = 0; // needed for mod_solo_level() to work
1738                 mod_solo_level (atoi (prop->value()));
1739         }
1740
1741         if ((prop = node.property ("solo-isolated")) != 0) {
1742                 set_solo_isolated (string_is_affirmative (prop->value()), this);
1743         }
1744
1745         if ((prop = node.property (X_("phase-invert"))) != 0) {
1746                 set_phase_invert (string_is_affirmative (prop->value()));
1747         }
1748
1749         if ((prop = node.property (X_("denormal-protection"))) != 0) {
1750                 set_denormal_protection (string_is_affirmative (prop->value()));
1751         }
1752
1753         if ((prop = node.property (X_("active"))) != 0) {
1754                 bool yn = string_is_affirmative (prop->value());
1755                 _active = !yn; // force switch
1756                 set_active (yn);
1757         }
1758
1759         if ((prop = node.property (X_("soloed"))) != 0) {
1760                 bool yn = string_is_affirmative (prop->value());
1761
1762                 /* XXX force reset of solo status */
1763
1764                 set_solo (yn, this);
1765         }
1766
1767         if ((prop = node.property (X_("meter-point"))) != 0) {
1768                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
1769         }
1770
1771         if ((prop = node.property (X_("route-group"))) != 0) {
1772                 RouteGroup* route_group = _session.route_group_by_name(prop->value());
1773                 if (route_group == 0) {
1774                         error << string_compose(_("Route %1: unknown route group \"%2 in saved state (ignored)"), _name, prop->value()) << endmsg;
1775                 } else {
1776                         set_route_group (route_group, this);
1777                 }
1778         }
1779
1780         if ((prop = node.property (X_("order-keys"))) != 0) {
1781
1782                 long n;
1783
1784                 string::size_type colon, equal;
1785                 string remaining = prop->value();
1786
1787                 while (remaining.length()) {
1788
1789                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
1790                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1791                                       << endmsg;
1792                         } else {
1793                                 if (sscanf (remaining.substr (equal+1).c_str(), "%ld", &n) != 1) {
1794                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1795                                               << endmsg;
1796                                 } else {
1797                                         set_order_key (remaining.substr (0, equal), n);
1798                                 }
1799                         }
1800
1801                         colon = remaining.find_first_of (':');
1802
1803                         if (colon != string::npos) {
1804                                 remaining = remaining.substr (colon+1);
1805                         } else {
1806                                 break;
1807                         }
1808                 }
1809         }
1810
1811         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1812                 child = *niter;
1813
1814                 if (child->name() == X_("Comment")) {
1815
1816                         /* XXX this is a terrible API design in libxml++ */
1817
1818                         XMLNode *cmt = *(child->children().begin());
1819                         _comment = cmt->content();
1820
1821                 } else if (child->name() == X_("Extra")) {
1822
1823                         _extra_xml = new XMLNode (*child);
1824
1825                 } else if (child->name() == X_("Controllable") && (prop = child->property("name")) != 0) {
1826
1827                         if (prop->value() == "solo") {
1828                                 _solo_control->set_state (*child, version);
1829                                 _session.add_controllable (_solo_control);
1830                         }
1831
1832                 } else if (child->name() == X_("RemoteControl")) {
1833                         if ((prop = child->property (X_("id"))) != 0) {
1834                                 int32_t x;
1835                                 sscanf (prop->value().c_str(), "%d", &x);
1836                                 set_remote_control_id (x);
1837                         }
1838
1839                 } else if (child->name() == X_("MuteMaster")) {
1840                         _mute_master->set_state (*child, version);
1841                 }
1842         }
1843
1844         return 0;
1845 }
1846
1847 int
1848 Route::_set_state_2X (const XMLNode& node, int version)
1849 {
1850         XMLNodeList nlist;
1851         XMLNodeConstIterator niter;
1852         XMLNode *child;
1853         XMLPropertyList plist;
1854         const XMLProperty *prop;
1855
1856         /* 2X things which still remain to be handled:
1857          * default-type
1858          * muted
1859          * mute-affects-pre-fader
1860          * mute-affects-post-fader
1861          * mute-affects-control-outs
1862          * mute-affects-main-outs
1863          * automation
1864          * controlouts
1865          */
1866
1867         if (node.name() != "Route") {
1868                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1869                 return -1;
1870         }
1871
1872         if ((prop = node.property (X_("flags"))) != 0) {
1873                 _flags = Flag (string_2_enum (prop->value(), _flags));
1874         } else {
1875                 _flags = Flag (0);
1876         }
1877
1878         /* add standard processors */
1879
1880         _meter.reset (new PeakMeter (_session));
1881         add_processor (_meter, PreFader);
1882
1883         if (_flags & ControlOut) {
1884                 /* where we listen to tracks */
1885                 _intreturn.reset (new InternalReturn (_session));
1886                 add_processor (_intreturn, PreFader);
1887         }
1888
1889         _main_outs.reset (new Delivery (_session, _output, _mute_master, _name, Delivery::Main));
1890         add_processor (_main_outs, PostFader);
1891
1892         /* IOs */
1893
1894         nlist = node.children ();
1895         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1896
1897                 child = *niter;
1898
1899                 if (child->name() == IO::state_node_name) {
1900
1901                         /* there is a note in IO::set_state_2X() about why we have to call
1902                            this directly.
1903                            */
1904
1905                         _input->set_state_2X (*child, version, true);
1906                         _output->set_state_2X (*child, version, false);
1907
1908                         if ((prop = child->property (X_("name"))) != 0) {
1909                                 set_name (prop->value ());
1910                         }
1911
1912                         if ((prop = child->property (X_("id"))) != 0) {
1913                                 _id = prop->value ();
1914                         }
1915
1916                         if ((prop = child->property (X_("active"))) != 0) {
1917                                 bool yn = string_is_affirmative (prop->value());
1918                                 _active = !yn; // force switch
1919                                 set_active (yn);
1920                         }
1921                 }
1922
1923                 /* XXX: panners? */
1924         }
1925
1926         if ((prop = node.property (X_("phase-invert"))) != 0) {
1927                 set_phase_invert (string_is_affirmative (prop->value()));
1928         }
1929
1930         if ((prop = node.property (X_("denormal-protection"))) != 0) {
1931                 set_denormal_protection (string_is_affirmative (prop->value()));
1932         }
1933
1934         if ((prop = node.property (X_("soloed"))) != 0) {
1935                 bool yn = string_is_affirmative (prop->value());
1936
1937                 /* XXX force reset of solo status */
1938
1939                 set_solo (yn, this);
1940         }
1941
1942         if ((prop = node.property (X_("meter-point"))) != 0) {
1943                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
1944         }
1945
1946         /* XXX: if the route was in both a mix group and an edit group, it'll end up
1947            just in the edit group. */
1948
1949         if ((prop = node.property (X_("mix-group"))) != 0) {
1950                 RouteGroup* route_group = _session.route_group_by_name(prop->value());
1951                 if (route_group == 0) {
1952                         error << string_compose(_("Route %1: unknown route group \"%2 in saved state (ignored)"), _name, prop->value()) << endmsg;
1953                 } else {
1954                         set_route_group (route_group, this);
1955                 }
1956         }
1957
1958         if ((prop = node.property (X_("edit-group"))) != 0) {
1959                 RouteGroup* route_group = _session.route_group_by_name(prop->value());
1960                 if (route_group == 0) {
1961                         error << string_compose(_("Route %1: unknown route group \"%2 in saved state (ignored)"), _name, prop->value()) << endmsg;
1962                 } else {
1963                         set_route_group (route_group, this);
1964                 }
1965         }
1966
1967         if ((prop = node.property (X_("order-keys"))) != 0) {
1968
1969                 long n;
1970
1971                 string::size_type colon, equal;
1972                 string remaining = prop->value();
1973
1974                 while (remaining.length()) {
1975
1976                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
1977                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1978                                         << endmsg;
1979                         } else {
1980                                 if (sscanf (remaining.substr (equal+1).c_str(), "%ld", &n) != 1) {
1981                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1982                                                 << endmsg;
1983                                 } else {
1984                                         set_order_key (remaining.substr (0, equal), n);
1985                                 }
1986                         }
1987
1988                         colon = remaining.find_first_of (':');
1989
1990                         if (colon != string::npos) {
1991                                 remaining = remaining.substr (colon+1);
1992                         } else {
1993                                 break;
1994                         }
1995                 }
1996         }
1997
1998         XMLNodeList redirect_nodes;
1999
2000         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2001
2002                 child = *niter;
2003
2004                 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2005                         redirect_nodes.push_back(child);
2006                 }
2007
2008         }
2009
2010         set_processor_state_2X (redirect_nodes, version);
2011
2012         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2013                 child = *niter;
2014
2015                 if (child->name() == X_("Comment")) {
2016
2017                         /* XXX this is a terrible API design in libxml++ */
2018
2019                         XMLNode *cmt = *(child->children().begin());
2020                         _comment = cmt->content();
2021
2022                 } else if (child->name() == X_("Extra")) {
2023
2024                         _extra_xml = new XMLNode (*child);
2025
2026                 } else if (child->name() == X_("Controllable") && (prop = child->property("name")) != 0) {
2027
2028                         if (prop->value() == "solo") {
2029                                 _solo_control->set_state (*child, version);
2030                                 _session.add_controllable (_solo_control);
2031                         }
2032
2033                 } else if (child->name() == X_("RemoteControl")) {
2034                         if ((prop = child->property (X_("id"))) != 0) {
2035                                 int32_t x;
2036                                 sscanf (prop->value().c_str(), "%d", &x);
2037                                 set_remote_control_id (x);
2038                         }
2039
2040                 }
2041         }
2042
2043         return 0;
2044 }
2045
2046 XMLNode&
2047 Route::get_processor_state ()
2048 {
2049         XMLNode* root = new XMLNode (X_("redirects"));
2050         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2051                 root->add_child_nocopy ((*i)->state (true));
2052         }
2053
2054         return *root;
2055 }
2056
2057 void
2058 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2059 {
2060         /* We don't bother removing existing processors not in nList, as this
2061            method will only be called when creating a Route from scratch, not
2062            for undo purposes.  Just put processors in at the appropriate place
2063            in the list.
2064         */
2065
2066         for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2067                 add_processor_from_xml_2X (**i, version, _processors.begin ());
2068         }
2069 }
2070
2071 void
2072 Route::set_processor_state (const XMLNode& node)
2073 {
2074         const XMLNodeList &nlist = node.children();
2075         XMLNodeConstIterator niter;
2076         ProcessorList::iterator i, o;
2077
2078         // Iterate through existing processors, remove those which are not in the state list
2079
2080         for (i = _processors.begin(); i != _processors.end(); ) {
2081
2082                 /* leave amp alone, always */
2083
2084                 if ((*i) == _amp) {
2085                         ++i;
2086                         continue;
2087                 }
2088
2089                 ProcessorList::iterator tmp = i;
2090                 ++tmp;
2091
2092                 bool processorInStateList = false;
2093
2094                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2095
2096                         XMLProperty* id_prop = (*niter)->property(X_("id"));
2097
2098                         if (id_prop && (*i)->id() == id_prop->value()) {
2099                                 processorInStateList = true;
2100                                 break;
2101                         }
2102                 }
2103
2104                 if (!processorInStateList) {
2105                         remove_processor (*i);
2106                 }
2107
2108                 i = tmp;
2109         }
2110
2111         // Iterate through state list and make sure all processors are on the track and in the correct order,
2112         // set the state of existing processors according to the new state on the same go
2113
2114         i = _processors.begin();
2115
2116         for (niter = nlist.begin(); niter != nlist.end(); ++niter, ++i) {
2117
2118                 XMLProperty* prop = (*niter)->property ("type");
2119
2120                 o = i;
2121
2122                 // Check whether the next processor in the list is the right one,
2123                 // except for "amp" which is always there and may not have the
2124                 // old ID since it is always created anew in every Route
2125
2126                 if (prop->value() != "amp") {
2127                         while (o != _processors.end()) {
2128                                 XMLProperty* id_prop = (*niter)->property(X_("id"));
2129                                 if (id_prop && (*o)->id() == id_prop->value()) {
2130                                         break;
2131                                 }
2132
2133                                 ++o;
2134                         }
2135                 }
2136
2137                 // If the processor (*niter) is not on the route,
2138                 // create it and move it to the correct location
2139
2140                 if (o == _processors.end()) {
2141
2142                         if (add_processor_from_xml (**niter, i)) {
2143                                 --i; // move iterator to the newly inserted processor
2144                         } else {
2145                                 cerr << "Error restoring route: unable to restore processor" << endl;
2146                         }
2147
2148                 } else {
2149
2150                         // Otherwise, the processor already exists; just
2151                         // ensure it is at the location provided in the XML state
2152
2153                         if (i != o) {
2154                                 boost::shared_ptr<Processor> tmp = (*o);
2155                                 _processors.erase (o); // remove the old copy
2156                                 _processors.insert (i, tmp); // insert the processor at the correct location
2157                                 --i; // move iterator to the correct processor
2158                         }
2159
2160                         // and make it (just) so
2161
2162                         (*i)->set_state (**niter, Stateful::current_state_version);
2163                 }
2164         }
2165
2166         /* note: there is no configure_processors() call because we figure that
2167            the XML state represents a working signal route.
2168         */
2169
2170         processors_changed ();
2171 }
2172
2173 void
2174 Route::curve_reallocate ()
2175 {
2176 //      _gain_automation_curve.finish_resize ();
2177 //      _pan_automation_curve.finish_resize ();
2178 }
2179
2180 void
2181 Route::silence (nframes_t nframes)
2182 {
2183         if (!_silent) {
2184
2185                 _output->silence (nframes);
2186
2187                 {
2188                         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2189
2190                         if (lm.locked()) {
2191                                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2192                                         boost::shared_ptr<PluginInsert> pi;
2193
2194                                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2195                                                 // skip plugins, they don't need anything when we're not active
2196                                                 continue;
2197                                         }
2198
2199                                         (*i)->silence (nframes);
2200                                 }
2201
2202                                 if (nframes == _session.get_block_size()) {
2203                                         // _silent = true;
2204                                 }
2205                         }
2206                 }
2207
2208         }
2209 }
2210
2211 void
2212 Route::add_internal_return ()
2213 {
2214         if (!_intreturn) {
2215                 _intreturn.reset (new InternalReturn (_session));
2216                 add_processor (_intreturn, PreFader);
2217         }
2218 }
2219
2220 BufferSet*
2221 Route::get_return_buffer () const
2222 {
2223         Glib::RWLock::ReaderLock rm (_processor_lock);
2224
2225         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2226                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2227
2228                 if (d) {
2229                         BufferSet* bs = d->get_buffers ();
2230                         return bs;
2231                 }
2232         }
2233
2234         return 0;
2235 }
2236
2237 void
2238 Route::release_return_buffer () const
2239 {
2240         Glib::RWLock::ReaderLock rm (_processor_lock);
2241
2242         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2243                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2244
2245                 if (d) {
2246                         return d->release_buffers ();
2247                 }
2248         }
2249 }
2250
2251 int
2252 Route::listen_via (boost::shared_ptr<Route> route, Placement placement, bool /*active*/, bool aux)
2253 {
2254         vector<string> ports;
2255         vector<string>::const_iterator i;
2256
2257         {
2258                 Glib::RWLock::ReaderLock rm (_processor_lock);
2259
2260                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2261
2262                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2263
2264                         if (d && d->target_route() == route) {
2265
2266                                 /* if the target is the control outs, then make sure
2267                                    we take note of which i-send is doing that.
2268                                 */
2269
2270                                 if (route == _session.control_out()) {
2271                                         _control_outs = boost::dynamic_pointer_cast<Delivery>(d);
2272                                 }
2273
2274                                 /* already listening via the specified IO: do nothing */
2275
2276                                 return 0;
2277                         }
2278                 }
2279         }
2280
2281         boost::shared_ptr<InternalSend> listener;
2282
2283         try {
2284                 listener.reset (new InternalSend (_session, _mute_master, route, (aux ? Delivery::Aux : Delivery::Listen)));
2285
2286         } catch (failed_constructor& err) {
2287                 return -1;
2288         }
2289
2290         if (route == _session.control_out()) {
2291                 _control_outs = listener;
2292         }
2293
2294         add_processor (listener, placement);
2295
2296         return 0;
2297 }
2298
2299 void
2300 Route::drop_listen (boost::shared_ptr<Route> route)
2301 {
2302         ProcessorStreams err;
2303         ProcessorList::iterator tmp;
2304
2305         Glib::RWLock::ReaderLock rl(_processor_lock);
2306         rl.acquire ();
2307
2308   again:
2309         for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ) {
2310
2311                 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2312
2313                 if (d && d->target_route() == route) {
2314                         rl.release ();
2315                         remove_processor (*x, &err);
2316                         rl.acquire ();
2317
2318                         /* list could have been demolished while we dropped the lock
2319                            so start over.
2320                         */
2321
2322                         goto again;
2323                 }
2324         }
2325
2326         rl.release ();
2327
2328         if (route == _session.control_out()) {
2329                 _control_outs.reset ();
2330         }
2331 }
2332
2333 void
2334 Route::set_route_group (RouteGroup *rg, void *src)
2335 {
2336         if (rg == _route_group) {
2337                 return;
2338         }
2339
2340         if (_route_group) {
2341                 _route_group->remove (this);
2342         }
2343
2344         if ((_route_group = rg) != 0) {
2345                 _route_group->add (this);
2346         }
2347
2348         _session.set_dirty ();
2349         route_group_changed (src); /* EMIT SIGNAL */
2350 }
2351
2352 void
2353 Route::drop_route_group (void *src)
2354 {
2355         _route_group = 0;
2356         _session.set_dirty ();
2357         route_group_changed (src); /* EMIT SIGNAL */
2358 }
2359
2360 void
2361 Route::set_comment (string cmt, void *src)
2362 {
2363         _comment = cmt;
2364         comment_changed (src);
2365         _session.set_dirty ();
2366 }
2367
2368 bool
2369 Route::feeds (boost::shared_ptr<Route> other)
2370 {
2371         // cerr << _name << endl;
2372
2373         if (_output->connected_to (other->input())) {
2374                 // cerr << "\tdirect FEEDS " << other->name() << endl;
2375                 return true;
2376         }
2377
2378         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); r++) {
2379
2380                 boost::shared_ptr<IOProcessor> iop;
2381
2382                 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
2383                         if (iop->feeds (other)) {
2384                                 // cerr << "\tIOP " << iop->name() << " feeds " << other->name() << endl;
2385                                 return true;
2386                         } else {
2387                                 // cerr << "\tIOP " << iop->name() << " does NOT feeds " << other->name() << endl;
2388                         }
2389                 }
2390         }
2391
2392         // cerr << "\tdoes NOT FEED " << other->name() << endl;
2393         return false;
2394 }
2395
2396 void
2397 Route::handle_transport_stopped (bool /*abort_ignored*/, bool did_locate, bool can_flush_processors)
2398 {
2399         nframes_t now = _session.transport_frame();
2400
2401         {
2402                 Glib::RWLock::ReaderLock lm (_processor_lock);
2403
2404                 if (!did_locate) {
2405                         automation_snapshot (now, true);
2406                 }
2407
2408                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2409
2410                         if (Config->get_plugins_stop_with_transport() && can_flush_processors) {
2411                                 (*i)->deactivate ();
2412                                 (*i)->activate ();
2413                         }
2414
2415                         (*i)->transport_stopped (now);
2416                 }
2417         }
2418
2419         _roll_delay = _initial_delay;
2420 }
2421
2422 void
2423 Route::input_change_handler (IOChange change, void * /*src*/)
2424 {
2425         if ((change & ConfigurationChanged)) {
2426                 configure_processors (0);
2427         }
2428 }
2429
2430 void
2431 Route::output_change_handler (IOChange change, void * /*src*/)
2432 {
2433         if ((change & ConfigurationChanged)) {
2434
2435                 /* XXX resize all listeners to match _main_outs? */
2436
2437                 // configure_processors (0);
2438         }
2439 }
2440
2441 uint32_t
2442 Route::pans_required () const
2443 {
2444         if (n_outputs().n_audio() < 2) {
2445                 return 0;
2446         }
2447
2448         return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
2449 }
2450
2451 int
2452 Route::no_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
2453                 bool session_state_changing, bool /*can_record*/, bool /*rec_monitors_input*/)
2454 {
2455         if (n_outputs().n_total() == 0) {
2456                 return 0;
2457         }
2458
2459         if (session_state_changing || !_active || n_inputs() == ChanCount::ZERO)  {
2460                 silence (nframes);
2461                 return 0;
2462         }
2463
2464         _amp->apply_gain_automation (false);
2465         passthru (start_frame, end_frame, nframes, 0);
2466
2467         return 0;
2468 }
2469
2470 nframes_t
2471 Route::check_initial_delay (nframes_t nframes, nframes_t& transport_frame)
2472 {
2473         if (_roll_delay > nframes) {
2474
2475                 _roll_delay -= nframes;
2476                 silence (nframes);
2477                 /* transport frame is not legal for caller to use */
2478                 return 0;
2479
2480         } else if (_roll_delay > 0) {
2481
2482                 nframes -= _roll_delay;
2483                 silence (_roll_delay);
2484                 /* we've written _roll_delay of samples into the
2485                    output ports, so make a note of that for
2486                    future reference.
2487                 */
2488                 _main_outs->increment_output_offset (_roll_delay);
2489                 transport_frame += _roll_delay;
2490
2491                 _roll_delay = 0;
2492         }
2493
2494         return nframes;
2495 }
2496
2497 int
2498 Route::roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame, int declick,
2499              bool /*can_record*/, bool /*rec_monitors_input*/)
2500 {
2501         {
2502                 // automation snapshot can also be called from the non-rt context
2503                 // and it uses the processor list, so we try to acquire the lock here
2504                 Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2505
2506                 if (lm.locked()) {
2507                         automation_snapshot (_session.transport_frame(), false);
2508                 }
2509         }
2510
2511         if (n_outputs().n_total() == 0) {
2512                 return 0;
2513         }
2514
2515         if (!_active || n_inputs().n_total() == 0) {
2516                 silence (nframes);
2517                 return 0;
2518         }
2519
2520         nframes_t unused = 0;
2521
2522         if ((nframes = check_initial_delay (nframes, unused)) == 0) {
2523                 return 0;
2524         }
2525
2526         _silent = false;
2527
2528         passthru (start_frame, end_frame, nframes, declick);
2529
2530         return 0;
2531 }
2532
2533 int
2534 Route::silent_roll (nframes_t nframes, sframes_t /*start_frame*/, sframes_t /*end_frame*/,
2535                     bool /*can_record*/, bool /*rec_monitors_input*/)
2536 {
2537         silence (nframes);
2538         return 0;
2539 }
2540
2541 void
2542 Route::toggle_monitor_input ()
2543 {
2544         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
2545                 i->ensure_monitor_input( ! i->monitoring_input());
2546         }
2547 }
2548
2549 bool
2550 Route::has_external_redirects () const
2551 {
2552         // FIXME: what about sends? - they don't return a signal back to ardour?
2553
2554         boost::shared_ptr<const PortInsert> pi;
2555
2556         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2557
2558                 if ((pi = boost::dynamic_pointer_cast<const PortInsert>(*i)) != 0) {
2559
2560                         for (PortSet::const_iterator port = pi->output()->ports().begin(); port != pi->output()->ports().end(); ++port) {
2561
2562                                 string port_name = port->name();
2563                                 string client_name = port_name.substr (0, port_name.find(':'));
2564
2565                                 /* only say "yes" if the redirect is actually in use */
2566
2567                                 if (client_name != "ardour" && pi->active()) {
2568                                         return true;
2569                                 }
2570                         }
2571                 }
2572         }
2573
2574         return false;
2575 }
2576
2577 void
2578 Route::flush_processors ()
2579 {
2580         /* XXX shouldn't really try to take this lock, since
2581            this is called from the RT audio thread.
2582         */
2583
2584         Glib::RWLock::ReaderLock lm (_processor_lock);
2585
2586         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2587                 (*i)->deactivate ();
2588                 (*i)->activate ();
2589         }
2590 }
2591
2592 void
2593 Route::set_meter_point (MeterPoint p, void *src)
2594 {
2595         if (_meter_point != p) {
2596                 _meter_point = p;
2597
2598                 // Move meter in the processors list
2599                 ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), _meter);
2600                 _processors.erase(loc);
2601                 switch (p) {
2602                 case MeterInput:
2603                         loc = _processors.begin();
2604                         break;
2605                 case MeterPreFader:
2606                         loc = find(_processors.begin(), _processors.end(), _amp);
2607                         break;
2608                 case MeterPostFader:
2609                         loc = _processors.end();
2610                         break;
2611                 }
2612                 _processors.insert(loc, _meter);
2613
2614                  meter_change (src); /* EMIT SIGNAL */
2615                 processors_changed (); /* EMIT SIGNAL */
2616                 _session.set_dirty ();
2617         }
2618 }
2619 void
2620 Route::put_control_outs_at (Placement p)
2621 {
2622         if (!_control_outs) {
2623                 return;
2624         }
2625
2626         // Move meter in the processors list
2627         ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), _control_outs);
2628         _processors.erase(loc);
2629
2630         switch (p) {
2631         case PreFader:
2632                 loc = find(_processors.begin(), _processors.end(), _amp);
2633                 if (loc != _processors.begin()) {
2634                         --loc;
2635                 }
2636                 break;
2637         case PostFader:
2638                 loc = find(_processors.begin(), _processors.end(), _amp);
2639                 assert (loc != _processors.end());
2640                 loc++;
2641                 break;
2642         }
2643
2644         _processors.insert(loc, _control_outs);
2645
2646         processors_changed (); /* EMIT SIGNAL */
2647         _session.set_dirty ();
2648 }
2649
2650 nframes_t
2651 Route::update_total_latency ()
2652 {
2653         nframes_t old = _output->effective_latency();
2654         nframes_t own_latency = _output->user_latency();
2655
2656         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2657                 if ((*i)->active ()) {
2658                         own_latency += (*i)->signal_latency ();
2659                 }
2660         }
2661
2662 #undef DEBUG_LATENCY
2663 #ifdef DEBUG_LATENCY
2664         cerr << _name << ": internal redirect latency = " << own_latency << endl;
2665 #endif
2666
2667         _output->set_port_latency (own_latency);
2668
2669         if (_output->user_latency() == 0) {
2670
2671                 /* this (virtual) function is used for pure Routes,
2672                    not derived classes like AudioTrack.  this means
2673                    that the data processed here comes from an input
2674                    port, not prerecorded material, and therefore we
2675                    have to take into account any input latency.
2676                 */
2677
2678                 own_latency += _input->signal_latency ();
2679         }
2680
2681         if (old != own_latency) {
2682                 _output->set_latency_delay (own_latency);
2683                 signal_latency_changed (); /* EMIT SIGNAL */
2684         }
2685
2686 #ifdef DEBUG_LATENCY
2687         cerr << _name << ": input latency = " << _input->signal_latency() << " total = "
2688              << own_latency << endl;
2689 #endif
2690
2691         return _output->effective_latency ();
2692 }
2693
2694 void
2695 Route::set_user_latency (nframes_t nframes)
2696 {
2697         _output->set_user_latency (nframes);
2698         _session.update_latency_compensation (false, false);
2699 }
2700
2701 void
2702 Route::set_latency_delay (nframes_t longest_session_latency)
2703 {
2704         nframes_t old = _initial_delay;
2705
2706         if (_output->effective_latency() < longest_session_latency) {
2707                 _initial_delay = longest_session_latency - _output->effective_latency();
2708         } else {
2709                 _initial_delay = 0;
2710         }
2711
2712         if (_initial_delay != old) {
2713                 initial_delay_changed (); /* EMIT SIGNAL */
2714         }
2715
2716         if (_session.transport_stopped()) {
2717                 _roll_delay = _initial_delay;
2718         }
2719 }
2720
2721 void
2722 Route::automation_snapshot (nframes_t now, bool force)
2723 {
2724         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2725                 (*i)->automation_snapshot (now, force);
2726         }
2727 }
2728
2729 Route::SoloControllable::SoloControllable (std::string name, Route& r)
2730         : AutomationControl (r.session(), Evoral::Parameter (SoloAutomation),
2731                              boost::shared_ptr<AutomationList>(), name)
2732         , route (r)
2733 {
2734         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
2735         set_list (gl);
2736 }
2737
2738 void
2739 Route::SoloControllable::set_value (float val)
2740 {
2741         bool bval = ((val >= 0.5f) ? true: false);
2742
2743         route.set_solo (bval, this);
2744 }
2745
2746 float
2747 Route::SoloControllable::get_value (void) const
2748 {
2749         return route.soloed() ? 1.0f : 0.0f;
2750 }
2751
2752 void
2753 Route::set_block_size (nframes_t nframes)
2754 {
2755         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2756                 (*i)->set_block_size (nframes);
2757         }
2758
2759         _session.ensure_buffers (n_process_buffers ());
2760 }
2761
2762 void
2763 Route::protect_automation ()
2764 {
2765         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
2766                 (*i)->protect_automation();
2767 }
2768
2769 void
2770 Route::set_pending_declick (int declick)
2771 {
2772         if (_declickable) {
2773                 /* this call is not allowed to turn off a pending declick unless "force" is true */
2774                 if (declick) {
2775                         _pending_declick = declick;
2776                 }
2777                 // cerr << _name << ": after setting to " << declick << " pending declick = " << _pending_declick << endl;
2778         } else {
2779                 _pending_declick = 0;
2780         }
2781
2782 }
2783
2784 /** Shift automation forwards from a particular place, thereby inserting time.
2785  *  Adds undo commands for any shifts that are performed.
2786  *
2787  * @param pos Position to start shifting from.
2788  * @param frames Amount to shift forwards by.
2789  */
2790
2791 void
2792 Route::shift (nframes64_t /*pos*/, nframes64_t /*frames*/)
2793 {
2794 #ifdef THIS_NEEDS_FIXING_FOR_V3
2795
2796         /* gain automation */
2797         XMLNode &before = _gain_control->get_state ();
2798         _gain_control->shift (pos, frames);
2799         XMLNode &after = _gain_control->get_state ();
2800         _session.add_command (new MementoCommand<AutomationList> (_gain_automation_curve, &before, &after));
2801
2802         /* pan automation */
2803         for (std::vector<StreamPanner*>::iterator i = _panner->begin (); i != _panner->end (); ++i) {
2804                 Curve & c = (*i)->automation ();
2805                 XMLNode &before = c.get_state ();
2806                 c.shift (pos, frames);
2807                 XMLNode &after = c.get_state ();
2808                 _session.add_command (new MementoCommand<AutomationList> (c, &before, &after));
2809         }
2810
2811         /* redirect automation */
2812         {
2813                 Glib::RWLock::ReaderLock lm (redirect_lock);
2814                 for (RedirectList::iterator i = _redirects.begin (); i != _redirects.end (); ++i) {
2815
2816                         set<uint32_t> a;
2817                         (*i)->what_has_automation (a);
2818
2819                         for (set<uint32_t>::const_iterator j = a.begin (); j != a.end (); ++j) {
2820                                 AutomationList & al = (*i)->automation_list (*j);
2821                                 XMLNode &before = al.get_state ();
2822                                 al.shift (pos, frames);
2823                                 XMLNode &after = al.get_state ();
2824                                 _session.add_command (new MementoCommand<AutomationList> (al, &before, &after));
2825                         }
2826                 }
2827         }
2828 #endif
2829
2830 }
2831
2832
2833 int
2834 Route::save_as_template (const string& path, const string& name)
2835 {
2836         XMLNode& node (state (false));
2837         XMLTree tree;
2838
2839         IO::set_name_in_state (*node.children().front(), name);
2840
2841         tree.set_root (&node);
2842         return tree.write (path.c_str());
2843 }
2844
2845
2846 bool
2847 Route::set_name (const string& str)
2848 {
2849         bool ret;
2850         string ioproc_name;
2851         string name;
2852
2853         name = Route::ensure_track_or_route_name (str, _session);
2854         SessionObject::set_name (name);
2855
2856         ret = (_input->set_name(name) && _output->set_name(name));
2857
2858         if (ret) {
2859
2860                 Glib::RWLock::ReaderLock lm (_processor_lock);
2861
2862                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2863
2864                         /* rename all I/O processors that have inputs or outputs */
2865
2866                         boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
2867
2868                         if (iop && (iop->output() || iop->input())) {
2869                                 if (!iop->set_name (name)) {
2870                                         ret = false;
2871                                 }
2872                         }
2873                 }
2874
2875         }
2876
2877         return ret;
2878 }
2879
2880 boost::shared_ptr<Send>
2881 Route::internal_send_for (boost::shared_ptr<const Route> target) const
2882 {
2883         Glib::RWLock::ReaderLock lm (_processor_lock);
2884
2885         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2886                 boost::shared_ptr<InternalSend> send;
2887
2888                 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
2889                         if (send->target_route() == target) {
2890                                 return send;
2891                         }
2892                 }
2893         }
2894
2895         return boost::shared_ptr<Send>();
2896 }
2897
2898 void
2899 Route::set_phase_invert (bool yn)
2900 {
2901         if (_phase_invert != yn) {
2902                 _phase_invert = 0xffff; // XXX all channels
2903                 phase_invert_changed (); /* EMIT SIGNAL */
2904         }
2905 }
2906
2907 bool
2908 Route::phase_invert () const
2909 {
2910         return _phase_invert != 0;
2911 }
2912
2913 void
2914 Route::set_denormal_protection (bool yn)
2915 {
2916         if (_denormal_protection != yn) {
2917                 _denormal_protection = yn;
2918                 denormal_protection_changed (); /* EMIT SIGNAL */
2919         }
2920 }
2921
2922 bool
2923 Route::denormal_protection () const
2924 {
2925         return _denormal_protection;
2926 }
2927
2928 void
2929 Route::set_active (bool yn)
2930 {
2931         if (_active != yn) {
2932                 _active = yn;
2933                 _input->set_active (yn);
2934                 _output->set_active (yn);
2935                 active_changed (); // EMIT SIGNAL
2936         }
2937 }
2938
2939 void
2940 Route::meter ()
2941 {
2942         Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
2943
2944         assert (_meter);
2945
2946         _meter->meter ();
2947
2948         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2949
2950                 boost::shared_ptr<Send> s;
2951                 boost::shared_ptr<Return> r;
2952
2953                 if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
2954                         s->meter()->meter();
2955                 } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
2956                         r->meter()->meter ();
2957                 }
2958         }
2959 }
2960
2961 boost::shared_ptr<Panner>
2962 Route::panner() const
2963 {
2964
2965         return _main_outs->panner();
2966 }
2967
2968 boost::shared_ptr<AutomationControl>
2969 Route::gain_control() const
2970 {
2971
2972         return _amp->gain_control();
2973 }
2974
2975 boost::shared_ptr<AutomationControl>
2976 Route::get_control (const Evoral::Parameter& param)
2977 {
2978         /* either we own the control or .... */
2979
2980         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(data().control (param));
2981
2982         if (!c) {
2983
2984                 /* maybe one of our processors does or ... */
2985
2986                 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
2987                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2988                         if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->data().control (param))) != 0) {
2989                                 break;
2990                         }
2991                 }
2992         }
2993
2994         if (!c) {
2995
2996                 /* nobody does so we'll make a new one */
2997
2998                 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
2999                 add_control(c);
3000         }
3001
3002         return c;
3003 }