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