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