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