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