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