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