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