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
  24 #include <sigc++/bind.h>
  25 #include <pbd/xml++.h>
  26 #include <pbd/enumwriter.h>
  27 #include <pbd/stacktrace.h>
  28 #include <pbd/memento_command.h>
  29
  30 #include <ardour/timestamps.h>
  31 #include <ardour/audioengine.h>
  32 #include <ardour/route.h>
  33 #include <ardour/buffer.h>
  34 #include <ardour/processor.h>
  35 #include <ardour/plugin_insert.h>
  36 #include <ardour/port_insert.h>
  37 #include <ardour/send.h>
  38 #include <ardour/session.h>
  39 #include <ardour/utils.h>
  40 #include <ardour/configuration.h>
  41 #include <ardour/cycle_timer.h>
  42 #include <ardour/route_group.h>
  43 #include <ardour/port.h>
  44 #include <ardour/audio_port.h>
  45 #include <ardour/ladspa_plugin.h>
  46 #include <ardour/panner.h>
  47 #include <ardour/dB.h>
  48 #include <ardour/amp.h>
  49 #include <ardour/meter.h>
  50 #include <ardour/buffer_set.h>
  51 #include <ardour/mix.h>
  52 #include <ardour/profile.h>
  53
  54 #include "i18n.h"
  55
  56 using namespace std;
  57 using namespace ARDOUR;
  58 using namespace PBD;
  59
  60 uint32_t Route::order_key_cnt = 0;
  61 sigc::signal<void,const char*> Route::SyncOrderKeys;
  62
  63 Route::Route (Session& sess, string name,
  64                 int in_min, int in_max, int out_min, int out_max,
  65                 Flag flg, DataType default_type)
  66         : IO (sess, name, in_min, in_max, out_min, out_max, default_type)
  67         , _flags (flg)
  68         , _solo_control (new ToggleControllable (X_("solo"), *this, ToggleControllable::SoloControl))
  69         , _mute_control (new ToggleControllable (X_("mute"), *this, ToggleControllable::MuteControl))
  70 {
  71         init ();
  72 }
  73
  74 Route::Route (Session& sess, const XMLNode& node, DataType default_type)
  75         : IO (sess, *node.child ("IO"), default_type)
  76         ,  _solo_control (new ToggleControllable (X_("solo"), *this, ToggleControllable::SoloControl))
  77         ,  _mute_control (new ToggleControllable (X_("mute"), *this, ToggleControllable::MuteControl))
  78 {
  79         init ();
  80         _set_state (node, false);
  81 }
  82
  83 void
  84 Route::init ()
  85 {
  86         processor_max_outs.reset();
  87         _muted = false;
  88         _soloed = false;
  89         _solo_safe = false;
  90         _recordable = true;
  91         _active = true;
  92         _phase_invert = false;
  93         _denormal_protection = false;
  94         order_keys[strdup (N_("signal"))] = order_key_cnt++;
  95         _silent = false;
  96         _meter_point = MeterPostFader;
  97         _initial_delay = 0;
  98         _roll_delay = 0;
  99         _own_latency = 0;
 100         _user_latency = 0;
 101         _have_internal_generator = false;
 102         _declickable = false;
 103         _pending_declick = true;
 104         _remote_control_id = 0;
 105
 106         _edit_group = 0;
 107         _mix_group = 0;
 108
 109         _mute_affects_pre_fader = Config->get_mute_affects_pre_fader();
 110         _mute_affects_post_fader = Config->get_mute_affects_post_fader();
 111         _mute_affects_control_outs = Config->get_mute_affects_control_outs();
 112         _mute_affects_main_outs = Config->get_mute_affects_main_outs();
 113
 114         solo_gain = 1.0;
 115         desired_solo_gain = 1.0;
 116         mute_gain = 1.0;
 117         desired_mute_gain = 1.0;
 118
 119         _control_outs = 0;
 120
 121         input_changed.connect (mem_fun (this, &Route::input_change_handler));
 122         output_changed.connect (mem_fun (this, &Route::output_change_handler));
 123 }
 124
 125 Route::~Route ()
 126 {
 127         clear_processors (PreFader);
 128         clear_processors (PostFader);
 129
 130         for (OrderKeys::iterator i = order_keys.begin(); i != order_keys.end(); ++i) {
 131                 free ((void*)(i->first));
 132         }
 133
 134         delete _control_outs;
 135 }
 136
 137 void
 138 Route::set_remote_control_id (uint32_t id)
 139 {
 140         if (id != _remote_control_id) {
 141                 _remote_control_id = id;
 142                 RemoteControlIDChanged ();
 143         }
 144 }
 145
 146 uint32_t
 147 Route::remote_control_id() const
 148 {
 149         return _remote_control_id;
 150 }
 151
 152 long
 153 Route::order_key (const char* name) const
 154 {
 155         OrderKeys::const_iterator i;
 156
 157         for (i = order_keys.begin(); i != order_keys.end(); ++i) {
 158                 if (!strcmp (name, i->first)) {
 159                         return i->second;
 160                 }
 161         }
 162
 163         return -1;
 164 }
 165
 166 void
 167 Route::set_order_key (const char* name, long n)
 168 {
 169         order_keys[strdup(name)] = n;
 170
 171         if (Config->get_sync_all_route_ordering()) {
 172                 for (OrderKeys::iterator x = order_keys.begin(); x != order_keys.end(); ++x) {
 173                         x->second = n;
 174                 }
 175         }
 176
 177         _session.set_dirty ();
 178 }
 179
 180 void
 181 Route::sync_order_keys (const char* base)
 182 {
 183         if (order_keys.empty()) {
 184                 return;
 185         }
 186
 187         OrderKeys::iterator i;
 188         uint32_t key;
 189
 190         if ((i = order_keys.find (base)) == order_keys.end()) {
 191                 /* key doesn't exist, use the first existing key (during session initialization) */
 192                 i = order_keys.begin();
 193                 key = i->second;
 194                 ++i;
 195         } else {
 196                 /* key exists - use it and reset all others (actually, itself included) */
 197                 i = order_keys.begin();
 198                 key = i->second;
 199         }
 200
 201         for (; i != order_keys.end(); ++i) {
 202                 i->second = key;
 203         }
 204 }
 205
 206 string
 207 Route::ensure_track_or_route_name(string name, Session &session)
 208 {
 209         string newname = name;
 210
 211         while (session.route_by_name (newname) != NULL) {
 212                 newname = bump_name_once (newname);
 213         }
 214
 215         return newname;
 216 }
 217
 218
 219 void
 220 Route::inc_gain (gain_t fraction, void *src)
 221 {
 222         IO::inc_gain (fraction, src);
 223 }
 224
 225 void
 226 Route::set_gain (gain_t val, void *src)
 227 {
 228         if (src != 0 && _mix_group && src != _mix_group && _mix_group->is_active()) {
 229
 230                 if (_mix_group->is_relative()) {
 231
 232                         gain_t usable_gain = gain();
 233                         if (usable_gain < 0.000001f) {
 234                                 usable_gain = 0.000001f;
 235                         }
 236
 237                         gain_t delta = val;
 238                         if (delta < 0.000001f) {
 239                                 delta = 0.000001f;
 240                         }
 241
 242                         delta -= usable_gain;
 243
 244                         if (delta == 0.0f)
 245                                 return;
 246
 247                         gain_t factor = delta / usable_gain;
 248
 249                         if (factor > 0.0f) {
 250                                 factor = _mix_group->get_max_factor(factor);
 251                                 if (factor == 0.0f) {
 252                                         _gain_control->Changed(); /* EMIT SIGNAL */
 253                                         return;
 254                                 }
 255                         } else {
 256                                 factor = _mix_group->get_min_factor(factor);
 257                                 if (factor == 0.0f) {
 258                                         _gain_control->Changed(); /* EMIT SIGNAL */
 259                                         return;
 260                                 }
 261                         }
 262
 263                         _mix_group->apply (&Route::inc_gain, factor, _mix_group);
 264
 265                 } else {
 266
 267                         _mix_group->apply (&Route::set_gain, val, _mix_group);
 268                 }
 269
 270                 return;
 271         }
 272
 273         if (val == gain()) {
 274                 return;
 275         }
 276
 277         IO::set_gain (val, src);
 278 }
 279
 280 /** Process this route for one (sub) cycle (process thread)
 281  *
 282  * @param bufs Scratch buffers to use for the signal path
 283  * @param start_frame Initial transport frame
 284  * @param end_frame Final transport frame
 285  * @param nframes Number of frames to output (to ports)
 286  * @param offset Output offset (of port buffers, for split cycles)
 287  *
 288  * Note that (end_frame - start_frame) may not be equal to nframes when the
 289  * transport speed isn't 1.0 (eg varispeed).
 290  */
 291 void
 292 Route::process_output_buffers (BufferSet& bufs,
 293                 nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset,
 294                 bool with_processors, int declick, bool meter)
 295 {
 296         // This is definitely very audio-only for now
 297         assert(_default_type == DataType::AUDIO);
 298
 299         ProcessorList::iterator i;
 300         bool post_fader_work = false;
 301         bool mute_declick_applied = false;
 302         gain_t dmg, dsg, dg;
 303         IO *co;
 304         bool mute_audible;
 305         bool solo_audible;
 306         bool no_monitor;
 307         gain_t* gab = _session.gain_automation_buffer();
 308
 309         switch (Config->get_monitoring_model()) {
 310         case HardwareMonitoring:
 311         case ExternalMonitoring:
 312                 no_monitor = true;
 313                 break;
 314         default:
 315                 no_monitor = false;
 316         }
 317
 318         declick = _pending_declick;
 319
 320         {
 321                 Glib::Mutex::Lock cm (_control_outs_lock, Glib::TRY_LOCK);
 322
 323                 if (cm.locked()) {
 324                         co = _control_outs;
 325                 } else {
 326                         co = 0;
 327                 }
 328         }
 329
 330         {
 331                 Glib::Mutex::Lock dm (declick_lock, Glib::TRY_LOCK);
 332
 333                 if (dm.locked()) {
 334                         dmg = desired_mute_gain;
 335                         dsg = desired_solo_gain;
 336                         dg = _desired_gain;
 337                 } else {
 338                         dmg = mute_gain;
 339                         dsg = solo_gain;
 340                         dg = _gain;
 341                 }
 342         }
 343
 344         /* -------------------------------------------------------------------------------------------
 345            GLOBAL DECLICK (for transport changes etc.)
 346            ----------------------------------------------------------------------------------------- */
 347
 348         if (declick > 0) {
 349                 Amp::run_in_place (bufs, nframes, 0.0, 1.0, false);
 350                 _pending_declick = 0;
 351         } else if (declick < 0) {
 352                 Amp::run_in_place (bufs, nframes, 1.0, 0.0, false);
 353                 _pending_declick = 0;
 354         } else {
 355
 356                 /* no global declick */
 357
 358                 if (solo_gain != dsg) {
 359                         Amp::run_in_place (bufs, nframes, solo_gain, dsg, false);
 360                         solo_gain = dsg;
 361                 }
 362         }
 363
 364
 365         /* -------------------------------------------------------------------------------------------
 366            INPUT METERING & MONITORING
 367            ----------------------------------------------------------------------------------------- */
 368
 369         if (meter && (_meter_point == MeterInput)) {
 370                 _meter->run_in_place(bufs, start_frame, end_frame, nframes, offset);
 371         }
 372
 373         if (!_soloed && _mute_affects_pre_fader && (mute_gain != dmg)) {
 374                 Amp::run_in_place (bufs, nframes, mute_gain, dmg, false);
 375                 mute_gain = dmg;
 376                 mute_declick_applied = true;
 377         }
 378
 379         if ((_meter_point == MeterInput) && co) {
 380
 381                 solo_audible = dsg > 0;
 382                 mute_audible = dmg > 0;// || !_mute_affects_pre_fader;
 383
 384                 if (    // muted by solo of another track
 385
 386                         !solo_audible ||
 387
 388                         // muted by mute of this track
 389
 390                         !mute_audible ||
 391
 392                         // rec-enabled but not s/w monitoring
 393
 394                         // TODO: this is probably wrong
 395
 396                         ( no_monitor && record_enabled()
 397                                 && (!Config->get_auto_input() || _session.actively_recording()) )
 398
 399                         ) {
 400
 401                         co->silence (nframes, offset);
 402
 403                 } else {
 404
 405                         co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
 406
 407                 }
 408         }
 409
 410         /* -------------------------------------------------------------------------------------------
 411            DENORMAL CONTROL
 412            ----------------------------------------------------------------------------------------- */
 413
 414         if (_denormal_protection || Config->get_denormal_protection()) {
 415
 416                 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
 417                         Sample* const sp = i->data();
 418
 419                         for (nframes_t nx = offset; nx < nframes + offset; ++nx) {
 420                                 sp[nx] += 1.0e-27f;
 421                         }
 422                 }
 423         }
 424
 425         /* -------------------------------------------------------------------------------------------
 426            PRE-FADER REDIRECTS
 427            ----------------------------------------------------------------------------------------- */
 428
 429         if (with_processors) {
 430                 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
 431                 if (rm.locked()) {
 432                         if (mute_gain > 0 || !_mute_affects_pre_fader) {
 433                                 for (i = _processors.begin(); i != _processors.end(); ++i) {
 434                                         switch ((*i)->placement()) {
 435                                         case PreFader:
 436                                                 (*i)->run_in_place (bufs, start_frame, end_frame, nframes, offset);
 437                                                 break;
 438                                         case PostFader:
 439                                                 post_fader_work = true;
 440                                                 break;
 441                                         }
 442                                 }
 443                         } else {
 444                                 for (i = _processors.begin(); i != _processors.end(); ++i) {
 445                                         switch ((*i)->placement()) {
 446                                         case PreFader:
 447                                                 (*i)->silence (nframes, offset);
 448                                                 break;
 449                                         case PostFader:
 450                                                 post_fader_work = true;
 451                                                 break;
 452                                         }
 453                                 }
 454                         }
 455                 }
 456         }
 457
 458         /* When we entered this method, the number of bufs was set by n_process_buffers(), so
 459          * it may be larger than required.  Consider e.g a mono track with two redirects A and B.
 460          * If A has one input and three outputs, and B three inputs and one output, n_process_buffers()
 461          * will be 3.  In this case, now we've done pre-fader redirects, we can reset the number of bufs.
 462          */
 463         bufs.set_count (pre_fader_streams());
 464
 465         if (!_soloed && (mute_gain != dmg) && !mute_declick_applied && _mute_affects_post_fader) {
 466                 Amp::run_in_place (bufs, nframes, mute_gain, dmg, false);
 467                 mute_gain = dmg;
 468                 mute_declick_applied = true;
 469         }
 470
 471         /* -------------------------------------------------------------------------------------------
 472            PRE-FADER METERING & MONITORING
 473            ----------------------------------------------------------------------------------------- */
 474
 475         if (meter && (_meter_point == MeterPreFader)) {
 476                 _meter->run_in_place(bufs, start_frame, end_frame, nframes, offset);
 477         }
 478
 479
 480         if ((_meter_point == MeterPreFader) && co) {
 481
 482                 solo_audible = dsg > 0;
 483                 mute_audible = dmg > 0 || !_mute_affects_pre_fader;
 484
 485                 if ( // muted by solo of another track
 486
 487                         !solo_audible ||
 488
 489                         // muted by mute of this track
 490
 491                         !mute_audible ||
 492
 493                         // rec-enabled but not s/w monitoring
 494
 495                         ( no_monitor && record_enabled()
 496                                 && (!Config->get_auto_input() || _session.actively_recording()) )
 497
 498                         ) {
 499
 500                         co->silence (nframes, offset);
 501
 502                 } else {
 503
 504                         co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
 505                 }
 506         }
 507
 508         /* -------------------------------------------------------------------------------------------
 509            GAIN STAGE
 510            ----------------------------------------------------------------------------------------- */
 511
 512         /* if not recording or recording and requiring any monitor signal, then apply gain */
 513
 514         if ( // not recording
 515
 516                 !(record_enabled() && _session.actively_recording()) ||
 517
 518                 // OR recording
 519
 520                 // AND software monitoring required
 521
 522                 Config->get_monitoring_model() == SoftwareMonitoring) {
 523
 524                 if (apply_gain_automation) {
 525
 526                         if (_phase_invert) {
 527                                 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
 528                                         Sample* const sp = i->data();
 529
 530                                         for (nframes_t nx = 0; nx < nframes; ++nx) {
 531                                                 sp[nx] *= -gab[nx];
 532                                         }
 533                                 }
 534                         } else {
 535                                 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
 536                                         Sample* const sp = i->data();
 537
 538                                         for (nframes_t nx = 0; nx < nframes; ++nx) {
 539                                                 sp[nx] *= gab[nx];
 540                                         }
 541                                 }
 542                         }
 543
 544                         if (apply_gain_automation && _session.transport_rolling() && nframes > 0) {
 545                                 _effective_gain = gab[nframes-1];
 546                         }
 547
 548                 } else {
 549
 550                         /* manual (scalar) gain */
 551
 552                         if (_gain != dg) {
 553
 554                                 Amp::run_in_place (bufs, nframes, _gain, dg, _phase_invert);
 555                                 _gain = dg;
 556
 557                         } else if (_gain != 0 && (_phase_invert || _gain != 1.0)) {
 558
 559                                 /* no need to interpolate current gain value,
 560                                    but its non-unity, so apply it. if the gain
 561                                    is zero, do nothing because we'll ship silence
 562                                    below.
 563                                 */
 564
 565                                 gain_t this_gain;
 566
 567                                 if (_phase_invert) {
 568                                         this_gain = -_gain;
 569                                 } else {
 570                                         this_gain = _gain;
 571                                 }
 572
 573                                 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
 574                                         Sample* const sp = i->data();
 575                                         apply_gain_to_buffer(sp,nframes,this_gain);
 576                                 }
 577
 578                         } else if (_gain == 0) {
 579                                 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
 580                                         i->clear();
 581                                 }
 582                         }
 583                 }
 584
 585         } else {
 586
 587                 /* actively recording, no monitoring required; leave buffers as-is to save CPU cycles */
 588
 589         }
 590
 591         /* -------------------------------------------------------------------------------------------
 592            POST-FADER REDIRECTS
 593            ----------------------------------------------------------------------------------------- */
 594
 595         /* note that post_fader_work cannot be true unless with_processors was also true,
 596            so don't test both
 597         */
 598
 599         if (post_fader_work) {
 600
 601                 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
 602                 if (rm.locked()) {
 603                         if (mute_gain > 0 || !_mute_affects_post_fader) {
 604                                 for (i = _processors.begin(); i != _processors.end(); ++i) {
 605                                         switch ((*i)->placement()) {
 606                                         case PreFader:
 607                                                 break;
 608                                         case PostFader:
 609                                                 (*i)->run_in_place (bufs, start_frame, end_frame, nframes, offset);
 610                                                 break;
 611                                         }
 612                                 }
 613                         } else {
 614                                 for (i = _processors.begin(); i != _processors.end(); ++i) {
 615                                         switch ((*i)->placement()) {
 616                                         case PreFader:
 617                                                 break;
 618                                         case PostFader:
 619                                                 (*i)->silence (nframes, offset);
 620                                                 break;
 621                                         }
 622                                 }
 623                         }
 624                 }
 625         }
 626
 627         if (!_soloed && (mute_gain != dmg) && !mute_declick_applied && _mute_affects_control_outs) {
 628                 Amp::run_in_place (bufs, nframes, mute_gain, dmg, false);
 629                 mute_gain = dmg;
 630                 mute_declick_applied = true;
 631         }
 632
 633         /* -------------------------------------------------------------------------------------------
 634            CONTROL OUTPUT STAGE
 635            ----------------------------------------------------------------------------------------- */
 636
 637         if ((_meter_point == MeterPostFader) && co) {
 638
 639                 solo_audible = solo_gain > 0;
 640                 mute_audible = dmg > 0 || !_mute_affects_control_outs;
 641
 642                 if ( // silent anyway
 643
 644                         (_gain == 0 && !apply_gain_automation) ||
 645
 646                         // muted by solo of another track
 647
 648                         !solo_audible ||
 649
 650                         // muted by mute of this track
 651
 652                         !mute_audible ||
 653
 654                         // recording but not s/w monitoring
 655
 656                         ( no_monitor && record_enabled()
 657                                 && (!Config->get_auto_input() || _session.actively_recording()) )
 658
 659                         ) {
 660
 661                         co->silence (nframes, offset);
 662
 663                 } else {
 664
 665                         co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
 666                 }
 667         }
 668
 669         /* -------------------------------------------------------------------------------------------
 670            GLOBAL MUTE
 671            ----------------------------------------------------------------------------------------- */
 672
 673         if (!_soloed && (mute_gain != dmg) && !mute_declick_applied && _mute_affects_main_outs) {
 674                 Amp::run_in_place (bufs, nframes, mute_gain, dmg, false);
 675                 mute_gain = dmg;
 676                 mute_declick_applied = true;
 677         }
 678
 679         /* -------------------------------------------------------------------------------------------
 680            MAIN OUTPUT STAGE
 681            ----------------------------------------------------------------------------------------- */
 682
 683         solo_audible = dsg > 0;
 684         mute_audible = dmg > 0 || !_mute_affects_main_outs;
 685
 686         if (n_outputs().get(_default_type) == 0) {
 687
 688             /* relax */
 689
 690         } else if (no_monitor && record_enabled()
 691                         && (!Config->get_auto_input() || _session.actively_recording())) {
 692
 693                 IO::silence (nframes, offset);
 694
 695         } else {
 696
 697                 if ( // silent anyway
 698
 699                         (_gain == 0 && !apply_gain_automation) ||
 700
 701                         // muted by solo of another track, but not using control outs for solo
 702
 703                         (!solo_audible && (Config->get_solo_model() != SoloBus)) ||
 704
 705                         // muted by mute of this track
 706
 707                         !mute_audible
 708
 709                         ) {
 710
 711                         /* don't use Route::silence() here, because that causes
 712                            all outputs (sends, port processors, etc. to be silent).
 713                         */
 714
 715                         if (_meter_point == MeterPostFader) {
 716                                 peak_meter().reset();
 717                         }
 718
 719                         IO::silence (nframes, offset);
 720
 721                 } else {
 722
 723                         deliver_output(bufs, start_frame, end_frame, nframes, offset);
 724
 725                 }
 726
 727         }
 728
 729         /* -------------------------------------------------------------------------------------------
 730            POST-FADER METERING
 731            ----------------------------------------------------------------------------------------- */
 732
 733         if (meter && (_meter_point == MeterPostFader)) {
 734                 if ((_gain == 0 && !apply_gain_automation) || dmg == 0) {
 735                         _meter->reset();
 736                 } else {
 737                         _meter->run_in_place(output_buffers(), start_frame, end_frame, nframes, offset);
 738                 }
 739         }
 740 }
 741
 742 #ifdef NEW_POB
 743 /** Process this route for one (sub) cycle (process thread)
 744  *
 745  * @param bufs Scratch buffers to use for the signal path
 746  * @param start_frame Initial transport frame
 747  * @param end_frame Final transport frame
 748  * @param nframes Number of frames to output (to ports)
 749  * @param offset Output offset (of port buffers, for split cycles)
 750  *
 751  * Note that (end_frame - start_frame) may not be equal to nframes when the
 752  * transport speed isn't 1.0 (eg varispeed).
 753  */
 754 void
 755 Route::process_output_buffers (BufferSet& bufs,
 756                 nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset,
 757                 bool with_processors, int declick, bool meter)
 758 {
 759         // This is definitely very audio-only for now
 760         assert(_default_type == DataType::AUDIO);
 761
 762         ProcessorList::iterator i;
 763         bool post_fader_work = false;
 764         bool mute_declick_applied = false;
 765         gain_t dmg, dsg, dg;
 766         IO *co;
 767         bool mute_audible;
 768         bool solo_audible;
 769         bool no_monitor;
 770         gain_t* gab = _session.gain_automation_buffer();
 771
 772         switch (Config->get_monitoring_model()) {
 773         case HardwareMonitoring:
 774         case ExternalMonitoring:
 775                 no_monitor = true;
 776                 break;
 777         default:
 778                 no_monitor = false;
 779         }
 780
 781         declick = _pending_declick;
 782
 783         {
 784                 Glib::Mutex::Lock cm (_control_outs_lock, Glib::TRY_LOCK);
 785
 786                 if (cm.locked()) {
 787                         co = _control_outs;
 788                 } else {
 789                         co = 0;
 790                 }
 791         }
 792
 793         {
 794                 Glib::Mutex::Lock dm (declick_lock, Glib::TRY_LOCK);
 795
 796                 if (dm.locked()) {
 797                         dmg = desired_mute_gain;
 798                         dsg = desired_solo_gain;
 799                         dg = _desired_gain;
 800                 } else {
 801                         dmg = mute_gain;
 802                         dsg = solo_gain;
 803                         dg = _gain;
 804                 }
 805         }
 806
 807         /* -------------------------------------------------------------------------------------------
 808            GLOBAL DECLICK (for transport changes etc.)
 809            input metering & monitoring (control outs)
 810            denormal control
 811            pre-fader redirects
 812            pre-fader metering & monitoring (control outs)
 813            gain stage
 814            post-fader redirects
 815            global mute
 816            main output
 817            post-fader metering & monitoring (control outs)
 818            ----------------------------------------------------------------------------------------- */
 819
 820         {
 821                 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
 822                 for (i = processors.begin(); i != processors.end(); ++i) {
 823                         (*i)->run_in_place (bufs, start_frame, end_frame, nframes, offset);
 824                 }
 825         }
 826
 827
 828         /* -------------------------------------------------------------------------------------------
 829            INPUT METERING & MONITORING
 830            ----------------------------------------------------------------------------------------- */
 831
 832         if (meter && (_meter_point == MeterInput)) {
 833                 _meter->run_in_place(bufs, start_frame, end_frame, nframes, offset);
 834         }
 835
 836         if (!_soloed && _mute_affects_pre_fader && (mute_gain != dmg)) {
 837                 Amp::run_in_place (bufs, nframes, mute_gain, dmg, false);
 838                 mute_gain = dmg;
 839                 mute_declick_applied = true;
 840         }
 841
 842         /* -------------------------------------------------------------------------------------------
 843            PRE-FADER REDIRECTS
 844            ----------------------------------------------------------------------------------------- */
 845
 846         // This really should already be true...
 847         bufs.set_count(pre_fader_streams());
 848
 849
 850         if ((_meter_point == MeterPreFader) && co) {
 851
 852                 solo_audible = dsg > 0;
 853                 mute_audible = dmg > 0 || !_mute_affects_pre_fader;
 854
 855                 if ( // muted by solo of another track
 856
 857                         !solo_audible ||
 858
 859                         // muted by mute of this track
 860
 861                         !mute_audible ||
 862
 863                         // rec-enabled but not s/w monitoring
 864
 865                         ( no_monitor && record_enabled()
 866                                 && (!Config->get_auto_input() || _session.actively_recording()) )
 867
 868                         ) {
 869
 870                         co->silence (nframes, offset);
 871
 872                 } else {
 873
 874                         co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
 875                 }
 876         }
 877
 878         /* -------------------------------------------------------------------------------------------
 879            GAIN STAGE
 880            ----------------------------------------------------------------------------------------- */
 881
 882         /* if not recording or recording and requiring any monitor signal, then apply gain */
 883
 884         if ( // not recording
 885
 886                 !(record_enabled() && _session.actively_recording()) ||
 887
 888                 // OR recording
 889
 890                 // AND software monitoring required
 891
 892                 Config->get_monitoring_model() == SoftwareMonitoring) {
 893
 894                 if (apply_gain_automation) {
 895
 896                         if (_phase_invert) {
 897                                 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
 898                                         Sample* const sp = i->data();
 899
 900                                         for (nframes_t nx = 0; nx < nframes; ++nx) {
 901                                                 sp[nx] *= -gab[nx];
 902                                         }
 903                                 }
 904                         } else {
 905                                 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
 906                                         Sample* const sp = i->data();
 907
 908                                         for (nframes_t nx = 0; nx < nframes; ++nx) {
 909                                                 sp[nx] *= gab[nx];
 910                                         }
 911                                 }
 912                         }
 913
 914                         if (apply_gain_automation && _session.transport_rolling() && nframes > 0) {
 915                                 _effective_gain = gab[nframes-1];
 916                         }
 917
 918                 } else {
 919
 920                         /* manual (scalar) gain */
 921
 922                         if (_gain != dg) {
 923
 924                                 Amp::run_in_place (bufs, nframes, _gain, dg, _phase_invert);
 925                                 _gain = dg;
 926
 927                         } else if (_gain != 0 && (_phase_invert || _gain != 1.0)) {
 928
 929                                 /* no need to interpolate current gain value,
 930                                    but its non-unity, so apply it. if the gain
 931                                    is zero, do nothing because we'll ship silence
 932                                    below.
 933                                 */
 934
 935                                 gain_t this_gain;
 936
 937                                 if (_phase_invert) {
 938                                         this_gain = -_gain;
 939                                 } else {
 940                                         this_gain = _gain;
 941                                 }
 942
 943                                 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
 944                                         Sample* const sp = i->data();
 945                                         apply_gain_to_buffer(sp,nframes,this_gain);
 946                                 }
 947
 948                         } else if (_gain == 0) {
 949                                 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
 950                                         i->clear();
 951                                 }
 952                         }
 953                 }
 954
 955         } else {
 956
 957                 /* actively recording, no monitoring required; leave buffers as-is to save CPU cycles */
 958
 959         }
 960
 961         /* -------------------------------------------------------------------------------------------
 962            CONTROL OUTPUT STAGE
 963            ----------------------------------------------------------------------------------------- */
 964
 965         if ((_meter_point == MeterPostFader) && co) {
 966
 967                 solo_audible = solo_gain > 0;
 968                 mute_audible = dmg > 0 || !_mute_affects_control_outs;
 969
 970                 if ( // silent anyway
 971
 972                         (_gain == 0 && !apply_gain_automation) ||
 973
 974                         // muted by solo of another track
 975
 976                         !solo_audible ||
 977
 978                         // muted by mute of this track
 979
 980                         !mute_audible ||
 981
 982                         // recording but not s/w monitoring
 983
 984                         (no_monitor && record_enabled() && (!Config->get_auto_input() || _session.actively_recording()))
 985
 986                         ) {
 987
 988                         co->silence (nframes, offset);
 989
 990                 } else {
 991
 992                         co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
 993                 }
 994         }
 995
 996         /* -------------------------------------------------------------------------------------------
 997            MAIN OUTPUT STAGE
 998            ----------------------------------------------------------------------------------------- */
 999
1000         solo_audible = dsg > 0;
1001         mute_audible = dmg > 0 || !_mute_affects_main_outs;
1002
1003         if (n_outputs().get(_default_type) == 0) {
1004
1005             /* relax */
1006
1007         } else if (no_monitor && record_enabled()
1008                         && (!Config->get_auto_input() || _session.actively_recording())) {
1009
1010                 IO::silence (nframes, offset);
1011
1012         } else {
1013
1014                 if ( // silent anyway
1015
1016                         (_gain == 0 && !apply_gain_automation) ||
1017
1018                         // muted by solo of another track, but not using control outs for solo
1019
1020                         (!solo_audible && (Config->get_solo_model() != SoloBus)) ||
1021
1022                         // muted by mute of this track
1023
1024                         !mute_audible
1025
1026                         ) {
1027
1028                         /* don't use Route::silence() here, because that causes
1029                            all outputs (sends, port processors, etc. to be silent).
1030                         */
1031
1032                         if (_meter_point == MeterPostFader) {
1033                                 peak_meter().reset();
1034                         }
1035
1036                         IO::silence (nframes, offset);
1037
1038                 } else {
1039
1040                         deliver_output(bufs, start_frame, end_frame, nframes, offset);
1041
1042                 }
1043
1044         }
1045 }
1046
1047 #endif /* NEW_POB */
1048
1049 ChanCount
1050 Route::n_process_buffers ()
1051 {
1052         return max (n_inputs(), processor_max_outs);
1053 }
1054
1055 void
1056 Route::passthru (nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset, int declick, bool meter_first)
1057 {
1058         BufferSet& bufs = _session.get_scratch_buffers(n_process_buffers());
1059
1060         _silent = false;
1061
1062         collect_input (bufs, nframes, offset);
1063
1064         if (meter_first) {
1065                 _meter->run_in_place(bufs, start_frame, end_frame, nframes, offset);
1066                 meter_first = false;
1067          } else {
1068                 meter_first = true;
1069          }
1070
1071         process_output_buffers (bufs, start_frame, end_frame, nframes, offset, true, declick, meter_first);
1072 }
1073
1074 void
1075 Route::passthru_silence (nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset, int declick, bool meter)
1076 {
1077         process_output_buffers (_session.get_silent_buffers (n_process_buffers()), start_frame, end_frame, nframes, offset, true, declick, meter);
1078 }
1079
1080 void
1081 Route::set_solo (bool yn, void *src)
1082 {
1083         if (_solo_safe) {
1084                 return;
1085         }
1086
1087         if (_mix_group && src != _mix_group && _mix_group->is_active()) {
1088                 _mix_group->apply (&Route::set_solo, yn, _mix_group);
1089                 return;
1090         }
1091
1092         if (_soloed != yn) {
1093                 _soloed = yn;
1094                 solo_changed (src); /* EMIT SIGNAL */
1095                 _solo_control->Changed (); /* EMIT SIGNAL */
1096         }
1097
1098         catch_up_on_solo_mute_override ();
1099 }
1100
1101 void
1102 Route::catch_up_on_solo_mute_override ()
1103 {
1104         if (Config->get_solo_model() != InverseMute) {
1105                 return;
1106         }
1107
1108         {
1109
1110                 Glib::Mutex::Lock lm (declick_lock);
1111
1112                 if (_muted) {
1113                         if (Config->get_solo_mute_override()) {
1114                                 desired_mute_gain = (_soloed?1.0:0.0);
1115                         } else {
1116                                 desired_mute_gain = 0.0;
1117                         }
1118                 } else {
1119                         desired_mute_gain = 1.0;
1120                 }
1121         }
1122 }
1123
1124 void
1125 Route::set_solo_mute (bool yn)
1126 {
1127         Glib::Mutex::Lock lm (declick_lock);
1128
1129         /* Called by Session in response to another Route being soloed.
1130          */
1131
1132         desired_solo_gain = (yn?0.0:1.0);
1133 }
1134
1135 void
1136 Route::set_solo_safe (bool yn, void *src)
1137 {
1138         if (_solo_safe != yn) {
1139                 _solo_safe = yn;
1140                  solo_safe_changed (src); /* EMIT SIGNAL */
1141         }
1142 }
1143
1144 void
1145 Route::set_mute (bool yn, void *src)
1146
1147 {
1148         if (_mix_group && src != _mix_group && _mix_group->is_active()) {
1149                 _mix_group->apply (&Route::set_mute, yn, _mix_group);
1150                 return;
1151         }
1152
1153         if (_muted != yn) {
1154                 _muted = yn;
1155                 mute_changed (src); /* EMIT SIGNAL */
1156
1157                 _mute_control->Changed (); /* EMIT SIGNAL */
1158
1159                 Glib::Mutex::Lock lm (declick_lock);
1160
1161                 if (_soloed && Config->get_solo_mute_override()){
1162                         desired_mute_gain = 1.0f;
1163                 } else {
1164                         desired_mute_gain = (yn?0.0f:1.0f);
1165                 }
1166         }
1167 }
1168
1169 int
1170 Route::add_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err)
1171 {
1172         ChanCount old_pmo = processor_max_outs;
1173
1174         if (!_session.engine().connected()) {
1175                 return 1;
1176         }
1177
1178         {
1179                 Glib::RWLock::WriterLock lm (_processor_lock);
1180
1181                 boost::shared_ptr<PluginInsert> pi;
1182                 boost::shared_ptr<PortInsert> porti;
1183
1184                 //processor->set_default_type(_default_type);
1185
1186                 _processors.push_back (processor);
1187
1188                 // Set up processor list channels.  This will set processor->[input|output]_streams(),
1189                 // configure redirect ports properly, etc.
1190                 if (_reset_processor_counts (err)) {
1191                         _processors.pop_back ();
1192                         _reset_processor_counts (0); // it worked before we tried to add it ...
1193                         return -1;
1194                 }
1195
1196                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(processor)) != 0) {
1197
1198                         if (pi->natural_input_streams() == ChanCount::ZERO) {
1199                                 /* generator plugin */
1200                                 _have_internal_generator = true;
1201                         }
1202
1203                 }
1204
1205                 // Ensure peak vector sizes before the plugin is activated
1206
1207                 ChanCount potential_max_streams;
1208
1209                 potential_max_streams.set (DataType::AUDIO, max (processor->input_streams().n_audio(),
1210                                                                  processor->output_streams().n_audio()));
1211                 potential_max_streams.set (DataType::MIDI, max (processor->input_streams().n_midi(),
1212                                                                 processor->output_streams().n_midi()));
1213
1214                 _meter->configure_io (potential_max_streams, potential_max_streams);
1215
1216                 // XXX: do we want to emit the signal here ? change call order.
1217                 processor->activate ();
1218                 processor->ActiveChanged.connect (bind (mem_fun (_session, &Session::update_latency_compensation), false, false));
1219
1220                 _user_latency = 0;
1221         }
1222
1223         if (processor_max_outs != old_pmo || old_pmo == ChanCount::ZERO) {
1224                 reset_panner ();
1225         }
1226
1227         processors_changed (); /* EMIT SIGNAL */
1228
1229         return 0;
1230 }
1231
1232 int
1233 Route::add_processors (const ProcessorList& others, ProcessorStreams* err)
1234 {
1235         /* NOTE: this is intended to be used ONLY when copying
1236            processors from another Route. Hence the subtle
1237            differences between this and ::add_processor()
1238         */
1239
1240         ChanCount old_pmo = processor_max_outs;
1241
1242         if (!_session.engine().connected()) {
1243                 return 1;
1244         }
1245
1246         {
1247                 Glib::RWLock::WriterLock lm (_processor_lock);
1248
1249                 ProcessorList::iterator existing_end = _processors.end();
1250                 --existing_end;
1251
1252                 ChanCount potential_max_streams;
1253
1254                 for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
1255
1256                         boost::shared_ptr<PluginInsert> pi;
1257
1258                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1259                                 pi->set_count (1);
1260
1261                                 ChanCount m = max(pi->input_streams(), pi->output_streams());
1262                                 if (m > potential_max_streams)
1263                                         potential_max_streams = m;
1264                         }
1265
1266                         // Ensure peak vector sizes before the plugin is activated
1267                         _meter->configure_io (potential_max_streams, potential_max_streams);
1268
1269                         _processors.push_back (*i);
1270
1271                         if (_reset_processor_counts (err)) {
1272                                 ++existing_end;
1273                                 _processors.erase (existing_end, _processors.end());
1274                                 _reset_processor_counts (0); // it worked before we tried to add it ...
1275                                 return -1;
1276                         }
1277
1278                         (*i)->ActiveChanged.connect (bind (mem_fun (_session, &Session::update_latency_compensation), false, false));
1279                 }
1280
1281                 _user_latency = 0;
1282         }
1283
1284         if (processor_max_outs != old_pmo || old_pmo == ChanCount::ZERO) {
1285                 reset_panner ();
1286         }
1287
1288         processors_changed (); /* EMIT SIGNAL */
1289         return 0;
1290 }
1291
1292 /** Turn off all processors with a given placement
1293  * @param p Placement of processors to disable
1294  */
1295 void
1296 Route::disable_processors (Placement p)
1297 {
1298         Glib::RWLock::ReaderLock lm (_processor_lock);
1299
1300         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1301                 if ((*i)->placement() == p) {
1302                         (*i)->deactivate ();
1303                 }
1304         }
1305
1306         _session.set_dirty ();
1307 }
1308
1309 /** Turn off all redirects
1310  */
1311 void
1312 Route::disable_processors ()
1313 {
1314         Glib::RWLock::ReaderLock lm (_processor_lock);
1315
1316         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1317                 (*i)->deactivate ();
1318         }
1319
1320         _session.set_dirty ();
1321 }
1322
1323 /** Turn off all redirects with a given placement
1324  * @param p Placement of redirects to disable
1325  */
1326 void
1327 Route::disable_plugins (Placement p)
1328 {
1329         Glib::RWLock::ReaderLock lm (_processor_lock);
1330
1331         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1332                 if (boost::dynamic_pointer_cast<PluginInsert> (*i) && (*i)->placement() == p) {
1333                         (*i)->deactivate ();
1334                 }
1335         }
1336
1337         _session.set_dirty ();
1338 }
1339
1340 /** Turn off all plugins
1341  */
1342 void
1343 Route::disable_plugins ()
1344 {
1345         Glib::RWLock::ReaderLock lm (_processor_lock);
1346
1347         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1348                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1349                         (*i)->deactivate ();
1350                 }
1351         }
1352
1353         _session.set_dirty ();
1354 }
1355
1356
1357 void
1358 Route::ab_plugins (bool forward)
1359 {
1360         Glib::RWLock::ReaderLock lm (_processor_lock);
1361
1362         if (forward) {
1363
1364                 /* forward = turn off all active redirects, and mark them so that the next time
1365                    we go the other way, we will revert them
1366                 */
1367
1368                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1369                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1370                                 continue;
1371                         }
1372
1373                         if ((*i)->active()) {
1374                                 (*i)->deactivate ();
1375                                 (*i)->set_next_ab_is_active (true);
1376                         } else {
1377                                 (*i)->set_next_ab_is_active (false);
1378                         }
1379                 }
1380
1381         } else {
1382
1383                 /* backward = if the redirect was marked to go active on the next ab, do so */
1384
1385                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1386
1387                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1388                                 continue;
1389                         }
1390
1391                         if ((*i)->get_next_ab_is_active()) {
1392                                 (*i)->activate ();
1393                         } else {
1394                                 (*i)->deactivate ();
1395                         }
1396                 }
1397         }
1398
1399         _session.set_dirty ();
1400 }
1401
1402
1403 /* Figure out the streams that will feed into PreFader */
1404 ChanCount
1405 Route::pre_fader_streams() const
1406 {
1407         boost::shared_ptr<Processor> processor;
1408
1409         /* Find the last pre-fader redirect that isn't a send; sends don't affect the number
1410          * of streams. */
1411         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
1412                 if ((*i)->placement() == PreFader && boost::dynamic_pointer_cast<Send> (*i) == 0) {
1413                         processor = *i;
1414                 }
1415         }
1416
1417         if (processor) {
1418                 return processor->output_streams();
1419         } else {
1420                 return n_inputs ();
1421         }
1422 }
1423
1424
1425 /** Remove processors with a given placement.
1426  * @param p Placement of processors to remove.
1427  */
1428 void
1429 Route::clear_processors (Placement p)
1430 {
1431         const ChanCount old_pmo = processor_max_outs;
1432
1433         if (!_session.engine().connected()) {
1434                 return;
1435         }
1436
1437         {
1438                 Glib::RWLock::WriterLock lm (_processor_lock);
1439                 ProcessorList new_list;
1440
1441                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1442                         if ((*i)->placement() == p) {
1443                                 /* it's the placement we want to get rid of */
1444                                 (*i)->drop_references ();
1445                         } else {
1446                                 /* it's a different placement, so keep it */
1447                                 new_list.push_back (*i);
1448                         }
1449                 }
1450
1451                 _processors = new_list;
1452         }
1453
1454         /* FIXME: can't see how this test can ever fire */
1455         if (processor_max_outs != old_pmo) {
1456                 reset_panner ();
1457         }
1458
1459         processor_max_outs.reset();
1460         _have_internal_generator = false;
1461         processors_changed (); /* EMIT SIGNAL */
1462 }
1463
1464 int
1465 Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err)
1466 {
1467         ChanCount old_pmo = processor_max_outs;
1468
1469         if (!_session.engine().connected()) {
1470                 return 1;
1471         }
1472
1473         processor_max_outs.reset();
1474
1475         {
1476                 Glib::RWLock::WriterLock lm (_processor_lock);
1477                 ProcessorList::iterator i;
1478                 bool removed = false;
1479
1480                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1481                         if (*i == processor) {
1482
1483                                 ProcessorList::iterator tmp;
1484
1485                                 /* move along, see failure case for reset_processor_counts()
1486                                    where we may need to reprocessor the processor.
1487                                 */
1488
1489                                 tmp = i;
1490                                 ++tmp;
1491
1492                                 /* stop redirects that send signals to JACK ports
1493                                    from causing noise as a result of no longer being
1494                                    run.
1495                                 */
1496
1497                                 boost::shared_ptr<IOProcessor> redirect;
1498
1499                                 if ((redirect = boost::dynamic_pointer_cast<IOProcessor> (*i)) != 0) {
1500                                         redirect->io()->disconnect_inputs (this);
1501                                         redirect->io()->disconnect_outputs (this);
1502                                 }
1503
1504                                 _processors.erase (i);
1505
1506                                 i = tmp;
1507                                 removed = true;
1508                                 break;
1509                         }
1510
1511                         _user_latency = 0;
1512                 }
1513
1514                 if (!removed) {
1515                         /* what? */
1516                         return 1;
1517                 }
1518
1519                 if (_reset_processor_counts (err)) {
1520                         /* get back to where we where */
1521                         _processors.insert (i, processor);
1522                         /* we know this will work, because it worked before :) */
1523                         _reset_processor_counts (0);
1524                         return -1;
1525                 }
1526
1527                 _have_internal_generator = false;
1528
1529                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1530                         boost::shared_ptr<PluginInsert> pi;
1531
1532                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1533                                 if (pi->is_generator()) {
1534                                         _have_internal_generator = true;
1535                                         break;
1536                                 }
1537                         }
1538                 }
1539         }
1540
1541         if (old_pmo != processor_max_outs) {
1542                 reset_panner ();
1543         }
1544
1545         processor->drop_references ();
1546
1547         processors_changed (); /* EMIT SIGNAL */
1548         return 0;
1549 }
1550
1551 int
1552 Route::reset_processor_counts (ProcessorStreams* err)
1553 {
1554         Glib::RWLock::WriterLock lm (_processor_lock);
1555         return _reset_processor_counts (err);
1556 }
1557
1558
1559 int
1560 Route::_reset_processor_counts (ProcessorStreams* err)
1561 {
1562         ProcessorList::iterator r;
1563         uint32_t insert_cnt = 0;
1564         uint32_t send_cnt = 0;
1565         map<Placement,list<ProcessorCount> > proc_map;
1566         ProcessorList::iterator prev;
1567         ChanCount initial_streams = n_inputs ();
1568         ChanCount previous_initial_streams = n_inputs ();
1569         int ret = -1;
1570         uint32_t max_audio = 0;
1571         uint32_t max_midi = 0;
1572
1573         processor_max_outs.reset ();
1574
1575         /* Step 1: build a map that links each insert to an in/out channel count
1576
1577            Divide inserts up by placement so we get the signal flow
1578            properly modelled. we need to do this because the _processors
1579            list is not sorted by placement, and because other reasons may
1580            exist now or in the future for this separate treatment.
1581         */
1582
1583         /* ... but it should/will be... */
1584
1585         for (r = _processors.begin(); r != _processors.end(); ++r) {
1586
1587                 boost::shared_ptr<PluginInsert> plugin_insert;
1588                 boost::shared_ptr<PortInsert> port_insert;
1589
1590                 if ((plugin_insert = boost::dynamic_pointer_cast<PluginInsert>(*r)) != 0) {
1591
1592                         ++insert_cnt;
1593                         proc_map[(*r)->placement()].push_back (ProcessorCount (*r));
1594
1595                         /* reset plugin counts back to one for now so
1596                            that we have a predictable, controlled
1597                            state to try to configure.
1598                         */
1599
1600                         plugin_insert->set_count (1);
1601
1602                 } else if ((port_insert = boost::dynamic_pointer_cast<PortInsert>(*r)) != 0) {
1603
1604                         ++insert_cnt;
1605                         proc_map[(*r)->placement()].push_back (ProcessorCount (*r));
1606
1607                 } else if (boost::dynamic_pointer_cast<Send> (*r) != 0) {
1608                         ++send_cnt;
1609                 }
1610         }
1611
1612         if (insert_cnt == 0) {
1613                 if (send_cnt) {
1614                         goto recompute;
1615                 } else {
1616                         ret = 0;
1617                         goto streamcount;
1618                 }
1619         }
1620
1621         /* Now process each placement in order, checking to see if we
1622            can really do what has been requested.
1623         */
1624
1625         /* A: PreFader */
1626
1627         if (check_some_processor_counts (proc_map[PreFader], n_inputs (), err)) {
1628                 goto streamcount;
1629         }
1630
1631         if (!proc_map[PreFader].empty()) {
1632                 previous_initial_streams = n_inputs ();
1633                 for (list<ProcessorCount>::iterator i = proc_map[PreFader].begin(); i != proc_map[PreFader].end(); i++) {
1634                         if (i->processor->can_support_io_configuration (previous_initial_streams, initial_streams) == false) {
1635                                 goto streamcount;
1636                         }
1637                         previous_initial_streams = initial_streams;
1638                 }
1639         }
1640
1641         /* B: PostFader */
1642
1643         if (check_some_processor_counts (proc_map[PostFader], initial_streams, err)) {
1644                 goto streamcount;
1645         }
1646
1647         if (!proc_map[PostFader].empty()) {
1648                 for (list<ProcessorCount>::iterator i = proc_map[PostFader].begin(); i != proc_map[PostFader].end(); i++) {
1649                         if (i->processor->can_support_io_configuration (previous_initial_streams, initial_streams) == false) {
1650                                 goto streamcount;
1651                         }
1652                         previous_initial_streams = initial_streams;
1653                 }
1654         }
1655
1656         /* OK, everything can be set up correctly, so lets do it */
1657
1658         apply_some_processor_counts (proc_map[PreFader]);
1659         apply_some_processor_counts (proc_map[PostFader]);
1660
1661         /* recompute max outs of any processor */
1662
1663         ret = 0;
1664
1665   recompute:
1666
1667         processor_max_outs.reset ();
1668         prev = _processors.end();
1669
1670         for (r = _processors.begin(); r != _processors.end(); prev = r, ++r) {
1671                 boost::shared_ptr<Send> s;
1672
1673                 if ((s = boost::dynamic_pointer_cast<Send> (*r)) != 0) {
1674
1675                         /* don't pay any attention to send output configuration, since it doesn't
1676                            affect the route.
1677                          */
1678
1679                         if (r == _processors.begin()) {
1680                                 s->expect_inputs (n_inputs());
1681                         } else {
1682                                 s->expect_inputs ((*prev)->output_streams());
1683                         }
1684
1685                 } else {
1686
1687                         max_audio = max ((*r)->output_streams ().n_audio(), max_audio);
1688                         max_midi = max ((*r)->output_streams ().n_midi(), max_midi);
1689                 }
1690         }
1691
1692         processor_max_outs.set (DataType::AUDIO, max_audio);
1693         processor_max_outs.set (DataType::MIDI, max_midi);
1694
1695         /* we're done */
1696         return 0;
1697
1698   streamcount:
1699         for (r = _processors.begin(); r != _processors.end(); ++r) {
1700                 max_audio = max ((*r)->output_streams ().n_audio(), max_audio);
1701                 max_midi = max ((*r)->output_streams ().n_midi(), max_midi);
1702         }
1703
1704         processor_max_outs.set (DataType::AUDIO, max_audio);
1705         processor_max_outs.set (DataType::MIDI, max_midi);
1706
1707         return ret;
1708 }
1709
1710 int32_t
1711 Route::apply_some_processor_counts (list<ProcessorCount>& iclist)
1712 {
1713         list<ProcessorCount>::iterator i;
1714
1715         for (i = iclist.begin(); i != iclist.end(); ++i) {
1716
1717                 ProcessorCount& pc (*i);
1718
1719                 if (pc.processor->configure_io (pc.in, pc.out)) {
1720                         return -1;
1721                 }
1722
1723                 /* make sure that however many we have, they are all active */
1724
1725                 pc.processor->activate ();
1726         }
1727
1728         return 0;
1729 }
1730
1731 /** Returns whether \a iclist can be configured and run starting with
1732  * \a required_inputs at the first processor's inputs.
1733  * If false is returned, \a iclist can not be run with \a required_inputs, and \a err is set.
1734  * Otherwise, \a err is set to the output of the list.
1735  */
1736 bool
1737 Route::check_some_processor_counts (list<ProcessorCount>& iclist, ChanCount required_inputs, ProcessorStreams* err)
1738 {
1739         list<ProcessorCount>::iterator i;
1740         size_t index = 0;
1741
1742         if (err) {
1743                 err->index = 0;
1744                 err->count = required_inputs;
1745         }
1746
1747         for (i = iclist.begin(); i != iclist.end(); ++i, ++index) {
1748
1749                 if (!(*i).processor->can_support_io_configuration (required_inputs, (*i).out)) {
1750                         if (err) {
1751                                 err->index = index;
1752                                 err->count = required_inputs;
1753                         }
1754                         return true;
1755                 }
1756
1757                 (*i).in = required_inputs;
1758                 required_inputs = (*i).out;
1759         }
1760
1761         return false;
1762 }
1763
1764 void
1765 Route::all_processors_flip ()
1766 {
1767         Glib::RWLock::ReaderLock lm (_processor_lock);
1768
1769         if (_processors.empty()) {
1770                 return;
1771         }
1772
1773         bool first_is_on = _processors.front()->active();
1774
1775         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1776                 if (first_is_on) {
1777                         (*i)->deactivate ();
1778                 } else {
1779                         (*i)->activate ();
1780                 }
1781         }
1782
1783         _session.set_dirty ();
1784 }
1785
1786 /** Set all processors with a given placement to a given active state.
1787  * @param p Placement of processors to change.
1788  * @param state New active state for those processors.
1789  */
1790 void
1791 Route::all_processors_active (Placement p, bool state)
1792 {
1793         Glib::RWLock::ReaderLock lm (_processor_lock);
1794
1795         if (_processors.empty()) {
1796                 return;
1797         }
1798
1799         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1800                 if ((*i)->placement() == p) {
1801                         if (state) {
1802                                 (*i)->activate ();
1803                         } else {
1804                                 (*i)->deactivate ();
1805                         }
1806                 }
1807         }
1808
1809         _session.set_dirty ();
1810 }
1811
1812 struct ProcessorSorter {
1813     bool operator() (boost::shared_ptr<const Processor> a, boost::shared_ptr<const Processor> b) {
1814             return a->sort_key() < b->sort_key();
1815     }
1816 };
1817
1818 int
1819 Route::sort_processors (ProcessorStreams* err)
1820 {
1821         {
1822                 ProcessorSorter comparator;
1823                 Glib::RWLock::WriterLock lm (_processor_lock);
1824                 ChanCount old_pmo = processor_max_outs;
1825
1826                 /* the sweet power of C++ ... */
1827
1828                 ProcessorList as_it_was_before = _processors;
1829
1830                 _processors.sort (comparator);
1831
1832                 if (_reset_processor_counts (err)) {
1833                         _processors = as_it_was_before;
1834                         processor_max_outs = old_pmo;
1835                         return -1;
1836                 }
1837         }
1838
1839         reset_panner ();
1840         processors_changed (); /* EMIT SIGNAL */
1841
1842         return 0;
1843 }
1844
1845 XMLNode&
1846 Route::get_state()
1847 {
1848         return state(true);
1849 }
1850
1851 XMLNode&
1852 Route::get_template()
1853 {
1854         return state(false);
1855 }
1856
1857 XMLNode&
1858 Route::state(bool full_state)
1859 {
1860         XMLNode *node = new XMLNode("Route");
1861         ProcessorList::iterator i;
1862         char buf[32];
1863
1864         if (_flags) {
1865                 node->add_property("flags", enum_2_string (_flags));
1866         }
1867
1868         node->add_property("default-type", _default_type.to_string());
1869
1870         node->add_property("active", _active?"yes":"no");
1871         node->add_property("muted", _muted?"yes":"no");
1872         node->add_property("soloed", _soloed?"yes":"no");
1873         node->add_property("phase-invert", _phase_invert?"yes":"no");
1874         node->add_property("denormal-protection", _denormal_protection?"yes":"no");
1875         node->add_property("mute-affects-pre-fader", _mute_affects_pre_fader?"yes":"no");
1876         node->add_property("mute-affects-post-fader", _mute_affects_post_fader?"yes":"no");
1877         node->add_property("mute-affects-control-outs", _mute_affects_control_outs?"yes":"no");
1878         node->add_property("mute-affects-main-outs", _mute_affects_main_outs?"yes":"no");
1879         node->add_property("meter-point", enum_2_string (_meter_point));
1880
1881         if (_edit_group) {
1882                 node->add_property("edit-group", _edit_group->name());
1883         }
1884         if (_mix_group) {
1885                 node->add_property("mix-group", _mix_group->name());
1886         }
1887
1888         string order_string;
1889         OrderKeys::iterator x = order_keys.begin();
1890
1891         while (x != order_keys.end()) {
1892                 order_string += string ((*x).first);
1893                 order_string += '=';
1894                 snprintf (buf, sizeof(buf), "%ld", (*x).second);
1895                 order_string += buf;
1896
1897                 ++x;
1898
1899                 if (x == order_keys.end()) {
1900                         break;
1901                 }
1902
1903                 order_string += ':';
1904         }
1905         node->add_property ("order-keys", order_string);
1906
1907         node->add_child_nocopy (IO::state (full_state));
1908         node->add_child_nocopy (_solo_control->get_state ());
1909         node->add_child_nocopy (_mute_control->get_state ());
1910
1911         XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
1912         snprintf (buf, sizeof (buf), "%d", _remote_control_id);
1913         remote_control_node->add_property (X_("id"), buf);
1914         node->add_child_nocopy (*remote_control_node);
1915
1916         if (_control_outs) {
1917                 XMLNode* cnode = new XMLNode (X_("ControlOuts"));
1918                 cnode->add_child_nocopy (_control_outs->state (full_state));
1919                 node->add_child_nocopy (*cnode);
1920         }
1921
1922         if (_comment.length()) {
1923                 XMLNode *cmt = node->add_child ("Comment");
1924                 cmt->add_content (_comment);
1925         }
1926
1927         for (i = _processors.begin(); i != _processors.end(); ++i) {
1928                 node->add_child_nocopy((*i)->state (full_state));
1929         }
1930
1931         if (_extra_xml){
1932                 node->add_child_copy (*_extra_xml);
1933         }
1934
1935         return *node;
1936 }
1937
1938 XMLNode&
1939 Route::get_processor_state ()
1940 {
1941         XMLNode* root = new XMLNode (X_("redirects"));
1942         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1943                 root->add_child_nocopy ((*i)->state (true));
1944         }
1945
1946         return *root;
1947 }
1948
1949 int
1950 Route::set_processor_state (const XMLNode& root)
1951 {
1952         if (root.name() != X_("redirects")) {
1953                 return -1;
1954         }
1955
1956         XMLNodeList nlist;
1957         XMLNodeList nnlist;
1958         XMLNodeConstIterator iter;
1959         XMLNodeConstIterator niter;
1960         Glib::RWLock::ReaderLock lm (_processor_lock);
1961
1962         nlist = root.children();
1963
1964         for (iter = nlist.begin(); iter != nlist.end(); ++iter){
1965
1966                 /* iter now points to a IOProcessor state node */
1967
1968                 nnlist = (*iter)->children ();
1969
1970                 for (niter = nnlist.begin(); niter != nnlist.end(); ++niter) {
1971
1972                         /* find the IO child node, since it contains the ID we need */
1973
1974                         /* XXX OOP encapsulation violation, ugh */
1975
1976                         if ((*niter)->name() == IO::state_node_name) {
1977
1978                                 XMLProperty* prop = (*niter)->property (X_("id"));
1979
1980                                 if (!prop) {
1981                                         warning << _("IOProcessor node has no ID, ignored") << endmsg;
1982                                         break;
1983                                 }
1984
1985                                 ID id = prop->value ();
1986
1987                                 /* now look for a processor with that ID */
1988
1989                                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1990                                         if ((*i)->id() == id) {
1991                                                 (*i)->set_state (**iter);
1992                                                 break;
1993                                         }
1994                                 }
1995
1996                                 break;
1997
1998                         }
1999                 }
2000
2001         }
2002
2003         return 0;
2004 }
2005
2006 void
2007 Route::set_deferred_state ()
2008 {
2009         XMLNodeList nlist;
2010         XMLNodeConstIterator niter;
2011
2012         if (!deferred_state) {
2013                 return;
2014         }
2015
2016         nlist = deferred_state->children();
2017
2018         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2019                 add_processor_from_xml (**niter);
2020         }
2021
2022         delete deferred_state;
2023         deferred_state = 0;
2024 }
2025
2026 void
2027 Route::add_processor_from_xml (const XMLNode& node)
2028 {
2029         const XMLProperty *prop;
2030
2031         // legacy sessions use a different node name for sends
2032         if (node.name() == "Send") {
2033
2034                 try {
2035                         boost::shared_ptr<Send> send (new Send (_session, node));
2036                         add_processor (send);
2037                 }
2038
2039                 catch (failed_constructor &err) {
2040                         error << _("Send construction failed") << endmsg;
2041                         return;
2042                 }
2043
2044         // use "Processor" in XML?
2045         } else if (node.name() == "Processor") {
2046
2047                 try {
2048                         if ((prop = node.property ("type")) != 0) {
2049
2050                                 boost::shared_ptr<Processor> processor;
2051                                 bool have_insert = false;
2052
2053                                 if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2054                                     prop->value() == "lv2" ||
2055                                     prop->value() == "vst" ||
2056                                     prop->value() == "audiounit") {
2057
2058                                         processor.reset (new PluginInsert(_session, node));
2059                                         have_insert = true;
2060
2061                                 } else if (prop->value() == "port") {
2062
2063                                         processor.reset (new PortInsert (_session, node));
2064
2065                                 } else if (prop->value() == "send") {
2066
2067                                         processor.reset (new Send (_session, node));
2068                                         have_insert = true;
2069
2070                                 } else {
2071
2072                                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2073                                 }
2074
2075                                 add_processor (processor);
2076
2077                         } else {
2078                                 error << _("Processor XML node has no type property") << endmsg;
2079                         }
2080                 }
2081
2082                 catch (failed_constructor &err) {
2083                         warning << _("processor could not be created. Ignored.") << endmsg;
2084                         return;
2085                 }
2086         }
2087 }
2088
2089 int
2090 Route::set_state (const XMLNode& node)
2091 {
2092         return _set_state (node, true);
2093 }
2094
2095 int
2096 Route::_set_state (const XMLNode& node, bool call_base)
2097 {
2098         XMLNodeList nlist;
2099         XMLNodeConstIterator niter;
2100         XMLNode *child;
2101         XMLPropertyList plist;
2102         const XMLProperty *prop;
2103
2104         if (node.name() != "Route"){
2105                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2106                 return -1;
2107         }
2108
2109         if ((prop = node.property (X_("flags"))) != 0) {
2110                 _flags = Flag (string_2_enum (prop->value(), _flags));
2111         } else {
2112                 _flags = Flag (0);
2113         }
2114
2115         if ((prop = node.property (X_("default-type"))) != 0) {
2116                 _default_type = DataType(prop->value());
2117                 assert(_default_type != DataType::NIL);
2118         }
2119
2120         if ((prop = node.property (X_("phase-invert"))) != 0) {
2121                 set_phase_invert (prop->value()=="yes"?true:false, this);
2122         }
2123
2124         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2125                 set_denormal_protection (prop->value()=="yes"?true:false, this);
2126         }
2127
2128         _active = true;
2129         if ((prop = node.property (X_("active"))) != 0) {
2130                 set_active (prop->value() == "yes");
2131         }
2132
2133         if ((prop = node.property (X_("muted"))) != 0) {
2134                 bool yn = prop->value()=="yes"?true:false;
2135
2136                 /* force reset of mute status */
2137
2138                 _muted = !yn;
2139                 set_mute(yn, this);
2140                 mute_gain = desired_mute_gain;
2141         }
2142
2143         if ((prop = node.property (X_("soloed"))) != 0) {
2144                 bool yn = prop->value()=="yes"?true:false;
2145
2146                 /* force reset of solo status */
2147
2148                 _soloed = !yn;
2149                 set_solo (yn, this);
2150                 solo_gain = desired_solo_gain;
2151         }
2152
2153         if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
2154                 _mute_affects_pre_fader = (prop->value()=="yes")?true:false;
2155         }
2156
2157         if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
2158                 _mute_affects_post_fader = (prop->value()=="yes")?true:false;
2159         }
2160
2161         if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
2162                 _mute_affects_control_outs = (prop->value()=="yes")?true:false;
2163         }
2164
2165         if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
2166                 _mute_affects_main_outs = (prop->value()=="yes")?true:false;
2167         }
2168
2169         if ((prop = node.property (X_("meter-point"))) != 0) {
2170                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2171         }
2172
2173         if ((prop = node.property (X_("edit-group"))) != 0) {
2174                 RouteGroup* edit_group = _session.edit_group_by_name(prop->value());
2175                 if(edit_group == 0) {
2176                         error << string_compose(_("Route %1: unknown edit group \"%2 in saved state (ignored)"), _name, prop->value()) << endmsg;
2177                 } else {
2178                         set_edit_group(edit_group, this);
2179                 }
2180         }
2181
2182         if ((prop = node.property (X_("order-keys"))) != 0) {
2183
2184                 long n;
2185
2186                 string::size_type colon, equal;
2187                 string remaining = prop->value();
2188
2189                 while (remaining.length()) {
2190
2191                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2192                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2193                                       << endmsg;
2194                         } else {
2195                                 if (sscanf (remaining.substr (equal+1).c_str(), "%ld", &n) != 1) {
2196                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2197                                               << endmsg;
2198                                 } else {
2199                                         set_order_key (remaining.substr (0, equal).c_str(), n);
2200                                 }
2201                         }
2202
2203                         colon = remaining.find_first_of (':');
2204
2205                         if (colon != string::npos) {
2206                                 remaining = remaining.substr (colon+1);
2207                         } else {
2208                                 break;
2209                         }
2210                 }
2211         }
2212
2213         nlist = node.children();
2214
2215         delete deferred_state;
2216         deferred_state = new XMLNode(X_("deferred state"));
2217
2218         /* set parent class properties before anything else */
2219
2220         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2221
2222                 child = *niter;
2223
2224                 if (child->name() == IO::state_node_name && call_base) {
2225
2226                         IO::set_state (*child);
2227                         break;
2228                 }
2229         }
2230
2231         XMLNodeList processor_nodes;
2232
2233         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2234
2235                 child = *niter;
2236
2237                 if (child->name() == X_("Send") || child->name() == X_("Processor")) {
2238                         processor_nodes.push_back(child);
2239                 }
2240
2241         }
2242
2243         _set_processor_states(processor_nodes);
2244
2245
2246         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2247                 child = *niter;
2248                 // All processors have been applied already
2249
2250                 if (child->name() == X_("Automation")) {
2251
2252                         if ((prop = child->property (X_("path"))) != 0)  {
2253                                 load_automation (prop->value());
2254                         }
2255
2256                 } else if (child->name() == X_("ControlOuts")) {
2257
2258                         string coutname = _name;
2259                         coutname += _("[control]");
2260
2261                         delete _control_outs;
2262                         _control_outs = new IO (_session, coutname);
2263                         _control_outs->set_state (**(child->children().begin()));
2264
2265                 } else if (child->name() == X_("Comment")) {
2266
2267                         /* XXX this is a terrible API design in libxml++ */
2268
2269                         XMLNode *cmt = *(child->children().begin());
2270                         _comment = cmt->content();
2271
2272                 } else if (child->name() == X_("Extra")) {
2273
2274                         _extra_xml = new XMLNode (*child);
2275
2276                 } else if (child->name() == X_("Controllable") && (prop = child->property("name")) != 0) {
2277
2278                         if (prop->value() == "solo") {
2279                                 _solo_control->set_state (*child);
2280                                 _session.add_controllable (_solo_control);
2281                         } else if (prop->value() == "mute") {
2282                                 _mute_control->set_state (*child);
2283                                 _session.add_controllable (_mute_control);
2284                         }
2285                 }
2286                 else if (child->name() == X_("RemoteControl")) {
2287                         if ((prop = child->property (X_("id"))) != 0) {
2288                                 int32_t x;
2289                                 sscanf (prop->value().c_str(), "%d", &x);
2290                                 set_remote_control_id (x);
2291                         }
2292                 }
2293         }
2294
2295         if ((prop = node.property (X_("mix-group"))) != 0) {
2296                 RouteGroup* mix_group = _session.mix_group_by_name(prop->value());
2297                 if (mix_group == 0) {
2298                         error << string_compose(_("Route %1: unknown mix group \"%2 in saved state (ignored)"), _name, prop->value()) << endmsg;
2299                 }  else {
2300                         set_mix_group(mix_group, this);
2301                 }
2302         }
2303
2304         return 0;
2305 }
2306
2307 void
2308 Route::_set_processor_states(const XMLNodeList &nlist)
2309 {
2310         XMLNodeConstIterator niter;
2311         char buf[64];
2312
2313         ProcessorList::iterator i, o;
2314
2315         // Iterate through existing processors, remove those which are not in the state list
2316         for (i = _processors.begin(); i != _processors.end(); ) {
2317                 ProcessorList::iterator tmp = i;
2318                 ++tmp;
2319
2320                 bool processorInStateList = false;
2321
2322                 (*i)->id().print (buf, sizeof (buf));
2323
2324
2325                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2326
2327                         // legacy sessions (IOProcessor as a child of Processor, both is-a IO)
2328                         if (strncmp(buf,(*niter)->child(X_("IOProcessor"))->child(X_("IO"))->property(X_("id"))->value().c_str(), sizeof(buf)) == 0) {
2329                                 processorInStateList = true;
2330                                 break;
2331                         } else if (strncmp(buf,(*niter)->property(X_("id"))->value().c_str(), sizeof(buf)) == 0) {
2332                                 processorInStateList = true;
2333                                 break;
2334                         }
2335                 }
2336
2337                 if (!processorInStateList) {
2338                         remove_processor (*i);
2339                 }
2340
2341
2342                 i = tmp;
2343         }
2344
2345
2346         // Iterate through state list and make sure all processors are on the track and in the correct order,
2347         // set the state of existing processors according to the new state on the same go
2348         i = _processors.begin();
2349         for (niter = nlist.begin(); niter != nlist.end(); ++niter, ++i) {
2350
2351                 // Check whether the next processor in the list
2352                 o = i;
2353
2354                 while (o != _processors.end()) {
2355                         (*o)->id().print (buf, sizeof (buf));
2356                         if ( strncmp(buf, (*niter)->child(X_("IOProcessor"))->child(X_("IO"))->property(X_("id"))->value().c_str(), sizeof(buf)) == 0)
2357                                 break;
2358                         else if (strncmp(buf,(*niter)->property(X_("id"))->value().c_str(), sizeof(buf)) == 0)
2359                                 break;
2360
2361                         ++o;
2362                 }
2363
2364                 if (o == _processors.end()) {
2365                         // If the processor (*niter) is not on the route, we need to create it
2366                         // and move it to the correct location
2367
2368                         ProcessorList::iterator prev_last = _processors.end();
2369                         --prev_last; // We need this to check whether adding succeeded
2370
2371                         add_processor_from_xml (**niter);
2372
2373                         ProcessorList::iterator last = _processors.end();
2374                         --last;
2375
2376                         if (prev_last == last) {
2377                                 cerr << "Could not fully restore state as some processors were not possible to create" << endl;
2378                                 continue;
2379
2380                         }
2381
2382                         boost::shared_ptr<Processor> tmp = (*last);
2383                         // remove the processor from the wrong location
2384                         _processors.erase(last);
2385                         // processor the new processor at the current location
2386                         _processors.insert(i, tmp);
2387
2388                         --i; // move pointer to the newly processored processor
2389                         continue;
2390                 }
2391
2392                 // We found the processor (*niter) on the route, first we must make sure the processor
2393                 // is at the location provided in the XML state
2394                 if (i != o) {
2395                         boost::shared_ptr<Processor> tmp = (*o);
2396                         // remove the old copy
2397                         _processors.erase(o);
2398                         // processor the processor at the correct location
2399                         _processors.insert(i, tmp);
2400
2401                         --i; // move pointer so it points to the right processor
2402                 }
2403
2404                 (*i)->set_state( (**niter) );
2405         }
2406
2407         processors_changed ();
2408 }
2409
2410 void
2411 Route::curve_reallocate ()
2412 {
2413 //      _gain_automation_curve.finish_resize ();
2414 //      _pan_automation_curve.finish_resize ();
2415 }
2416
2417 void
2418 Route::silence (nframes_t nframes, nframes_t offset)
2419 {
2420         if (!_silent) {
2421
2422                 IO::silence (nframes, offset);
2423
2424                 if (_control_outs) {
2425                         _control_outs->silence (nframes, offset);
2426                 }
2427
2428                 {
2429                         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2430
2431                         if (lm.locked()) {
2432                                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2433                                         boost::shared_ptr<PluginInsert> pi;
2434                                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2435                                                 // skip plugins, they don't need anything when we're not active
2436                                                 continue;
2437                                         }
2438
2439                                         (*i)->silence (nframes, offset);
2440                                 }
2441
2442                                 if (nframes == _session.get_block_size() && offset == 0) {
2443                                         // _silent = true;
2444                                 }
2445                         }
2446                 }
2447
2448         }
2449 }
2450
2451 int
2452 Route::set_control_outs (const vector<string>& ports)
2453 {
2454         Glib::Mutex::Lock lm (_control_outs_lock);
2455         vector<string>::const_iterator i;
2456         size_t limit;
2457
2458         delete _control_outs;
2459         _control_outs = 0;
2460
2461         if (is_control() || is_master()) {
2462                 /* no control outs for these two special busses */
2463                 return 0;
2464         }
2465
2466         if (ports.empty()) {
2467                 return 0;
2468         }
2469
2470         string coutname = _name;
2471         coutname += _("[control]");
2472
2473         _control_outs = new IO (_session, coutname);
2474
2475         /* our control outs need as many outputs as we
2476            have audio outputs. we track the changes in ::output_change_handler().
2477         */
2478
2479         // XXX its stupid that we have to get this value twice
2480
2481         limit = n_outputs().n_audio();
2482
2483         if (_control_outs->ensure_io (ChanCount::ZERO, ChanCount (DataType::AUDIO, n_outputs().get (DataType::AUDIO)), true, this)) {
2484                 return -1;
2485         }
2486
2487         /* now connect to the named ports */
2488
2489         for (size_t n = 0; n < limit; ++n) {
2490                 if (_control_outs->connect_output (_control_outs->output (n), ports[n % ports.size()], this)) {
2491                         error << string_compose (_("could not connect %1 to %2"), _control_outs->output(n)->name(), ports[n]) << endmsg;
2492                         return -1;
2493                 }
2494         }
2495
2496         return 0;
2497 }
2498
2499 void
2500 Route::set_edit_group (RouteGroup *eg, void *src)
2501
2502 {
2503         if (eg == _edit_group) {
2504                 return;
2505         }
2506
2507         if (_edit_group) {
2508                 _edit_group->remove (this);
2509         }
2510
2511         if ((_edit_group = eg) != 0) {
2512                 _edit_group->add (this);
2513         }
2514
2515         _session.set_dirty ();
2516         edit_group_changed (src); /* EMIT SIGNAL */
2517 }
2518
2519 void
2520 Route::drop_edit_group (void *src)
2521 {
2522         _edit_group = 0;
2523         _session.set_dirty ();
2524         edit_group_changed (src); /* EMIT SIGNAL */
2525 }
2526
2527 void
2528 Route::set_mix_group (RouteGroup *mg, void *src)
2529
2530 {
2531         if (mg == _mix_group) {
2532                 return;
2533         }
2534
2535         if (_mix_group) {
2536                 _mix_group->remove (this);
2537         }
2538
2539         if ((_mix_group = mg) != 0) {
2540                 _mix_group->add (this);
2541         }
2542
2543         _session.set_dirty ();
2544         mix_group_changed (src); /* EMIT SIGNAL */
2545 }
2546
2547 void
2548 Route::drop_mix_group (void *src)
2549 {
2550         _mix_group = 0;
2551         _session.set_dirty ();
2552         mix_group_changed (src); /* EMIT SIGNAL */
2553 }
2554
2555 void
2556 Route::set_comment (string cmt, void *src)
2557 {
2558         _comment = cmt;
2559         comment_changed (src);
2560         _session.set_dirty ();
2561 }
2562
2563 bool
2564 Route::feeds (boost::shared_ptr<Route> other)
2565 {
2566         uint32_t i, j;
2567
2568         IO& self = *this;
2569         uint32_t no = self.n_outputs().n_total();
2570         uint32_t ni = other->n_inputs ().n_total();
2571
2572         for (i = 0; i < no; ++i) {
2573                 for (j = 0; j < ni; ++j) {
2574                         if (self.output(i)->connected_to (other->input(j)->name())) {
2575                                 return true;
2576                         }
2577                 }
2578         }
2579
2580         /* check IOProcessors which may also interconnect Routes */
2581
2582         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); r++) {
2583
2584                 boost::shared_ptr<IOProcessor> redirect = boost::dynamic_pointer_cast<IOProcessor>(*r);
2585
2586                 if ( ! redirect)
2587                         continue;
2588
2589                 // TODO: support internal redirects here
2590
2591                 no = redirect->io()->n_outputs().n_total();
2592
2593                 for (i = 0; i < no; ++i) {
2594                         for (j = 0; j < ni; ++j) {
2595                                 if (redirect->io()->output(i)->connected_to (other->input (j)->name())) {
2596                                         return true;
2597                                 }
2598                         }
2599                 }
2600         }
2601
2602         /* check for control room outputs which may also interconnect Routes */
2603
2604         if (_control_outs) {
2605
2606                 no = _control_outs->n_outputs().n_total();
2607
2608                 for (i = 0; i < no; ++i) {
2609                         for (j = 0; j < ni; ++j) {
2610                                 if (_control_outs->output(i)->connected_to (other->input (j)->name())) {
2611                                         return true;
2612                                 }
2613                         }
2614                 }
2615         }
2616
2617         return false;
2618 }
2619
2620 void
2621 Route::set_mute_config (mute_type t, bool onoff, void *src)
2622 {
2623         switch (t) {
2624         case PRE_FADER:
2625                 _mute_affects_pre_fader = onoff;
2626                  pre_fader_changed(src); /* EMIT SIGNAL */
2627                 break;
2628
2629         case POST_FADER:
2630                 _mute_affects_post_fader = onoff;
2631                  post_fader_changed(src); /* EMIT SIGNAL */
2632                 break;
2633
2634         case CONTROL_OUTS:
2635                 _mute_affects_control_outs = onoff;
2636                  control_outs_changed(src); /* EMIT SIGNAL */
2637                 break;
2638
2639         case MAIN_OUTS:
2640                 _mute_affects_main_outs = onoff;
2641                  main_outs_changed(src); /* EMIT SIGNAL */
2642                 break;
2643         }
2644 }
2645
2646 bool
2647 Route::get_mute_config (mute_type t)
2648 {
2649         bool onoff = false;
2650
2651         switch (t){
2652         case PRE_FADER:
2653                 onoff = _mute_affects_pre_fader;
2654                 break;
2655         case POST_FADER:
2656                 onoff = _mute_affects_post_fader;
2657                 break;
2658         case CONTROL_OUTS:
2659                 onoff = _mute_affects_control_outs;
2660                 break;
2661         case MAIN_OUTS:
2662                 onoff = _mute_affects_main_outs;
2663                 break;
2664         }
2665
2666         return onoff;
2667 }
2668
2669 void
2670 Route::handle_transport_stopped (bool abort_ignored, bool did_locate, bool can_flush_processors)
2671 {
2672         nframes_t now = _session.transport_frame();
2673
2674         {
2675                 Glib::RWLock::ReaderLock lm (_processor_lock);
2676
2677                 if (!did_locate) {
2678                         automation_snapshot (now, true);
2679                 }
2680
2681                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2682
2683                         if (Config->get_plugins_stop_with_transport() && can_flush_processors) {
2684                                 (*i)->deactivate ();
2685                                 (*i)->activate ();
2686                         }
2687
2688                         (*i)->transport_stopped (now);
2689                 }
2690         }
2691
2692         IO::transport_stopped (now);
2693
2694         _roll_delay = _initial_delay;
2695 }
2696
2697 void
2698 Route::input_change_handler (IOChange change, void *ignored)
2699 {
2700         if (change & ConfigurationChanged) {
2701                 reset_processor_counts (0);
2702         }
2703 }
2704
2705 void
2706 Route::output_change_handler (IOChange change, void *ignored)
2707 {
2708         if (change & ConfigurationChanged) {
2709                 if (_control_outs) {
2710                         _control_outs->ensure_io (ChanCount::ZERO, ChanCount(DataType::AUDIO, n_outputs().n_audio()), true, this);
2711                 }
2712
2713                 reset_processor_counts (0);
2714         }
2715 }
2716
2717 uint32_t
2718 Route::pans_required () const
2719 {
2720         if (n_outputs().n_audio() < 2) {
2721                 return 0;
2722         }
2723
2724         return max (n_inputs ().n_audio(), processor_max_outs.n_audio());
2725 }
2726
2727 int
2728 Route::no_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset,
2729                    bool session_state_changing, bool can_record, bool rec_monitors_input)
2730 {
2731         if (n_outputs().n_total() == 0) {
2732                 return 0;
2733         }
2734
2735         if (session_state_changing || !_active)  {
2736                 silence (nframes, offset);
2737                 return 0;
2738         }
2739
2740         apply_gain_automation = false;
2741
2742         if (n_inputs().n_total()) {
2743                 passthru (start_frame, end_frame, nframes, offset, 0, false);
2744         } else {
2745                 silence (nframes, offset);
2746         }
2747
2748         return 0;
2749 }
2750
2751 nframes_t
2752 Route::check_initial_delay (nframes_t nframes, nframes_t& offset, nframes_t& transport_frame)
2753 {
2754         if (_roll_delay > nframes) {
2755
2756                 _roll_delay -= nframes;
2757                 silence (nframes, offset);
2758                 /* transport frame is not legal for caller to use */
2759                 return 0;
2760
2761         } else if (_roll_delay > 0) {
2762
2763                 nframes -= _roll_delay;
2764
2765                 silence (_roll_delay, offset);
2766
2767                 offset += _roll_delay;
2768                 transport_frame += _roll_delay;
2769
2770                 _roll_delay = 0;
2771         }
2772
2773         return nframes;
2774 }
2775
2776 int
2777 Route::roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset, int declick,
2778              bool can_record, bool rec_monitors_input)
2779 {
2780         {
2781                 Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2782                 if (lm.locked()) {
2783                         // automation snapshot can also be called from the non-rt context
2784                         // and it uses the processor list, so we take the lock out here
2785                         automation_snapshot (_session.transport_frame(), false);
2786                 }
2787         }
2788
2789         if ((n_outputs().n_total() == 0 && _processors.empty()) || n_inputs().n_total() == 0 || !_active) {
2790                 silence (nframes, offset);
2791                 return 0;
2792         }
2793
2794         nframes_t unused = 0;
2795
2796         if ((nframes = check_initial_delay (nframes, offset, unused)) == 0) {
2797                 return 0;
2798         }
2799
2800         _silent = false;
2801
2802         apply_gain_automation = false;
2803
2804         {
2805                 Glib::Mutex::Lock am (data().control_lock(), Glib::TRY_LOCK);
2806
2807                 if (am.locked() && _session.transport_rolling()) {
2808
2809                         if (_gain_control->automation_playback()) {
2810                                 apply_gain_automation = _gain_control->list()->curve().rt_safe_get_vector (
2811                                                 start_frame, end_frame, _session.gain_automation_buffer(), nframes);
2812                         }
2813                 }
2814         }
2815
2816         passthru (start_frame, end_frame, nframes, offset, declick, false);
2817
2818         return 0;
2819 }
2820
2821 int
2822 Route::silent_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset,
2823                     bool can_record, bool rec_monitors_input)
2824 {
2825         silence (nframes, offset);
2826         return 0;
2827 }
2828
2829 void
2830 Route::toggle_monitor_input ()
2831 {
2832         for (PortSet::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
2833                 i->ensure_monitor_input( ! i->monitoring_input());
2834         }
2835 }
2836
2837 bool
2838 Route::has_external_redirects () const
2839 {
2840         // FIXME: what about sends?
2841
2842         boost::shared_ptr<const PortInsert> pi;
2843
2844         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2845                 if ((pi = boost::dynamic_pointer_cast<const PortInsert>(*i)) != 0) {
2846
2847                         for (PortSet::const_iterator port = pi->io()->outputs().begin();
2848                                         port != pi->io()->outputs().end(); ++port) {
2849
2850                                 string port_name = port->name();
2851                                 string client_name = port_name.substr (0, port_name.find(':'));
2852
2853                                 /* only say "yes" if the redirect is actually in use */
2854
2855                                 if (client_name != "ardour" && pi->active()) {
2856                                         return true;
2857                                 }
2858                         }
2859                 }
2860         }
2861
2862         return false;
2863 }
2864
2865 void
2866 Route::flush_processors ()
2867 {
2868         /* XXX shouldn't really try to take this lock, since
2869            this is called from the RT audio thread.
2870         */
2871
2872         Glib::RWLock::ReaderLock lm (_processor_lock);
2873
2874         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2875                 (*i)->deactivate ();
2876                 (*i)->activate ();
2877         }
2878 }
2879
2880 void
2881 Route::set_meter_point (MeterPoint p, void *src)
2882 {
2883         if (_meter_point != p) {
2884                 _meter_point = p;
2885                  meter_change (src); /* EMIT SIGNAL */
2886                 _session.set_dirty ();
2887         }
2888 }
2889
2890 nframes_t
2891 Route::update_total_latency ()
2892 {
2893         nframes_t old = _own_latency;
2894
2895         if (_user_latency) {
2896                 _own_latency = _user_latency;
2897         } else {
2898                 _own_latency = 0;
2899
2900                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2901                         if ((*i)->active ()) {
2902                                 _own_latency += (*i)->signal_latency ();
2903                         }
2904                 }
2905         }
2906
2907 #undef DEBUG_LATENCY
2908 #ifdef DEBUG_LATENCY
2909         cerr << _name << ": internal redirect latency = " << _own_latency << endl;
2910 #endif
2911
2912         set_port_latency (_own_latency);
2913
2914         if (!_user_latency) {
2915                 /* this (virtual) function is used for pure Routes,
2916                    not derived classes like AudioTrack.  this means
2917                    that the data processed here comes from an input
2918                    port, not prerecorded material, and therefore we
2919                    have to take into account any input latency.
2920                 */
2921
2922
2923                 _own_latency += input_latency ();
2924         }
2925
2926         if (old != _own_latency) {
2927                 signal_latency_changed (); /* EMIT SIGNAL */
2928         }
2929
2930 #ifdef DEBUG_LATENCY
2931         cerr << _name << ": input latency = " << input_latency() << " total = "
2932              << _own_latency << endl;
2933 #endif
2934
2935         return _own_latency;
2936 }
2937
2938 void
2939 Route::set_user_latency (nframes_t nframes)
2940 {
2941         Latent::set_user_latency (nframes);
2942         _session.update_latency_compensation (false, false);
2943 }
2944
2945 void
2946 Route::set_latency_delay (nframes_t longest_session_latency)
2947 {
2948         nframes_t old = _initial_delay;
2949
2950         if (_own_latency < longest_session_latency) {
2951                 _initial_delay = longest_session_latency - _own_latency;
2952         } else {
2953                 _initial_delay = 0;
2954         }
2955
2956         if (_initial_delay != old) {
2957                 initial_delay_changed (); /* EMIT SIGNAL */
2958         }
2959
2960         if (_session.transport_stopped()) {
2961                 _roll_delay = _initial_delay;
2962         }
2963 }
2964
2965 void
2966 Route::automation_snapshot (nframes_t now, bool force)
2967 {
2968         if (!force && !should_snapshot(now)) {
2969                 return;
2970         }
2971
2972         IO::automation_snapshot (now, force);
2973
2974         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2975                 (*i)->automation_snapshot (now, force);
2976         }
2977 }
2978
2979 Route::ToggleControllable::ToggleControllable (std::string name, Route& s, ToggleType tp)
2980         : Controllable (name), route (s), type(tp)
2981 {
2982
2983 }
2984
2985 void
2986 Route::ToggleControllable::set_value (float val)
2987 {
2988         bool bval = ((val >= 0.5f) ? true: false);
2989
2990         switch (type) {
2991         case MuteControl:
2992                 route.set_mute (bval, this);
2993                 break;
2994         case SoloControl:
2995                 route.set_solo (bval, this);
2996                 break;
2997         default:
2998                 break;
2999         }
3000 }
3001
3002 float
3003 Route::ToggleControllable::get_value (void) const
3004 {
3005         float val = 0.0f;
3006
3007         switch (type) {
3008         case MuteControl:
3009                 val = route.muted() ? 1.0f : 0.0f;
3010                 break;
3011         case SoloControl:
3012                 val = route.soloed() ? 1.0f : 0.0f;
3013                 break;
3014         default:
3015                 break;
3016         }
3017
3018         return val;
3019 }
3020
3021 void
3022 Route::set_block_size (nframes_t nframes)
3023 {
3024         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3025                 (*i)->set_block_size (nframes);
3026         }
3027 }
3028
3029 void
3030 Route::protect_automation ()
3031 {
3032         Automatable::protect_automation();
3033
3034         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3035                 (*i)->protect_automation();
3036 }
3037
3038 void
3039 Route::set_pending_declick (int declick)
3040 {
3041         if (_declickable) {
3042                 /* this call is not allowed to turn off a pending declick unless "force" is true */
3043                 if (declick) {
3044                         _pending_declick = declick;
3045                 }
3046                 // cerr << _name << ": after setting to " << declick << " pending declick = " << _pending_declick << endl;
3047         } else {
3048                 _pending_declick = 0;
3049         }
3050
3051 }
3052
3053 /** Shift automation forwards from a particular place, thereby inserting time.
3054  *  Adds undo commands for any shifts that are performed.
3055  *
3056  * @param pos Position to start shifting from.
3057  * @param frames Amount to shift forwards by.
3058  */
3059
3060 void
3061 Route::shift (nframes64_t pos, nframes64_t frames)
3062 {
3063 #ifdef THIS_NEEDS_FIXING_FOR_V3
3064
3065         /* gain automation */
3066         XMLNode &before = _gain_control->get_state ();
3067         _gain_control->shift (pos, frames);
3068         XMLNode &after = _gain_control->get_state ();
3069         _session.add_command (new MementoCommand<AutomationList> (_gain_automation_curve, &before, &after));
3070
3071         /* pan automation */
3072         for (std::vector<StreamPanner*>::iterator i = _panner->begin (); i != _panner->end (); ++i) {
3073                 Curve & c = (*i)->automation ();
3074                 XMLNode &before = c.get_state ();
3075                 c.shift (pos, frames);
3076                 XMLNode &after = c.get_state ();
3077                 _session.add_command (new MementoCommand<AutomationList> (c, &before, &after));
3078         }
3079
3080         /* redirect automation */
3081         {
3082                 Glib::RWLock::ReaderLock lm (redirect_lock);
3083                 for (RedirectList::iterator i = _redirects.begin (); i != _redirects.end (); ++i) {
3084
3085                         set<uint32_t> a;
3086                         (*i)->what_has_automation (a);
3087
3088                         for (set<uint32_t>::const_iterator j = a.begin (); j != a.end (); ++j) {
3089                                 AutomationList & al = (*i)->automation_list (*j);
3090                                 XMLNode &before = al.get_state ();
3091                                 al.shift (pos, frames);
3092                                 XMLNode &after = al.get_state ();
3093                                 _session.add_command (new MementoCommand<AutomationList> (al, &before, &after));
3094                         }
3095                 }
3096         }
3097 #endif
3098
3099 }