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