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
  28 #include <ardour/timestamps.h>
  29 #include <ardour/buffer.h>
  30 #include <ardour/audioengine.h>
  31 #include <ardour/route.h>
  32 #include <ardour/insert.h>
  33 #include <ardour/send.h>
  34 #include <ardour/session.h>
  35 #include <ardour/utils.h>
  36 #include <ardour/configuration.h>
  37 #include <ardour/cycle_timer.h>
  38 #include <ardour/route_group.h>
  39 #include <ardour/port.h>
  40 #include <ardour/ladspa_plugin.h>
  41 #include <ardour/panner.h>
  42 #include <ardour/dB.h>
  43 #include <ardour/mix.h>
  44
  45 #include "i18n.h"
  46
  47 using namespace std;
  48 using namespace ARDOUR;
  49 using namespace PBD;
  50
  51 uint32_t Route::order_key_cnt = 0;
  52 sigc::signal<void> Route::SyncOrderKeys;
  53
  54 Route::Route (Session& sess, string name, int input_min, int input_max, int output_min, int output_max, Flag flg, DataType default_type)
  55         : IO (sess, name, input_min, input_max, output_min, output_max, default_type),
  56           _flags (flg),
  57           _solo_control (X_("solo"), *this, ToggleControllable::SoloControl),
  58           _mute_control (X_("mute"), *this, ToggleControllable::MuteControl)
  59 {
  60         init ();
  61 }
  62
  63 Route::Route (Session& sess, const XMLNode& node, DataType default_type)
  64         : IO (sess, *node.child ("IO"), default_type),
  65           _solo_control (X_("solo"), *this, ToggleControllable::SoloControl),
  66           _mute_control (X_("mute"), *this, ToggleControllable::MuteControl)
  67 {
  68         init ();
  69         _set_state (node, false);
  70 }
  71
  72 void
  73 Route::init ()
  74 {
  75         redirect_max_outs = 0;
  76         _muted = false;
  77         _soloed = false;
  78         _solo_safe = false;
  79         _phase_invert = false;
  80         _denormal_protection = false;
  81         order_keys[strdup (N_("signal"))] = order_key_cnt++;
  82         _silent = false;
  83         _meter_point = MeterPostFader;
  84         _initial_delay = 0;
  85         _roll_delay = 0;
  86         _own_latency = 0;
  87         _have_internal_generator = false;
  88         _declickable = false;
  89         _pending_declick = true;
  90         _remote_control_id = 0;
  91         _ignore_gain_on_deliver = true;
  92
  93         _edit_group = 0;
  94         _mix_group = 0;
  95
  96         _mute_affects_pre_fader = Config->get_mute_affects_pre_fader();
  97         _mute_affects_post_fader = Config->get_mute_affects_post_fader();
  98         _mute_affects_control_outs = Config->get_mute_affects_control_outs();
  99         _mute_affects_main_outs = Config->get_mute_affects_main_outs();
 100
 101         solo_gain = 1.0;
 102         desired_solo_gain = 1.0;
 103         mute_gain = 1.0;
 104         desired_mute_gain = 1.0;
 105
 106         _control_outs = 0;
 107
 108         input_changed.connect (mem_fun (this, &Route::input_change_handler));
 109         output_changed.connect (mem_fun (this, &Route::output_change_handler));
 110 }
 111
 112 Route::~Route ()
 113 {
 114         clear_redirects (PreFader, this);
 115         clear_redirects (PostFader, this);
 116
 117         for (OrderKeys::iterator i = order_keys.begin(); i != order_keys.end(); ++i) {
 118                 free ((void*)(i->first));
 119         }
 120
 121         if (_control_outs) {
 122                 delete _control_outs;
 123         }
 124 }
 125
 126 void
 127 Route::set_remote_control_id (uint32_t id)
 128 {
 129         if (id != _remote_control_id) {
 130                 _remote_control_id = id;
 131                 RemoteControlIDChanged ();
 132         }
 133 }
 134
 135 uint32_t
 136 Route::remote_control_id() const
 137 {
 138         return _remote_control_id;
 139 }
 140
 141 long
 142 Route::order_key (const char* name) const
 143 {
 144         OrderKeys::const_iterator i;
 145
 146         for (i = order_keys.begin(); i != order_keys.end(); ++i) {
 147                 if (!strcmp (name, i->first)) {
 148                         return i->second;
 149                 }
 150         }
 151
 152         return -1;
 153 }
 154
 155 void
 156 Route::set_order_key (const char* name, long n)
 157 {
 158         order_keys[strdup(name)] = n;
 159
 160         if (Config->get_sync_all_route_ordering()) {
 161                 for (OrderKeys::iterator x = order_keys.begin(); x != order_keys.end(); ++x) {
 162                         x->second = n;
 163                 }
 164         }
 165
 166         _session.set_dirty ();
 167 }
 168
 169 void
 170 Route::sync_order_keys ()
 171 {
 172         uint32_t key;
 173
 174         if (order_keys.empty()) {
 175                 return;
 176         }
 177
 178         OrderKeys::iterator x = order_keys.begin();
 179         key = x->second;
 180         ++x;
 181
 182         for (; x != order_keys.end(); ++x) {
 183                 x->second = key;
 184         }
 185 }
 186
 187 void
 188 Route::inc_gain (gain_t fraction, void *src)
 189 {
 190         IO::inc_gain (fraction, src);
 191 }
 192
 193 void
 194 Route::set_gain (gain_t val, void *src)
 195 {
 196         if (src != 0 && _mix_group && src != _mix_group && _mix_group->is_active()) {
 197
 198                 if (_mix_group->is_relative()) {
 199
 200
 201                         gain_t usable_gain  = gain();
 202                         if (usable_gain < 0.000001f) {
 203                                 usable_gain=0.000001f;
 204                         }
 205
 206                         gain_t delta = val;
 207                         if (delta < 0.000001f) {
 208                                 delta=0.000001f;
 209                         }
 210
 211                         delta -= usable_gain;
 212
 213                         if (delta == 0.0f) return;
 214
 215                         gain_t factor = delta / usable_gain;
 216
 217                         if (factor > 0.0f) {
 218                                 factor = _mix_group->get_max_factor(factor);
 219                                 if (factor == 0.0f) {
 220                                         gain_changed (src);
 221                                         return;
 222                                 }
 223                         } else {
 224                                 factor = _mix_group->get_min_factor(factor);
 225                                 if (factor == 0.0f) {
 226                                         gain_changed (src);
 227                                         return;
 228                                 }
 229                         }
 230
 231                         _mix_group->apply (&Route::inc_gain, factor, _mix_group);
 232
 233                 } else {
 234
 235                         _mix_group->apply (&Route::set_gain, val, _mix_group);
 236                 }
 237
 238                 return;
 239         }
 240
 241         if (val == gain()) {
 242                 return;
 243         }
 244
 245         IO::set_gain (val, src);
 246 }
 247
 248 void
 249 Route::process_output_buffers (vector<Sample*>& bufs, uint32_t nbufs,
 250                                nframes_t start_frame, nframes_t end_frame,
 251                                nframes_t nframes, nframes_t offset, bool with_redirects, int declick,
 252                                bool meter)
 253 {
 254         uint32_t n;
 255         RedirectList::iterator i;
 256         bool post_fader_work = false;
 257         bool mute_declick_applied = false;
 258         gain_t dmg, dsg, dg;
 259         vector<Sample*>::iterator bufiter;
 260         IO *co;
 261         bool mute_audible;
 262         bool solo_audible;
 263         bool no_monitor;
 264         gain_t* gab = _session.gain_automation_buffer();
 265
 266         switch (Config->get_monitoring_model()) {
 267         case HardwareMonitoring:
 268         case ExternalMonitoring:
 269                 no_monitor = true;
 270                 break;
 271         default:
 272                 no_monitor = false;
 273         }
 274
 275         declick = _pending_declick;
 276
 277         {
 278                 Glib::Mutex::Lock cm (control_outs_lock, Glib::TRY_LOCK);
 279
 280                 if (cm.locked()) {
 281                         co = _control_outs;
 282                 } else {
 283                         co = 0;
 284                 }
 285         }
 286
 287         {
 288                 Glib::Mutex::Lock dm (declick_lock, Glib::TRY_LOCK);
 289
 290                 if (dm.locked()) {
 291                         dmg = desired_mute_gain;
 292                         dsg = desired_solo_gain;
 293                         dg = _desired_gain;
 294                 } else {
 295                         dmg = mute_gain;
 296                         dsg = solo_gain;
 297                         dg = _gain;
 298                 }
 299         }
 300
 301         /* ----------------------------------------------------------------------------------------------------
 302            GLOBAL DECLICK (for transport changes etc.)
 303            -------------------------------------------------------------------------------------------------- */
 304
 305         if (declick > 0) {
 306                 apply_declick (bufs, nbufs, nframes, 0.0, 1.0, false);
 307                 _pending_declick = 0;
 308         } else if (declick < 0) {
 309                 apply_declick (bufs, nbufs, nframes, 1.0, 0.0, false);
 310                 _pending_declick = 0;
 311         } else {
 312
 313                 /* no global declick */
 314
 315                 if (solo_gain != dsg) {
 316                         apply_declick (bufs, nbufs, nframes, solo_gain, dsg, false);
 317                         solo_gain = dsg;
 318                 }
 319         }
 320
 321
 322         /* ----------------------------------------------------------------------------------------------------
 323            INPUT METERING & MONITORING
 324            -------------------------------------------------------------------------------------------------- */
 325
 326         if (meter && (_meter_point == MeterInput)) {
 327                 for (n = 0; n < nbufs; ++n) {
 328                         _peak_power[n] = Session::compute_peak (bufs[n], nframes, _peak_power[n]);
 329                 }
 330         }
 331
 332         if (!_soloed && _mute_affects_pre_fader && (mute_gain != dmg)) {
 333                 apply_declick (bufs, nbufs, nframes, mute_gain, dmg, false);
 334                 mute_gain = dmg;
 335                 mute_declick_applied = true;
 336         }
 337
 338         if ((_meter_point == MeterInput) && co) {
 339
 340                 solo_audible = dsg > 0;
 341                 mute_audible = dmg > 0;// || !_mute_affects_pre_fader;
 342
 343                 if (    // muted by solo of another track
 344
 345                         !solo_audible ||
 346
 347                         // muted by mute of this track
 348
 349                         !mute_audible ||
 350
 351                         // rec-enabled but not s/w monitoring
 352
 353                         // TODO: this is probably wrong
 354
 355                         (no_monitor && record_enabled() && (!Config->get_auto_input() || _session.actively_recording()))
 356
 357                         ) {
 358
 359                         co->silence (nframes, offset);
 360
 361                 } else {
 362
 363                         co->deliver_output (bufs, nbufs, nframes, offset);
 364
 365                 }
 366         }
 367
 368         /* -----------------------------------------------------------------------------------------------------
 369            DENORMAL CONTROL
 370            -------------------------------------------------------------------------------------------------- */
 371
 372         if (_denormal_protection || Config->get_denormal_protection()) {
 373
 374                 for (n = 0; n < nbufs; ++n)  {
 375                         Sample *sp = bufs[n];
 376
 377                         for (nframes_t nx = offset; nx < nframes + offset; ++nx) {
 378                                 sp[nx] += 1.0e-27f;
 379                         }
 380                 }
 381         }
 382
 383
 384         /* ----------------------------------------------------------------------------------------------------
 385            PRE-FADER REDIRECTS
 386            -------------------------------------------------------------------------------------------------- */
 387
 388         if (with_redirects) {
 389                 Glib::RWLock::ReaderLock rm (redirect_lock, Glib::TRY_LOCK);
 390                 if (rm.locked()) {
 391                         if (mute_gain > 0 || !_mute_affects_pre_fader) {
 392                                 for (i = _redirects.begin(); i != _redirects.end(); ++i) {
 393                                         switch ((*i)->placement()) {
 394                                         case PreFader:
 395                                                 if (dsg == 0) {
 396                                                         if (boost::dynamic_pointer_cast<Send>(*i) || boost::dynamic_pointer_cast<PortInsert>(*i)) {
 397                                                                 (*i)->silence (nframes, offset);
 398                                                         }
 399                                                 } else {
 400                                                         (*i)->run (bufs, nbufs, nframes, offset);
 401                                                 }
 402                                                 break;
 403                                         case PostFader:
 404                                                 post_fader_work = true;
 405                                                 break;
 406                                         }
 407                                 }
 408                         } else {
 409                                 for (i = _redirects.begin(); i != _redirects.end(); ++i) {
 410                                         switch ((*i)->placement()) {
 411                                         case PreFader:
 412                                                 (*i)->silence (nframes, offset);
 413                                                 break;
 414                                         case PostFader:
 415                                                 post_fader_work = true;
 416                                                 break;
 417                                         }
 418                                 }
 419                         }
 420                 }
 421         }
 422
 423
 424         if (!_soloed && (mute_gain != dmg) && !mute_declick_applied && _mute_affects_post_fader) {
 425                 apply_declick (bufs, nbufs, nframes, mute_gain, dmg, false);
 426                 mute_gain = dmg;
 427                 mute_declick_applied = true;
 428         }
 429
 430         /* ----------------------------------------------------------------------------------------------------
 431            PRE-FADER METERING & MONITORING
 432            -------------------------------------------------------------------------------------------------- */
 433
 434         if (meter && (_meter_point == MeterPreFader)) {
 435                 for (n = 0; n < nbufs; ++n) {
 436                         _peak_power[n] = Session::compute_peak (bufs[n], nframes, _peak_power[n]);
 437                 }
 438         }
 439
 440
 441         if ((_meter_point == MeterPreFader) && co) {
 442
 443                 solo_audible = dsg > 0;
 444                 mute_audible = dmg > 0 || !_mute_affects_pre_fader;
 445
 446                 if ( // muted by solo of another track
 447
 448                         !solo_audible ||
 449
 450                         // muted by mute of this track
 451
 452                         !mute_audible ||
 453
 454                         // rec-enabled but not s/w monitoring
 455
 456                         (no_monitor && record_enabled() && (!Config->get_auto_input() || _session.actively_recording()))
 457
 458                         ) {
 459
 460                         co->silence (nframes, offset);
 461
 462                 } else {
 463
 464                         co->deliver_output_no_pan (bufs, nbufs, nframes, offset);
 465
 466                 }
 467         }
 468
 469         /* ----------------------------------------------------------------------------------------------------
 470            GAIN STAGE
 471            -------------------------------------------------------------------------------------------------- */
 472
 473         /* if not recording or recording and requiring any monitor signal, then apply gain */
 474
 475         if ( // not recording
 476
 477                 !(record_enabled() && _session.actively_recording()) ||
 478
 479             // OR recording
 480
 481                 // AND software monitoring required
 482
 483                 (Config->get_monitoring_model() == SoftwareMonitoring)) {
 484
 485                 if (apply_gain_automation) {
 486
 487                         if (_phase_invert) {
 488                                 for (n = 0; n < nbufs; ++n)  {
 489                                         Sample *sp = bufs[n];
 490
 491                                         for (nframes_t nx = 0; nx < nframes; ++nx) {
 492                                                 sp[nx] *= -gab[nx];
 493                                         }
 494                                 }
 495                         } else {
 496                                 for (n = 0; n < nbufs; ++n) {
 497                                         Sample *sp = bufs[n];
 498
 499                                         for (nframes_t nx = 0; nx < nframes; ++nx) {
 500                                                 sp[nx] *= gab[nx];
 501                                         }
 502                                 }
 503                         }
 504
 505                         if (apply_gain_automation && _session.transport_rolling() && nframes > 0) {
 506                                 _effective_gain = gab[nframes-1];
 507                         }
 508
 509                 } else {
 510
 511                         /* manual (scalar) gain */
 512
 513                         if (_gain != dg) {
 514
 515                                 apply_declick (bufs, nbufs, nframes, _gain, dg, _phase_invert);
 516                                 _gain = dg;
 517
 518                         } else if (_gain != 0 && (_phase_invert || _gain != 1.0)) {
 519
 520                                 /* no need to interpolate current gain value,
 521                                    but its non-unity, so apply it. if the gain
 522                                    is zero, do nothing because we'll ship silence
 523                                    below.
 524                                 */
 525
 526                                 gain_t this_gain;
 527
 528                                 if (_phase_invert) {
 529                                         this_gain = -_gain;
 530                                 } else {
 531                                         this_gain = _gain;
 532                                 }
 533
 534                                 for (n = 0; n < nbufs; ++n) {
 535                                         Sample *sp = bufs[n];
 536                                         Session::apply_gain_to_buffer(sp,nframes,this_gain);
 537                                 }
 538
 539                         } else if (_gain == 0) {
 540                                 for (n = 0; n < nbufs; ++n) {
 541                                         memset (bufs[n], 0, sizeof (Sample) * nframes);
 542                                 }
 543                         }
 544                 }
 545
 546         } else {
 547
 548                 /* actively recording, no monitoring required; leave buffers as-is to save CPU cycles */
 549
 550         }
 551
 552         /* ----------------------------------------------------------------------------------------------------
 553            POST-FADER REDIRECTS
 554            -------------------------------------------------------------------------------------------------- */
 555
 556         /* note that post_fader_work cannot be true unless with_redirects was also true, so don't test both */
 557
 558         if (post_fader_work) {
 559
 560                 Glib::RWLock::ReaderLock rm (redirect_lock, Glib::TRY_LOCK);
 561                 if (rm.locked()) {
 562                         if (mute_gain > 0 || !_mute_affects_post_fader) {
 563                                 for (i = _redirects.begin(); i != _redirects.end(); ++i) {
 564                                         switch ((*i)->placement()) {
 565                                         case PreFader:
 566                                                 break;
 567                                         case PostFader:
 568                                                 if (dsg == 0) {
 569                                                         if (boost::dynamic_pointer_cast<Send>(*i) || boost::dynamic_pointer_cast<PortInsert>(*i)) {
 570                                                                 (*i)->silence (nframes, offset);
 571                                                         }
 572                                                 } else {
 573                                                         (*i)->run (bufs, nbufs, nframes, offset);
 574                                                 }
 575                                                 break;
 576                                         }
 577                                 }
 578                         } else {
 579                                 for (i = _redirects.begin(); i != _redirects.end(); ++i) {
 580                                         switch ((*i)->placement()) {
 581                                         case PreFader:
 582                                                 break;
 583                                         case PostFader:
 584                                                 (*i)->silence (nframes, offset);
 585                                                 break;
 586                                         }
 587                                 }
 588                         }
 589                 }
 590         }
 591
 592         if (!_soloed && (mute_gain != dmg) && !mute_declick_applied && _mute_affects_control_outs) {
 593                 apply_declick (bufs, nbufs, nframes, mute_gain, dmg, false);
 594                 mute_gain = dmg;
 595                 mute_declick_applied = true;
 596         }
 597
 598         /* ----------------------------------------------------------------------------------------------------
 599            CONTROL OUTPUT STAGE
 600            -------------------------------------------------------------------------------------------------- */
 601
 602         if ((_meter_point == MeterPostFader) && co) {
 603
 604                 solo_audible = solo_gain > 0;
 605                 mute_audible = dmg > 0 || !_mute_affects_control_outs;
 606
 607                 if ( // silent anyway
 608
 609                         (_gain == 0 && !apply_gain_automation) ||
 610
 611                      // muted by solo of another track
 612
 613                         !solo_audible ||
 614
 615                      // muted by mute of this track
 616
 617                         !mute_audible ||
 618
 619                     // recording but not s/w monitoring
 620
 621                         (no_monitor && record_enabled() && (!Config->get_auto_input() || _session.actively_recording()))
 622
 623                         ) {
 624
 625                         co->silence (nframes, offset);
 626
 627                 } else {
 628
 629                         co->deliver_output_no_pan (bufs, nbufs, nframes, offset);
 630                 }
 631         }
 632
 633         /* ----------------------------------------------------------------------
 634            GLOBAL MUTE
 635            ----------------------------------------------------------------------*/
 636
 637         if (!_soloed && (mute_gain != dmg) && !mute_declick_applied && _mute_affects_main_outs) {
 638                 apply_declick (bufs, nbufs, nframes, mute_gain, dmg, false);
 639                 mute_gain = dmg;
 640                 mute_declick_applied = true;
 641         }
 642
 643         /* ----------------------------------------------------------------------------------------------------
 644            MAIN OUTPUT STAGE
 645            -------------------------------------------------------------------------------------------------- */
 646
 647         solo_audible = dsg > 0;
 648         mute_audible = dmg > 0 || !_mute_affects_main_outs;
 649
 650         if (n_outputs() == 0) {
 651
 652             /* relax */
 653
 654         } else if (no_monitor && record_enabled() && (!Config->get_auto_input() || _session.actively_recording())) {
 655
 656                 IO::silence (nframes, offset);
 657
 658         } else {
 659
 660                 if ( // silent anyway
 661
 662                     (_gain == 0 && !apply_gain_automation) ||
 663
 664                     // muted by solo of another track, but not using control outs for solo
 665
 666                     (!solo_audible && (Config->get_solo_model() != SoloBus)) ||
 667
 668                     // muted by mute of this track
 669
 670                     !mute_audible
 671
 672                         ) {
 673
 674                         /* don't use Route::silence() here, because that causes
 675                            all outputs (sends, port inserts, etc. to be silent).
 676                         */
 677
 678                         if (_meter_point == MeterPostFader) {
 679                                 reset_peak_meters ();
 680                         }
 681
 682                         IO::silence (nframes, offset);
 683
 684                 } else {
 685
 686                         if ((_session.transport_speed() > 1.5f ||
 687                              _session.transport_speed() < -1.5f) &&
 688                             Config->get_quieten_at_speed()) {
 689                                 pan (bufs, nbufs, nframes, offset, speed_quietning);
 690                         } else {
 691                                 // cerr << _name << " panner state = " << _panner->automation_state() << endl;
 692                                 if (!_panner->empty() &&
 693                                     (_panner->automation_state() & Play ||
 694                                      ((_panner->automation_state() & Touch) && !_panner->touching()))) {
 695                                         pan_automated (bufs, nbufs, start_frame, end_frame, nframes, offset);
 696                                 } else {
 697                                         pan (bufs, nbufs, nframes, offset, 1.0);
 698                                 }
 699                         }
 700                 }
 701
 702         }
 703
 704         /* ----------------------------------------------------------------------------------------------------
 705            POST-FADER METERING
 706            -------------------------------------------------------------------------------------------------- */
 707
 708         if (meter && (_meter_point == MeterPostFader)) {
 709
 710                 if ((_gain == 0 && !apply_gain_automation) || dmg == 0) {
 711                         uint32_t no = n_outputs();
 712                         for (n = 0; n < no; ++n) {
 713                                 _peak_power[n] = 0;
 714                         }
 715                 } else {
 716                         uint32_t no = n_outputs();
 717                         for (n = 0; n < no; ++n) {
 718                                 _peak_power[n] = Session::compute_peak (output(n)->get_buffer (nframes) + offset, nframes, _peak_power[n]);
 719                         }
 720                 }
 721         }
 722 }
 723
 724 uint32_t
 725 Route::n_process_buffers ()
 726 {
 727         return max (n_inputs(), redirect_max_outs);
 728 }
 729
 730 void
 731
 732 Route::passthru (nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset, int declick, bool meter_first)
 733 {
 734         vector<Sample*>& bufs = _session.get_passthru_buffers();
 735         uint32_t limit = n_process_buffers ();
 736
 737         _silent = false;
 738
 739         collect_input (bufs, limit, nframes, offset);
 740
 741 #define meter_stream meter_first
 742
 743         if (meter_first) {
 744                 for (uint32_t n = 0; n < limit; ++n) {
 745                         _peak_power[n] = Session::compute_peak (bufs[n], nframes, _peak_power[n]);
 746                 }
 747                 meter_stream = false;
 748         } else {
 749                 meter_stream = true;
 750         }
 751
 752         process_output_buffers (bufs, limit, start_frame, end_frame, nframes, offset, true, declick, meter_stream);
 753
 754 #undef meter_stream
 755 }
 756
 757 void
 758 Route::set_phase_invert (bool yn, void *src)
 759 {
 760         if (_phase_invert != yn) {
 761                 _phase_invert = yn;
 762                 //  phase_invert_changed (src); /* EMIT SIGNAL */
 763         }
 764 }
 765
 766 void
 767 Route::set_denormal_protection (bool yn, void *src)
 768 {
 769         if (_denormal_protection != yn) {
 770                 _denormal_protection = yn;
 771                 //  denormal_protection_changed (src); /* EMIT SIGNAL */
 772         }
 773 }
 774
 775 void
 776 Route::set_solo (bool yn, void *src)
 777 {
 778         if (_solo_safe) {
 779                 return;
 780         }
 781
 782         if (_mix_group && src != _mix_group && _mix_group->is_active()) {
 783                 _mix_group->apply (&Route::set_solo, yn, _mix_group);
 784                 return;
 785         }
 786
 787         if (_soloed != yn) {
 788                 _soloed = yn;
 789                 solo_changed (src); /* EMIT SIGNAL */
 790                 _solo_control.Changed (); /* EMIT SIGNAL */
 791         }
 792 }
 793
 794 void
 795 Route::set_solo_mute (bool yn)
 796 {
 797         Glib::Mutex::Lock lm (declick_lock);
 798
 799         /* Called by Session in response to another Route being soloed.
 800          */
 801
 802         desired_solo_gain = (yn?0.0:1.0);
 803 }
 804
 805 void
 806 Route::set_solo_safe (bool yn, void *src)
 807 {
 808         if (_solo_safe != yn) {
 809                 _solo_safe = yn;
 810                  solo_safe_changed (src); /* EMIT SIGNAL */
 811         }
 812 }
 813
 814 void
 815 Route::set_mute (bool yn, void *src)
 816
 817 {
 818         if (_mix_group && src != _mix_group && _mix_group->is_active()) {
 819                 _mix_group->apply (&Route::set_mute, yn, _mix_group);
 820                 return;
 821         }
 822
 823         if (_muted != yn) {
 824                 _muted = yn;
 825                 mute_changed (src); /* EMIT SIGNAL */
 826
 827                 _mute_control.Changed (); /* EMIT SIGNAL */
 828
 829                 Glib::Mutex::Lock lm (declick_lock);
 830                 desired_mute_gain = (yn?0.0f:1.0f);
 831         }
 832 }
 833
 834 int
 835 Route::add_redirect (boost::shared_ptr<Redirect> redirect, void *src, uint32_t* err_streams)
 836 {
 837         uint32_t old_rmo = redirect_max_outs;
 838
 839         if (!_session.engine().connected()) {
 840                 return 1;
 841         }
 842
 843         {
 844                 Glib::RWLock::WriterLock lm (redirect_lock);
 845
 846                 boost::shared_ptr<PluginInsert> pi;
 847                 boost::shared_ptr<PortInsert> porti;
 848
 849                 uint32_t potential_max_streams = 0;
 850
 851                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(redirect)) != 0) {
 852                         pi->set_count (1);
 853
 854                         if (pi->input_streams() == 0) {
 855                                 /* instrument plugin */
 856                                 _have_internal_generator = true;
 857                         }
 858
 859                         potential_max_streams = max(pi->input_streams(), pi->output_streams());
 860
 861                 } else if ((porti = boost::dynamic_pointer_cast<PortInsert>(redirect)) != 0) {
 862
 863                         /* force new port inserts to start out with an i/o configuration
 864                            that matches this route's i/o configuration.
 865
 866                            the "inputs" for the port are supposed to match the output
 867                            of this route.
 868
 869                            the "outputs" of the route should match the inputs of this
 870                            route. XXX shouldn't they match the number of active signal
 871                            streams at the point of insertion?
 872
 873                         */
 874
 875                         porti->ensure_io (n_outputs (), n_inputs(), false, this);
 876                 }
 877
 878                 // Ensure peak vector sizes before the plugin is activated
 879                 while (_peak_power.size() < potential_max_streams) {
 880                         _peak_power.push_back(0);
 881                 }
 882                 while (_visible_peak_power.size() < potential_max_streams) {
 883                         _visible_peak_power.push_back(-INFINITY);
 884                 }
 885                 while (_max_peak_power.size() < potential_max_streams) {
 886                         _max_peak_power.push_back(-INFINITY);
 887                 }
 888
 889                 _redirects.push_back (redirect);
 890
 891                 if (_reset_plugin_counts (err_streams)) {
 892                         _redirects.pop_back ();
 893                         _reset_plugin_counts (0); // it worked before we tried to add it ...
 894                         return -1;
 895                 }
 896
 897                 redirect->activate ();
 898                 redirect->active_changed.connect (mem_fun (*this, &Route::redirect_active_proxy));
 899         }
 900
 901         if (redirect_max_outs != old_rmo || old_rmo == 0) {
 902                 reset_panner ();
 903         }
 904
 905
 906         redirects_changed (src); /* EMIT SIGNAL */
 907         return 0;
 908 }
 909
 910 int
 911 Route::add_redirects (const RedirectList& others, void *src, uint32_t* err_streams)
 912 {
 913         uint32_t old_rmo = redirect_max_outs;
 914
 915         assert (ports_legal);
 916
 917         if (!_session.engine().connected()) {
 918                 return 1;
 919         }
 920
 921         {
 922                 Glib::RWLock::WriterLock lm (redirect_lock);
 923
 924                 RedirectList::iterator existing_end = _redirects.end();
 925                 --existing_end;
 926
 927                 uint32_t potential_max_streams = 0;
 928
 929                 for (RedirectList::const_iterator i = others.begin(); i != others.end(); ++i) {
 930
 931                         boost::shared_ptr<PluginInsert> pi;
 932
 933                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
 934                                 pi->set_count (1);
 935
 936                                 uint32_t m = max(pi->input_streams(), pi->output_streams());
 937                                 if (m > potential_max_streams)
 938                                         potential_max_streams = m;
 939                         }
 940
 941                         // Ensure peak vector sizes before the plugin is activated
 942                         while (_peak_power.size() < potential_max_streams) {
 943                                 _peak_power.push_back(0);
 944                         }
 945                         while (_visible_peak_power.size() < potential_max_streams) {
 946                                 _visible_peak_power.push_back(-INFINITY);
 947                         }
 948                         while (_max_peak_power.size() < potential_max_streams) {
 949                                 _max_peak_power.push_back(-INFINITY);
 950                         }
 951
 952                         _redirects.push_back (*i);
 953
 954                         if (_reset_plugin_counts (err_streams)) {
 955                                 ++existing_end;
 956                                 _redirects.erase (existing_end, _redirects.end());
 957                                 _reset_plugin_counts (0); // it worked before we tried to add it ...
 958                                 return -1;
 959                         }
 960
 961                         (*i)->activate ();
 962                         (*i)->active_changed.connect (mem_fun (*this, &Route::redirect_active_proxy));
 963                 }
 964         }
 965
 966         if (redirect_max_outs != old_rmo || old_rmo == 0) {
 967                 reset_panner ();
 968         }
 969
 970         redirects_changed (src); /* EMIT SIGNAL */
 971         return 0;
 972 }
 973
 974 /** Remove redirects with a given placement.
 975  * @param p Placement of redirects to remove.
 976  */
 977 void
 978 Route::clear_redirects (Placement p, void *src)
 979 {
 980         const uint32_t old_rmo = redirect_max_outs;
 981
 982         if (!_session.engine().connected()) {
 983                 return;
 984         }
 985
 986         {
 987                 Glib::RWLock::WriterLock lm (redirect_lock);
 988                 RedirectList new_list;
 989
 990                 for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
 991                         if ((*i)->placement() == p) {
 992                                 /* it's the placement we want to get rid of */
 993                                 (*i)->drop_references ();
 994                         } else {
 995                                 /* it's a different placement, so keep it */
 996                                 new_list.push_back (*i);
 997                         }
 998                 }
 999
1000                 _redirects = new_list;
1001         }
1002
1003         /* FIXME: can't see how this test can ever fire */
1004         if (redirect_max_outs != old_rmo) {
1005                 reset_panner ();
1006         }
1007
1008         redirect_max_outs = 0;
1009         _have_internal_generator = false;
1010         redirects_changed (src); /* EMIT SIGNAL */
1011 }
1012
1013 int
1014 Route::remove_redirect (boost::shared_ptr<Redirect> redirect, void *src, uint32_t* err_streams)
1015 {
1016         uint32_t old_rmo = redirect_max_outs;
1017
1018         assert (ports_legal);
1019
1020         if (!_session.engine().connected()) {
1021                 return 1;
1022         }
1023
1024         redirect_max_outs = 0;
1025
1026         {
1027                 Glib::RWLock::WriterLock lm (redirect_lock);
1028                 RedirectList::iterator i;
1029                 bool removed = false;
1030
1031                 for (i = _redirects.begin(); i != _redirects.end(); ++i) {
1032                         if (*i == redirect) {
1033
1034                                 RedirectList::iterator tmp;
1035
1036                                 /* move along, see failure case for reset_plugin_counts()
1037                                    where we may need to reinsert the redirect.
1038                                 */
1039
1040                                 tmp = i;
1041                                 ++tmp;
1042
1043                                 /* stop redirects that send signals to JACK ports
1044                                    from causing noise as a result of no longer being
1045                                    run.
1046                                 */
1047
1048                                 boost::shared_ptr<Send> send;
1049                                 boost::shared_ptr<PortInsert> port_insert;
1050
1051                                 if ((send = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
1052                                         send->disconnect_inputs (this);
1053                                         send->disconnect_outputs (this);
1054                                 } else if ((port_insert = boost::dynamic_pointer_cast<PortInsert> (*i)) != 0) {
1055                                         port_insert->disconnect_inputs (this);
1056                                         port_insert->disconnect_outputs (this);
1057                                 }
1058
1059                                 _redirects.erase (i);
1060
1061                                 i = tmp;
1062                                 removed = true;
1063                                 break;
1064                         }
1065                 }
1066
1067                 if (!removed) {
1068                         /* what? */
1069                         return 1;
1070                 }
1071
1072                 if (_reset_plugin_counts (err_streams)) {
1073                         /* get back to where we where */
1074                         _redirects.insert (i, redirect);
1075                         /* we know this will work, because it worked before :) */
1076                         _reset_plugin_counts (0);
1077                         return -1;
1078                 }
1079
1080                 bool foo = false;
1081
1082                 for (i = _redirects.begin(); i != _redirects.end(); ++i) {
1083                         boost::shared_ptr<PluginInsert> pi;
1084
1085                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1086                                 if (pi->is_generator()) {
1087                                         foo = true;
1088                                 }
1089                         }
1090                 }
1091
1092                 _have_internal_generator = foo;
1093         }
1094
1095         if (old_rmo != redirect_max_outs) {
1096                 reset_panner ();
1097         }
1098
1099         redirect->drop_references ();
1100
1101         redirects_changed (src); /* EMIT SIGNAL */
1102         return 0;
1103 }
1104
1105 int
1106 Route::reset_plugin_counts (uint32_t* lpc)
1107 {
1108         Glib::RWLock::WriterLock lm (redirect_lock);
1109         return _reset_plugin_counts (lpc);
1110 }
1111
1112
1113 int
1114 Route::_reset_plugin_counts (uint32_t* err_streams)
1115 {
1116         RedirectList::iterator r;
1117         uint32_t i_cnt;
1118         uint32_t s_cnt;
1119         map<Placement,list<InsertCount> > insert_map;
1120         nframes_t initial_streams;
1121
1122         redirect_max_outs = 0;
1123         i_cnt = 0;
1124         s_cnt = 0;
1125
1126         /* divide inserts up by placement so we get the signal flow
1127            properly modelled. we need to do this because the _redirects
1128            list is not sorted by placement, and because other reasons may
1129            exist now or in the future for this separate treatment.
1130         */
1131
1132         for (r = _redirects.begin(); r != _redirects.end(); ++r) {
1133
1134                 boost::shared_ptr<Insert> insert;
1135
1136                 /* do this here in case we bomb out before we get to the end of
1137                    this function.
1138                 */
1139
1140                 redirect_max_outs = max ((*r)->output_streams (), redirect_max_outs);
1141
1142                 if ((insert = boost::dynamic_pointer_cast<Insert>(*r)) != 0) {
1143                         ++i_cnt;
1144                         insert_map[insert->placement()].push_back (InsertCount (insert));
1145
1146                         /* reset plugin counts back to one for now so
1147                            that we have a predictable, controlled
1148                            state to try to configure.
1149                         */
1150
1151                         boost::shared_ptr<PluginInsert> pi;
1152
1153                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(insert)) != 0) {
1154                                 pi->set_count (1);
1155                         }
1156
1157                 } else if (boost::dynamic_pointer_cast<Send> (*r) != 0) {
1158                         ++s_cnt;
1159                 }
1160         }
1161
1162         if (i_cnt == 0) {
1163                 if (s_cnt) {
1164                         goto recompute;
1165                 } else {
1166                         return 0;
1167                 }
1168         }
1169
1170         /* Now process each placement in order, checking to see if we
1171            can really do what has been requested.
1172         */
1173
1174         /* A: PreFader */
1175
1176         if (check_some_plugin_counts (insert_map[PreFader], n_inputs (), err_streams)) {
1177                 return -1;
1178         }
1179
1180         /* figure out the streams that will feed into PreFader */
1181
1182         if (!insert_map[PreFader].empty()) {
1183                 InsertCount& ic (insert_map[PreFader].back());
1184                 initial_streams = ic.insert->compute_output_streams (ic.cnt);
1185         } else {
1186                 initial_streams = n_inputs ();
1187         }
1188
1189         /* B: PostFader */
1190
1191         if (check_some_plugin_counts (insert_map[PostFader], initial_streams, err_streams)) {
1192                 return -1;
1193         }
1194
1195         /* OK, everything can be set up correctly, so lets do it */
1196
1197         apply_some_plugin_counts (insert_map[PreFader]);
1198         apply_some_plugin_counts (insert_map[PostFader]);
1199
1200         /* recompute max outs of any redirect */
1201
1202   recompute:
1203
1204         redirect_max_outs = 0;
1205         RedirectList::iterator prev = _redirects.end();
1206
1207         for (r = _redirects.begin(); r != _redirects.end(); prev = r, ++r) {
1208                 boost::shared_ptr<Send> s;
1209
1210                 if ((s = boost::dynamic_pointer_cast<Send> (*r)) != 0) {
1211                         if (r == _redirects.begin()) {
1212                                 s->expect_inputs (n_inputs());
1213                         } else {
1214                                 s->expect_inputs ((*prev)->output_streams());
1215                         }
1216
1217                 } else {
1218
1219                         /* don't pay any attention to send output configuration, since it doesn't
1220                            affect the route.
1221                          */
1222
1223                         redirect_max_outs = max ((*r)->output_streams (), redirect_max_outs);
1224
1225                 }
1226         }
1227
1228         /* we're done */
1229
1230         return 0;
1231 }
1232
1233 int32_t
1234 Route::apply_some_plugin_counts (list<InsertCount>& iclist)
1235 {
1236         list<InsertCount>::iterator i;
1237
1238         for (i = iclist.begin(); i != iclist.end(); ++i) {
1239
1240                 if ((*i).insert->configure_io ((*i).cnt, (*i).in, (*i).out)) {
1241                         return -1;
1242                 }
1243                 /* make sure that however many we have, they are all active */
1244                 (*i).insert->activate ();
1245         }
1246
1247         return 0;
1248 }
1249
1250 int32_t
1251 Route::check_some_plugin_counts (list<InsertCount>& iclist, int32_t required_inputs, uint32_t* err_streams)
1252 {
1253         list<InsertCount>::iterator i;
1254
1255         for (i = iclist.begin(); i != iclist.end(); ++i) {
1256
1257                 if (((*i).cnt = (*i).insert->can_support_input_configuration (required_inputs)) < 0) {
1258                         if (err_streams) {
1259                                 *err_streams = required_inputs;
1260                         }
1261                         return -1;
1262                 }
1263
1264                 (*i).in = required_inputs;
1265
1266                 if (((*i).out = (*i).insert->compute_output_streams ((*i).cnt)) < 0) {
1267                         if (err_streams) {
1268                                 *err_streams = required_inputs;
1269                         }
1270                         return -1;
1271                 }
1272
1273                 required_inputs = (*i).out;
1274         }
1275
1276         return 0;
1277 }
1278
1279 int
1280 Route::copy_redirects (const Route& other, Placement placement, uint32_t* err_streams)
1281 {
1282         uint32_t old_rmo = redirect_max_outs;
1283
1284         if (err_streams) {
1285                 *err_streams = 0;
1286         }
1287
1288         RedirectList to_be_deleted;
1289
1290         {
1291                 Glib::RWLock::WriterLock lm (redirect_lock);
1292                 RedirectList::iterator tmp;
1293                 RedirectList the_copy;
1294
1295                 the_copy = _redirects;
1296
1297                 /* remove all relevant redirects */
1298
1299                 for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ) {
1300                         tmp = i;
1301                         ++tmp;
1302
1303                         if ((*i)->placement() == placement) {
1304                                 to_be_deleted.push_back (*i);
1305                                 _redirects.erase (i);
1306                         }
1307
1308                         i = tmp;
1309                 }
1310
1311                 /* now copy the relevant ones from "other" */
1312
1313                 for (RedirectList::const_iterator i = other._redirects.begin(); i != other._redirects.end(); ++i) {
1314                         if ((*i)->placement() == placement) {
1315                                 _redirects.push_back (Redirect::clone (*i));
1316                         }
1317                 }
1318
1319                 /* reset plugin stream handling */
1320
1321                 if (_reset_plugin_counts (err_streams)) {
1322
1323                         /* FAILED COPY ATTEMPT: we have to restore order */
1324
1325                         /* delete all cloned redirects */
1326
1327                         for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ) {
1328
1329                                 tmp = i;
1330                                 ++tmp;
1331
1332                                 if ((*i)->placement() == placement) {
1333                                         _redirects.erase (i);
1334                                 }
1335
1336                                 i = tmp;
1337                         }
1338
1339                         /* restore the natural order */
1340
1341                         _redirects = the_copy;
1342                         redirect_max_outs = old_rmo;
1343
1344                         /* we failed, even though things are OK again */
1345
1346                         return -1;
1347
1348                 } else {
1349
1350                         /* SUCCESSFUL COPY ATTEMPT: delete the redirects we removed pre-copy */
1351                         to_be_deleted.clear ();
1352                 }
1353         }
1354
1355         if (redirect_max_outs != old_rmo || old_rmo == 0) {
1356                 reset_panner ();
1357         }
1358
1359         redirects_changed (this); /* EMIT SIGNAL */
1360         return 0;
1361 }
1362
1363 void
1364 Route::all_redirects_flip ()
1365 {
1366         Glib::RWLock::ReaderLock lm (redirect_lock);
1367
1368         if (_redirects.empty()) {
1369                 return;
1370         }
1371
1372         bool first_is_on = _redirects.front()->active();
1373
1374         for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
1375                 (*i)->set_active (!first_is_on, this);
1376         }
1377 }
1378
1379 /** Set all redirects with a given placement to a given active state.
1380  * @param p Placement of redirects to change.
1381  * @param state New active state for those redirects.
1382  */
1383 void
1384 Route::all_redirects_active (Placement p, bool state)
1385 {
1386         Glib::RWLock::ReaderLock lm (redirect_lock);
1387
1388         if (_redirects.empty()) {
1389                 return;
1390         }
1391
1392         for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
1393                 if ((*i)->placement() == p) {
1394                         (*i)->set_active (state, this);
1395                 }
1396         }
1397 }
1398
1399 struct RedirectSorter {
1400     bool operator() (boost::shared_ptr<const Redirect> a, boost::shared_ptr<const Redirect> b) {
1401             return a->sort_key() < b->sort_key();
1402     }
1403 };
1404
1405 int
1406 Route::sort_redirects (uint32_t* err_streams)
1407 {
1408         {
1409                 RedirectSorter comparator;
1410                 Glib::RWLock::WriterLock lm (redirect_lock);
1411                 uint32_t old_rmo = redirect_max_outs;
1412
1413                 /* the sweet power of C++ ... */
1414
1415                 RedirectList as_it_was_before = _redirects;
1416
1417                 _redirects.sort (comparator);
1418
1419                 if (_reset_plugin_counts (err_streams)) {
1420                         _redirects = as_it_was_before;
1421                         redirect_max_outs = old_rmo;
1422                         return -1;
1423                 }
1424         }
1425
1426         reset_panner ();
1427         redirects_changed (this); /* EMIT SIGNAL */
1428
1429         return 0;
1430 }
1431
1432 XMLNode&
1433 Route::get_state()
1434 {
1435         return state(true);
1436 }
1437
1438 XMLNode&
1439 Route::get_template()
1440 {
1441         return state(false);
1442 }
1443
1444 XMLNode&
1445 Route::state(bool full_state)
1446 {
1447         XMLNode *node = new XMLNode("Route");
1448         RedirectList:: iterator i;
1449         char buf[32];
1450
1451         if (_flags) {
1452                 node->add_property("flags", enum_2_string (_flags));
1453         }
1454
1455         node->add_property("default-type", _default_type.to_string());
1456
1457         node->add_property("muted", _muted?"yes":"no");
1458         node->add_property("soloed", _soloed?"yes":"no");
1459         node->add_property("phase-invert", _phase_invert?"yes":"no");
1460         node->add_property("denormal-protection", _denormal_protection?"yes":"no");
1461         node->add_property("mute-affects-pre-fader", _mute_affects_pre_fader?"yes":"no");
1462         node->add_property("mute-affects-post-fader", _mute_affects_post_fader?"yes":"no");
1463         node->add_property("mute-affects-control-outs", _mute_affects_control_outs?"yes":"no");
1464         node->add_property("mute-affects-main-outs", _mute_affects_main_outs?"yes":"no");
1465
1466         if (_edit_group) {
1467                 node->add_property("edit-group", _edit_group->name());
1468         }
1469         if (_mix_group) {
1470                 node->add_property("mix-group", _mix_group->name());
1471         }
1472
1473         string order_string;
1474         OrderKeys::iterator x = order_keys.begin();
1475
1476         while (x != order_keys.end()) {
1477                 order_string += string ((*x).first);
1478                 order_string += '=';
1479                 snprintf (buf, sizeof(buf), "%ld", (*x).second);
1480                 order_string += buf;
1481
1482                 ++x;
1483
1484                 if (x == order_keys.end()) {
1485                         break;
1486                 }
1487
1488                 order_string += ':';
1489         }
1490         node->add_property ("order-keys", order_string);
1491
1492         node->add_child_nocopy (IO::state (full_state));
1493         node->add_child_nocopy (_solo_control.get_state ());
1494         node->add_child_nocopy (_mute_control.get_state ());
1495
1496         XMLNode* remote_control_node = new XMLNode (X_("remote_control"));
1497         snprintf (buf, sizeof (buf), "%d", _remote_control_id);
1498         remote_control_node->add_property (X_("id"), buf);
1499         node->add_child_nocopy (*remote_control_node);
1500
1501         if (_control_outs) {
1502                 XMLNode* cnode = new XMLNode (X_("ControlOuts"));
1503                 cnode->add_child_nocopy (_control_outs->state (full_state));
1504                 node->add_child_nocopy (*cnode);
1505         }
1506
1507         if (_comment.length()) {
1508                 XMLNode *cmt = node->add_child ("Comment");
1509                 cmt->add_content (_comment);
1510         }
1511
1512         for (i = _redirects.begin(); i != _redirects.end(); ++i) {
1513                 node->add_child_nocopy((*i)->state (full_state));
1514         }
1515
1516         if (_extra_xml){
1517                 node->add_child_copy (*_extra_xml);
1518         }
1519
1520         return *node;
1521 }
1522
1523 void
1524 Route::set_deferred_state ()
1525 {
1526         XMLNodeList nlist;
1527         XMLNodeConstIterator niter;
1528
1529         if (!deferred_state) {
1530                 return;
1531         }
1532
1533         nlist = deferred_state->children();
1534
1535         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1536                 add_redirect_from_xml (**niter);
1537         }
1538
1539         delete deferred_state;
1540         deferred_state = 0;
1541 }
1542
1543 void
1544 Route::add_redirect_from_xml (const XMLNode& node)
1545 {
1546         const XMLProperty *prop;
1547
1548         if (node.name() == "Send") {
1549
1550
1551                 try {
1552                         boost::shared_ptr<Send> send (new Send (_session, node));
1553                         add_redirect (send, this);
1554                 }
1555
1556                 catch (failed_constructor &err) {
1557                         error << _("Send construction failed") << endmsg;
1558                         return;
1559                 }
1560
1561         } else if (node.name() == "Insert") {
1562
1563                 try {
1564                         if ((prop = node.property ("type")) != 0) {
1565
1566                                 boost::shared_ptr<Insert> insert;
1567                                 bool have_insert = false;
1568
1569                                 if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
1570                                     prop->value() == "vst" ||
1571                                     prop->value() == "audiounit") {
1572
1573                                         insert.reset (new PluginInsert(_session, node));
1574                                         have_insert = true;
1575
1576                                 } else if (prop->value() == "port") {
1577
1578
1579                                         insert.reset (new PortInsert (_session, node));
1580                                         have_insert = true;
1581
1582                                 } else {
1583
1584                                         error << string_compose(_("unknown Insert type \"%1\"; ignored"), prop->value()) << endmsg;
1585                                 }
1586
1587                                 if (have_insert) {
1588                                         add_redirect (insert, this);
1589                                 }
1590
1591                         } else {
1592                                 error << _("Insert XML node has no type property") << endmsg;
1593                         }
1594                 }
1595
1596                 catch (failed_constructor &err) {
1597                         warning << _("insert could not be created. Ignored.") << endmsg;
1598                         return;
1599                 }
1600         }
1601 }
1602
1603 int
1604 Route::set_state (const XMLNode& node)
1605 {
1606         return _set_state (node, true);
1607 }
1608
1609 int
1610 Route::_set_state (const XMLNode& node, bool call_base)
1611 {
1612         XMLNodeList nlist;
1613         XMLNodeConstIterator niter;
1614         XMLNode *child;
1615         XMLPropertyList plist;
1616         const XMLProperty *prop;
1617
1618         if (node.name() != "Route"){
1619                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1620                 return -1;
1621         }
1622
1623         if ((prop = node.property (X_("flags"))) != 0) {
1624                 _flags = Flag (string_2_enum (prop->value(), _flags));
1625         } else {
1626                 _flags = Flag (0);
1627         }
1628
1629         if ((prop = node.property (X_("default-type"))) != 0) {
1630                 _default_type = DataType(prop->value());
1631                 assert(_default_type != DataType::NIL);
1632         }
1633
1634         if ((prop = node.property (X_("phase-invert"))) != 0) {
1635                 set_phase_invert (prop->value()=="yes"?true:false, this);
1636         }
1637
1638         if ((prop = node.property (X_("denormal-protection"))) != 0) {
1639                 set_denormal_protection (prop->value()=="yes"?true:false, this);
1640         }
1641
1642         if ((prop = node.property (X_("muted"))) != 0) {
1643                 bool yn = prop->value()=="yes"?true:false;
1644
1645                 /* force reset of mute status */
1646
1647                 _muted = !yn;
1648                 set_mute(yn, this);
1649                 mute_gain = desired_mute_gain;
1650         }
1651
1652         if ((prop = node.property (X_("soloed"))) != 0) {
1653                 bool yn = prop->value()=="yes"?true:false;
1654
1655                 /* force reset of solo status */
1656
1657                 _soloed = !yn;
1658                 set_solo (yn, this);
1659                 solo_gain = desired_solo_gain;
1660         }
1661
1662         if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
1663                 _mute_affects_pre_fader = (prop->value()=="yes")?true:false;
1664         }
1665
1666         if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
1667                 _mute_affects_post_fader = (prop->value()=="yes")?true:false;
1668         }
1669
1670         if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
1671                 _mute_affects_control_outs = (prop->value()=="yes")?true:false;
1672         }
1673
1674         if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
1675                 _mute_affects_main_outs = (prop->value()=="yes")?true:false;
1676         }
1677
1678         if ((prop = node.property (X_("edit-group"))) != 0) {
1679                 RouteGroup* edit_group = _session.edit_group_by_name(prop->value());
1680                 if(edit_group == 0) {
1681                         error << string_compose(_("Route %1: unknown edit group \"%2 in saved state (ignored)"), _name, prop->value()) << endmsg;
1682                 } else {
1683                         set_edit_group(edit_group, this);
1684                 }
1685         }
1686
1687         if ((prop = node.property (X_("order-keys"))) != 0) {
1688
1689                 long n;
1690
1691                 string::size_type colon, equal;
1692                 string remaining = prop->value();
1693
1694                 while (remaining.length()) {
1695
1696                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
1697                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1698                                       << endmsg;
1699                         } else {
1700                                 if (sscanf (remaining.substr (equal+1).c_str(), "%ld", &n) != 1) {
1701                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1702                                               << endmsg;
1703                                 } else {
1704                                         set_order_key (remaining.substr (0, equal).c_str(), n);
1705                                 }
1706                         }
1707
1708                         colon = remaining.find_first_of (':');
1709
1710                         if (colon != string::npos) {
1711                                 remaining = remaining.substr (colon+1);
1712                         } else {
1713                                 break;
1714                         }
1715                 }
1716         }
1717
1718         nlist = node.children();
1719
1720         if (deferred_state) {
1721                 delete deferred_state;
1722         }
1723
1724         deferred_state = new XMLNode(X_("deferred state"));
1725
1726         /* set parent class properties before anything else */
1727
1728         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1729
1730                 child = *niter;
1731
1732                 if (child->name() == IO::state_node_name && call_base) {
1733
1734                         IO::set_state (*child);
1735                         break;
1736                 }
1737         }
1738
1739
1740         XMLNodeList redirect_nodes;
1741
1742         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1743
1744                 child = *niter;
1745
1746                 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
1747                         redirect_nodes.push_back(child);
1748                 }
1749
1750         }
1751
1752         _set_redirect_states (redirect_nodes);
1753
1754         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1755                 child = *niter;
1756                 // All redirects (sends and inserts) have been applied already
1757
1758                 if (child->name() == X_("Automation")) {
1759
1760                         if ((prop = child->property (X_("path"))) != 0)  {
1761                                 load_automation (prop->value());
1762                         }
1763
1764                 } else if (child->name() == X_("ControlOuts")) {
1765
1766                         string coutname = _name;
1767                         coutname += _("[control]");
1768
1769                         _control_outs = new IO (_session, coutname);
1770                         _control_outs->set_state (**(child->children().begin()));
1771
1772                 } else if (child->name() == X_("Comment")) {
1773
1774                         /* XXX this is a terrible API design in libxml++ */
1775
1776                         XMLNode *cmt = *(child->children().begin());
1777                         _comment = cmt->content();
1778
1779                 } else if (child->name() == X_("extra")) {
1780
1781                         _extra_xml = new XMLNode (*child);
1782
1783                 } else if (child->name() == X_("controllable") && (prop = child->property("name")) != 0) {
1784
1785                         if (prop->value() == "solo") {
1786                                 _solo_control.set_state (*child);
1787                                 _session.add_controllable (&_solo_control);
1788                         }
1789                         else if (prop->value() == "mute") {
1790                                 _mute_control.set_state (*child);
1791                                 _session.add_controllable (&_mute_control);
1792                         }
1793                 }
1794                 else if (child->name() == X_("remote_control")) {
1795                         if ((prop = child->property (X_("id"))) != 0) {
1796                                 int32_t x;
1797                                 sscanf (prop->value().c_str(), "%d", &x);
1798                                 set_remote_control_id (x);
1799                         }
1800                 }
1801         }
1802
1803         if ((prop = node.property (X_("mix-group"))) != 0) {
1804                 RouteGroup* mix_group = _session.mix_group_by_name(prop->value());
1805                 if (mix_group == 0) {
1806                         error << string_compose(_("Route %1: unknown mix group \"%2 in saved state (ignored)"), _name, prop->value()) << endmsg;
1807                 }  else {
1808                         set_mix_group(mix_group, this);
1809                 }
1810         }
1811
1812         return 0;
1813 }
1814
1815 void
1816 Route::_set_redirect_states(const XMLNodeList &nlist)
1817 {
1818         XMLNodeConstIterator niter;
1819         char buf[64];
1820
1821         RedirectList::iterator i, o;
1822
1823         if (!ports_legal) {
1824
1825                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1826                         deferred_state->add_child_copy (**niter);
1827                 }
1828
1829                 return;
1830         }
1831
1832         // Iterate through existing redirects, remove those which are not in the state list
1833         for (i = _redirects.begin(); i != _redirects.end(); ) {
1834                 RedirectList::iterator tmp = i;
1835                 ++tmp;
1836
1837                 bool redirectInStateList = false;
1838
1839                 (*i)->id().print (buf, sizeof (buf));
1840
1841                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1842
1843                         if (strncmp (buf,(*niter)->child(X_("Redirect"))->child(X_("IO"))->property(X_("id"))->value().c_str(), sizeof(buf)) == 0) {
1844                                 redirectInStateList = true;
1845                                 break;
1846                         }
1847                 }
1848
1849                 if (!redirectInStateList) {
1850                         remove_redirect ( *i, this);
1851                 }
1852
1853
1854                 i = tmp;
1855         }
1856
1857
1858         // Iterate through state list and make sure all redirects are on the track and in the correct order,
1859         // set the state of existing redirects according to the new state on the same go
1860         i = _redirects.begin();
1861         for (niter = nlist.begin(); niter != nlist.end(); ++niter, ++i) {
1862
1863                 // Check whether the next redirect in the list
1864                 o = i;
1865
1866                 while (o != _redirects.end()) {
1867                         (*o)->id().print (buf, sizeof (buf));
1868                         if ( strncmp(buf, (*niter)->child(X_("Redirect"))->child(X_("IO"))->property(X_("id"))->value().c_str(), sizeof(buf)) == 0)
1869                                 break;
1870                         ++o;
1871                 }
1872
1873                 if (o == _redirects.end()) {
1874                         // If the redirect (*niter) is not on the route, we need to create it
1875                         // and move it to the correct location
1876
1877                         RedirectList::iterator prev_last = _redirects.end();
1878                         --prev_last; // We need this to check whether adding succeeded
1879
1880                         add_redirect_from_xml (**niter);
1881
1882                         RedirectList::iterator last = _redirects.end();
1883                         --last;
1884
1885                         if (prev_last == last) {
1886                                 warning << _name << ": could not fully restore state as some redirects were not possible to create" << endmsg;
1887                                 continue;
1888
1889                         }
1890
1891                         boost::shared_ptr<Redirect> tmp = (*last);
1892                         // remove the redirect from the wrong location
1893                         _redirects.erase(last);
1894                         // insert the new redirect at the current location
1895                         _redirects.insert(i, tmp);
1896
1897                         --i; // move pointer to the newly inserted redirect
1898                         continue;
1899                 }
1900
1901                 // We found the redirect (*niter) on the route, first we must make sure the redirect
1902                 // is at the location provided in the XML state
1903                 if (i != o) {
1904                         boost::shared_ptr<Redirect> tmp = (*o);
1905                         // remove the old copy
1906                         _redirects.erase(o);
1907                         // insert the redirect at the correct location
1908                         _redirects.insert(i, tmp);
1909
1910                         --i; // move pointer so it points to the right redirect
1911                 }
1912
1913                 (*i)->set_state( (**niter) );
1914         }
1915
1916         redirects_changed(this);
1917 }
1918
1919 void
1920 Route::curve_reallocate ()
1921 {
1922 //      _gain_automation_curve.finish_resize ();
1923 //      _pan_automation_curve.finish_resize ();
1924 }
1925
1926 void
1927 Route::silence (nframes_t nframes, nframes_t offset)
1928 {
1929         if (!_silent) {
1930
1931                 // reset_peak_meters ();
1932
1933                 IO::silence (nframes, offset);
1934
1935                 if (_control_outs) {
1936                         _control_outs->silence (nframes, offset);
1937                 }
1938
1939                 {
1940                         Glib::RWLock::ReaderLock lm (redirect_lock, Glib::TRY_LOCK);
1941
1942                         if (lm.locked()) {
1943                                 for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
1944                                         boost::shared_ptr<PluginInsert> pi;
1945                                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
1946                                                 // skip plugins, they don't need anything when we're not active
1947                                                 continue;
1948                                         }
1949
1950                                         (*i)->silence (nframes, offset);
1951                                 }
1952
1953                                 if (nframes == _session.get_block_size() && offset == 0) {
1954                                         // _silent = true;
1955                                 }
1956                         }
1957                 }
1958
1959         }
1960 }
1961
1962 int
1963 Route::set_control_outs (const vector<string>& ports)
1964 {
1965         Glib::Mutex::Lock lm (control_outs_lock);
1966         vector<string>::const_iterator i;
1967         uint32_t limit;
1968
1969         if (_control_outs) {
1970                 delete _control_outs;
1971                 _control_outs = 0;
1972         }
1973
1974         if (control() || master()) {
1975                 /* no control outs for these two special busses */
1976                 return 0;
1977         }
1978
1979         if (ports.empty()) {
1980                 return 0;
1981         }
1982
1983         string coutname = _name;
1984         coutname += _("[control]");
1985
1986         _control_outs = new IO (_session, coutname);
1987
1988         /* our control outs need as many outputs as we
1989            have outputs. we track the changes in ::output_change_handler().
1990         */
1991
1992         limit = n_outputs ();
1993
1994         if (_control_outs->ensure_io (0, limit, true, this)) {
1995                 return -1;
1996         }
1997
1998         /* now connect to the named ports */
1999
2000         for (uint32_t n = 0; n < limit; ++n) {
2001                 if (_control_outs->connect_output (_control_outs->output (n), ports[n % ports.size()], this)) {
2002                         error << string_compose (_("could not connect %1 to %2"), _control_outs->output(n)->name(), ports[n]) << endmsg;
2003                         return -1;
2004                 }
2005         }
2006
2007         return 0;
2008 }
2009
2010 void
2011 Route::set_edit_group (RouteGroup *eg, void *src)
2012
2013 {
2014         if (eg == _edit_group) {
2015                 return;
2016         }
2017
2018         if (_edit_group) {
2019                 _edit_group->remove (this);
2020         }
2021
2022         if ((_edit_group = eg) != 0) {
2023                 _edit_group->add (this);
2024         }
2025
2026         _session.set_dirty ();
2027         edit_group_changed (src); /* EMIT SIGNAL */
2028 }
2029
2030 void
2031 Route::drop_edit_group (void *src)
2032 {
2033         _edit_group = 0;
2034         _session.set_dirty ();
2035         edit_group_changed (src); /* EMIT SIGNAL */
2036 }
2037
2038 void
2039 Route::set_mix_group (RouteGroup *mg, void *src)
2040
2041 {
2042         if (mg == _mix_group) {
2043                 return;
2044         }
2045
2046         if (_mix_group) {
2047                 _mix_group->remove (this);
2048         }
2049
2050         if ((_mix_group = mg) != 0) {
2051                 _mix_group->add (this);
2052         }
2053
2054         _session.set_dirty ();
2055         mix_group_changed (src); /* EMIT SIGNAL */
2056 }
2057
2058 void
2059 Route::drop_mix_group (void *src)
2060 {
2061         _mix_group = 0;
2062         _session.set_dirty ();
2063         mix_group_changed (src); /* EMIT SIGNAL */
2064 }
2065
2066 void
2067 Route::set_comment (string cmt, void *src)
2068 {
2069         _comment = cmt;
2070         comment_changed (src);
2071         _session.set_dirty ();
2072 }
2073
2074 bool
2075 Route::feeds (boost::shared_ptr<Route> other)
2076 {
2077         uint32_t i, j;
2078
2079         IO& self = *this;
2080         uint32_t no = self.n_outputs();
2081         uint32_t ni = other->n_inputs ();
2082
2083         for (i = 0; i < no; ++i) {
2084                 for (j = 0; j < ni; ++j) {
2085                         if (self.output(i)->connected_to (other->input(j)->name())) {
2086                                 return true;
2087                         }
2088                 }
2089         }
2090
2091         /* check Redirects which may also interconnect Routes */
2092
2093         for (RedirectList::iterator r = _redirects.begin(); r != _redirects.end(); r++) {
2094
2095                 no = (*r)->n_outputs();
2096
2097                 for (i = 0; i < no; ++i) {
2098                         for (j = 0; j < ni; ++j) {
2099                                 if ((*r)->output(i)->connected_to (other->input (j)->name())) {
2100                                         return true;
2101                                 }
2102                         }
2103                 }
2104         }
2105
2106         /* check for control room outputs which may also interconnect Routes */
2107
2108         if (_control_outs) {
2109
2110                 no = _control_outs->n_outputs();
2111
2112                 for (i = 0; i < no; ++i) {
2113                         for (j = 0; j < ni; ++j) {
2114                                 if (_control_outs->output(i)->connected_to (other->input (j)->name())) {
2115                                         return true;
2116                                 }
2117                         }
2118                 }
2119         }
2120
2121         return false;
2122 }
2123
2124 void
2125 Route::set_mute_config (mute_type t, bool onoff, void *src)
2126 {
2127         switch (t) {
2128         case PRE_FADER:
2129                 _mute_affects_pre_fader = onoff;
2130                  pre_fader_changed(src); /* EMIT SIGNAL */
2131                 break;
2132
2133         case POST_FADER:
2134                 _mute_affects_post_fader = onoff;
2135                  post_fader_changed(src); /* EMIT SIGNAL */
2136                 break;
2137
2138         case CONTROL_OUTS:
2139                 _mute_affects_control_outs = onoff;
2140                  control_outs_changed(src); /* EMIT SIGNAL */
2141                 break;
2142
2143         case MAIN_OUTS:
2144                 _mute_affects_main_outs = onoff;
2145                  main_outs_changed(src); /* EMIT SIGNAL */
2146                 break;
2147         }
2148 }
2149
2150 bool
2151 Route::get_mute_config (mute_type t)
2152 {
2153         bool onoff = false;
2154
2155         switch (t){
2156         case PRE_FADER:
2157                 onoff = _mute_affects_pre_fader;
2158                 break;
2159         case POST_FADER:
2160                 onoff = _mute_affects_post_fader;
2161                 break;
2162         case CONTROL_OUTS:
2163                 onoff = _mute_affects_control_outs;
2164                 break;
2165         case MAIN_OUTS:
2166                 onoff = _mute_affects_main_outs;
2167                 break;
2168         }
2169
2170         return onoff;
2171 }
2172
2173 void
2174 Route::handle_transport_stopped (bool abort_ignored, bool did_locate, bool can_flush_redirects)
2175 {
2176         nframes_t now = _session.transport_frame();
2177
2178         {
2179                 Glib::RWLock::ReaderLock lm (redirect_lock);
2180
2181                 if (!did_locate) {
2182                         automation_snapshot (now);
2183                 }
2184
2185                 for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
2186
2187                         if (Config->get_plugins_stop_with_transport() && can_flush_redirects) {
2188                                 (*i)->deactivate ();
2189                                 (*i)->activate ();
2190                         }
2191
2192                         (*i)->transport_stopped (now);
2193                 }
2194         }
2195
2196         IO::transport_stopped (now);
2197
2198         _roll_delay = _initial_delay;
2199 }
2200
2201 void
2202 Route::input_change_handler (IOChange change, void *ignored)
2203 {
2204         if (change & ConfigurationChanged) {
2205                 reset_plugin_counts (0);
2206         }
2207 }
2208
2209 void
2210 Route::output_change_handler (IOChange change, void *ignored)
2211 {
2212         if (change & ConfigurationChanged) {
2213                 if (_control_outs) {
2214                         _control_outs->ensure_io (0, n_outputs(), true, this);
2215                 }
2216
2217                 reset_plugin_counts (0);
2218         }
2219 }
2220
2221 uint32_t
2222 Route::pans_required () const
2223 {
2224         if (n_outputs() < 2) {
2225                 return 0;
2226         }
2227
2228         return max (n_inputs (), redirect_max_outs);
2229 }
2230
2231 int
2232 Route::no_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset,
2233                    bool session_state_changing, bool can_record, bool rec_monitors_input)
2234 {
2235         if (n_outputs() == 0) {
2236                 return 0;
2237         }
2238
2239         if (session_state_changing || !_active)  {
2240                 silence (nframes, offset);
2241                 return 0;
2242         }
2243
2244         apply_gain_automation = false;
2245
2246         if (n_inputs()) {
2247                 passthru (start_frame, end_frame, nframes, offset, 0, false);
2248         } else {
2249                 silence (nframes, offset);
2250         }
2251
2252         return 0;
2253 }
2254
2255 nframes_t
2256 Route::check_initial_delay (nframes_t nframes, nframes_t& offset, nframes_t& transport_frame)
2257 {
2258         if (_roll_delay > nframes) {
2259
2260                 _roll_delay -= nframes;
2261                 silence (nframes, offset);
2262                 /* transport frame is not legal for caller to use */
2263                 return 0;
2264
2265         } else if (_roll_delay > 0) {
2266
2267                 nframes -= _roll_delay;
2268
2269                 silence (_roll_delay, offset);
2270
2271                 offset += _roll_delay;
2272                 transport_frame += _roll_delay;
2273
2274                 _roll_delay = 0;
2275         }
2276
2277         return nframes;
2278 }
2279
2280 int
2281 Route::roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset, int declick,
2282              bool can_record, bool rec_monitors_input)
2283 {
2284         {
2285                 Glib::RWLock::ReaderLock lm (redirect_lock, Glib::TRY_LOCK);
2286                 if (lm.locked()) {
2287                         // automation snapshot can also be called from the non-rt context
2288                         // and it uses the redirect list, so we take the lock out here
2289                         automation_snapshot (_session.transport_frame());
2290                 }
2291         }
2292
2293         if ((n_outputs() == 0 && _redirects.empty()) || n_inputs() == 0 || !_active) {
2294                 silence (nframes, offset);
2295                 return 0;
2296         }
2297
2298         nframes_t unused = 0;
2299
2300         if ((nframes = check_initial_delay (nframes, offset, unused)) == 0) {
2301                 return 0;
2302         }
2303
2304         _silent = false;
2305
2306         apply_gain_automation = false;
2307
2308         {
2309                 Glib::Mutex::Lock am (automation_lock, Glib::TRY_LOCK);
2310
2311                 if (am.locked() && _session.transport_rolling()) {
2312
2313                         nframes_t start_frame = end_frame - nframes;
2314
2315                         if (gain_automation_playback()) {
2316                                 apply_gain_automation = _gain_automation_curve.rt_safe_get_vector (start_frame, end_frame, _session.gain_automation_buffer(), nframes);
2317                         }
2318                 }
2319         }
2320
2321         passthru (start_frame, end_frame, nframes, offset, declick, false);
2322
2323         return 0;
2324 }
2325
2326 int
2327 Route::silent_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset,
2328                     bool can_record, bool rec_monitors_input)
2329 {
2330         silence (nframes, offset);
2331         return 0;
2332 }
2333
2334 void
2335 Route::toggle_monitor_input ()
2336 {
2337         for (vector<Port*>::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
2338                 (*i)->ensure_monitor_input(!(*i)->monitoring_input());
2339         }
2340 }
2341
2342 bool
2343 Route::has_external_redirects () const
2344 {
2345         boost::shared_ptr<const PortInsert> pi;
2346
2347         for (RedirectList::const_iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
2348                 if ((pi = boost::dynamic_pointer_cast<const PortInsert>(*i)) != 0) {
2349
2350                         uint32_t no = pi->n_outputs();
2351
2352                         for (uint32_t n = 0; n < no; ++n) {
2353
2354                                 string port_name = pi->output(n)->name();
2355                                 string client_name = port_name.substr (0, port_name.find(':'));
2356
2357                                 /* only say "yes" if the redirect is actually in use */
2358
2359                                 if (client_name != "ardour" && pi->active()) {
2360                                         return true;
2361                                 }
2362                         }
2363                 }
2364         }
2365
2366         return false;
2367 }
2368
2369 void
2370 Route::flush_redirects ()
2371 {
2372         /* XXX shouldn't really try to take this lock, since
2373            this is called from the RT audio thread.
2374         */
2375
2376         Glib::RWLock::ReaderLock lm (redirect_lock);
2377
2378         for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
2379                 (*i)->deactivate ();
2380                 (*i)->activate ();
2381         }
2382 }
2383
2384 void
2385 Route::set_meter_point (MeterPoint p, void *src)
2386 {
2387         if (_meter_point != p) {
2388                 _meter_point = p;
2389                  meter_change (src); /* EMIT SIGNAL */
2390                 _session.set_dirty ();
2391         }
2392 }
2393
2394 nframes_t
2395 Route::update_total_latency ()
2396 {
2397         _own_latency = 0;
2398
2399         for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
2400                 if ((*i)->active ()) {
2401                         _own_latency += (*i)->latency ();
2402                 }
2403         }
2404
2405         set_port_latency (_own_latency);
2406
2407         /* this (virtual) function is used for pure Routes,
2408            not derived classes like AudioTrack.  this means
2409            that the data processed here comes from an input
2410            port, not prerecorded material, and therefore we
2411            have to take into account any input latency.
2412         */
2413
2414         _own_latency += input_latency ();
2415
2416         return _own_latency;
2417 }
2418
2419 void
2420 Route::set_latency_delay (nframes_t longest_session_latency)
2421 {
2422         _initial_delay = longest_session_latency - _own_latency;
2423
2424         if (_session.transport_stopped()) {
2425                 _roll_delay = _initial_delay;
2426         }
2427 }
2428
2429 void
2430 Route::automation_snapshot (nframes_t now)
2431 {
2432         IO::automation_snapshot (now);
2433
2434         for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
2435                 (*i)->automation_snapshot (now);
2436         }
2437 }
2438
2439 Route::ToggleControllable::ToggleControllable (std::string name, Route& s, ToggleType tp)
2440         : Controllable (name), route (s), type(tp)
2441 {
2442
2443 }
2444
2445 void
2446 Route::ToggleControllable::set_value (float val)
2447 {
2448         bool bval = ((val >= 0.5f) ? true: false);
2449
2450         switch (type) {
2451         case MuteControl:
2452                 route.set_mute (bval, this);
2453                 break;
2454         case SoloControl:
2455                 route.set_solo (bval, this);
2456                 break;
2457         default:
2458                 break;
2459         }
2460 }
2461
2462 float
2463 Route::ToggleControllable::get_value (void) const
2464 {
2465         float val = 0.0f;
2466
2467         switch (type) {
2468         case MuteControl:
2469                 val = route.muted() ? 1.0f : 0.0f;
2470                 break;
2471         case SoloControl:
2472                 val = route.soloed() ? 1.0f : 0.0f;
2473                 break;
2474         default:
2475                 break;
2476         }
2477
2478         return val;
2479 }
2480
2481 void
2482 Route::set_block_size (nframes_t nframes)
2483 {
2484         for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
2485                 (*i)->set_block_size (nframes);
2486         }
2487 }
2488
2489 void
2490 Route::redirect_active_proxy (Redirect* ignored, void* ignored_src)
2491 {
2492         _session.update_latency_compensation (false, false);
2493 }
2494
2495 void
2496 Route::protect_automation ()
2497 {
2498         switch (gain_automation_state()) {
2499         case Write:
2500                 set_gain_automation_state (Off);
2501         case Touch:
2502                 set_gain_automation_state (Play);
2503                 break;
2504         default:
2505                 break;
2506         }
2507
2508         switch (panner().automation_state ()) {
2509         case Write:
2510                 panner().set_automation_state (Off);
2511                 break;
2512         case Touch:
2513                 panner().set_automation_state (Play);
2514                 break;
2515         default:
2516                 break;
2517         }
2518
2519         for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
2520                 boost::shared_ptr<PluginInsert> pi;
2521                 if ((pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2522                         pi->protect_automation ();
2523                 }
2524         }
2525 }
2526
2527 void
2528 Route::set_pending_declick (int declick)
2529 {
2530         if (_declickable) {
2531                 /* this call is not allowed to turn off a pending declick unless "force" is true */
2532                 if (declick) {
2533                         _pending_declick = declick;
2534                 }
2535                 // cerr << _name << ": after setting to " << declick << " pending declick = " << _pending_declick << endl;
2536         } else {
2537                 _pending_declick = 0;
2538         }
2539
2540 }