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 (*this, ToggleControllable::SoloControl),
  59           _mute_control (*this, ToggleControllable::MuteControl)
  60 {
  61         init ();
  62 }
  63
  64 Route::Route (Session& sess, const XMLNode& node)
  65         : IO (sess, "route"),
  66           _solo_control (*this, ToggleControllable::SoloControl),
  67           _mute_control (*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 || _session.transport_speed() < -1.5f) {
 631                                 pan (bufs, nbufs, nframes, offset, speed_quietning);
 632                         } else {
 633                                 // cerr << _name << " panner state = " << _panner->automation_state() << endl;
 634                                 if (!_panner->empty() &&
 635                                     (_panner->automation_state() & Play ||
 636                                      ((_panner->automation_state() & Touch) && !_panner->touching()))) {
 637                                         pan_automated (bufs, nbufs, start_frame, end_frame, nframes, offset);
 638                                 } else {
 639                                         pan (bufs, nbufs, nframes, offset, 1.0);
 640                                 }
 641                         }
 642                 }
 643
 644         }
 645
 646         /* ----------------------------------------------------------------------------------------------------
 647            POST-FADER METERING
 648            -------------------------------------------------------------------------------------------------- */
 649
 650         if (meter && (_meter_point == MeterPostFader)) {
 651 //              cerr << "meter post" << endl;
 652
 653                 if ((_gain == 0 && !apply_gain_automation) || dmg == 0) {
 654                         uint32_t no = n_outputs();
 655                         for (n = 0; n < no; ++n) {
 656                                 _peak_power[n] = 0;
 657                         }
 658                 } else {
 659                         uint32_t no = n_outputs();
 660                         for (n = 0; n < no; ++n) {
 661                                 _peak_power[n] = Session::compute_peak (output(n)->get_buffer (nframes) + offset, nframes, _peak_power[n]);
 662                         }
 663                 }
 664         }
 665 }
 666
 667 uint32_t
 668 Route::n_process_buffers ()
 669 {
 670         return max (n_inputs(), redirect_max_outs);
 671 }
 672
 673 void
 674
 675 Route::passthru (nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset, int declick, bool meter_first)
 676 {
 677         vector<Sample*>& bufs = _session.get_passthru_buffers();
 678         uint32_t limit = n_process_buffers ();
 679
 680         _silent = false;
 681
 682         collect_input (bufs, limit, nframes, offset);
 683
 684 #define meter_stream meter_first
 685
 686         if (meter_first) {
 687                 for (uint32_t n = 0; n < limit; ++n) {
 688                         _peak_power[n] = Session::compute_peak (bufs[n], nframes, _peak_power[n]);
 689                 }
 690                 meter_stream = false;
 691         } else {
 692                 meter_stream = true;
 693         }
 694
 695         process_output_buffers (bufs, limit, start_frame, end_frame, nframes, offset, true, declick, meter_stream);
 696
 697 #undef meter_stream
 698 }
 699
 700 void
 701 Route::set_phase_invert (bool yn, void *src)
 702 {
 703         if (_phase_invert != yn) {
 704                 _phase_invert = yn;
 705         }
 706         //  phase_invert_changed (src); /* EMIT SIGNAL */
 707 }
 708
 709 void
 710 Route::set_solo (bool yn, void *src)
 711 {
 712         if (_solo_safe) {
 713                 return;
 714         }
 715
 716         if (_mix_group && src != _mix_group && _mix_group->is_active()) {
 717                 _mix_group->apply (&Route::set_solo, yn, _mix_group);
 718                 return;
 719         }
 720
 721         if (_soloed != yn) {
 722                 _soloed = yn;
 723                 solo_changed (src); /* EMIT SIGNAL */
 724                 _solo_control.Changed (); /* EMIT SIGNAL */
 725         }
 726 }
 727
 728 void
 729 Route::set_solo_mute (bool yn)
 730 {
 731         Glib::Mutex::Lock lm (declick_lock);
 732
 733         /* Called by Session in response to another Route being soloed.
 734          */
 735
 736         desired_solo_gain = (yn?0.0:1.0);
 737 }
 738
 739 void
 740 Route::set_solo_safe (bool yn, void *src)
 741 {
 742         if (_solo_safe != yn) {
 743                 _solo_safe = yn;
 744                  solo_safe_changed (src); /* EMIT SIGNAL */
 745         }
 746 }
 747
 748 void
 749 Route::set_mute (bool yn, void *src)
 750
 751 {
 752         if (_mix_group && src != _mix_group && _mix_group->is_active()) {
 753                 _mix_group->apply (&Route::set_mute, yn, _mix_group);
 754                 return;
 755         }
 756
 757         if (_muted != yn) {
 758                 _muted = yn;
 759                 mute_changed (src); /* EMIT SIGNAL */
 760
 761                 _mute_control.Changed (); /* EMIT SIGNAL */
 762
 763                 Glib::Mutex::Lock lm (declick_lock);
 764                 desired_mute_gain = (yn?0.0f:1.0f);
 765         }
 766 }
 767
 768 int
 769 Route::add_redirect (boost::shared_ptr<Redirect> redirect, void *src, uint32_t* err_streams)
 770 {
 771         uint32_t old_rmo = redirect_max_outs;
 772
 773         if (!_session.engine().connected()) {
 774                 return 1;
 775         }
 776
 777         {
 778                 Glib::RWLock::WriterLock lm (redirect_lock);
 779
 780                 boost::shared_ptr<PluginInsert> pi;
 781                 boost::shared_ptr<PortInsert> porti;
 782
 783                 uint32_t potential_max_streams = 0;
 784
 785                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(redirect)) != 0) {
 786                         pi->set_count (1);
 787
 788                         if (pi->input_streams() == 0) {
 789                                 /* instrument plugin */
 790                                 _have_internal_generator = true;
 791                         }
 792
 793                         potential_max_streams = max(pi->input_streams(), pi->output_streams());
 794
 795                 } else if ((porti = boost::dynamic_pointer_cast<PortInsert>(redirect)) != 0) {
 796
 797                         /* force new port inserts to start out with an i/o configuration
 798                            that matches this route's i/o configuration.
 799
 800                            the "inputs" for the port are supposed to match the output
 801                            of this route.
 802
 803                            the "outputs" of the route should match the inputs of this
 804                            route. XXX shouldn't they match the number of active signal
 805                            streams at the point of insertion?
 806
 807                         */
 808
 809                         porti->ensure_io (n_outputs (), n_inputs(), false, this);
 810                 }
 811
 812                 // Ensure peak vector sizes before the plugin is activated
 813                 while (_peak_power.size() < potential_max_streams) {
 814                         _peak_power.push_back(0);
 815                 }
 816                 while (_visible_peak_power.size() < potential_max_streams) {
 817                         _visible_peak_power.push_back(0);
 818                 }
 819
 820                 _redirects.push_back (redirect);
 821
 822                 if (_reset_plugin_counts (err_streams)) {
 823                         _redirects.pop_back ();
 824                         _reset_plugin_counts (0); // it worked before we tried to add it ...
 825                         return -1;
 826                 }
 827
 828                 redirect->activate ();
 829                 redirect->active_changed.connect (mem_fun (*this, &Route::redirect_active_proxy));
 830         }
 831
 832         if (redirect_max_outs != old_rmo || old_rmo == 0) {
 833                 reset_panner ();
 834         }
 835
 836
 837         redirects_changed (src); /* EMIT SIGNAL */
 838         return 0;
 839 }
 840
 841 int
 842 Route::add_redirects (const RedirectList& others, void *src, uint32_t* err_streams)
 843 {
 844         uint32_t old_rmo = redirect_max_outs;
 845
 846         if (!_session.engine().connected()) {
 847                 return 1;
 848         }
 849
 850         {
 851                 Glib::RWLock::WriterLock lm (redirect_lock);
 852
 853                 RedirectList::iterator existing_end = _redirects.end();
 854                 --existing_end;
 855
 856                 uint32_t potential_max_streams = 0;
 857
 858                 for (RedirectList::const_iterator i = others.begin(); i != others.end(); ++i) {
 859
 860                         boost::shared_ptr<PluginInsert> pi;
 861
 862                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
 863                                 pi->set_count (1);
 864
 865                                 uint32_t m = max(pi->input_streams(), pi->output_streams());
 866                                 if (m > potential_max_streams)
 867                                         potential_max_streams = m;
 868                         }
 869
 870                         // Ensure peak vector sizes before the plugin is activated
 871                         while (_peak_power.size() < potential_max_streams) {
 872                                 _peak_power.push_back(0);
 873                         }
 874                         while (_visible_peak_power.size() < potential_max_streams) {
 875                                 _visible_peak_power.push_back(0);
 876                         }
 877
 878                         _redirects.push_back (*i);
 879
 880                         if (_reset_plugin_counts (err_streams)) {
 881                                 ++existing_end;
 882                                 _redirects.erase (existing_end, _redirects.end());
 883                                 _reset_plugin_counts (0); // it worked before we tried to add it ...
 884                                 return -1;
 885                         }
 886
 887                         (*i)->activate ();
 888                         (*i)->active_changed.connect (mem_fun (*this, &Route::redirect_active_proxy));
 889                 }
 890         }
 891
 892         if (redirect_max_outs != old_rmo || old_rmo == 0) {
 893                 reset_panner ();
 894         }
 895
 896         redirects_changed (src); /* EMIT SIGNAL */
 897         return 0;
 898 }
 899
 900 void
 901 Route::clear_redirects (void *src)
 902 {
 903         uint32_t old_rmo = redirect_max_outs;
 904
 905         if (!_session.engine().connected()) {
 906                 return;
 907         }
 908
 909         {
 910                 Glib::RWLock::WriterLock lm (redirect_lock);
 911                 _redirects.clear ();
 912         }
 913
 914         if (redirect_max_outs != old_rmo) {
 915                 reset_panner ();
 916         }
 917
 918         redirect_max_outs = 0;
 919         _have_internal_generator = false;
 920         redirects_changed (src); /* EMIT SIGNAL */
 921 }
 922
 923 int
 924 Route::remove_redirect (boost::shared_ptr<Redirect> redirect, void *src, uint32_t* err_streams)
 925 {
 926         uint32_t old_rmo = redirect_max_outs;
 927
 928         if (!_session.engine().connected()) {
 929                 return 1;
 930         }
 931
 932         redirect_max_outs = 0;
 933
 934         {
 935                 Glib::RWLock::WriterLock lm (redirect_lock);
 936                 RedirectList::iterator i;
 937                 bool removed = false;
 938
 939                 for (i = _redirects.begin(); i != _redirects.end(); ++i) {
 940                         if (*i == redirect) {
 941
 942                                 RedirectList::iterator tmp;
 943
 944                                 /* move along, see failure case for reset_plugin_counts()
 945                                    where we may need to reinsert the redirect.
 946                                 */
 947
 948                                 tmp = i;
 949                                 ++tmp;
 950
 951                                 /* stop redirects that send signals to JACK ports
 952                                    from causing noise as a result of no longer being
 953                                    run.
 954                                 */
 955
 956                                 boost::shared_ptr<Send> send;
 957                                 boost::shared_ptr<PortInsert> port_insert;
 958
 959                                 if ((send = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
 960                                         send->disconnect_inputs (this);
 961                                         send->disconnect_outputs (this);
 962                                 } else if ((port_insert = boost::dynamic_pointer_cast<PortInsert> (*i)) != 0) {
 963                                         port_insert->disconnect_inputs (this);
 964                                         port_insert->disconnect_outputs (this);
 965                                 }
 966
 967                                 _redirects.erase (i);
 968
 969                                 i = tmp;
 970                                 removed = true;
 971                                 break;
 972                         }
 973                 }
 974
 975                 if (!removed) {
 976                         /* what? */
 977                         return 1;
 978                 }
 979
 980                 if (_reset_plugin_counts (err_streams)) {
 981                         /* get back to where we where */
 982                         _redirects.insert (i, redirect);
 983                         /* we know this will work, because it worked before :) */
 984                         _reset_plugin_counts (0);
 985                         return -1;
 986                 }
 987
 988                 bool foo = false;
 989
 990                 for (i = _redirects.begin(); i != _redirects.end(); ++i) {
 991                         boost::shared_ptr<PluginInsert> pi;
 992
 993                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
 994                                 if (pi->is_generator()) {
 995                                         foo = true;
 996                                 }
 997                         }
 998                 }
 999
1000                 _have_internal_generator = foo;
1001         }
1002
1003         if (old_rmo != redirect_max_outs) {
1004                 reset_panner ();
1005         }
1006
1007         redirects_changed (src); /* EMIT SIGNAL */
1008         return 0;
1009 }
1010
1011 int
1012 Route::reset_plugin_counts (uint32_t* lpc)
1013 {
1014         Glib::RWLock::WriterLock lm (redirect_lock);
1015         return _reset_plugin_counts (lpc);
1016 }
1017
1018
1019 int
1020 Route::_reset_plugin_counts (uint32_t* err_streams)
1021 {
1022         RedirectList::iterator r;
1023         uint32_t i_cnt;
1024         uint32_t s_cnt;
1025         map<Placement,list<InsertCount> > insert_map;
1026         nframes_t initial_streams;
1027
1028         redirect_max_outs = 0;
1029         i_cnt = 0;
1030         s_cnt = 0;
1031
1032         /* divide inserts up by placement so we get the signal flow
1033            properly modelled. we need to do this because the _redirects
1034            list is not sorted by placement, and because other reasons may
1035            exist now or in the future for this separate treatment.
1036         */
1037
1038         for (r = _redirects.begin(); r != _redirects.end(); ++r) {
1039
1040                 boost::shared_ptr<Insert> insert;
1041
1042                 /* do this here in case we bomb out before we get to the end of
1043                    this function.
1044                 */
1045
1046                 redirect_max_outs = max ((*r)->output_streams (), redirect_max_outs);
1047
1048                 if ((insert = boost::dynamic_pointer_cast<Insert>(*r)) != 0) {
1049                         ++i_cnt;
1050                         insert_map[insert->placement()].push_back (InsertCount (insert));
1051
1052                         /* reset plugin counts back to one for now so
1053                            that we have a predictable, controlled
1054                            state to try to configure.
1055                         */
1056
1057                         boost::shared_ptr<PluginInsert> pi;
1058
1059                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(insert)) != 0) {
1060                                 pi->set_count (1);
1061                         }
1062
1063                 } else if (boost::dynamic_pointer_cast<Send> (*r) != 0) {
1064                         ++s_cnt;
1065                 }
1066         }
1067
1068         if (i_cnt == 0) {
1069                 if (s_cnt) {
1070                         goto recompute;
1071                 } else {
1072                         return 0;
1073                 }
1074         }
1075
1076         /* Now process each placement in order, checking to see if we
1077            can really do what has been requested.
1078         */
1079
1080         /* A: PreFader */
1081
1082         if (check_some_plugin_counts (insert_map[PreFader], n_inputs (), err_streams)) {
1083                 return -1;
1084         }
1085
1086         /* figure out the streams that will feed into PreFader */
1087
1088         if (!insert_map[PreFader].empty()) {
1089                 InsertCount& ic (insert_map[PreFader].back());
1090                 initial_streams = ic.insert->compute_output_streams (ic.cnt);
1091         } else {
1092                 initial_streams = n_inputs ();
1093         }
1094
1095         /* B: PostFader */
1096
1097         if (check_some_plugin_counts (insert_map[PostFader], initial_streams, err_streams)) {
1098                 return -1;
1099         }
1100
1101         /* OK, everything can be set up correctly, so lets do it */
1102
1103         apply_some_plugin_counts (insert_map[PreFader]);
1104         apply_some_plugin_counts (insert_map[PostFader]);
1105
1106         /* recompute max outs of any redirect */
1107
1108   recompute:
1109
1110         redirect_max_outs = 0;
1111         RedirectList::iterator prev = _redirects.end();
1112
1113         for (r = _redirects.begin(); r != _redirects.end(); prev = r, ++r) {
1114                 boost::shared_ptr<Send> s;
1115
1116                 if ((s = boost::dynamic_pointer_cast<Send> (*r)) != 0) {
1117                         if (r == _redirects.begin()) {
1118                                 s->expect_inputs (n_inputs());
1119                         } else {
1120                                 s->expect_inputs ((*prev)->output_streams());
1121                         }
1122                 }
1123
1124                 redirect_max_outs = max ((*r)->output_streams (), redirect_max_outs);
1125         }
1126
1127         /* we're done */
1128
1129         return 0;
1130 }
1131
1132 int32_t
1133 Route::apply_some_plugin_counts (list<InsertCount>& iclist)
1134 {
1135         list<InsertCount>::iterator i;
1136
1137         for (i = iclist.begin(); i != iclist.end(); ++i) {
1138
1139                 if ((*i).insert->configure_io ((*i).cnt, (*i).in, (*i).out)) {
1140                         return -1;
1141                 }
1142                 /* make sure that however many we have, they are all active */
1143                 (*i).insert->activate ();
1144         }
1145
1146         return 0;
1147 }
1148
1149 int32_t
1150 Route::check_some_plugin_counts (list<InsertCount>& iclist, int32_t required_inputs, uint32_t* err_streams)
1151 {
1152         list<InsertCount>::iterator i;
1153
1154         for (i = iclist.begin(); i != iclist.end(); ++i) {
1155
1156                 if (((*i).cnt = (*i).insert->can_support_input_configuration (required_inputs)) < 0) {
1157                         if (err_streams) {
1158                                 *err_streams = required_inputs;
1159                         }
1160                         return -1;
1161                 }
1162
1163                 (*i).in = required_inputs;
1164                 (*i).out = (*i).insert->compute_output_streams ((*i).cnt);
1165
1166                 required_inputs = (*i).out;
1167         }
1168
1169         return 0;
1170 }
1171
1172 int
1173 Route::copy_redirects (const Route& other, Placement placement, uint32_t* err_streams)
1174 {
1175         uint32_t old_rmo = redirect_max_outs;
1176
1177         if (err_streams) {
1178                 *err_streams = 0;
1179         }
1180
1181         RedirectList to_be_deleted;
1182
1183         {
1184                 Glib::RWLock::WriterLock lm (redirect_lock);
1185                 RedirectList::iterator tmp;
1186                 RedirectList the_copy;
1187
1188                 the_copy = _redirects;
1189
1190                 /* remove all relevant redirects */
1191
1192                 for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ) {
1193                         tmp = i;
1194                         ++tmp;
1195
1196                         if ((*i)->placement() == placement) {
1197                                 to_be_deleted.push_back (*i);
1198                                 _redirects.erase (i);
1199                         }
1200
1201                         i = tmp;
1202                 }
1203
1204                 /* now copy the relevant ones from "other" */
1205
1206                 for (RedirectList::const_iterator i = other._redirects.begin(); i != other._redirects.end(); ++i) {
1207                         if ((*i)->placement() == placement) {
1208                                 _redirects.push_back (Redirect::clone (*i));
1209                         }
1210                 }
1211
1212                 /* reset plugin stream handling */
1213
1214                 if (_reset_plugin_counts (err_streams)) {
1215
1216                         /* FAILED COPY ATTEMPT: we have to restore order */
1217
1218                         /* delete all cloned redirects */
1219
1220                         for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ) {
1221
1222                                 tmp = i;
1223                                 ++tmp;
1224
1225                                 if ((*i)->placement() == placement) {
1226                                         _redirects.erase (i);
1227                                 }
1228
1229                                 i = tmp;
1230                         }
1231
1232                         /* restore the natural order */
1233
1234                         _redirects = the_copy;
1235                         redirect_max_outs = old_rmo;
1236
1237                         /* we failed, even though things are OK again */
1238
1239                         return -1;
1240
1241                 } else {
1242
1243                         /* SUCCESSFUL COPY ATTEMPT: delete the redirects we removed pre-copy */
1244                         to_be_deleted.clear ();
1245                 }
1246         }
1247
1248         if (redirect_max_outs != old_rmo || old_rmo == 0) {
1249                 reset_panner ();
1250         }
1251
1252         redirects_changed (this); /* EMIT SIGNAL */
1253         return 0;
1254 }
1255
1256 void
1257 Route::all_redirects_flip ()
1258 {
1259         Glib::RWLock::ReaderLock lm (redirect_lock);
1260
1261         if (_redirects.empty()) {
1262                 return;
1263         }
1264
1265         bool first_is_on = _redirects.front()->active();
1266
1267         for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
1268                 (*i)->set_active (!first_is_on, this);
1269         }
1270 }
1271
1272 void
1273 Route::all_redirects_active (bool state)
1274 {
1275         Glib::RWLock::ReaderLock lm (redirect_lock);
1276
1277         if (_redirects.empty()) {
1278                 return;
1279         }
1280
1281         for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
1282                 (*i)->set_active (state, this);
1283         }
1284 }
1285
1286 struct RedirectSorter {
1287     bool operator() (boost::shared_ptr<const Redirect> a, boost::shared_ptr<const Redirect> b) {
1288             return a->sort_key() < b->sort_key();
1289     }
1290 };
1291
1292 int
1293 Route::sort_redirects (uint32_t* err_streams)
1294 {
1295         {
1296                 RedirectSorter comparator;
1297                 Glib::RWLock::WriterLock lm (redirect_lock);
1298                 uint32_t old_rmo = redirect_max_outs;
1299
1300                 /* the sweet power of C++ ... */
1301
1302                 RedirectList as_it_was_before = _redirects;
1303
1304                 _redirects.sort (comparator);
1305
1306                 if (_reset_plugin_counts (err_streams)) {
1307                         _redirects = as_it_was_before;
1308                         redirect_max_outs = old_rmo;
1309                         return -1;
1310                 }
1311         }
1312
1313         reset_panner ();
1314         redirects_changed (this); /* EMIT SIGNAL */
1315
1316         return 0;
1317 }
1318
1319 XMLNode&
1320 Route::get_state()
1321 {
1322         return state(true);
1323 }
1324
1325 XMLNode&
1326 Route::get_template()
1327 {
1328         return state(false);
1329 }
1330
1331 XMLNode&
1332 Route::state(bool full_state)
1333 {
1334         XMLNode *node = new XMLNode("Route");
1335         XMLNode *aevents;
1336         RedirectList:: iterator i;
1337         char buf[32];
1338
1339         if (_flags) {
1340                 snprintf (buf, sizeof (buf), "0x%x", _flags);
1341                 node->add_property("flags", buf);
1342         }
1343
1344         node->add_property("default-type", _default_type.to_string());
1345
1346         node->add_property("active", _active?"yes":"no");
1347         node->add_property("muted", _muted?"yes":"no");
1348         node->add_property("soloed", _soloed?"yes":"no");
1349         node->add_property("phase-invert", _phase_invert?"yes":"no");
1350         node->add_property("mute-affects-pre-fader", _mute_affects_pre_fader?"yes":"no");
1351         node->add_property("mute-affects-post-fader", _mute_affects_post_fader?"yes":"no");
1352         node->add_property("mute-affects-control-outs", _mute_affects_control_outs?"yes":"no");
1353         node->add_property("mute-affects-main-outs", _mute_affects_main_outs?"yes":"no");
1354
1355         if (_edit_group) {
1356                 node->add_property("edit-group", _edit_group->name());
1357         }
1358         if (_mix_group) {
1359                 node->add_property("mix-group", _mix_group->name());
1360         }
1361
1362         string order_string;
1363         OrderKeys::iterator x = order_keys.begin();
1364
1365         while (x != order_keys.end()) {
1366                 order_string += (*x).first;
1367                 order_string += '=';
1368                 snprintf (buf, sizeof(buf), "%ld", (*x).second);
1369                 order_string += buf;
1370
1371                 ++x;
1372
1373                 if (x == order_keys.end()) {
1374                         break;
1375                 }
1376
1377                 order_string += ':';
1378         }
1379         node->add_property ("order-keys", order_string);
1380
1381         node->add_child_nocopy (IO::state (full_state));
1382
1383         if (_control_outs) {
1384                 XMLNode* cnode = new XMLNode (X_("ControlOuts"));
1385                 cnode->add_child_nocopy (_control_outs->state (full_state));
1386                 node->add_child_nocopy (*cnode);
1387         }
1388
1389         if (_comment.length()) {
1390                 XMLNode *cmt = node->add_child ("Comment");
1391                 cmt->add_content (_comment);
1392         }
1393
1394         if (full_state) {
1395                 string path;
1396
1397                 path = _session.snap_name();
1398                 path += "-gain-";
1399                 path += legalize_for_path (_name);
1400                 path += ".automation";
1401
1402                 /* XXX we didn't ask for a state save, we asked for the current state.
1403                    FIX ME!
1404                 */
1405
1406                 if (save_automation (path)) {
1407                         error << _("Could not get state of route.  Problem with save_automation") << endmsg;
1408                 }
1409
1410                 aevents = node->add_child ("Automation");
1411                 aevents->add_property ("path", path);
1412         }
1413
1414         for (i = _redirects.begin(); i != _redirects.end(); ++i) {
1415                 node->add_child_nocopy((*i)->state (full_state));
1416         }
1417
1418         if (_extra_xml){
1419                 node->add_child_copy (*_extra_xml);
1420         }
1421
1422         return *node;
1423 }
1424
1425 void
1426 Route::set_deferred_state ()
1427 {
1428         XMLNodeList nlist;
1429         XMLNodeConstIterator niter;
1430
1431         if (!deferred_state) {
1432                 return;
1433         }
1434
1435         nlist = deferred_state->children();
1436
1437         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1438                 add_redirect_from_xml (**niter);
1439         }
1440
1441         delete deferred_state;
1442         deferred_state = 0;
1443 }
1444
1445 void
1446 Route::add_redirect_from_xml (const XMLNode& node)
1447 {
1448         const XMLProperty *prop;
1449
1450         if (node.name() == "Send") {
1451
1452
1453                 try {
1454                         boost::shared_ptr<Send> send (new Send (_session, node));
1455                         add_redirect (send, this);
1456                 }
1457
1458                 catch (failed_constructor &err) {
1459                         error << _("Send construction failed") << endmsg;
1460                         return;
1461                 }
1462
1463         } else if (node.name() == "Insert") {
1464
1465                 try {
1466                         if ((prop = node.property ("type")) != 0) {
1467
1468                                 boost::shared_ptr<Insert> insert;
1469
1470                                 if (prop->value() == "ladspa" || prop->value() == "Ladspa" || prop->value() == "vst") {
1471
1472                                         insert.reset (new PluginInsert(_session, node));
1473
1474                                 } else if (prop->value() == "port") {
1475
1476
1477                                         insert.reset (new PortInsert (_session, node));
1478
1479                                 } else {
1480
1481                                         error << string_compose(_("unknown Insert type \"%1\"; ignored"), prop->value()) << endmsg;
1482                                 }
1483
1484                                 add_redirect (insert, this);
1485
1486                         } else {
1487                                 error << _("Insert XML node has no type property") << endmsg;
1488                         }
1489                 }
1490
1491                 catch (failed_constructor &err) {
1492                         warning << _("insert could not be created. Ignored.") << endmsg;
1493                         return;
1494                 }
1495         }
1496 }
1497
1498 int
1499 Route::set_state (const XMLNode& node)
1500 {
1501         XMLNodeList nlist;
1502         XMLNodeConstIterator niter;
1503         XMLNode *child;
1504         XMLPropertyList plist;
1505         const XMLProperty *prop;
1506
1507         if (node.name() != "Route"){
1508                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1509                 return -1;
1510         }
1511
1512         if ((prop = node.property ("flags")) != 0) {
1513                 int x;
1514                 sscanf (prop->value().c_str(), "0x%x", &x);
1515                 _flags = Flag (x);
1516         } else {
1517                 _flags = Flag (0);
1518         }
1519
1520         if ((prop = node.property ("default-type")) != 0) {
1521                 _default_type = DataType(prop->value());
1522                 assert(_default_type != DataType::NIL);
1523         }
1524
1525         if ((prop = node.property ("phase-invert")) != 0) {
1526                 set_phase_invert(prop->value()=="yes"?true:false, this);
1527         }
1528
1529         if ((prop = node.property ("active")) != 0) {
1530                 set_active (prop->value() == "yes");
1531         }
1532
1533         if ((prop = node.property ("muted")) != 0) {
1534                 bool yn = prop->value()=="yes"?true:false;
1535
1536                 /* force reset of mute status */
1537
1538                 _muted = !yn;
1539                 set_mute(yn, this);
1540                 mute_gain = desired_mute_gain;
1541         }
1542
1543         if ((prop = node.property ("soloed")) != 0) {
1544                 bool yn = prop->value()=="yes"?true:false;
1545
1546                 /* force reset of solo status */
1547
1548                 _soloed = !yn;
1549                 set_solo (yn, this);
1550                 solo_gain = desired_solo_gain;
1551         }
1552
1553         if ((prop = node.property ("mute-affects-pre-fader")) != 0) {
1554                 _mute_affects_pre_fader = (prop->value()=="yes")?true:false;
1555         }
1556
1557         if ((prop = node.property ("mute-affects-post-fader")) != 0) {
1558                 _mute_affects_post_fader = (prop->value()=="yes")?true:false;
1559         }
1560
1561         if ((prop = node.property ("mute-affects-control-outs")) != 0) {
1562                 _mute_affects_control_outs = (prop->value()=="yes")?true:false;
1563         }
1564
1565         if ((prop = node.property ("mute-affects-main-outs")) != 0) {
1566                 _mute_affects_main_outs = (prop->value()=="yes")?true:false;
1567         }
1568
1569         if ((prop = node.property ("edit-group")) != 0) {
1570                 RouteGroup* edit_group = _session.edit_group_by_name(prop->value());
1571                 if(edit_group == 0) {
1572                         error << string_compose(_("Route %1: unknown edit group \"%2 in saved state (ignored)"), _name, prop->value()) << endmsg;
1573                 } else {
1574                         set_edit_group(edit_group, this);
1575                 }
1576         }
1577
1578         if ((prop = node.property ("order-keys")) != 0) {
1579
1580                 long n;
1581
1582                 string::size_type colon, equal;
1583                 string remaining = prop->value();
1584
1585                 while (remaining.length()) {
1586
1587                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
1588                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1589                                       << endmsg;
1590                         } else {
1591                                 if (sscanf (remaining.substr (equal+1).c_str(), "%ld", &n) != 1) {
1592                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1593                                               << endmsg;
1594                                 } else {
1595                                         set_order_key (remaining.substr (0, equal), n);
1596                                 }
1597                         }
1598
1599                         colon = remaining.find_first_of (':');
1600
1601                         if (colon != string::npos) {
1602                                 remaining = remaining.substr (colon+1);
1603                         } else {
1604                                 break;
1605                         }
1606                 }
1607         }
1608
1609         nlist = node.children();
1610
1611         if (deferred_state) {
1612                 delete deferred_state;
1613         }
1614
1615         deferred_state = new XMLNode("deferred state");
1616
1617         /* set parent class properties before anything else */
1618
1619         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1620
1621                 child = *niter;
1622
1623                 if (child->name() == IO::state_node_name) {
1624
1625                         IO::set_state (*child);
1626                         break;
1627                 }
1628         }
1629
1630         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1631
1632                 child = *niter;
1633
1634                 if (child->name() == "Send") {
1635
1636
1637                         if (!IO::ports_legal) {
1638
1639                                 deferred_state->add_child_copy (*child);
1640
1641                         } else {
1642                                 add_redirect_from_xml (*child);
1643                         }
1644
1645                 } else if (child->name() == "Insert") {
1646
1647                         if (!IO::ports_legal) {
1648
1649                                 deferred_state->add_child_copy (*child);
1650
1651                         } else {
1652
1653                                 add_redirect_from_xml (*child);
1654                         }
1655
1656                 } else if (child->name() == "Automation") {
1657
1658                         XMLPropertyList plist;
1659                         XMLPropertyConstIterator piter;
1660                         XMLProperty *prop;
1661
1662                         plist = child->properties();
1663                         for (piter = plist.begin(); piter != plist.end(); ++piter) {
1664                                 prop = *piter;
1665                                 if (prop->name() == "path") {
1666                                         load_automation (prop->value());
1667                                 }
1668                         }
1669
1670                 } else if (child->name() == "ControlOuts") {
1671
1672                         string coutname = _name;
1673                         coutname += _("[control]");
1674
1675                         _control_outs = new IO (_session, coutname);
1676                         _control_outs->set_state (**(child->children().begin()));
1677
1678                 } else if (child->name() == "Comment") {
1679
1680                         /* XXX this is a terrible API design in libxml++ */
1681
1682                         XMLNode *cmt = *(child->children().begin());
1683                         _comment = cmt->content();
1684
1685                 } else if (child->name() == "extra") {
1686                         _extra_xml = new XMLNode (*child);
1687                 }
1688         }
1689
1690         if ((prop = node.property ("mix-group")) != 0) {
1691                 RouteGroup* mix_group = _session.mix_group_by_name(prop->value());
1692                 if (mix_group == 0) {
1693                         error << string_compose(_("Route %1: unknown mix group \"%2 in saved state (ignored)"), _name, prop->value()) << endmsg;
1694                 }  else {
1695                         set_mix_group(mix_group, this);
1696                 }
1697         }
1698
1699         return 0;
1700 }
1701
1702 void
1703 Route::curve_reallocate ()
1704 {
1705 //      _gain_automation_curve.finish_resize ();
1706 //      _pan_automation_curve.finish_resize ();
1707 }
1708
1709 void
1710 Route::silence (nframes_t nframes, nframes_t offset)
1711 {
1712         if (!_silent) {
1713
1714                 // reset_peak_meters ();
1715
1716                 IO::silence (nframes, offset);
1717
1718                 if (_control_outs) {
1719                         _control_outs->silence (nframes, offset);
1720                 }
1721
1722                 {
1723                         Glib::RWLock::ReaderLock lm (redirect_lock, Glib::TRY_LOCK);
1724
1725                         if (lm.locked()) {
1726                                 for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
1727                                         boost::shared_ptr<PluginInsert> pi;
1728                                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
1729                                                 // skip plugins, they don't need anything when we're not active
1730                                                 continue;
1731                                         }
1732
1733                                         (*i)->silence (nframes, offset);
1734                                 }
1735
1736                                 if (nframes == _session.get_block_size() && offset == 0) {
1737                                         // _silent = true;
1738                                 }
1739                         }
1740                 }
1741
1742         }
1743 }
1744
1745 int
1746 Route::set_control_outs (const vector<string>& ports)
1747 {
1748         Glib::Mutex::Lock lm (control_outs_lock);
1749         vector<string>::const_iterator i;
1750
1751         if (_control_outs) {
1752                 delete _control_outs;
1753                 _control_outs = 0;
1754         }
1755
1756         if (ports.empty()) {
1757                 return 0;
1758         }
1759
1760         string coutname = _name;
1761         coutname += _("[control]");
1762
1763         _control_outs = new IO (_session, coutname);
1764
1765         /* our control outs need as many outputs as we
1766            have outputs. we track the changes in ::output_change_handler().
1767         */
1768
1769         _control_outs->ensure_io (0, n_outputs(), true, this);
1770
1771         return 0;
1772 }
1773
1774 void
1775 Route::set_edit_group (RouteGroup *eg, void *src)
1776
1777 {
1778         if (eg == _edit_group) {
1779                 return;
1780         }
1781
1782         if (_edit_group) {
1783                 _edit_group->remove (this);
1784         }
1785
1786         if ((_edit_group = eg) != 0) {
1787                 _edit_group->add (this);
1788         }
1789
1790         _session.set_dirty ();
1791         edit_group_changed (src); /* EMIT SIGNAL */
1792 }
1793
1794 void
1795 Route::drop_edit_group (void *src)
1796 {
1797         _edit_group = 0;
1798         _session.set_dirty ();
1799         edit_group_changed (src); /* EMIT SIGNAL */
1800 }
1801
1802 void
1803 Route::set_mix_group (RouteGroup *mg, void *src)
1804
1805 {
1806         if (mg == _mix_group) {
1807                 return;
1808         }
1809
1810         if (_mix_group) {
1811                 _mix_group->remove (this);
1812         }
1813
1814         if ((_mix_group = mg) != 0) {
1815                 _mix_group->add (this);
1816         }
1817
1818         _session.set_dirty ();
1819         mix_group_changed (src); /* EMIT SIGNAL */
1820 }
1821
1822 void
1823 Route::drop_mix_group (void *src)
1824 {
1825         _mix_group = 0;
1826         _session.set_dirty ();
1827         mix_group_changed (src); /* EMIT SIGNAL */
1828 }
1829
1830 void
1831 Route::set_comment (string cmt, void *src)
1832 {
1833         _comment = cmt;
1834         comment_changed (src);
1835         _session.set_dirty ();
1836 }
1837
1838 bool
1839 Route::feeds (boost::shared_ptr<Route> other)
1840 {
1841         uint32_t i, j;
1842
1843         IO& self = *this;
1844         uint32_t no = self.n_outputs();
1845         uint32_t ni = other->n_inputs ();
1846
1847         for (i = 0; i < no; ++i) {
1848                 for (j = 0; j < ni; ++j) {
1849                         if (self.output(i)->connected_to (other->input(j)->name())) {
1850                                 return true;
1851                         }
1852                 }
1853         }
1854
1855         /* check Redirects which may also interconnect Routes */
1856
1857         for (RedirectList::iterator r = _redirects.begin(); r != _redirects.end(); r++) {
1858
1859                 no = (*r)->n_outputs();
1860
1861                 for (i = 0; i < no; ++i) {
1862                         for (j = 0; j < ni; ++j) {
1863                                 if ((*r)->output(i)->connected_to (other->input (j)->name())) {
1864                                         return true;
1865                                 }
1866                         }
1867                 }
1868         }
1869
1870         /* check for control room outputs which may also interconnect Routes */
1871
1872         if (_control_outs) {
1873
1874                 no = _control_outs->n_outputs();
1875
1876                 for (i = 0; i < no; ++i) {
1877                         for (j = 0; j < ni; ++j) {
1878                                 if (_control_outs->output(i)->connected_to (other->input (j)->name())) {
1879                                         return true;
1880                                 }
1881                         }
1882                 }
1883         }
1884
1885         return false;
1886 }
1887
1888 void
1889 Route::set_mute_config (mute_type t, bool onoff, void *src)
1890 {
1891         switch (t) {
1892         case PRE_FADER:
1893                 _mute_affects_pre_fader = onoff;
1894                  pre_fader_changed(src); /* EMIT SIGNAL */
1895                 break;
1896
1897         case POST_FADER:
1898                 _mute_affects_post_fader = onoff;
1899                  post_fader_changed(src); /* EMIT SIGNAL */
1900                 break;
1901
1902         case CONTROL_OUTS:
1903                 _mute_affects_control_outs = onoff;
1904                  control_outs_changed(src); /* EMIT SIGNAL */
1905                 break;
1906
1907         case MAIN_OUTS:
1908                 _mute_affects_main_outs = onoff;
1909                  main_outs_changed(src); /* EMIT SIGNAL */
1910                 break;
1911         }
1912 }
1913
1914 bool
1915 Route::get_mute_config (mute_type t)
1916 {
1917         bool onoff = false;
1918
1919         switch (t){
1920         case PRE_FADER:
1921                 onoff = _mute_affects_pre_fader;
1922                 break;
1923         case POST_FADER:
1924                 onoff = _mute_affects_post_fader;
1925                 break;
1926         case CONTROL_OUTS:
1927                 onoff = _mute_affects_control_outs;
1928                 break;
1929         case MAIN_OUTS:
1930                 onoff = _mute_affects_main_outs;
1931                 break;
1932         }
1933
1934         return onoff;
1935 }
1936
1937 void
1938 Route::set_active (bool yn)
1939 {
1940         _active = yn;
1941          active_changed(); /* EMIT SIGNAL */
1942 }
1943
1944 void
1945 Route::handle_transport_stopped (bool abort_ignored, bool did_locate, bool can_flush_redirects)
1946 {
1947         nframes_t now = _session.transport_frame();
1948
1949         {
1950                 Glib::RWLock::ReaderLock lm (redirect_lock);
1951
1952                 if (!did_locate) {
1953                         automation_snapshot (now);
1954                 }
1955
1956                 for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
1957
1958                         if (Config->get_plugins_stop_with_transport() && can_flush_redirects) {
1959                                 (*i)->deactivate ();
1960                                 (*i)->activate ();
1961                         }
1962
1963                         (*i)->transport_stopped (now);
1964                 }
1965         }
1966
1967         IO::transport_stopped (now);
1968
1969         _roll_delay = _initial_delay;
1970 }
1971
1972 UndoAction
1973 Route::get_memento() const
1974 {
1975         void (Route::*pmf)(state_id_t) = &Route::set_state;
1976         return sigc::bind (mem_fun (*(const_cast<Route *>(this)), pmf), _current_state_id);
1977 }
1978
1979 void
1980 Route::set_state (state_id_t id)
1981 {
1982         return;
1983 }
1984
1985 void
1986 Route::input_change_handler (IOChange change, void *ignored)
1987 {
1988         if (change & ConfigurationChanged) {
1989                 reset_plugin_counts (0);
1990         }
1991 }
1992
1993 void
1994 Route::output_change_handler (IOChange change, void *ignored)
1995 {
1996         if (change & ConfigurationChanged) {
1997                 if (_control_outs) {
1998                         _control_outs->ensure_io (0, n_outputs(), true, this);
1999                 }
2000
2001                 reset_plugin_counts (0);
2002         }
2003 }
2004
2005 uint32_t
2006 Route::pans_required () const
2007 {
2008         if (n_outputs() < 2) {
2009                 return 0;
2010         }
2011
2012         return max (n_inputs (), redirect_max_outs);
2013 }
2014
2015 int
2016 Route::no_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset,
2017                    bool session_state_changing, bool can_record, bool rec_monitors_input)
2018 {
2019         if (n_outputs() == 0) {
2020                 return 0;
2021         }
2022
2023         if (session_state_changing || !_active)  {
2024                 silence (nframes, offset);
2025                 return 0;
2026         }
2027
2028         apply_gain_automation = false;
2029
2030         if (n_inputs()) {
2031                 passthru (start_frame, end_frame, nframes, offset, 0, false);
2032         } else {
2033                 silence (nframes, offset);
2034         }
2035
2036         return 0;
2037 }
2038
2039 nframes_t
2040 Route::check_initial_delay (nframes_t nframes, nframes_t& offset, nframes_t& transport_frame)
2041 {
2042         if (_roll_delay > nframes) {
2043
2044                 _roll_delay -= nframes;
2045                 silence (nframes, offset);
2046                 /* transport frame is not legal for caller to use */
2047                 return 0;
2048
2049         } else if (_roll_delay > 0) {
2050
2051                 nframes -= _roll_delay;
2052
2053                 silence (_roll_delay, offset);
2054
2055                 offset += _roll_delay;
2056                 transport_frame += _roll_delay;
2057
2058                 _roll_delay = 0;
2059         }
2060
2061         return nframes;
2062 }
2063
2064 int
2065 Route::roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset, int declick,
2066              bool can_record, bool rec_monitors_input)
2067 {
2068         {
2069                 Glib::RWLock::ReaderLock lm (redirect_lock, Glib::TRY_LOCK);
2070                 if (lm.locked()) {
2071                         // automation snapshot can also be called from the non-rt context
2072                         // and it uses the redirect list, so we take the lock out here
2073                         automation_snapshot (_session.transport_frame());
2074                 }
2075         }
2076
2077         if ((n_outputs() == 0 && _redirects.empty()) || n_inputs() == 0 || !_active) {
2078                 silence (nframes, offset);
2079                 return 0;
2080         }
2081
2082         nframes_t unused = 0;
2083
2084         if ((nframes = check_initial_delay (nframes, offset, unused)) == 0) {
2085                 return 0;
2086         }
2087
2088         _silent = false;
2089
2090         apply_gain_automation = false;
2091
2092         {
2093                 Glib::Mutex::Lock am (automation_lock, Glib::TRY_LOCK);
2094
2095                 if (am.locked() && _session.transport_rolling()) {
2096
2097                         nframes_t start_frame = end_frame - nframes;
2098
2099                         if (gain_automation_playback()) {
2100                                 apply_gain_automation = _gain_automation_curve.rt_safe_get_vector (start_frame, end_frame, _session.gain_automation_buffer(), nframes);
2101                         }
2102                 }
2103         }
2104
2105         passthru (start_frame, end_frame, nframes, offset, declick, false);
2106
2107         return 0;
2108 }
2109
2110 int
2111 Route::silent_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset,
2112                     bool can_record, bool rec_monitors_input)
2113 {
2114         silence (nframes, offset);
2115         return 0;
2116 }
2117
2118 void
2119 Route::toggle_monitor_input ()
2120 {
2121         for (vector<Port*>::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
2122                 (*i)->ensure_monitor_input(!(*i)->monitoring_input());
2123         }
2124 }
2125
2126 bool
2127 Route::has_external_redirects () const
2128 {
2129         boost::shared_ptr<const PortInsert> pi;
2130
2131         for (RedirectList::const_iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
2132                 if ((pi = boost::dynamic_pointer_cast<const PortInsert>(*i)) != 0) {
2133
2134                         uint32_t no = pi->n_outputs();
2135
2136                         for (uint32_t n = 0; n < no; ++n) {
2137
2138                                 string port_name = pi->output(n)->name();
2139                                 string client_name = port_name.substr (0, port_name.find(':'));
2140
2141                                 /* only say "yes" if the redirect is actually in use */
2142
2143                                 if (client_name != "ardour" && pi->active()) {
2144                                         return true;
2145                                 }
2146                         }
2147                 }
2148         }
2149
2150         return false;
2151 }
2152
2153 void
2154 Route::flush_redirects ()
2155 {
2156         /* XXX shouldn't really try to take this lock, since
2157            this is called from the RT audio thread.
2158         */
2159
2160         Glib::RWLock::ReaderLock lm (redirect_lock);
2161
2162         for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
2163                 (*i)->deactivate ();
2164                 (*i)->activate ();
2165         }
2166 }
2167
2168 void
2169 Route::set_meter_point (MeterPoint p, void *src)
2170 {
2171         if (_meter_point != p) {
2172                 _meter_point = p;
2173                  meter_change (src); /* EMIT SIGNAL */
2174                 _session.set_dirty ();
2175         }
2176 }
2177
2178 nframes_t
2179 Route::update_total_latency ()
2180 {
2181         _own_latency = 0;
2182
2183         for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
2184                 if ((*i)->active ()) {
2185                         _own_latency += (*i)->latency ();
2186                 }
2187         }
2188
2189         set_port_latency (_own_latency);
2190
2191         /* this (virtual) function is used for pure Routes,
2192            not derived classes like AudioTrack.  this means
2193            that the data processed here comes from an input
2194            port, not prerecorded material, and therefore we
2195            have to take into account any input latency.
2196         */
2197
2198         _own_latency += input_latency ();
2199
2200         return _own_latency;
2201 }
2202
2203 void
2204 Route::set_latency_delay (nframes_t longest_session_latency)
2205 {
2206         _initial_delay = longest_session_latency - _own_latency;
2207
2208         if (_session.transport_stopped()) {
2209                 _roll_delay = _initial_delay;
2210         }
2211 }
2212
2213 void
2214 Route::automation_snapshot (nframes_t now)
2215 {
2216         IO::automation_snapshot (now);
2217
2218         for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
2219                 (*i)->automation_snapshot (now);
2220         }
2221 }
2222
2223 Route::ToggleControllable::ToggleControllable (Route& s, ToggleType tp)
2224         : route (s), type(tp)
2225 {
2226
2227 }
2228
2229 void
2230 Route::ToggleControllable::set_value (float val)
2231 {
2232         bool bval = ((val >= 0.5f) ? true: false);
2233
2234         switch (type) {
2235         case MuteControl:
2236                 route.set_mute (bval, this);
2237                 break;
2238         case SoloControl:
2239                 route.set_solo (bval, this);
2240                 break;
2241         default:
2242                 break;
2243         }
2244 }
2245
2246 float
2247 Route::ToggleControllable::get_value (void) const
2248 {
2249         float val = 0.0f;
2250
2251         switch (type) {
2252         case MuteControl:
2253                 val = route.muted() ? 1.0f : 0.0f;
2254                 break;
2255         case SoloControl:
2256                 val = route.soloed() ? 1.0f : 0.0f;
2257                 break;
2258         default:
2259                 break;
2260         }
2261
2262         return val;
2263 }
2264
2265 void
2266 Route::set_block_size (nframes_t nframes)
2267 {
2268         for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
2269                 (*i)->set_block_size (nframes);
2270         }
2271 }
2272
2273 void
2274 Route::redirect_active_proxy (Redirect* ignored, void* ignored_src)
2275 {
2276         _session.update_latency_compensation (false, false);
2277 }
2278
2279 void
2280 Route::protect_automation ()
2281 {
2282         switch (gain_automation_state()) {
2283         case Write:
2284         case Touch:
2285                 set_gain_automation_state (Off);
2286                 break;
2287         default:
2288                 break;
2289         }
2290
2291         switch (panner().automation_state ()) {
2292         case Write:
2293         case Touch:
2294                 panner().set_automation_state (Off);
2295                 break;
2296         default:
2297                 break;
2298         }
2299
2300         for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
2301                 boost::shared_ptr<PluginInsert> pi;
2302                 if ((pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2303                         pi->protect_automation ();
2304                 }
2305         }
2306 }
2307
2308 void
2309 Route::set_pending_declick (int declick)
2310 {
2311         if (_declickable) {
2312                 /* this call is not allowed to turn off a pending declick unless "force" is true */
2313                 if (declick) {
2314                         _pending_declick = declick;
2315                 }
2316                 // cerr << _name << ": after setting to " << declick << " pending declick = " << _pending_declick << endl;
2317         } else {
2318                 _pending_declick = 0;
2319         }
2320
2321 }