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