convert Route::_solo_isolated from counter to a boolean.
[ardour.git] / 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 #ifdef WAF_BUILD
21 #include "libardour-config.h"
22 #endif
23
24 #include <cmath>
25 #include <fstream>
26 #include <cassert>
27 #include <algorithm>
28
29 #include <glibmm.h>
30 #include <boost/algorithm/string.hpp>
31
32 #include "pbd/xml++.h"
33 #include "pbd/enumwriter.h"
34 #include "pbd/memento_command.h"
35 #include "pbd/stacktrace.h"
36 #include "pbd/convert.h"
37 #include "pbd/boost_debug.h"
38
39 #include "ardour/amp.h"
40 #include "ardour/audio_buffer.h"
41 #include "ardour/audio_track.h"
42 #include "ardour/audio_port.h"
43 #include "ardour/audioengine.h"
44 #include "ardour/buffer.h"
45 #include "ardour/buffer_set.h"
46 #include "ardour/capturing_processor.h"
47 #include "ardour/debug.h"
48 #include "ardour/delivery.h"
49 #include "ardour/internal_return.h"
50 #include "ardour/internal_send.h"
51 #include "ardour/meter.h"
52 #include "ardour/delayline.h"
53 #include "ardour/midi_buffer.h"
54 #include "ardour/midi_port.h"
55 #include "ardour/monitor_processor.h"
56 #include "ardour/pannable.h"
57 #include "ardour/panner.h"
58 #include "ardour/panner_shell.h"
59 #include "ardour/plugin_insert.h"
60 #include "ardour/port.h"
61 #include "ardour/port_insert.h"
62 #include "ardour/processor.h"
63 #include "ardour/profile.h"
64 #include "ardour/route.h"
65 #include "ardour/route_group.h"
66 #include "ardour/send.h"
67 #include "ardour/session.h"
68 #include "ardour/unknown_processor.h"
69 #include "ardour/utils.h"
70
71 #include "i18n.h"
72
73 using namespace std;
74 using namespace ARDOUR;
75 using namespace PBD;
76
77 PBD::Signal0<void> Route::SyncOrderKeys;
78 PBD::Signal0<void> Route::RemoteControlIDChange;
79
80 Route::Route (Session& sess, string name, Flag flg, DataType default_type)
81         : SessionObject (sess, name)
82         , Automatable (sess)
83         , GraphNode (sess._process_graph)
84         , _active (true)
85         , _signal_latency (0)
86         , _signal_latency_at_amp_position (0)
87         , _signal_latency_at_trim_position (0)
88         , _initial_delay (0)
89         , _roll_delay (0)
90         , _pending_process_reorder (0)
91         , _flags (flg)
92         , _pending_declick (true)
93         , _meter_point (MeterPostFader)
94         , _pending_meter_point (MeterPostFader)
95         , _meter_type (MeterPeak)
96         , _self_solo (false)
97         , _soloed_by_others_upstream (0)
98         , _soloed_by_others_downstream (0)
99         , _solo_isolated (false)
100         , _solo_isolated_by_upstream (0)
101         , _denormal_protection (false)
102         , _recordable (true)
103         , _silent (false)
104         , _declickable (false)
105         , _mute_master (new MuteMaster (sess, name))
106         , _have_internal_generator (false)
107         , _solo_safe (false)
108         , _default_type (default_type)
109         , _order_key (0)
110         , _has_order_key (false)
111         , _remote_control_id (0)
112         , _track_number (0)
113         , _in_configure_processors (false)
114         , _initial_io_setup (false)
115         , _custom_meter_position_noted (false)
116 {
117         processor_max_streams.reset();
118 }
119
120 int
121 Route::init ()
122 {
123         /* set default meter type */
124         if (is_master()) {
125                 _meter_type = Config->get_meter_type_master ();
126         }
127         else if (dynamic_cast<Track*>(this)) {
128                 _meter_type = Config->get_meter_type_track ();
129         } else {
130                 _meter_type = Config->get_meter_type_bus ();
131         }
132
133         /* add standard controls */
134
135         _solo_control.reset (new SoloControllable (X_("solo"), shared_from_this ()));
136         _mute_control.reset (new MuteControllable (X_("mute"), shared_from_this ()));
137
138         _solo_control->set_flags (Controllable::Flag (_solo_control->flags() | Controllable::Toggle));
139         _mute_control->set_flags (Controllable::Flag (_mute_control->flags() | Controllable::Toggle));
140
141         add_control (_solo_control);
142         add_control (_mute_control);
143
144         /* panning */
145
146         if (!(_flags & Route::MonitorOut)) {
147                 _pannable.reset (new Pannable (_session));
148         }
149
150         /* input and output objects */
151
152         _input.reset (new IO (_session, _name, IO::Input, _default_type));
153         _output.reset (new IO (_session, _name, IO::Output, _default_type));
154
155         _input->changed.connect_same_thread (*this, boost::bind (&Route::input_change_handler, this, _1, _2));
156         _input->PortCountChanging.connect_same_thread (*this, boost::bind (&Route::input_port_count_changing, this, _1));
157
158         _output->changed.connect_same_thread (*this, boost::bind (&Route::output_change_handler, this, _1, _2));
159         _output->PortCountChanging.connect_same_thread (*this, boost::bind (&Route::output_port_count_changing, this, _1));
160
161 #if 0 // not used - just yet
162         if (!is_master() && !is_monitor() && !is_auditioner()) {
163                 _delayline.reset (new DelayLine (_session, _name));
164                 add_processor (_delayline, PreFader);
165         }
166 #endif
167
168         /* add amp processor  */
169
170         _amp.reset (new Amp (_session));
171         add_processor (_amp, PostFader);
172
173         /* and input trim */
174         _trim.reset (new Amp (_session, "trim"));
175         _trim->set_display_to_user (false);
176
177         if (dynamic_cast<AudioTrack*>(this)) {
178                 /* we can't do this in the AudioTrack's constructor
179                  * because _trim does not exit then
180                  */
181                 _trim->activate();
182         }
183         else if (!dynamic_cast<Track*>(this) && ! ( is_monitor() || is_auditioner() )) {
184                 /* regular bus */
185                 _trim->activate();
186         }
187
188         /* create standard processors: meter, main outs, monitor out;
189            they will be added to _processors by setup_invisible_processors ()
190         */
191
192         _meter.reset (new PeakMeter (_session, _name));
193         _meter->set_owner (this);
194         _meter->set_display_to_user (false);
195         _meter->activate ();
196
197         _main_outs.reset (new Delivery (_session, _output, _pannable, _mute_master, _name, Delivery::Main));
198         _main_outs->activate ();
199
200         if (is_monitor()) {
201                 /* where we listen to tracks */
202                 _intreturn.reset (new InternalReturn (_session));
203                 _intreturn->activate ();
204
205                 /* the thing that provides proper control over a control/monitor/listen bus
206                    (such as per-channel cut, dim, solo, invert, etc).
207                 */
208                 _monitor_control.reset (new MonitorProcessor (_session));
209                 _monitor_control->activate ();
210         }
211
212         if (is_master() || is_monitor() || is_auditioner()) {
213                 _mute_master->set_solo_ignore (true);
214         }
215
216         /* now that we have _meter, its safe to connect to this */
217
218         {
219                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
220                 configure_processors (0);
221         }
222
223         return 0;
224 }
225
226 Route::~Route ()
227 {
228         DEBUG_TRACE (DEBUG::Destruction, string_compose ("route %1 destructor\n", _name));
229
230         /* do this early so that we don't get incoming signals as we are going through destruction
231          */
232
233         drop_connections ();
234
235         /* don't use clear_processors here, as it depends on the session which may
236            be half-destroyed by now
237         */
238
239         Glib::Threads::RWLock::WriterLock lm (_processor_lock);
240         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
241                 (*i)->drop_references ();
242         }
243
244         _processors.clear ();
245 }
246
247 void
248 Route::set_remote_control_id (uint32_t id, bool notify_class_listeners)
249 {
250         if (Config->get_remote_model() != UserOrdered) {
251                 return;
252         }
253
254         set_remote_control_id_internal (id, notify_class_listeners);
255 }
256
257 void
258 Route::set_remote_control_id_internal (uint32_t id, bool notify_class_listeners)
259 {
260         /* force IDs for master/monitor busses and prevent 
261            any other route from accidentally getting these IDs
262            (i.e. legacy sessions)
263         */
264
265         if (is_master() && id != MasterBusRemoteControlID) {
266                 id = MasterBusRemoteControlID;
267         }
268
269         if (is_monitor() && id != MonitorBusRemoteControlID) {
270                 id = MonitorBusRemoteControlID;
271         }
272
273         if (id < 1) {
274                 return;
275         }
276
277         /* don't allow it to collide */
278
279         if (!is_master () && !is_monitor() && 
280             (id == MasterBusRemoteControlID || id == MonitorBusRemoteControlID)) {
281                 id += MonitorBusRemoteControlID;
282         }
283
284         if (id != remote_control_id()) {
285                 _remote_control_id = id;
286                 RemoteControlIDChanged ();
287
288                 if (notify_class_listeners) {
289                         RemoteControlIDChange ();
290                 }
291         }
292 }
293
294 uint32_t
295 Route::remote_control_id() const
296 {
297         if (is_master()) {
298                 return MasterBusRemoteControlID;
299         } 
300
301         if (is_monitor()) {
302                 return MonitorBusRemoteControlID;
303         }
304
305         return _remote_control_id;
306 }
307
308 bool
309 Route::has_order_key () const
310 {
311         return _has_order_key;
312 }
313
314 uint32_t
315 Route::order_key () const
316 {
317         return _order_key;
318 }
319
320 void
321 Route::set_remote_control_id_explicit (uint32_t rid)
322 {
323         if (is_master() || is_monitor() || is_auditioner()) {
324                 /* hard-coded remote IDs, or no remote ID */
325                 return;
326         }
327
328         if (_remote_control_id != rid) {
329                 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("%1: set edit-based RID to %2\n", name(), rid));
330                 _remote_control_id = rid;
331                 RemoteControlIDChanged (); /* EMIT SIGNAL (per-route) */
332         }
333
334         /* don't emit the class-level RID signal RemoteControlIDChange here,
335            leave that to the entity that changed the order key, so that we
336            don't get lots of emissions for no good reasons (e.g. when changing
337            all route order keys).
338
339            See Session::sync_remote_id_from_order_keys() for the (primary|only)
340            spot where that is emitted.
341         */
342 }
343
344 void
345 Route::set_order_key (uint32_t n)
346 {
347         _has_order_key = true;
348
349         if (_order_key == n) {
350                 return;
351         }
352
353         _order_key = n;
354
355         DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("%1 order key set to %2\n",
356                                                        name(), order_key ()));
357
358         _session.set_dirty ();
359 }
360
361 string
362 Route::ensure_track_or_route_name(string name, Session &session)
363 {
364         string newname = name;
365
366         while (!session.io_name_is_legal (newname)) {
367                 newname = bump_name_once (newname, '.');
368         }
369
370         return newname;
371 }
372
373 void
374 Route::inc_gain (gain_t fraction, void *src)
375 {
376         _amp->inc_gain (fraction, src);
377 }
378
379 void
380 Route::set_gain (gain_t val, void *src)
381 {
382         if (src != 0 && _route_group && src != _route_group && _route_group->is_active() && _route_group->is_gain()) {
383
384                 if (_route_group->is_relative()) {
385
386                         gain_t usable_gain = _amp->gain();
387                         if (usable_gain < 0.000001f) {
388                                 usable_gain = 0.000001f;
389                         }
390
391                         gain_t delta = val;
392                         if (delta < 0.000001f) {
393                                 delta = 0.000001f;
394                         }
395
396                         delta -= usable_gain;
397
398                         if (delta == 0.0f)
399                                 return;
400
401                         gain_t factor = delta / usable_gain;
402
403                         if (factor > 0.0f) {
404                                 factor = _route_group->get_max_factor(factor);
405                                 if (factor == 0.0f) {
406                                         _amp->gain_control()->Changed(); /* EMIT SIGNAL */
407                                         return;
408                                 }
409                         } else {
410                                 factor = _route_group->get_min_factor(factor);
411                                 if (factor == 0.0f) {
412                                         _amp->gain_control()->Changed(); /* EMIT SIGNAL */
413                                         return;
414                                 }
415                         }
416
417                         _route_group->foreach_route (boost::bind (&Route::inc_gain, _1, factor, _route_group));
418
419                 } else {
420
421                         _route_group->foreach_route (boost::bind (&Route::set_gain, _1, val, _route_group));
422                 }
423
424                 return;
425         }
426
427         if (val == _amp->gain()) {
428                 return;
429         }
430
431         _amp->set_gain (val, src);
432 }
433
434 void
435 Route::inc_trim (gain_t fraction, void *src)
436 {
437         _trim->inc_gain (fraction, src);
438 }
439
440 void
441 Route::set_trim (gain_t val, void * /* src */)
442 {
443         // TODO route group, see set_gain()
444         _trim->set_gain (val, 0);
445 }
446
447 void
448 Route::maybe_declick (BufferSet&, framecnt_t, int)
449 {
450         /* this is the "bus" implementation and they never declick.
451          */
452         return;
453 }
454
455 /** Process this route for one (sub) cycle (process thread)
456  *
457  * @param bufs Scratch buffers to use for the signal path
458  * @param start_frame Initial transport frame
459  * @param end_frame Final transport frame
460  * @param nframes Number of frames to output (to ports)
461  *
462  * Note that (end_frame - start_frame) may not be equal to nframes when the
463  * transport speed isn't 1.0 (eg varispeed).
464  */
465 void
466 Route::process_output_buffers (BufferSet& bufs,
467                                framepos_t start_frame, framepos_t end_frame, pframes_t nframes,
468                                int declick, bool gain_automation_ok)
469 {
470         /* Caller must hold process lock */
471         assert (!AudioEngine::instance()->process_lock().trylock());
472
473         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
474         if (!lm.locked()) {
475                 // can this actually happen? functions calling process_output_buffers()
476                 // already take a reader-lock.
477                 bufs.silence (nframes, 0);
478                 return;
479         }
480
481         /* figure out if we're going to use gain automation */
482         if (gain_automation_ok) {
483                 _amp->set_gain_automation_buffer (_session.gain_automation_buffer ());
484                 _amp->setup_gain_automation (
485                                 start_frame + _signal_latency_at_amp_position,
486                                 end_frame + _signal_latency_at_amp_position,
487                                 nframes);
488
489                 _trim->set_gain_automation_buffer (_session.trim_automation_buffer ());
490                 _trim->setup_gain_automation (
491                                 start_frame + _signal_latency_at_trim_position,
492                                 end_frame + _signal_latency_at_trim_position,
493                                 nframes);
494         } else {
495                 _amp->apply_gain_automation (false);
496                 _trim->apply_gain_automation (false);
497         }
498
499         /* Tell main outs what to do about monitoring.  We do this so that
500            on a transition between monitoring states we get a de-clicking gain
501            change in the _main_outs delivery.
502         */
503         bool silence = monitoring_state () == MonitoringSilence;
504
505         //but we override this in the case where we have an internal generator
506         if ( _have_internal_generator )
507                 silence = false;
508
509         _main_outs->no_outs_cuz_we_no_monitor (silence);
510
511         /* -------------------------------------------------------------------------------------------
512            GLOBAL DECLICK (for transport changes etc.)
513            ----------------------------------------------------------------------------------------- */
514
515         maybe_declick (bufs, nframes, declick);
516         _pending_declick = 0;
517
518         /* -------------------------------------------------------------------------------------------
519            DENORMAL CONTROL/PHASE INVERT
520            ----------------------------------------------------------------------------------------- */
521
522         if (_phase_invert.any ()) {
523
524                 int chn = 0;
525
526                 if (_denormal_protection || Config->get_denormal_protection()) {
527
528                         for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
529                                 Sample* const sp = i->data();
530
531                                 if (_phase_invert[chn]) {
532                                         for (pframes_t nx = 0; nx < nframes; ++nx) {
533                                                 sp[nx]  = -sp[nx];
534                                                 sp[nx] += 1.0e-27f;
535                                         }
536                                 } else {
537                                         for (pframes_t nx = 0; nx < nframes; ++nx) {
538                                                 sp[nx] += 1.0e-27f;
539                                         }
540                                 }
541                         }
542
543                 } else {
544
545                         for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
546                                 Sample* const sp = i->data();
547
548                                 if (_phase_invert[chn]) {
549                                         for (pframes_t nx = 0; nx < nframes; ++nx) {
550                                                 sp[nx] = -sp[nx];
551                                         }
552                                 }
553                         }
554                 }
555
556         } else {
557
558                 if (_denormal_protection || Config->get_denormal_protection()) {
559
560                         for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
561                                 Sample* const sp = i->data();
562                                 for (pframes_t nx = 0; nx < nframes; ++nx) {
563                                         sp[nx] += 1.0e-27f;
564                                 }
565                         }
566
567                 }
568         }
569
570         /* -------------------------------------------------------------------------------------------
571            and go ....
572            ----------------------------------------------------------------------------------------- */
573
574         /* set this to be true if the meter will already have been ::run() earlier */
575         bool const meter_already_run = metering_state() == MeteringInput;
576
577         framecnt_t latency = 0;
578
579         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
580
581                 if (meter_already_run && boost::dynamic_pointer_cast<PeakMeter> (*i)) {
582                         /* don't ::run() the meter, otherwise it will have its previous peak corrupted */
583                         continue;
584                 }
585
586 #ifndef NDEBUG
587                 /* if it has any inputs, make sure they match */
588                 if (boost::dynamic_pointer_cast<UnknownProcessor> (*i) == 0 && (*i)->input_streams() != ChanCount::ZERO) {
589                         if (bufs.count() != (*i)->input_streams()) {
590                                 DEBUG_TRACE (
591                                         DEBUG::Processors, string_compose (
592                                                 "input port mismatch %1 bufs = %2 input for %3 = %4\n",
593                                                 _name, bufs.count(), (*i)->name(), (*i)->input_streams()
594                                                 )
595                                         );
596                         }
597                 }
598 #endif
599
600                 /* should we NOT run plugins here if the route is inactive?
601                    do we catch route != active somewhere higher?
602                 */
603
604                 if (boost::dynamic_pointer_cast<Send>(*i) != 0) {
605                         boost::dynamic_pointer_cast<Send>(*i)->set_delay_in(_signal_latency - latency);
606                 }
607
608                 (*i)->run (bufs, start_frame - latency, end_frame - latency, nframes, *i != _processors.back());
609                 bufs.set_count ((*i)->output_streams());
610
611                 if ((*i)->active ()) {
612                         latency += (*i)->signal_latency ();
613                 }
614         }
615 }
616
617 void
618 Route::bounce_process (BufferSet& buffers, framepos_t start, framecnt_t nframes,
619                 boost::shared_ptr<Processor> endpoint,
620                 bool include_endpoint, bool for_export, bool for_freeze)
621 {
622         /* If no processing is required, there's no need to go any further. */
623         if (!endpoint && !include_endpoint) {
624                 return;
625         }
626
627         framecnt_t latency = bounce_get_latency(_amp, false, for_export, for_freeze);
628         _amp->set_gain_automation_buffer (_session.gain_automation_buffer ());
629         _amp->setup_gain_automation (start - latency, start - latency + nframes, nframes);
630
631         /* trim is always at the top, for bounce no latency compensation is needed */
632         _trim->set_gain_automation_buffer (_session.trim_automation_buffer ());
633         _trim->setup_gain_automation (start, start + nframes, nframes);
634
635         latency = 0;
636         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
637
638                 if (!include_endpoint && (*i) == endpoint) {
639                         break;
640                 }
641
642                 /* if we're not exporting, stop processing if we come across a routing processor. */
643                 if (!for_export && boost::dynamic_pointer_cast<PortInsert>(*i)) {
644                         break;
645                 }
646                 if (!for_export && for_freeze && (*i)->does_routing() && (*i)->active()) {
647                         break;
648                 }
649
650                 /* don't run any processors that does routing.
651                  * oh, and don't bother with the peak meter either.
652                  */
653                 if (!(*i)->does_routing() && !boost::dynamic_pointer_cast<PeakMeter>(*i)) {
654                         (*i)->run (buffers, start - latency, start - latency + nframes, nframes, true);
655                         buffers.set_count ((*i)->output_streams());
656                         latency += (*i)->signal_latency ();
657                 }
658
659                 if ((*i) == endpoint) {
660                         break;
661                 }
662         }
663 }
664
665 framecnt_t
666 Route::bounce_get_latency (boost::shared_ptr<Processor> endpoint,
667                 bool include_endpoint, bool for_export, bool for_freeze) const
668 {
669         framecnt_t latency = 0;
670         if (!endpoint && !include_endpoint) {
671                 return latency;
672         }
673
674         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
675                 if (!include_endpoint && (*i) == endpoint) {
676                         break;
677                 }
678                 if (!for_export && boost::dynamic_pointer_cast<PortInsert>(*i)) {
679                         break;
680                 }
681                 if (!for_export && for_freeze && (*i)->does_routing() && (*i)->active()) {
682                         break;
683                 }
684                 if (!(*i)->does_routing() && !boost::dynamic_pointer_cast<PeakMeter>(*i)) {
685                         latency += (*i)->signal_latency ();
686                 }
687                 if ((*i) == endpoint) {
688                         break;
689                 }
690         }
691         return latency;
692 }
693
694 ChanCount
695 Route::bounce_get_output_streams (ChanCount &cc, boost::shared_ptr<Processor> endpoint,
696                 bool include_endpoint, bool for_export, bool for_freeze) const
697 {
698         if (!endpoint && !include_endpoint) {
699                 return cc;
700         }
701
702         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
703                 if (!include_endpoint && (*i) == endpoint) {
704                         break;
705                 }
706                 if (!for_export && boost::dynamic_pointer_cast<PortInsert>(*i)) {
707                         break;
708                 }
709                 if (!for_export && for_freeze && (*i)->does_routing() && (*i)->active()) {
710                         break;
711                 }
712                 if (!(*i)->does_routing() && !boost::dynamic_pointer_cast<PeakMeter>(*i)) {
713                         cc = (*i)->output_streams();
714                 }
715                 if ((*i) == endpoint) {
716                         break;
717                 }
718         }
719         return cc;
720 }
721
722 ChanCount
723 Route::n_process_buffers ()
724 {
725         return max (_input->n_ports(), processor_max_streams);
726 }
727
728 void
729 Route::monitor_run (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
730 {
731         assert (is_monitor());
732         BufferSet& bufs (_session.get_route_buffers (n_process_buffers()));
733         fill_buffers_with_input (bufs, _input, nframes);
734         passthru (bufs, start_frame, end_frame, nframes, declick);
735 }
736
737 void
738 Route::passthru (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
739 {
740         _silent = false;
741
742         if (is_monitor() && _session.listening() && !_session.is_auditioning()) {
743
744                 /* control/monitor bus ignores input ports when something is
745                    feeding the listen "stream". data will "arrive" into the
746                    route from the intreturn processor element.
747                 */
748
749                 bufs.silence (nframes, 0);
750         }
751
752         write_out_of_band_data (bufs, start_frame, end_frame, nframes);
753         process_output_buffers (bufs, start_frame, end_frame, nframes, declick, true);
754 }
755
756 void
757 Route::passthru_silence (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
758 {
759         BufferSet& bufs (_session.get_route_buffers (n_process_buffers(), true));
760
761         bufs.set_count (_input->n_ports());
762         write_out_of_band_data (bufs, start_frame, end_frame, nframes);
763         process_output_buffers (bufs, start_frame, end_frame, nframes, declick, false);
764 }
765
766 void
767 Route::set_listen (bool yn, void* src)
768 {
769         if (_solo_safe) {
770                 return;
771         }
772
773         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
774                 _route_group->foreach_route (boost::bind (&Route::set_listen, _1, yn, _route_group));
775                 return;
776         }
777
778         if (_monitor_send) {
779                 if (yn != _monitor_send->active()) {
780                         if (yn) {
781                                 _monitor_send->activate ();
782                                 _mute_master->set_soloed (true);
783                         } else {
784                                 _monitor_send->deactivate ();
785                                 _mute_master->set_soloed (false);
786                         }
787
788                         listen_changed (src); /* EMIT SIGNAL */
789                 }
790         }
791 }
792
793 bool
794 Route::listening_via_monitor () const
795 {
796         if (_monitor_send) {
797                 return _monitor_send->active ();
798         } else {
799                 return false;
800         }
801 }
802
803 void
804 Route::set_solo_safe (bool yn, void *src)
805 {
806         if (_solo_safe != yn) {
807                 _solo_safe = yn;
808                 solo_safe_changed (src);
809         }
810 }
811
812 bool
813 Route::solo_safe() const
814 {
815         return _solo_safe;
816 }
817
818 void
819 Route::set_solo (bool yn, void *src)
820 {
821         if (_solo_safe) {
822                 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 ignore solo change due to solo-safe\n", name()));
823                 return;
824         }
825
826         if (is_master() || is_monitor() || is_auditioner()) {
827                 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 ignore solo change (master, monitor or auditioner)\n", name()));
828                 return;
829         }
830
831         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
832                 _route_group->foreach_route (boost::bind (&Route::set_solo, _1, yn, _route_group));
833                 return;
834         }
835
836         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1: set solo => %2, src: %3 grp ? %4 currently self-soloed ? %5\n", 
837                                                   name(), yn, src, (src == _route_group), self_soloed()));
838
839         if (self_soloed() != yn) {
840                 set_self_solo (yn);
841                 set_mute_master_solo ();
842                 solo_changed (true, src); /* EMIT SIGNAL */
843                 _solo_control->Changed (); /* EMIT SIGNAL */
844         }
845
846         /* XXX TRACKS DEVELOPERS: THIS LOGIC SUGGESTS THAT YOU ARE NOT AWARE OF
847            Config->get_solo_mute_overrride().
848         */
849
850         if (yn && Profile->get_trx()) {
851                 set_mute (false, src);
852         }
853 }
854
855 void
856 Route::set_self_solo (bool yn)
857 {
858         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1: set SELF solo => %2\n", name(), yn));
859         _self_solo = yn;
860 }
861
862 void
863 Route::mod_solo_by_others_upstream (int32_t delta)
864 {
865         if (_solo_safe) {
866                 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 ignore solo-by-upstream due to solo-safe\n", name()));
867                 return;
868         }
869
870         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 mod solo-by-upstream by %2, current up = %3 down = %4\n", 
871                                                   name(), delta, _soloed_by_others_upstream, _soloed_by_others_downstream));
872
873         uint32_t old_sbu = _soloed_by_others_upstream;
874
875         if (delta < 0) {
876                 if (_soloed_by_others_upstream >= (uint32_t) abs (delta)) {
877                         _soloed_by_others_upstream += delta;
878                 } else {
879                         _soloed_by_others_upstream = 0;
880                 }
881         } else {
882                 _soloed_by_others_upstream += delta;
883         }
884
885         DEBUG_TRACE (DEBUG::Solo, string_compose (
886                              "%1 SbU delta %2 = %3 old = %4 sbd %5 ss %6 exclusive %7\n",
887                              name(), delta, _soloed_by_others_upstream, old_sbu,
888                              _soloed_by_others_downstream, _self_solo, Config->get_exclusive_solo()));
889
890         /* push the inverse solo change to everything that feeds us.
891
892            This is important for solo-within-group. When we solo 1 track out of N that
893            feed a bus, that track will cause mod_solo_by_upstream (+1) to be called
894            on the bus. The bus then needs to call mod_solo_by_downstream (-1) on all
895            tracks that feed it. This will silence them if they were audible because
896            of a bus solo, but the newly soloed track will still be audible (because
897            it is self-soloed).
898
899            but .. do this only when we are being told to solo-by-upstream (i.e delta = +1),
900            not in reverse.
901         */
902
903         if ((_self_solo || _soloed_by_others_downstream) &&
904             ((old_sbu == 0 && _soloed_by_others_upstream > 0) ||
905              (old_sbu > 0 && _soloed_by_others_upstream == 0))) {
906
907                 if (delta > 0 || !Config->get_exclusive_solo()) {
908                         DEBUG_TRACE (DEBUG::Solo, "\t ... INVERT push\n");
909                         for (FedBy::iterator i = _fed_by.begin(); i != _fed_by.end(); ++i) {
910                                 boost::shared_ptr<Route> sr = i->r.lock();
911                                 if (sr) {
912                                         sr->mod_solo_by_others_downstream (-delta);
913                                 }
914                         }
915                 }
916         }
917
918         set_mute_master_solo ();
919         solo_changed (false, this);
920 }
921
922 void
923 Route::mod_solo_by_others_downstream (int32_t delta)
924 {
925         if (_solo_safe) {
926                 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 ignore solo-by-downstream due to solo safe\n", name()));
927                 return;
928         }
929
930         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 mod solo-by-downstream by %2, current up = %3 down = %4\n", 
931                                                   name(), delta, _soloed_by_others_upstream, _soloed_by_others_downstream));
932
933         if (delta < 0) {
934                 if (_soloed_by_others_downstream >= (uint32_t) abs (delta)) {
935                         _soloed_by_others_downstream += delta;
936                 } else {
937                         _soloed_by_others_downstream = 0;
938                 }
939         } else {
940                 _soloed_by_others_downstream += delta;
941         }
942
943         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 SbD delta %2 = %3\n", name(), delta, _soloed_by_others_downstream));
944
945         set_mute_master_solo ();
946         solo_changed (false, this);
947 }
948
949 void
950 Route::set_mute_master_solo ()
951 {
952         _mute_master->set_soloed (self_soloed() || soloed_by_others_downstream() || soloed_by_others_upstream());
953 }
954
955 void
956 Route::mod_solo_isolated_by_upstream (bool yn, void* src)
957 {
958         bool old = solo_isolated ();
959
960         if (!yn) {
961                 if (_solo_isolated_by_upstream >= 1) {
962                         _solo_isolated_by_upstream--;
963                 } else {
964                         _solo_isolated_by_upstream = 0;
965                 }
966         } else {
967                 _solo_isolated_by_upstream++;
968         }
969
970         if (solo_isolated() != old) {
971                 /* solo isolated status changed */
972                 _mute_master->set_solo_ignore (yn);
973                 solo_isolated_changed (src);
974         }
975 }
976
977 void
978 Route::set_solo_isolated (bool yn, void *src)
979 {
980         if (is_master() || is_monitor() || is_auditioner()) {
981                 return;
982         }
983
984         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
985                 _route_group->foreach_route (boost::bind (&Route::set_solo_isolated, _1, yn, _route_group));
986                 return;
987         }
988
989         bool changed = false;
990
991         if (yn) {
992                 if (_solo_isolated == false) {
993                         _mute_master->set_solo_ignore (true);
994                         changed = true;
995                 }
996                 _solo_isolated = true;
997         } else {
998                 if (_solo_isolated == true) {
999                         _solo_isolated = false;
1000             _mute_master->set_solo_ignore (false);
1001                         changed = true;
1002                 }
1003         }
1004
1005         
1006         if (!changed) {
1007                 return;
1008         }
1009         
1010         /* forward propagate solo-isolate status to everything fed by this route, but not those via sends only */
1011
1012         boost::shared_ptr<RouteList> routes = _session.get_routes ();
1013         for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
1014                 
1015                 if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
1016                         continue;
1017                 }
1018                 
1019                 bool sends_only;
1020                 bool does_feed = feeds (*i, &sends_only);
1021                 
1022                 if (does_feed && !sends_only) {
1023                         (*i)->mod_solo_isolated_by_upstream (yn, src);
1024                 }
1025         }
1026         
1027         /* XXX should we back-propagate as well? (April 2010: myself and chris goddard think not) */
1028
1029         solo_isolated_changed (src);
1030 }
1031
1032 bool
1033 Route::solo_isolated () const
1034 {
1035         return (_solo_isolated == true) || (_solo_isolated_by_upstream > 0);
1036 }
1037
1038 void
1039 Route::set_mute_points (MuteMaster::MutePoint mp)
1040 {
1041         _mute_master->set_mute_points (mp);
1042         mute_points_changed (); /* EMIT SIGNAL */
1043
1044         if (_mute_master->muted_by_self()) {
1045                 mute_changed (this); /* EMIT SIGNAL */
1046                 _mute_control->Changed (); /* EMIT SIGNAL */
1047         }
1048 }
1049
1050 void
1051 Route::set_mute (bool yn, void *src)
1052 {
1053         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_mute()) {
1054                 _route_group->foreach_route (boost::bind (&Route::set_mute, _1, yn, _route_group));
1055                 return;
1056         }
1057
1058         if (muted() != yn) {
1059                 _mute_master->set_muted_by_self (yn);
1060                 /* allow any derived classes to respond to the mute change
1061                    before anybody else knows about it.
1062                 */
1063                 act_on_mute ();
1064                 /* tell everyone else */
1065                 mute_changed (src); /* EMIT SIGNAL */
1066                 _mute_control->Changed (); /* EMIT SIGNAL */
1067         }
1068 }
1069
1070 bool
1071 Route::muted () const
1072 {
1073         return _mute_master->muted_by_self();
1074 }
1075
1076 bool
1077 Route::muted_by_others () const
1078 {
1079         //master is never muted by others
1080         if (is_master())
1081                 return false;
1082                 
1083         //now check to see if something is soloed (and I am not)
1084         return (_session.soloing() && !self_soloed() && !solo_isolated());
1085 }
1086
1087 #if 0
1088 static void
1089 dump_processors(const string& name, const list<boost::shared_ptr<Processor> >& procs)
1090 {
1091         cerr << name << " {" << endl;
1092         for (list<boost::shared_ptr<Processor> >::const_iterator p = procs.begin();
1093                         p != procs.end(); ++p) {
1094                 cerr << "\t" << (*p)->name() << " ID = " << (*p)->id() << " @ " << (*p) << endl;
1095         }
1096         cerr << "}" << endl;
1097 }
1098 #endif
1099
1100 /** Supposing that we want to insert a Processor at a given Placement, return
1101  *  the processor to add the new one before (or 0 to add at the end).
1102  */
1103 boost::shared_ptr<Processor>
1104 Route::before_processor_for_placement (Placement p)
1105 {
1106         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1107
1108         ProcessorList::iterator loc;
1109         
1110         if (p == PreFader) {
1111                 /* generic pre-fader: insert immediately before the amp */
1112                 loc = find (_processors.begin(), _processors.end(), _amp);
1113         } else {
1114                 /* generic post-fader: insert right before the main outs */
1115                 loc = find (_processors.begin(), _processors.end(), _main_outs);
1116         }
1117
1118         return loc != _processors.end() ? *loc : boost::shared_ptr<Processor> ();
1119 }
1120
1121 /** Supposing that we want to insert a Processor at a given index, return
1122  *  the processor to add the new one before (or 0 to add at the end).
1123  */
1124 boost::shared_ptr<Processor>
1125 Route::before_processor_for_index (int index)
1126 {
1127         if (index == -1) {
1128                 return boost::shared_ptr<Processor> ();
1129         }
1130
1131         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1132         
1133         ProcessorList::iterator i = _processors.begin ();
1134         int j = 0;
1135         while (i != _processors.end() && j < index) {
1136                 if ((*i)->display_to_user()) {
1137                         ++j;
1138                 }
1139                 
1140                 ++i;
1141         }
1142
1143         return (i != _processors.end() ? *i : boost::shared_ptr<Processor> ());
1144 }
1145
1146 /** Add a processor either pre- or post-fader
1147  *  @return 0 on success, non-0 on failure.
1148  */
1149 int
1150 Route::add_processor (boost::shared_ptr<Processor> processor, Placement placement, ProcessorStreams* err, bool activation_allowed)
1151 {
1152         return add_processor (processor, before_processor_for_placement (placement), err, activation_allowed);
1153 }
1154
1155
1156 /** Add a processor to a route such that it ends up with a given index into the visible processors.
1157  *  @param index Index to add the processor at, or -1 to add at the end of the list.
1158  *  @return 0 on success, non-0 on failure.
1159  */
1160 int
1161 Route::add_processor_by_index (boost::shared_ptr<Processor> processor, int index, ProcessorStreams* err, bool activation_allowed)
1162 {
1163         return add_processor (processor, before_processor_for_index (index), err, activation_allowed);
1164 }
1165
1166 /** Add a processor to the route.
1167  *  @param before An existing processor in the list, or 0; the new processor will be inserted immediately before it (or at the end).
1168  *  @return 0 on success, non-0 on failure.
1169  */
1170 int
1171 Route::add_processor (boost::shared_ptr<Processor> processor, boost::shared_ptr<Processor> before, ProcessorStreams* err, bool activation_allowed)
1172 {
1173         assert (processor != _meter);
1174         assert (processor != _main_outs);
1175
1176         DEBUG_TRACE (DEBUG::Processors, string_compose (
1177                              "%1 adding processor %2\n", name(), processor->name()));
1178
1179         if (!AudioEngine::instance()->connected() || !processor) {
1180                 return 1;
1181         }
1182
1183         {
1184                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1185                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1186                 ProcessorState pstate (this);
1187
1188                 boost::shared_ptr<PluginInsert> pi;
1189                 boost::shared_ptr<PortInsert> porti;
1190
1191                 if (processor == _amp) {
1192                         /* Ensure that only one amp is in the list at any time */
1193                         ProcessorList::iterator check = find (_processors.begin(), _processors.end(), processor);
1194                         if (check != _processors.end()) {
1195                                 if (before == _amp) {
1196                                         /* Already in position; all is well */
1197                                         return 0;
1198                                 } else {
1199                                         _processors.erase (check);
1200                                 }
1201                         }
1202                 }
1203
1204                 assert (find (_processors.begin(), _processors.end(), processor) == _processors.end ());
1205
1206                 ProcessorList::iterator loc;
1207                 if (before) {
1208                         /* inserting before a processor; find it */
1209                         loc = find (_processors.begin(), _processors.end(), before);
1210                         if (loc == _processors.end ()) {
1211                                 /* Not found */
1212                                 return 1;
1213                         }
1214                 } else {
1215                         /* inserting at end */
1216                         loc = _processors.end ();
1217                 }
1218
1219                 _processors.insert (loc, processor);
1220                 processor->set_owner (this);
1221
1222                 // Set up processor list channels.  This will set processor->[input|output]_streams(),
1223                 // configure redirect ports properly, etc.
1224
1225                 {
1226                         if (configure_processors_unlocked (err)) {
1227                                 pstate.restore ();
1228                                 configure_processors_unlocked (0); // it worked before we tried to add it ...
1229                                 return -1;
1230                         }
1231                 }
1232
1233                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(processor)) != 0) {
1234
1235                         if (pi->has_no_inputs ()) {
1236                                 /* generator plugin */
1237                                 _have_internal_generator = true;
1238                         }
1239
1240                 }
1241
1242                 if (activation_allowed && (!_session.get_disable_all_loaded_plugins () || !processor->display_to_user ())) {
1243                         processor->activate ();
1244                 }
1245
1246                 processor->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
1247
1248                 _output->set_user_latency (0);
1249         }
1250
1251         reset_instrument_info ();
1252         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1253         set_processor_positions ();
1254
1255         return 0;
1256 }
1257
1258 bool
1259 Route::add_processor_from_xml_2X (const XMLNode& node, int version)
1260 {
1261         const XMLProperty *prop;
1262
1263         try {
1264                 boost::shared_ptr<Processor> processor;
1265
1266                 /* bit of a hack: get the `placement' property from the <Redirect> tag here
1267                    so that we can add the processor in the right place (pre/post-fader)
1268                 */
1269
1270                 XMLNodeList const & children = node.children ();
1271                 XMLNodeList::const_iterator i = children.begin ();
1272
1273                 while (i != children.end() && (*i)->name() != X_("Redirect")) {
1274                         ++i;
1275                 }
1276
1277                 Placement placement = PreFader;
1278
1279                 if (i != children.end()) {
1280                         if ((prop = (*i)->property (X_("placement"))) != 0) {
1281                                 placement = Placement (string_2_enum (prop->value(), placement));
1282                         }
1283                 }
1284
1285                 if (node.name() == "Insert") {
1286
1287                         if ((prop = node.property ("type")) != 0) {
1288
1289                                 if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
1290                                                 prop->value() == "lv2" ||
1291                                                 prop->value() == "windows-vst" ||
1292                                                 prop->value() == "lxvst" ||
1293                                                 prop->value() == "audiounit") {
1294
1295                                         processor.reset (new PluginInsert (_session));
1296
1297                                 } else {
1298
1299                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
1300                                 }
1301
1302                         }
1303
1304                 } else if (node.name() == "Send") {
1305
1306                         boost::shared_ptr<Pannable> sendpan (new Pannable (_session));
1307                         processor.reset (new Send (_session, sendpan, _mute_master));
1308
1309                 } else {
1310
1311                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), node.name()) << endmsg;
1312                         return false;
1313                 }
1314
1315                 if (processor->set_state (node, version)) {
1316                         return false;
1317                 }
1318                 
1319                 //A2 uses the "active" flag in the toplevel redirect node, not in the child plugin/IO
1320                 if (i != children.end()) {
1321                         if ((prop = (*i)->property (X_("active"))) != 0) {
1322                                 if ( string_is_affirmative (prop->value()) && (!_session.get_disable_all_loaded_plugins () || !processor->display_to_user () ) )
1323                                         processor->activate();
1324                                 else
1325                                         processor->deactivate();
1326                         }
1327                 }
1328
1329                 return (add_processor (processor, placement, 0, false) == 0);
1330         }
1331
1332         catch (failed_constructor &err) {
1333                 warning << _("processor could not be created. Ignored.") << endmsg;
1334                 return false;
1335         }
1336 }
1337
1338 int
1339 Route::add_processors (const ProcessorList& others, boost::shared_ptr<Processor> before, ProcessorStreams* err)
1340 {
1341         /* NOTE: this is intended to be used ONLY when copying
1342            processors from another Route. Hence the subtle
1343            differences between this and ::add_processor()
1344         */
1345
1346         ProcessorList::iterator loc;
1347
1348         if (before) {
1349                 loc = find(_processors.begin(), _processors.end(), before);
1350         } else {
1351                 /* nothing specified - at end */
1352                 loc = _processors.end ();
1353         }
1354
1355         if (!_session.engine().connected()) {
1356                 return 1;
1357         }
1358
1359         if (others.empty()) {
1360                 return 0;
1361         }
1362
1363         {
1364                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1365                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1366                 ProcessorState pstate (this);
1367
1368                 for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
1369
1370                         if (*i == _meter) {
1371                                 continue;
1372                         }
1373
1374                         boost::shared_ptr<PluginInsert> pi;
1375
1376                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1377                                 pi->set_count (1);
1378                         }
1379
1380                         _processors.insert (loc, *i);
1381                         (*i)->set_owner (this);
1382
1383                         if ((*i)->active()) {
1384                                 (*i)->activate ();
1385                         }
1386
1387                         /* Think: does this really need to be called for every processor in the loop? */
1388                         {
1389                                 if (configure_processors_unlocked (err)) {
1390                                         pstate.restore ();
1391                                         configure_processors_unlocked (0); // it worked before we tried to add it ...
1392                                         return -1;
1393                                 }
1394                         }
1395
1396                         (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
1397                 }
1398
1399                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
1400                         boost::shared_ptr<PluginInsert> pi;
1401
1402                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1403                                 if (pi->has_no_inputs ()) {
1404                                         _have_internal_generator = true;
1405                                         break;
1406                                 }
1407                         }
1408                 }
1409
1410                 _output->set_user_latency (0);
1411         }
1412
1413         reset_instrument_info ();
1414         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1415         set_processor_positions ();
1416
1417         return 0;
1418 }
1419
1420 void
1421 Route::placement_range(Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end)
1422 {
1423         if (p == PreFader) {
1424                 start = _processors.begin();
1425                 end = find(_processors.begin(), _processors.end(), _amp);
1426         } else {
1427                 start = find(_processors.begin(), _processors.end(), _amp);
1428                 ++start;
1429                 end = _processors.end();
1430         }
1431 }
1432
1433 /** Turn off all processors with a given placement
1434  * @param p Placement of processors to disable
1435  */
1436 void
1437 Route::disable_processors (Placement p)
1438 {
1439         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1440
1441         ProcessorList::iterator start, end;
1442         placement_range(p, start, end);
1443
1444         for (ProcessorList::iterator i = start; i != end; ++i) {
1445                 (*i)->deactivate ();
1446         }
1447
1448         _session.set_dirty ();
1449 }
1450
1451 /** Turn off all redirects
1452  */
1453 void
1454 Route::disable_processors ()
1455 {
1456         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1457
1458         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1459                 (*i)->deactivate ();
1460         }
1461
1462         _session.set_dirty ();
1463 }
1464
1465 /** Turn off all redirects with a given placement
1466  * @param p Placement of redirects to disable
1467  */
1468 void
1469 Route::disable_plugins (Placement p)
1470 {
1471         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1472
1473         ProcessorList::iterator start, end;
1474         placement_range(p, start, end);
1475
1476         for (ProcessorList::iterator i = start; i != end; ++i) {
1477                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1478                         (*i)->deactivate ();
1479                 }
1480         }
1481
1482         _session.set_dirty ();
1483 }
1484
1485 /** Turn off all plugins
1486  */
1487 void
1488 Route::disable_plugins ()
1489 {
1490         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1491
1492         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1493                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1494                         (*i)->deactivate ();
1495                 }
1496         }
1497
1498         _session.set_dirty ();
1499 }
1500
1501
1502 void
1503 Route::ab_plugins (bool forward)
1504 {
1505         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1506
1507         if (forward) {
1508
1509                 /* forward = turn off all active redirects, and mark them so that the next time
1510                    we go the other way, we will revert them
1511                 */
1512
1513                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1514                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1515                                 continue;
1516                         }
1517
1518                         if ((*i)->active()) {
1519                                 (*i)->deactivate ();
1520                                 (*i)->set_next_ab_is_active (true);
1521                         } else {
1522                                 (*i)->set_next_ab_is_active (false);
1523                         }
1524                 }
1525
1526         } else {
1527
1528                 /* backward = if the redirect was marked to go active on the next ab, do so */
1529
1530                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1531
1532                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1533                                 continue;
1534                         }
1535
1536                         if ((*i)->get_next_ab_is_active()) {
1537                                 (*i)->activate ();
1538                         } else {
1539                                 (*i)->deactivate ();
1540                         }
1541                 }
1542         }
1543
1544         _session.set_dirty ();
1545 }
1546
1547
1548 /** Remove processors with a given placement.
1549  * @param p Placement of processors to remove.
1550  */
1551 void
1552 Route::clear_processors (Placement p)
1553 {
1554         if (!_session.engine().connected()) {
1555                 return;
1556         }
1557
1558         bool already_deleting = _session.deletion_in_progress();
1559         if (!already_deleting) {
1560                 _session.set_deletion_in_progress();
1561         }
1562
1563         {
1564                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1565                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1566                 ProcessorList new_list;
1567                 ProcessorStreams err;
1568                 bool seen_amp = false;
1569
1570                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1571
1572                         if (*i == _amp) {
1573                                 seen_amp = true;
1574                         }
1575
1576                         if ((*i) == _amp || (*i) == _meter || (*i) == _main_outs || (*i) == _delayline || (*i) == _trim) {
1577
1578                                 /* you can't remove these */
1579
1580                                 new_list.push_back (*i);
1581
1582                         } else {
1583                                 if (seen_amp) {
1584
1585                                         switch (p) {
1586                                         case PreFader:
1587                                                 new_list.push_back (*i);
1588                                                 break;
1589                                         case PostFader:
1590                                                 (*i)->drop_references ();
1591                                                 break;
1592                                         }
1593
1594                                 } else {
1595
1596                                         switch (p) {
1597                                         case PreFader:
1598                                                 (*i)->drop_references ();
1599                                                 break;
1600                                         case PostFader:
1601                                                 new_list.push_back (*i);
1602                                                 break;
1603                                         }
1604                                 }
1605                         }
1606                 }
1607
1608                 _processors = new_list;
1609                 configure_processors_unlocked (&err); // this can't fail
1610         }
1611
1612         processor_max_streams.reset();
1613         _have_internal_generator = false;
1614         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1615         set_processor_positions ();
1616
1617         reset_instrument_info ();
1618
1619         if (!already_deleting) {
1620                 _session.clear_deletion_in_progress();
1621         }
1622 }
1623
1624 int
1625 Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err, bool need_process_lock)
1626 {
1627         // TODO once the export point can be configured properly, do something smarter here
1628         if (processor == _capturing_processor) {
1629                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1630                 if (need_process_lock) {
1631                         lx.acquire();
1632                 }
1633
1634                 _capturing_processor.reset();
1635
1636                 if (need_process_lock) {
1637                         lx.release();
1638                 }
1639         }
1640
1641         /* these can never be removed */
1642
1643         if (processor == _amp || processor == _meter || processor == _main_outs || processor == _delayline || processor == _trim) {
1644                 return 0;
1645         }
1646
1647         if (!_session.engine().connected()) {
1648                 return 1;
1649         }
1650
1651         processor_max_streams.reset();
1652
1653         {
1654                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1655                 if (need_process_lock) {
1656                         lx.acquire();
1657                 }
1658
1659                 /* Caller must hold process lock */
1660                 assert (!AudioEngine::instance()->process_lock().trylock());
1661
1662                 Glib::Threads::RWLock::WriterLock lm (_processor_lock); // XXX deadlock after export
1663
1664                 ProcessorState pstate (this);
1665
1666                 ProcessorList::iterator i;
1667                 bool removed = false;
1668
1669                 for (i = _processors.begin(); i != _processors.end(); ) {
1670                         if (*i == processor) {
1671
1672                                 /* move along, see failure case for configure_processors()
1673                                    where we may need to reconfigure the processor.
1674                                 */
1675
1676                                 /* stop redirects that send signals to JACK ports
1677                                    from causing noise as a result of no longer being
1678                                    run.
1679                                 */
1680
1681                                 boost::shared_ptr<IOProcessor> iop;
1682
1683                                 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (*i)) != 0) {
1684                                         iop->disconnect ();
1685                                 }
1686
1687                                 i = _processors.erase (i);
1688                                 removed = true;
1689                                 break;
1690
1691                         } else {
1692                                 ++i;
1693                         }
1694
1695                         _output->set_user_latency (0);
1696                 }
1697
1698                 if (!removed) {
1699                         /* what? */
1700                         return 1;
1701                 } 
1702
1703                 if (configure_processors_unlocked (err)) {
1704                         pstate.restore ();
1705                         /* we know this will work, because it worked before :) */
1706                         configure_processors_unlocked (0);
1707                         return -1;
1708                 }
1709
1710                 _have_internal_generator = false;
1711
1712                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1713                         boost::shared_ptr<PluginInsert> pi;
1714
1715                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1716                                 if (pi->has_no_inputs ()) {
1717                                         _have_internal_generator = true;
1718                                         break;
1719                                 }
1720                         }
1721                 }
1722                 if (need_process_lock) {
1723                         lx.release();
1724                 }
1725         }
1726
1727         reset_instrument_info ();
1728         processor->drop_references ();
1729         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1730         set_processor_positions ();
1731
1732         return 0;
1733 }
1734
1735 int
1736 Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
1737 {
1738         ProcessorList deleted;
1739
1740         if (!_session.engine().connected()) {
1741                 return 1;
1742         }
1743
1744         processor_max_streams.reset();
1745
1746         {
1747                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1748                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1749                 ProcessorState pstate (this);
1750
1751                 ProcessorList::iterator i;
1752                 boost::shared_ptr<Processor> processor;
1753
1754                 for (i = _processors.begin(); i != _processors.end(); ) {
1755
1756                         processor = *i;
1757
1758                         /* these can never be removed */
1759
1760                         if (processor == _amp || processor == _meter || processor == _main_outs || processor == _delayline || processor == _trim) {
1761                                 ++i;
1762                                 continue;
1763                         }
1764
1765                         /* see if its in the list of processors to delete */
1766
1767                         if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
1768                                 ++i;
1769                                 continue;
1770                         }
1771
1772                         /* stop IOProcessors that send to JACK ports
1773                            from causing noise as a result of no longer being
1774                            run.
1775                         */
1776
1777                         boost::shared_ptr<IOProcessor> iop;
1778
1779                         if ((iop = boost::dynamic_pointer_cast<IOProcessor> (processor)) != 0) {
1780                                 iop->disconnect ();
1781                         }
1782
1783                         deleted.push_back (processor);
1784                         i = _processors.erase (i);
1785                 }
1786
1787                 if (deleted.empty()) {
1788                         /* none of those in the requested list were found */
1789                         return 0;
1790                 }
1791
1792                 _output->set_user_latency (0);
1793
1794                 if (configure_processors_unlocked (err)) {
1795                         pstate.restore ();
1796                         /* we know this will work, because it worked before :) */
1797                         configure_processors_unlocked (0);
1798                         return -1;
1799                 }
1800                 //lx.unlock();
1801
1802                 _have_internal_generator = false;
1803
1804                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1805                         boost::shared_ptr<PluginInsert> pi;
1806
1807                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1808                                 if (pi->has_no_inputs ()) {
1809                                         _have_internal_generator = true;
1810                                         break;
1811                                 }
1812                         }
1813                 }
1814         }
1815
1816         /* now try to do what we need to so that those that were removed will be deleted */
1817
1818         for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
1819                 (*i)->drop_references ();
1820         }
1821
1822         reset_instrument_info ();
1823         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1824         set_processor_positions ();
1825
1826         return 0;
1827 }
1828
1829 void
1830 Route::reset_instrument_info ()
1831 {
1832         boost::shared_ptr<Processor> instr = the_instrument();
1833         if (instr) {
1834                 _instrument_info.set_internal_instrument (instr);
1835         }
1836 }
1837
1838 /** Caller must hold process lock */
1839 int
1840 Route::configure_processors (ProcessorStreams* err)
1841 {
1842 #ifndef PLATFORM_WINDOWS
1843         assert (!AudioEngine::instance()->process_lock().trylock());
1844 #endif
1845
1846         if (!_in_configure_processors) {
1847                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1848                 return configure_processors_unlocked (err);
1849         }
1850
1851         return 0;
1852 }
1853
1854 ChanCount
1855 Route::input_streams () const
1856 {
1857         return _input->n_ports ();
1858 }
1859
1860 list<pair<ChanCount, ChanCount> >
1861 Route::try_configure_processors (ChanCount in, ProcessorStreams* err)
1862 {
1863         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1864
1865         return try_configure_processors_unlocked (in, err);
1866 }
1867
1868 list<pair<ChanCount, ChanCount> >
1869 Route::try_configure_processors_unlocked (ChanCount in, ProcessorStreams* err)
1870 {
1871         // Check each processor in order to see if we can configure as requested
1872         ChanCount out;
1873         list<pair<ChanCount, ChanCount> > configuration;
1874         uint32_t index = 0;
1875
1876         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
1877         DEBUG_TRACE (DEBUG::Processors, "{\n");
1878
1879         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1880
1881                 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1882                         DEBUG_TRACE (DEBUG::Processors, "--- CONFIGURE ABORTED due to unknown processor.\n");
1883                         DEBUG_TRACE (DEBUG::Processors, "}\n");
1884                         return list<pair<ChanCount, ChanCount> > ();
1885                 }
1886
1887                 if ((*p)->can_support_io_configuration(in, out)) {
1888                         DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID=%2 in=%3 out=%4\n",(*p)->name(), (*p)->id(), in, out));
1889                         configuration.push_back(make_pair(in, out));
1890                         in = out;
1891                 } else {
1892                         if (err) {
1893                                 err->index = index;
1894                                 err->count = in;
1895                         }
1896                         DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
1897                         DEBUG_TRACE (DEBUG::Processors, string_compose ("---- %1 cannot support in=%2 out=%3\n", (*p)->name(), in, out));
1898                         DEBUG_TRACE (DEBUG::Processors, "}\n");
1899                         return list<pair<ChanCount, ChanCount> > ();
1900                 }
1901         }
1902
1903         DEBUG_TRACE (DEBUG::Processors, "}\n");
1904
1905         return configuration;
1906 }
1907
1908 /** Set the input/output configuration of each processor in the processors list.
1909  *  Caller must hold process lock.
1910  *  Return 0 on success, otherwise configuration is impossible.
1911  */
1912 int
1913 Route::configure_processors_unlocked (ProcessorStreams* err)
1914 {
1915 #ifndef PLATFORM_WINDOWS
1916         assert (!AudioEngine::instance()->process_lock().trylock());
1917 #endif
1918
1919         if (_in_configure_processors) {
1920                 return 0;
1921         }
1922
1923         /* put invisible processors where they should be */
1924         setup_invisible_processors ();
1925
1926         _in_configure_processors = true;
1927
1928         list<pair<ChanCount, ChanCount> > configuration = try_configure_processors_unlocked (input_streams (), err);
1929
1930         if (configuration.empty ()) {
1931                 _in_configure_processors = false;
1932                 return -1;
1933         }
1934
1935         ChanCount out;
1936         bool seen_mains_out = false;
1937         processor_out_streams = _input->n_ports();
1938         processor_max_streams.reset();
1939
1940         list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1941         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1942
1943                 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1944                         break;
1945                 }
1946
1947                 (*p)->configure_io(c->first, c->second);
1948                 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1949                 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1950
1951                 boost::shared_ptr<PluginInsert> pi;
1952                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
1953                         /* plugins connected via Split Match may have more channels.
1954                          * route/scratch buffers are needed for all of them*/
1955                         processor_max_streams = ChanCount::max(processor_max_streams, pi->input_streams());
1956                         processor_max_streams = ChanCount::max(processor_max_streams, pi->natural_input_streams());
1957                 }
1958                 out = c->second;
1959
1960                 if (boost::dynamic_pointer_cast<Delivery> (*p)
1961                                 && boost::dynamic_pointer_cast<Delivery> (*p)->role() == Delivery::Main) {
1962                         /* main delivery will increase port count to match input.
1963                          * the Delivery::Main is usually the last processor - followed only by
1964                          * 'MeterOutput'.
1965                          */
1966                         seen_mains_out = true;
1967                 }
1968                 if (!seen_mains_out) {
1969                         processor_out_streams = out;
1970                 }
1971         }
1972
1973
1974         if (_meter) {
1975                 _meter->set_max_channels (processor_max_streams);
1976         }
1977
1978         /* make sure we have sufficient scratch buffers to cope with the new processor
1979            configuration 
1980         */
1981         _session.ensure_buffers (n_process_buffers ());
1982
1983         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
1984
1985         _in_configure_processors = false;
1986         return 0;
1987 }
1988
1989 /** Set all visible processors to a given active state (except Fader, whose state is not changed)
1990  *  @param state New active state for those processors.
1991  */
1992 void
1993 Route::all_visible_processors_active (bool state)
1994 {
1995         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1996
1997         if (_processors.empty()) {
1998                 return;
1999         }
2000         
2001         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2002                 if (!(*i)->display_to_user() || boost::dynamic_pointer_cast<Amp> (*i)) {
2003                         continue;
2004                 }
2005                 
2006                 if (state) {
2007                         (*i)->activate ();
2008                 } else {
2009                         (*i)->deactivate ();
2010                 }
2011         }
2012
2013         _session.set_dirty ();
2014 }
2015
2016 bool
2017 Route::processors_reorder_needs_configure (const ProcessorList& new_order)
2018 {
2019         /* check if re-order requires re-configuration of any processors
2020          * -> compare channel configuration for all processors
2021          */
2022         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2023         ChanCount c = input_streams ();
2024
2025         for (ProcessorList::const_iterator j = new_order.begin(); j != new_order.end(); ++j) {
2026                 bool found = false;
2027                 if (c != (*j)->input_streams()) {
2028                         return true;
2029                 }
2030                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2031                         if (*i == *j) {
2032                                 found = true;
2033                                 if ((*i)->input_streams() != c) {
2034                                         return true;
2035                                 }
2036                                 c = (*i)->output_streams();
2037                                 break;
2038                         }
2039                 }
2040                 if (!found) {
2041                         return true;
2042                 }
2043         }
2044         return false;
2045 }
2046
2047 #ifdef __clang__
2048 __attribute__((annotate("realtime")))
2049 #endif
2050 void
2051 Route::apply_processor_order (const ProcessorList& new_order)
2052 {
2053         /* need to hold processor_lock; either read or write lock
2054          * and the engine process_lock.
2055          * Due to r/w lock ambiguity we can only assert the latter
2056          */
2057         assert (!AudioEngine::instance()->process_lock().trylock());
2058
2059
2060         /* "new_order" is an ordered list of processors to be positioned according to "placement".
2061          * NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
2062          * processors in the current actual processor list that are hidden. Any visible processors
2063          *  in the current list but not in "new_order" will be assumed to be deleted.
2064          */
2065
2066         /* "as_it_will_be" and "_processors" are lists of shared pointers.
2067          * actual memory usage is small, but insert/erase is not actually rt-safe :(
2068          * (note though that  ::processors_reorder_needs_configure() ensured that
2069          * this function will only ever be called from the rt-thread if no processor were removed)
2070          *
2071          * either way, I can't proove it, but an x-run due to re-order here is less likley
2072          * than an x-run-less 'ardour-silent cycle' both of which effectively "click".
2073          */
2074
2075         ProcessorList as_it_will_be;
2076         ProcessorList::iterator oiter;
2077         ProcessorList::const_iterator niter;
2078
2079         oiter = _processors.begin();
2080         niter = new_order.begin();
2081
2082         while (niter !=  new_order.end()) {
2083
2084                 /* if the next processor in the old list is invisible (i.e. should not be in the new order)
2085                    then append it to the temp list.
2086
2087                    Otherwise, see if the next processor in the old list is in the new list. if not,
2088                    its been deleted. If its there, append it to the temp list.
2089                    */
2090
2091                 if (oiter == _processors.end()) {
2092
2093                         /* no more elements in the old list, so just stick the rest of
2094                            the new order onto the temp list.
2095                            */
2096
2097                         as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
2098                         while (niter != new_order.end()) {
2099                                 ++niter;
2100                         }
2101                         break;
2102
2103                 } else {
2104
2105                         if (!(*oiter)->display_to_user()) {
2106
2107                                 as_it_will_be.push_back (*oiter);
2108
2109                         } else {
2110
2111                                 /* visible processor: check that its in the new order */
2112
2113                                 if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
2114                                         /* deleted: do nothing, shared_ptr<> will clean up */
2115                                 } else {
2116                                         /* ignore this one, and add the next item from the new order instead */
2117                                         as_it_will_be.push_back (*niter);
2118                                         ++niter;
2119                                 }
2120                         }
2121
2122                         /* now remove from old order - its taken care of no matter what */
2123                         oiter = _processors.erase (oiter);
2124                 }
2125
2126         }
2127         _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
2128
2129         /* If the meter is in a custom position, find it and make a rough note of its position */
2130         maybe_note_meter_position ();
2131 }
2132
2133 int
2134 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
2135 {
2136         // it a change is already queued, wait for it
2137         // (unless engine is stopped. apply immediately and proceed
2138         while (g_atomic_int_get (&_pending_process_reorder)) {
2139                 if (!AudioEngine::instance()->running()) {
2140                         DEBUG_TRACE (DEBUG::Processors, "offline apply queued processor re-order.\n");
2141                         Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2142
2143                         apply_processor_order(_pending_processor_order);
2144                         setup_invisible_processors ();
2145
2146                         g_atomic_int_set (&_pending_process_reorder, 0);
2147
2148                         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2149                         set_processor_positions ();
2150                 } else {
2151                         // TODO rather use a semaphore or something.
2152                         // but since ::reorder_processors() is called
2153                         // from the GUI thread, this is fine..
2154                         Glib::usleep(500);
2155                 }
2156         }
2157
2158         if (processors_reorder_needs_configure (new_order) || !AudioEngine::instance()->running()) {
2159
2160                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2161                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2162                 ProcessorState pstate (this);
2163
2164                 apply_processor_order (new_order);
2165
2166                 if (configure_processors_unlocked (err)) {
2167                         pstate.restore ();
2168                         return -1;
2169                 }
2170
2171                 lm.release();
2172                 lx.release();
2173
2174                 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2175                 set_processor_positions ();
2176
2177         } else {
2178                 DEBUG_TRACE (DEBUG::Processors, "Queue clickless processor re-order.\n");
2179                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2180
2181                 // _pending_processor_order is protected by _processor_lock
2182                 _pending_processor_order = new_order;
2183                 g_atomic_int_set (&_pending_process_reorder, 1);
2184         }
2185
2186         return 0;
2187 }
2188
2189 XMLNode&
2190 Route::get_state()
2191 {
2192         return state(true);
2193 }
2194
2195 XMLNode&
2196 Route::get_template()
2197 {
2198         return state(false);
2199 }
2200
2201 XMLNode&
2202 Route::state(bool full_state)
2203 {
2204         XMLNode *node = new XMLNode("Route");
2205         ProcessorList::iterator i;
2206         char buf[32];
2207
2208         id().print (buf, sizeof (buf));
2209         node->add_property("id", buf);
2210         node->add_property ("name", _name);
2211         node->add_property("default-type", _default_type.to_string());
2212
2213         if (_flags) {
2214                 node->add_property("flags", enum_2_string (_flags));
2215         }
2216
2217         node->add_property("active", _active?"yes":"no");
2218         string p;
2219         boost::to_string (_phase_invert, p);
2220         node->add_property("phase-invert", p);
2221         node->add_property("denormal-protection", _denormal_protection?"yes":"no");
2222         node->add_property("meter-point", enum_2_string (_meter_point));
2223
2224         node->add_property("meter-type", enum_2_string (_meter_type));
2225
2226         if (_route_group) {
2227                 node->add_property("route-group", _route_group->name());
2228         }
2229
2230         snprintf (buf, sizeof (buf), "%d", _order_key);
2231         node->add_property ("order-key", buf);
2232         node->add_property ("self-solo", (_self_solo ? "yes" : "no"));
2233         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_upstream);
2234         node->add_property ("soloed-by-upstream", buf);
2235         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_downstream);
2236         node->add_property ("soloed-by-downstream", buf);
2237         node->add_property ("solo-isolated", solo_isolated() ? "yes" : "no");
2238         node->add_property ("solo-safe", _solo_safe ? "yes" : "no");
2239
2240         node->add_child_nocopy (_input->state (full_state));
2241         node->add_child_nocopy (_output->state (full_state));
2242         node->add_child_nocopy (_solo_control->get_state ());
2243         node->add_child_nocopy (_mute_control->get_state ());
2244         node->add_child_nocopy (_mute_master->get_state ());
2245
2246         if (full_state) {
2247                 node->add_child_nocopy (Automatable::get_automation_xml_state ());
2248         }
2249
2250         XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
2251         snprintf (buf, sizeof (buf), "%d", _remote_control_id);
2252         remote_control_node->add_property (X_("id"), buf);
2253         node->add_child_nocopy (*remote_control_node);
2254
2255         if (_comment.length()) {
2256                 XMLNode *cmt = node->add_child ("Comment");
2257                 cmt->add_content (_comment);
2258         }
2259
2260         if (_pannable) {
2261                 node->add_child_nocopy (_pannable->state (full_state));
2262         }
2263
2264         for (i = _processors.begin(); i != _processors.end(); ++i) {
2265                 if (!full_state) {
2266                         /* template save: do not include internal sends functioning as 
2267                            aux sends because the chance of the target ID
2268                            in the session where this template is used
2269                            is not very likely.
2270
2271                            similarly, do not save listen sends which connect to
2272                            the monitor section, because these will always be
2273                            added if necessary.
2274                         */
2275                         boost::shared_ptr<InternalSend> is;
2276
2277                         if ((is = boost::dynamic_pointer_cast<InternalSend> (*i)) != 0) {
2278                                 if (is->role() == Delivery::Listen) {
2279                                         continue;
2280                                 }
2281                         }
2282                 }
2283                 node->add_child_nocopy((*i)->state (full_state));
2284         }
2285
2286         if (_extra_xml) {
2287                 node->add_child_copy (*_extra_xml);
2288         }
2289
2290         if (_custom_meter_position_noted) {
2291                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
2292                 if (after) {
2293                         after->id().print (buf, sizeof (buf));
2294                         node->add_property (X_("processor-after-last-custom-meter"), buf);
2295                 }
2296         }
2297
2298         return *node;
2299 }
2300
2301 int
2302 Route::set_state (const XMLNode& node, int version)
2303 {
2304         if (version < 3000) {
2305                 return set_state_2X (node, version);
2306         }
2307
2308         XMLNodeList nlist;
2309         XMLNodeConstIterator niter;
2310         XMLNode *child;
2311         const XMLProperty *prop;
2312
2313         if (node.name() != "Route"){
2314                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2315                 return -1;
2316         }
2317
2318         if ((prop = node.property (X_("name"))) != 0) {
2319                 Route::set_name (prop->value());
2320         }
2321
2322         set_id (node);
2323         _initial_io_setup = true;
2324
2325         if ((prop = node.property (X_("flags"))) != 0) {
2326                 _flags = Flag (string_2_enum (prop->value(), _flags));
2327         } else {
2328                 _flags = Flag (0);
2329         }
2330
2331         if (is_master() || is_monitor() || is_auditioner()) {
2332                 _mute_master->set_solo_ignore (true);
2333         }
2334
2335         if (is_monitor()) {
2336                 /* monitor bus does not get a panner, but if (re)created
2337                    via XML, it will already have one by the time we
2338                    call ::set_state(). so ... remove it.
2339                 */
2340                 unpan ();
2341         }
2342
2343         /* add all processors (except amp, which is always present) */
2344
2345         nlist = node.children();
2346         XMLNode processor_state (X_("processor_state"));
2347
2348         Stateful::save_extra_xml (node);
2349
2350         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2351
2352                 child = *niter;
2353
2354                 if (child->name() == IO::state_node_name) {
2355                         if ((prop = child->property (X_("direction"))) == 0) {
2356                                 continue;
2357                         }
2358
2359                         if (prop->value() == "Input") {
2360                                 _input->set_state (*child, version);
2361                         } else if (prop->value() == "Output") {
2362                                 _output->set_state (*child, version);
2363                         }
2364                 }
2365
2366                 if (child->name() == X_("Processor")) {
2367                         processor_state.add_child_copy (*child);
2368                 }
2369
2370                 if (child->name() == X_("Pannable")) {
2371                         if (_pannable) {
2372                                 _pannable->set_state (*child, version);
2373                         } else {
2374                                 warning << string_compose (_("Pannable state found for route (%1) without a panner!"), name()) << endmsg;
2375                         }
2376                 }
2377         }
2378
2379         if ((prop = node.property (X_("meter-point"))) != 0) {
2380                 MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
2381                 set_meter_point (mp, true);
2382                 if (_meter) {
2383                         _meter->set_display_to_user (_meter_point == MeterCustom);
2384                 }
2385         }
2386
2387         if ((prop = node.property (X_("meter-type"))) != 0) {
2388                 _meter_type = MeterType (string_2_enum (prop->value (), _meter_type));
2389         }
2390
2391         _initial_io_setup = false;
2392
2393         set_processor_state (processor_state);
2394
2395         // this looks up the internal instrument in processors
2396         reset_instrument_info();
2397
2398         if ((prop = node.property ("self-solo")) != 0) {
2399                 set_self_solo (string_is_affirmative (prop->value()));
2400         }
2401
2402         if ((prop = node.property ("soloed-by-upstream")) != 0) {
2403                 _soloed_by_others_upstream = 0; // needed for mod_.... () to work
2404                 mod_solo_by_others_upstream (atoi (prop->value()));
2405         }
2406
2407         if ((prop = node.property ("soloed-by-downstream")) != 0) {
2408                 _soloed_by_others_downstream = 0; // needed for mod_.... () to work
2409                 mod_solo_by_others_downstream (atoi (prop->value()));
2410         }
2411
2412         if ((prop = node.property ("solo-isolated")) != 0) {
2413                 set_solo_isolated (string_is_affirmative (prop->value()), this);
2414         }
2415
2416         if ((prop = node.property ("solo-safe")) != 0) {
2417                 set_solo_safe (string_is_affirmative (prop->value()), this);
2418         }
2419
2420         if ((prop = node.property (X_("phase-invert"))) != 0) {
2421                 set_phase_invert (boost::dynamic_bitset<> (prop->value ()));
2422         }
2423
2424         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2425                 set_denormal_protection (string_is_affirmative (prop->value()));
2426         }
2427
2428         if ((prop = node.property (X_("active"))) != 0) {
2429                 bool yn = string_is_affirmative (prop->value());
2430                 _active = !yn; // force switch
2431                 set_active (yn, this);
2432         }
2433
2434         if ((prop = node.property (X_("order-key"))) != 0) { // New order key (no separate mixer/editor ordering)
2435                 set_order_key (atoi(prop->value()));
2436         }
2437
2438         if ((prop = node.property (X_("order-keys"))) != 0) { // Deprecated order keys
2439
2440                 int32_t n;
2441
2442                 string::size_type colon, equal;
2443                 string remaining = prop->value();
2444
2445                 while (remaining.length()) {
2446
2447                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2448                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2449                                       << endmsg;
2450                         } else {
2451                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2452                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2453                                               << endmsg;
2454                                 } else {
2455                                         string keyname = remaining.substr (0, equal);
2456
2457                                         if ((keyname == "EditorSort") || (keyname == "editor")) {
2458                                                 cerr << "Setting " << name() << " order key to " << n << " using saved Editor order." << endl;
2459                                                 set_order_key (n);
2460                                         }
2461                                 }
2462                         }
2463
2464                         colon = remaining.find_first_of (':');
2465
2466                         if (colon != string::npos) {
2467                                 remaining = remaining.substr (colon+1);
2468                         } else {
2469                                 break;
2470                         }
2471                 }
2472         }
2473
2474         if ((prop = node.property (X_("processor-after-last-custom-meter"))) != 0) {
2475                 PBD::ID id (prop->value ());
2476                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2477                 ProcessorList::const_iterator i = _processors.begin ();
2478                 while (i != _processors.end() && (*i)->id() != id) {
2479                         ++i;
2480                 }
2481
2482                 if (i != _processors.end ()) {
2483                         _processor_after_last_custom_meter = *i;
2484                         _custom_meter_position_noted = true;
2485                 }
2486         }
2487
2488         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2489                 child = *niter;
2490
2491                 if (child->name() == X_("Comment")) {
2492
2493                         /* XXX this is a terrible API design in libxml++ */
2494
2495                         XMLNode *cmt = *(child->children().begin());
2496                         _comment = cmt->content();
2497
2498                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2499                         if (prop->value() == "solo") {
2500                                 _solo_control->set_state (*child, version);
2501                         } else if (prop->value() == "mute") {
2502                                 _mute_control->set_state (*child, version);
2503                         }
2504
2505                 } else if (child->name() == X_("RemoteControl")) {
2506                         if ((prop = child->property (X_("id"))) != 0) {
2507                                 int32_t x;
2508                                 sscanf (prop->value().c_str(), "%d", &x);
2509                                 set_remote_control_id_internal (x);
2510                         }
2511
2512                 } else if (child->name() == X_("MuteMaster")) {
2513                         _mute_master->set_state (*child, version);
2514
2515                 } else if (child->name() == Automatable::xml_node_name) {
2516                         set_automation_xml_state (*child, Evoral::Parameter(NullAutomation));
2517                 }
2518         }
2519
2520         return 0;
2521 }
2522
2523 int
2524 Route::set_state_2X (const XMLNode& node, int version)
2525 {
2526         LocaleGuard lg (X_("C"));
2527         XMLNodeList nlist;
2528         XMLNodeConstIterator niter;
2529         XMLNode *child;
2530         const XMLProperty *prop;
2531
2532         /* 2X things which still remain to be handled:
2533          * default-type
2534          * automation
2535          * controlouts
2536          */
2537
2538         if (node.name() != "Route") {
2539                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2540                 return -1;
2541         }
2542
2543         if ((prop = node.property (X_("flags"))) != 0) {
2544                 string f = prop->value ();
2545                 boost::replace_all (f, "ControlOut", "MonitorOut");
2546                 _flags = Flag (string_2_enum (f, _flags));
2547         } else {
2548                 _flags = Flag (0);
2549         }
2550
2551         if (is_master() || is_monitor() || is_auditioner()) {
2552                 _mute_master->set_solo_ignore (true);
2553         }
2554
2555         if ((prop = node.property (X_("phase-invert"))) != 0) {
2556                 boost::dynamic_bitset<> p (_input->n_ports().n_audio ());
2557                 if (string_is_affirmative (prop->value ())) {
2558                         p.set ();
2559                 }
2560                 set_phase_invert (p);
2561         }
2562
2563         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2564                 set_denormal_protection (string_is_affirmative (prop->value()));
2565         }
2566
2567         if ((prop = node.property (X_("soloed"))) != 0) {
2568                 bool yn = string_is_affirmative (prop->value());
2569
2570                 /* XXX force reset of solo status */
2571
2572                 set_solo (yn, this);
2573         }
2574
2575         if ((prop = node.property (X_("muted"))) != 0) {
2576
2577                 bool first = true;
2578                 bool muted = string_is_affirmative (prop->value());
2579
2580                 if (muted) {
2581
2582                         string mute_point;
2583
2584                         if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
2585
2586                                 if (string_is_affirmative (prop->value())){
2587                                         mute_point = mute_point + "PreFader";
2588                                         first = false;
2589                                 }
2590                         }
2591
2592                         if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
2593
2594                                 if (string_is_affirmative (prop->value())){
2595
2596                                         if (!first) {
2597                                                 mute_point = mute_point + ",";
2598                                         }
2599
2600                                         mute_point = mute_point + "PostFader";
2601                                         first = false;
2602                                 }
2603                         }
2604
2605                         if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
2606
2607                                 if (string_is_affirmative (prop->value())){
2608
2609                                         if (!first) {
2610                                                 mute_point = mute_point + ",";
2611                                         }
2612
2613                                         mute_point = mute_point + "Listen";
2614                                         first = false;
2615                                 }
2616                         }
2617
2618                         if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
2619
2620                                 if (string_is_affirmative (prop->value())){
2621
2622                                         if (!first) {
2623                                                 mute_point = mute_point + ",";
2624                                         }
2625
2626                                         mute_point = mute_point + "Main";
2627                                 }
2628                         }
2629
2630                         _mute_master->set_mute_points (mute_point);
2631                         _mute_master->set_muted_by_self (true);
2632                 }
2633         }
2634
2635         if ((prop = node.property (X_("meter-point"))) != 0) {
2636                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2637         }
2638
2639         /* do not carry over edit/mix groups from 2.X because (a) its hard (b) they
2640            don't mean the same thing.
2641         */
2642
2643         if ((prop = node.property (X_("order-keys"))) != 0) {
2644
2645                 int32_t n;
2646
2647                 string::size_type colon, equal;
2648                 string remaining = prop->value();
2649
2650                 while (remaining.length()) {
2651
2652                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2653                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2654                                         << endmsg;
2655                         } else {
2656                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2657                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2658                                                 << endmsg;
2659                                 } else {
2660                                         string keyname = remaining.substr (0, equal);
2661
2662                                         if (keyname == "EditorSort" || keyname == "editor") {
2663                                                 info << string_compose(_("Converting deprecated order key for %1 using Editor order %2"), name (), n) << endmsg;
2664                                                 set_order_key (n);
2665                                         }
2666                                 }
2667                         }
2668
2669                         colon = remaining.find_first_of (':');
2670
2671                         if (colon != string::npos) {
2672                                 remaining = remaining.substr (colon+1);
2673                         } else {
2674                                 break;
2675                         }
2676                 }
2677         }
2678
2679         /* IOs */
2680
2681         nlist = node.children ();
2682         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2683
2684                 child = *niter;
2685
2686                 if (child->name() == IO::state_node_name) {
2687
2688                         /* there is a note in IO::set_state_2X() about why we have to call
2689                            this directly.
2690                            */
2691
2692                         _input->set_state_2X (*child, version, true);
2693                         _output->set_state_2X (*child, version, false);
2694
2695                         if ((prop = child->property (X_("name"))) != 0) {
2696                                 Route::set_name (prop->value ());
2697                         }
2698
2699                         set_id (*child);
2700
2701                         if ((prop = child->property (X_("active"))) != 0) {
2702                                 bool yn = string_is_affirmative (prop->value());
2703                                 _active = !yn; // force switch
2704                                 set_active (yn, this);
2705                         }
2706
2707                         if ((prop = child->property (X_("gain"))) != 0) {
2708                                 gain_t val;
2709
2710                                 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2711                                         _amp->gain_control()->set_value (val);
2712                                 }
2713                         }
2714
2715                         /* Set up Panners in the IO */
2716                         XMLNodeList io_nlist = child->children ();
2717
2718                         XMLNodeConstIterator io_niter;
2719                         XMLNode *io_child;
2720
2721                         for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2722
2723                                 io_child = *io_niter;
2724
2725                                 if (io_child->name() == X_("Panner")) {
2726                                         _main_outs->panner_shell()->set_state(*io_child, version);
2727                                 } else if (io_child->name() == X_("Automation")) {
2728                                         /* IO's automation is for the fader */
2729                                         _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
2730                                 }
2731                         }
2732                 }
2733         }
2734
2735         XMLNodeList redirect_nodes;
2736
2737         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2738
2739                 child = *niter;
2740
2741                 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2742                         redirect_nodes.push_back(child);
2743                 }
2744
2745         }
2746
2747         set_processor_state_2X (redirect_nodes, version);
2748
2749         Stateful::save_extra_xml (node);
2750
2751         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2752                 child = *niter;
2753
2754                 if (child->name() == X_("Comment")) {
2755
2756                         /* XXX this is a terrible API design in libxml++ */
2757
2758                         XMLNode *cmt = *(child->children().begin());
2759                         _comment = cmt->content();
2760
2761                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2762                         if (prop->value() == X_("solo")) {
2763                                 _solo_control->set_state (*child, version);
2764                         } else if (prop->value() == X_("mute")) {
2765                                 _mute_control->set_state (*child, version);
2766                         }
2767
2768                 } else if (child->name() == X_("RemoteControl")) {
2769                         if ((prop = child->property (X_("id"))) != 0) {
2770                                 int32_t x;
2771                                 sscanf (prop->value().c_str(), "%d", &x);
2772                                 set_remote_control_id_internal (x);
2773                         }
2774
2775                 }
2776         }
2777
2778         return 0;
2779 }
2780
2781 XMLNode&
2782 Route::get_processor_state ()
2783 {
2784         XMLNode* root = new XMLNode (X_("redirects"));
2785         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2786                 root->add_child_nocopy ((*i)->state (true));
2787         }
2788
2789         return *root;
2790 }
2791
2792 void
2793 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2794 {
2795         /* We don't bother removing existing processors not in nList, as this
2796            method will only be called when creating a Route from scratch, not
2797            for undo purposes.  Just put processors in at the appropriate place
2798            in the list.
2799         */
2800
2801         for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2802                 add_processor_from_xml_2X (**i, version);
2803         }
2804 }
2805
2806 void
2807 Route::set_processor_state (const XMLNode& node)
2808 {
2809         const XMLNodeList &nlist = node.children();
2810         XMLNodeConstIterator niter;
2811         ProcessorList new_order;
2812         bool must_configure = false;
2813
2814         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2815
2816                 XMLProperty* prop = (*niter)->property ("type");
2817
2818                 if (prop->value() == "amp") {
2819                         _amp->set_state (**niter, Stateful::current_state_version);
2820                         new_order.push_back (_amp);
2821                 } else if (prop->value() == "trim") {
2822                         _trim->set_state (**niter, Stateful::current_state_version);
2823                         new_order.push_back (_trim);
2824                 } else if (prop->value() == "meter") {
2825                         _meter->set_state (**niter, Stateful::current_state_version);
2826                         new_order.push_back (_meter);
2827                 } else if (prop->value() == "delay") {
2828                         if (_delayline) {
2829                                 _delayline->set_state (**niter, Stateful::current_state_version);
2830                                 new_order.push_back (_delayline);
2831                         }
2832                 } else if (prop->value() == "main-outs") {
2833                         _main_outs->set_state (**niter, Stateful::current_state_version);
2834                 } else if (prop->value() == "intreturn") {
2835                         if (!_intreturn) {
2836                                 _intreturn.reset (new InternalReturn (_session));
2837                                 must_configure = true;
2838                         }
2839                         _intreturn->set_state (**niter, Stateful::current_state_version);
2840                 } else if (is_monitor() && prop->value() == "monitor") {
2841                         if (!_monitor_control) {
2842                                 _monitor_control.reset (new MonitorProcessor (_session));
2843                                 must_configure = true;
2844                         }
2845                         _monitor_control->set_state (**niter, Stateful::current_state_version);
2846                 } else if (prop->value() == "capture") {
2847                         /* CapturingProcessor should never be restored, it's always
2848                            added explicitly when needed */
2849                 } else {
2850                         ProcessorList::iterator o;
2851
2852                         for (o = _processors.begin(); o != _processors.end(); ++o) {
2853                                 XMLProperty* id_prop = (*niter)->property(X_("id"));
2854                                 if (id_prop && (*o)->id() == id_prop->value()) {
2855                                         (*o)->set_state (**niter, Stateful::current_state_version);
2856                                         new_order.push_back (*o);
2857                                         break;
2858                                 }
2859                         }
2860
2861                         // If the processor (*niter) is not on the route then create it
2862
2863                         if (o == _processors.end()) {
2864
2865                                 boost::shared_ptr<Processor> processor;
2866
2867                                 if (prop->value() == "intsend") {
2868
2869                                         processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), boost::shared_ptr<Route>(), Delivery::Aux, true));
2870
2871                                 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2872                                            prop->value() == "lv2" ||
2873                                            prop->value() == "windows-vst" ||
2874                                            prop->value() == "lxvst" ||
2875                                            prop->value() == "audiounit") {
2876
2877                                         processor.reset (new PluginInsert(_session));
2878
2879                                 } else if (prop->value() == "port") {
2880
2881                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
2882
2883                                 } else if (prop->value() == "send") {
2884
2885                                         processor.reset (new Send (_session, _pannable, _mute_master, Delivery::Send, true));
2886
2887                                 } else {
2888                                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2889                                         continue;
2890                                 }
2891
2892                                 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2893                                         /* This processor could not be configured.  Turn it into a UnknownProcessor */
2894                                         processor.reset (new UnknownProcessor (_session, **niter));
2895                                 }
2896
2897                                 /* we have to note the monitor send here, otherwise a new one will be created
2898                                    and the state of this one will be lost.
2899                                 */
2900                                 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
2901                                 if (isend && isend->role() == Delivery::Listen) {
2902                                         _monitor_send = isend;
2903                                 }
2904
2905                                 /* it doesn't matter if invisible processors are added here, as they
2906                                    will be sorted out by setup_invisible_processors () shortly.
2907                                 */
2908
2909                                 new_order.push_back (processor);
2910                                 must_configure = true;
2911                         }
2912                 }
2913         }
2914
2915         {
2916                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2917                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2918                 _processors = new_order;
2919
2920                 if (must_configure) {
2921                         configure_processors_unlocked (0);
2922                 }
2923
2924                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2925
2926                         (*i)->set_owner (this);
2927                         (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
2928
2929                         boost::shared_ptr<PluginInsert> pi;
2930
2931                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
2932                                 if (pi->has_no_inputs ()) {
2933                                         _have_internal_generator = true;
2934                                         break;
2935                                 }
2936                         }
2937                 }
2938         }
2939
2940         reset_instrument_info ();
2941         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2942         set_processor_positions ();
2943 }
2944
2945 void
2946 Route::curve_reallocate ()
2947 {
2948 //      _gain_automation_curve.finish_resize ();
2949 //      _pan_automation_curve.finish_resize ();
2950 }
2951
2952 void
2953 Route::silence (framecnt_t nframes)
2954 {
2955         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
2956         if (!lm.locked()) {
2957                 return;
2958         }
2959
2960         silence_unlocked (nframes);
2961 }
2962
2963 void
2964 Route::silence_unlocked (framecnt_t nframes)
2965 {
2966         /* Must be called with the processor lock held */
2967
2968         if (!_silent) {
2969
2970                 _output->silence (nframes);
2971
2972                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2973                         boost::shared_ptr<PluginInsert> pi;
2974
2975                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2976                                 // skip plugins, they don't need anything when we're not active
2977                                 continue;
2978                         }
2979
2980                         (*i)->silence (nframes);
2981                 }
2982
2983                 if (nframes == _session.get_block_size()) {
2984                         // _silent = true;
2985                 }
2986         }
2987 }
2988
2989 void
2990 Route::add_internal_return ()
2991 {
2992         if (!_intreturn) {
2993                 _intreturn.reset (new InternalReturn (_session));
2994                 add_processor (_intreturn, PreFader);
2995         }
2996 }
2997
2998 void
2999 Route::add_send_to_internal_return (InternalSend* send)
3000 {
3001         Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3002
3003         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
3004                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
3005
3006                 if (d) {
3007                         return d->add_send (send);
3008                 }
3009         }
3010 }
3011
3012 void
3013 Route::remove_send_from_internal_return (InternalSend* send)
3014 {
3015         Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3016
3017         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
3018                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
3019
3020                 if (d) {
3021                         return d->remove_send (send);
3022                 }
3023         }
3024 }
3025
3026 void
3027 Route::enable_monitor_send ()
3028 {
3029         /* Caller must hold process lock */
3030         assert (!AudioEngine::instance()->process_lock().trylock());
3031
3032         /* master never sends to monitor section via the normal mechanism */
3033         assert (!is_master ());
3034         assert (!is_monitor ());
3035
3036         /* make sure we have one */
3037         if (!_monitor_send) {
3038                 _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), _session.monitor_out(), Delivery::Listen));
3039                 _monitor_send->set_display_to_user (false);
3040         }
3041
3042         /* set it up */
3043         configure_processors (0);
3044 }
3045
3046 /** Add an aux send to a route.
3047  *  @param route route to send to.
3048  *  @param before Processor to insert before, or 0 to insert at the end.
3049  */
3050 int
3051 Route::add_aux_send (boost::shared_ptr<Route> route, boost::shared_ptr<Processor> before)
3052 {
3053         assert (route != _session.monitor_out ());
3054
3055         {
3056                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3057
3058                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3059
3060                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
3061
3062                         if (d && d->target_route() == route) {
3063                                 /* already listening via the specified IO: do nothing */
3064                                 return 0;
3065                         }
3066                 }
3067         }
3068
3069         try {
3070
3071                 boost::shared_ptr<InternalSend> listener;
3072
3073                 {
3074                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3075                         boost::shared_ptr<Pannable> sendpan (new Pannable (_session));
3076                         listener.reset (new InternalSend (_session, sendpan, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), route, Delivery::Aux));
3077                 }
3078
3079                 add_processor (listener, before);
3080
3081         } catch (failed_constructor& err) {
3082                 return -1;
3083         }
3084
3085         return 0;
3086 }
3087
3088 void
3089 Route::remove_aux_or_listen (boost::shared_ptr<Route> route)
3090 {
3091         ProcessorStreams err;
3092         ProcessorList::iterator tmp;
3093
3094         {
3095                 Glib::Threads::RWLock::ReaderLock rl(_processor_lock);
3096
3097                 /* have to do this early because otherwise processor reconfig
3098                  * will put _monitor_send back in the list
3099                  */
3100
3101                 if (route == _session.monitor_out()) {
3102                         _monitor_send.reset ();
3103                 }
3104
3105           again:
3106                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3107                         
3108                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
3109                         
3110                         if (d && d->target_route() == route) {
3111                                 rl.release ();
3112                                 remove_processor (*x, &err, false);
3113                                 rl.acquire ();
3114
3115                                 /* list could have been demolished while we dropped the lock
3116                                    so start over.
3117                                 */
3118                                 
3119                                 goto again;
3120                         }
3121                 }
3122         }
3123 }
3124
3125 void
3126 Route::set_comment (string cmt, void *src)
3127 {
3128         _comment = cmt;
3129         comment_changed (src);
3130         _session.set_dirty ();
3131 }
3132
3133 bool
3134 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
3135 {
3136         FeedRecord fr (other, via_sends_only);
3137
3138         pair<FedBy::iterator,bool> result =  _fed_by.insert (fr);
3139
3140         if (!result.second) {
3141
3142                 /* already a record for "other" - make sure sends-only information is correct */
3143                 if (!via_sends_only && result.first->sends_only) {
3144                         FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
3145                         frp->sends_only = false;
3146                 }
3147         }
3148
3149         return result.second;
3150 }
3151
3152 void
3153 Route::clear_fed_by ()
3154 {
3155         _fed_by.clear ();
3156 }
3157
3158 bool
3159 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
3160 {
3161         const FedBy& fed_by (other->fed_by());
3162
3163         for (FedBy::const_iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
3164                 boost::shared_ptr<Route> sr = f->r.lock();
3165
3166                 if (sr && (sr.get() == this)) {
3167
3168                         if (via_sends_only) {
3169                                 *via_sends_only = f->sends_only;
3170                         }
3171
3172                         return true;
3173                 }
3174         }
3175
3176         return false;
3177 }
3178
3179 bool
3180 Route::direct_feeds_according_to_reality (boost::shared_ptr<Route> other, bool* via_send_only)
3181 {
3182         DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
3183
3184         if (_output->connected_to (other->input())) {
3185                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
3186                 if (via_send_only) {
3187                         *via_send_only = false;
3188                 }
3189
3190                 return true;
3191         }
3192
3193
3194         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
3195
3196                 boost::shared_ptr<IOProcessor> iop;
3197
3198                 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
3199                         if (iop->feeds (other)) {
3200                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
3201                                 if (via_send_only) {
3202                                         *via_send_only = true;
3203                                 }
3204                                 return true;
3205                         } else {
3206                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
3207                         }
3208                 } else {
3209                         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
3210                 }
3211
3212         }
3213
3214         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tdoes NOT feed %1\n", other->name()));
3215         return false;
3216 }
3217
3218 bool
3219 Route::direct_feeds_according_to_graph (boost::shared_ptr<Route> other, bool* via_send_only)
3220 {
3221         return _session._current_route_graph.has (shared_from_this (), other, via_send_only);
3222 }
3223
3224 /** Called from the (non-realtime) butler thread when the transport is stopped */
3225 void
3226 Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool /*did_locate*/, bool can_flush_processors)
3227 {
3228         framepos_t now = _session.transport_frame();
3229
3230         {
3231                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3232
3233                 Automatable::transport_stopped (now);
3234
3235                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3236
3237                         if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && can_flush_processors)) {
3238                                 (*i)->flush ();
3239                         }
3240
3241                         (*i)->transport_stopped (now);
3242                 }
3243         }
3244
3245         _roll_delay = _initial_delay;
3246 }
3247
3248 void
3249 Route::input_change_handler (IOChange change, void * /*src*/)
3250 {
3251         bool need_to_queue_solo_change = true;
3252
3253         if ((change.type & IOChange::ConfigurationChanged)) {
3254                 /* This is called with the process lock held if change 
3255                    contains ConfigurationChanged 
3256                 */
3257                 need_to_queue_solo_change = false;
3258                 configure_processors (0);
3259                 _phase_invert.resize (_input->n_ports().n_audio ());
3260                 io_changed (); /* EMIT SIGNAL */
3261         }
3262
3263         if (!_input->connected() && _soloed_by_others_upstream) {
3264                 if (need_to_queue_solo_change) {
3265                         _session.cancel_solo_after_disconnect (shared_from_this(), true);
3266                 } else {
3267                         cancel_solo_after_disconnect (true);
3268                 }
3269         }
3270 }
3271
3272 void
3273 Route::output_change_handler (IOChange change, void * /*src*/)
3274 {
3275         bool need_to_queue_solo_change = true;
3276         if (_initial_io_setup) {
3277                 return;
3278         }
3279
3280         if ((change.type & IOChange::ConfigurationChanged)) {
3281                 /* This is called with the process lock held if change 
3282                    contains ConfigurationChanged 
3283                 */
3284                 need_to_queue_solo_change = false;
3285                 configure_processors (0);
3286
3287                 if (is_master()) {
3288                         _session.reset_monitor_section();
3289                 }
3290
3291                 io_changed (); /* EMIT SIGNAL */
3292         }
3293
3294         if (!_output->connected() && _soloed_by_others_downstream) {
3295                 if (need_to_queue_solo_change) {
3296                         _session.cancel_solo_after_disconnect (shared_from_this(), false);
3297                 } else {
3298                         cancel_solo_after_disconnect (false);
3299                 }
3300         }
3301 }
3302
3303 void
3304 Route::cancel_solo_after_disconnect (bool upstream)
3305 {
3306         if (upstream) {
3307                 _soloed_by_others_upstream = 0;
3308         } else {
3309                 _soloed_by_others_downstream = 0;
3310         }
3311         set_mute_master_solo ();
3312         solo_changed (false, this);
3313 }
3314
3315 uint32_t
3316 Route::pans_required () const
3317 {
3318         if (n_outputs().n_audio() < 2) {
3319                 return 0;
3320         }
3321
3322         return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
3323 }
3324
3325 int
3326 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
3327 {
3328         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3329
3330         if (!lm.locked()) {
3331                 return 0;
3332         }
3333
3334         if (n_outputs().n_total() == 0) {
3335                 return 0;
3336         }
3337
3338         if (!_active || n_inputs() == ChanCount::ZERO)  {
3339                 silence_unlocked (nframes);
3340                 return 0;
3341         }
3342
3343         if (session_state_changing) {
3344                 if (_session.transport_speed() != 0.0f) {
3345                         /* we're rolling but some state is changing (e.g. our diskstream contents)
3346                            so we cannot use them. Be silent till this is over.
3347
3348                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
3349                         */
3350                         silence_unlocked (nframes);
3351                         return 0;
3352                 }
3353                 /* we're really not rolling, so we're either delivery silence or actually
3354                    monitoring, both of which are safe to do while session_state_changing is true.
3355                 */
3356         }
3357
3358         BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
3359
3360         fill_buffers_with_input (bufs, _input, nframes);
3361
3362         if (_meter_point == MeterInput) {
3363                 _meter->run (bufs, start_frame, end_frame, nframes, true);
3364         }
3365
3366         _amp->apply_gain_automation (false);
3367         _trim->apply_gain_automation (false);
3368         passthru (bufs, start_frame, end_frame, nframes, 0);
3369
3370         return 0;
3371 }
3372
3373 int
3374 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& /* need_butler */)
3375 {
3376         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3377         if (!lm.locked()) {
3378                 return 0;
3379         }
3380
3381         if (n_outputs().n_total() == 0) {
3382                 return 0;
3383         }
3384
3385         if (!_active || n_inputs().n_total() == 0) {
3386                 silence_unlocked (nframes);
3387                 return 0;
3388         }
3389
3390         framepos_t unused = 0;
3391
3392         if ((nframes = check_initial_delay (nframes, unused)) == 0) {
3393                 return 0;
3394         }
3395
3396         _silent = false;
3397
3398         BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
3399
3400         fill_buffers_with_input (bufs, _input, nframes);
3401
3402         if (_meter_point == MeterInput) {
3403                 _meter->run (bufs, start_frame, end_frame, nframes, true);
3404         }
3405
3406         passthru (bufs, start_frame, end_frame, nframes, declick);
3407
3408         return 0;
3409 }
3410
3411 int
3412 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& /* need_butler */)
3413 {
3414         silence (nframes);
3415         return 0;
3416 }
3417
3418 void
3419 Route::flush_processors ()
3420 {
3421         /* XXX shouldn't really try to take this lock, since
3422            this is called from the RT audio thread.
3423         */
3424
3425         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3426
3427         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3428                 (*i)->flush ();
3429         }
3430 }
3431
3432 #ifdef __clang__
3433 __attribute__((annotate("realtime")))
3434 #endif
3435 bool
3436 Route::apply_processor_changes_rt ()
3437 {
3438         int emissions = EmitNone;
3439
3440         if (_pending_meter_point != _meter_point) {
3441                 Glib::Threads::RWLock::WriterLock pwl (_processor_lock, Glib::Threads::TRY_LOCK);
3442                 if (pwl.locked()) {
3443                         /* meters always have buffers for 'processor_max_streams'
3444                          * they can be re-positioned without re-allocation */
3445                         if (set_meter_point_unlocked()) {
3446                                 emissions |= EmitMeterChanged | EmitMeterVisibilityChange;;
3447                         } else {
3448                                 emissions |= EmitMeterChanged;
3449                         }
3450                 }
3451         }
3452
3453         bool changed = false;
3454
3455         if (g_atomic_int_get (&_pending_process_reorder)) {
3456                 Glib::Threads::RWLock::WriterLock pwl (_processor_lock, Glib::Threads::TRY_LOCK);
3457                 if (pwl.locked()) {
3458                         apply_processor_order (_pending_processor_order);
3459                         setup_invisible_processors ();
3460                         changed = true;
3461                         g_atomic_int_set (&_pending_process_reorder, 0);
3462                         emissions |= EmitRtProcessorChange;
3463                 }
3464         }
3465         if (changed) {
3466                 set_processor_positions ();
3467         }
3468         if (emissions != 0) {
3469                 g_atomic_int_set (&_pending_signals, emissions);
3470                 return true;
3471         }
3472         return false;
3473 }
3474
3475 void
3476 Route::emit_pending_signals ()
3477 {
3478
3479         int sig = g_atomic_int_and (&_pending_signals, 0);
3480         if (sig & EmitMeterChanged) {
3481                 _meter->emit_configuration_changed();
3482                 meter_change (); /* EMIT SIGNAL */
3483                 if (sig & EmitMeterVisibilityChange) {
3484                 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, true)); /* EMIT SIGNAL */
3485                 } else {
3486                 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, false)); /* EMIT SIGNAL */
3487                 }
3488         }
3489         if (sig & EmitRtProcessorChange) {
3490                 processors_changed (RouteProcessorChange (RouteProcessorChange::RealTimeChange)); /* EMIT SIGNAL */
3491         }
3492 }
3493
3494 void
3495 Route::set_meter_point (MeterPoint p, bool force)
3496 {
3497         if (_pending_meter_point == p && !force) {
3498                 return;
3499         }
3500
3501         if (force || !AudioEngine::instance()->running()) {
3502                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3503                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3504                 _pending_meter_point = p;
3505                 _meter->emit_configuration_changed();
3506                 meter_change (); /* EMIT SIGNAL */
3507                 if (set_meter_point_unlocked()) {
3508                         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, true)); /* EMIT SIGNAL */
3509                 } else {
3510                         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, false)); /* EMIT SIGNAL */
3511                 }
3512         } else {
3513                 _pending_meter_point = p;
3514         }
3515 }
3516
3517
3518 #ifdef __clang__
3519 __attribute__((annotate("realtime")))
3520 #endif
3521 bool
3522 Route::set_meter_point_unlocked ()
3523 {
3524 #ifndef NDEBUG
3525         /* Caller must hold process and processor write lock */
3526         assert (!AudioEngine::instance()->process_lock().trylock());
3527         Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3528         assert (!lm.locked ());
3529 #endif
3530
3531         _meter_point = _pending_meter_point;
3532
3533         bool meter_was_visible_to_user = _meter->display_to_user ();
3534
3535         if (!_custom_meter_position_noted) {
3536                 maybe_note_meter_position ();
3537         }
3538
3539         if (_meter_point != MeterCustom) {
3540
3541                 _meter->set_display_to_user (false);
3542
3543                 setup_invisible_processors ();
3544
3545         } else {
3546                 _meter->set_display_to_user (true);
3547
3548                 /* If we have a previous position for the custom meter, try to put it there */
3549                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
3550                 if (after) {
3551                         ProcessorList::iterator i = find (_processors.begin(), _processors.end(), after);
3552                         if (i != _processors.end ()) {
3553                                 _processors.remove (_meter);
3554                                 _processors.insert (i, _meter);
3555                         }
3556                 } else {// at end, right before the mains_out/panner
3557                         _processors.remove (_meter);
3558                         ProcessorList::iterator main = _processors.end();
3559                         _processors.insert (--main, _meter);
3560                 }
3561         }
3562
3563         /* Set up the meter for its new position */
3564
3565         ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
3566         
3567         ChanCount m_in;
3568         
3569         if (loc == _processors.begin()) {
3570                 m_in = _input->n_ports();
3571         } else {
3572                 ProcessorList::iterator before = loc;
3573                 --before;
3574                 m_in = (*before)->output_streams ();
3575         }
3576
3577         _meter->reflect_inputs (m_in);
3578
3579         /* we do not need to reconfigure the processors, because the meter
3580            (a) is always ready to handle processor_max_streams
3581            (b) is always an N-in/N-out processor, and thus moving
3582            it doesn't require any changes to the other processors.
3583         */
3584
3585         /* these should really be done after releasing the lock
3586          * but all those signals are subscribed to with gui_thread()
3587          * so we're safe.
3588          */
3589          return (_meter->display_to_user() != meter_was_visible_to_user);
3590 }
3591
3592 void
3593 Route::listen_position_changed ()
3594 {
3595         {
3596                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3597                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3598                 ProcessorState pstate (this);
3599
3600                 if (configure_processors_unlocked (0)) {
3601                         pstate.restore ();
3602                         configure_processors_unlocked (0); // it worked before we tried to add it ...
3603                         return;
3604                 }
3605         }
3606
3607         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
3608         _session.set_dirty ();
3609 }
3610
3611 boost::shared_ptr<CapturingProcessor>
3612 Route::add_export_point()
3613 {
3614         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3615         if (!_capturing_processor) {
3616                 lm.release();
3617                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3618                 Glib::Threads::RWLock::WriterLock lw (_processor_lock);
3619
3620                 _capturing_processor.reset (new CapturingProcessor (_session));
3621                 _capturing_processor->activate ();
3622
3623                 configure_processors_unlocked (0);
3624
3625         }
3626
3627         return _capturing_processor;
3628 }
3629
3630 framecnt_t
3631 Route::update_signal_latency ()
3632 {
3633         framecnt_t l = _output->user_latency();
3634         framecnt_t lamp = 0;
3635         bool before_amp = true;
3636         framecnt_t ltrim = 0;
3637         bool before_trim = true;
3638
3639         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3640                 if ((*i)->active ()) {
3641                         l += (*i)->signal_latency ();
3642                 }
3643                 if ((*i) == _amp) {
3644                         before_amp = false;
3645                 }
3646                 if ((*i) == _trim) {
3647                         before_amp = false;
3648                 }
3649                 if (before_amp) {
3650                         lamp = l;
3651                 }
3652                 if (before_trim) {
3653                         lamp = l;
3654                 }
3655         }
3656
3657         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l));
3658
3659         // TODO: (lamp - _signal_latency) to sync to output (read-ahed),  currently _roll_delay shifts this around
3660         _signal_latency_at_amp_position = lamp;
3661         _signal_latency_at_trim_position = ltrim;
3662
3663         if (_signal_latency != l) {
3664                 _signal_latency = l;
3665                 signal_latency_changed (); /* EMIT SIGNAL */
3666         }
3667
3668         return _signal_latency;
3669 }
3670
3671 void
3672 Route::set_user_latency (framecnt_t nframes)
3673 {
3674         _output->set_user_latency (nframes);
3675         _session.update_latency_compensation ();
3676 }
3677
3678 void
3679 Route::set_latency_compensation (framecnt_t longest_session_latency)
3680 {
3681         framecnt_t old = _initial_delay;
3682
3683         if (_signal_latency < longest_session_latency) {
3684                 _initial_delay = longest_session_latency - _signal_latency;
3685         } else {
3686                 _initial_delay = 0;
3687         }
3688
3689         DEBUG_TRACE (DEBUG::Latency, string_compose (
3690                              "%1: compensate for maximum latency of %2,"
3691                              "given own latency of %3, using initial delay of %4\n",
3692                              name(), longest_session_latency, _signal_latency, _initial_delay));
3693
3694         if (_initial_delay != old) {
3695                 initial_delay_changed (); /* EMIT SIGNAL */
3696         }
3697
3698         if (_session.transport_stopped()) {
3699                 _roll_delay = _initial_delay;
3700         }
3701 }
3702
3703 Route::SoloControllable::SoloControllable (std::string name, boost::shared_ptr<Route> r)
3704         : AutomationControl (r->session(),
3705                              Evoral::Parameter (SoloAutomation),
3706                              ParameterDescriptor(Evoral::Parameter (SoloAutomation)),
3707                              boost::shared_ptr<AutomationList>(), name)
3708         , _route (r)
3709 {
3710         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
3711         gl->set_interpolation(Evoral::ControlList::Discrete);
3712         set_list (gl);
3713 }
3714
3715 void
3716 Route::SoloControllable::set_value (double val)
3717 {
3718         const bool bval = ((val >= 0.5) ? true : false);
3719
3720         boost::shared_ptr<RouteList> rl (new RouteList);
3721
3722         boost::shared_ptr<Route> r = _route.lock ();
3723         if (!r) {
3724                 return;
3725         }
3726
3727         rl->push_back (r);
3728
3729         if (Config->get_solo_control_is_listen_control()) {
3730                 _session.set_listen (rl, bval);
3731         } else {
3732                 _session.set_solo (rl, bval);
3733         }
3734 }
3735
3736 double
3737 Route::SoloControllable::get_value () const
3738 {
3739         boost::shared_ptr<Route> r = _route.lock ();
3740         if (!r) {
3741                 return 0;
3742         }
3743
3744         if (Config->get_solo_control_is_listen_control()) {
3745                 return r->listening_via_monitor() ? GAIN_COEFF_UNITY : GAIN_COEFF_ZERO;
3746         } else {
3747                 return r->self_soloed() ? GAIN_COEFF_UNITY : GAIN_COEFF_ZERO;
3748         }
3749 }
3750
3751 Route::MuteControllable::MuteControllable (std::string name, boost::shared_ptr<Route> r)
3752         : AutomationControl (r->session(),
3753                              Evoral::Parameter (MuteAutomation),
3754                              ParameterDescriptor (Evoral::Parameter (MuteAutomation)),
3755                              boost::shared_ptr<AutomationList>(),
3756                              name)
3757         , _route (r)
3758 {
3759         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MuteAutomation)));
3760         gl->set_interpolation(Evoral::ControlList::Discrete);
3761         set_list (gl);
3762 }
3763
3764 void
3765 Route::MuteControllable::set_superficial_value(bool muted)
3766 {
3767         /* Note we can not use AutomationControl::set_value here since it will emit
3768            Changed(), but the value will not be correct to the observer. */
3769
3770         bool to_list = _list && ((AutomationList*)_list.get())->automation_write();
3771
3772         Control::set_double (muted, _session.transport_frame(), to_list);
3773 }
3774
3775 void
3776 Route::MuteControllable::set_value (double val)
3777 {
3778         const bool bval = ((val >= 0.5) ? true : false);
3779
3780         boost::shared_ptr<Route> r = _route.lock ();
3781         if (!r) {
3782                 return;
3783         }
3784
3785         if (_list && ((AutomationList*)_list.get())->automation_playback()) {
3786                 // Playing back automation, set route mute directly
3787                 r->set_mute (bval, this);
3788         } else {
3789                 // Set from user, queue mute event
3790                 boost::shared_ptr<RouteList> rl (new RouteList);
3791                 rl->push_back (r);
3792                 _session.set_mute (rl, bval, Session::rt_cleanup);
3793         }
3794
3795         // Set superficial/automation value to drive controller (and possibly record)
3796         set_superficial_value(bval);
3797 }
3798
3799 double
3800 Route::MuteControllable::get_value () const
3801 {
3802         if (_list && ((AutomationList*)_list.get())->automation_playback()) {
3803                 // Playing back automation, get the value from the list
3804                 return AutomationControl::get_value();
3805         }
3806
3807         // Not playing back automation, get the actual route mute value
3808         boost::shared_ptr<Route> r = _route.lock ();
3809         return (r && r->muted()) ? GAIN_COEFF_UNITY : GAIN_COEFF_ZERO;
3810 }
3811
3812 void
3813 Route::set_block_size (pframes_t nframes)
3814 {
3815         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3816                 (*i)->set_block_size (nframes);
3817         }
3818
3819         _session.ensure_buffers (n_process_buffers ());
3820 }
3821
3822 void
3823 Route::protect_automation ()
3824 {
3825         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3826                 (*i)->protect_automation();
3827 }
3828
3829 /** @param declick 1 to set a pending declick fade-in,
3830  *                -1 to set a pending declick fade-out
3831  */
3832 void
3833 Route::set_pending_declick (int declick)
3834 {
3835         if (_declickable) {
3836                 /* this call is not allowed to turn off a pending declick */
3837                 if (declick) {
3838                         _pending_declick = declick;
3839                 }
3840         } else {
3841                 _pending_declick = 0;
3842         }
3843 }
3844
3845 /** Shift automation forwards from a particular place, thereby inserting time.
3846  *  Adds undo commands for any shifts that are performed.
3847  *
3848  * @param pos Position to start shifting from.
3849  * @param frames Amount to shift forwards by.
3850  */
3851
3852 void
3853 Route::shift (framepos_t pos, framecnt_t frames)
3854 {
3855         /* gain automation */
3856         {
3857                 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
3858
3859                 XMLNode &before = gc->alist()->get_state ();
3860                 gc->alist()->shift (pos, frames);
3861                 XMLNode &after = gc->alist()->get_state ();
3862                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3863         }
3864
3865         /* gain automation */
3866         {
3867                 boost::shared_ptr<AutomationControl> gc = _trim->gain_control();
3868
3869                 XMLNode &before = gc->alist()->get_state ();
3870                 gc->alist()->shift (pos, frames);
3871                 XMLNode &after = gc->alist()->get_state ();
3872                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3873         }
3874
3875         // TODO mute automation ??
3876
3877         /* pan automation */
3878         if (_pannable) {
3879                 ControlSet::Controls& c (_pannable->controls());
3880
3881                 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
3882                         boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
3883                         if (pc) {
3884                                 boost::shared_ptr<AutomationList> al = pc->alist();
3885                                 XMLNode& before = al->get_state ();
3886                                 al->shift (pos, frames);
3887                                 XMLNode& after = al->get_state ();
3888                                 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3889                         }
3890                 }
3891         }
3892
3893         /* redirect automation */
3894         {
3895                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3896                 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
3897
3898                         set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
3899
3900                         for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
3901                                 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
3902                                 if (ac) {
3903                                         boost::shared_ptr<AutomationList> al = ac->alist();
3904                                         XMLNode &before = al->get_state ();
3905                                         al->shift (pos, frames);
3906                                         XMLNode &after = al->get_state ();
3907                                         _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3908                                 }
3909                         }
3910                 }
3911         }
3912 }
3913
3914
3915 int
3916 Route::save_as_template (const string& path, const string& name)
3917 {
3918         XMLNode& node (state (false));
3919         XMLTree tree;
3920
3921         IO::set_name_in_state (*node.children().front(), name);
3922
3923         tree.set_root (&node);
3924         return tree.write (path.c_str());
3925 }
3926
3927
3928 bool
3929 Route::set_name (const string& str)
3930 {
3931         if (str == name()) {
3932                 return true;
3933         }
3934
3935         string name = Route::ensure_track_or_route_name (str, _session);
3936         SessionObject::set_name (name);
3937
3938         bool ret = (_input->set_name(name) && _output->set_name(name));
3939
3940         if (ret) {
3941                 /* rename the main outs. Leave other IO processors
3942                  * with whatever name they already have, because its
3943                  * just fine as it is (it will not contain the route
3944                  * name if its a port insert, port send or port return).
3945                  */
3946
3947                 if (_main_outs) {
3948                         if (_main_outs->set_name (name)) {
3949                                 /* XXX returning false here is stupid because
3950                                    we already changed the route name.
3951                                 */
3952                                 return false;
3953                         }
3954                 }
3955         }
3956
3957         return ret;
3958 }
3959
3960 /** Set the name of a route in an XML description.
3961  *  @param node XML <Route> node to set the name in.
3962  *  @param name New name.
3963  */
3964 void
3965 Route::set_name_in_state (XMLNode& node, string const & name)
3966 {
3967         node.add_property (X_("name"), name);
3968
3969         XMLNodeList children = node.children();
3970         for (XMLNodeIterator i = children.begin(); i != children.end(); ++i) {
3971                 
3972                 if ((*i)->name() == X_("IO")) {
3973
3974                         IO::set_name_in_state (**i, name);
3975
3976                 } else if ((*i)->name() == X_("Processor")) {
3977
3978                         XMLProperty* role = (*i)->property (X_("role"));
3979                         if (role && role->value() == X_("Main")) {
3980                                 (*i)->add_property (X_("name"), name);
3981                         }
3982                         
3983                 } else if ((*i)->name() == X_("Diskstream")) {
3984
3985                         (*i)->add_property (X_("playlist"), string_compose ("%1.1", name).c_str());
3986                         (*i)->add_property (X_("name"), name);
3987                         
3988                 }
3989         }
3990 }
3991
3992 boost::shared_ptr<Send>
3993 Route::internal_send_for (boost::shared_ptr<const Route> target) const
3994 {
3995         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3996
3997         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3998                 boost::shared_ptr<InternalSend> send;
3999
4000                 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
4001                         if (send->target_route() == target) {
4002                                 return send;
4003                         }
4004                 }
4005         }
4006
4007         return boost::shared_ptr<Send>();
4008 }
4009
4010 /** @param c Audio channel index.
4011  *  @param yn true to invert phase, otherwise false.
4012  */
4013 void
4014 Route::set_phase_invert (uint32_t c, bool yn)
4015 {
4016         if (_phase_invert[c] != yn) {
4017                 _phase_invert[c] = yn;
4018                 phase_invert_changed (); /* EMIT SIGNAL */
4019                 _session.set_dirty ();
4020         }
4021 }
4022
4023 void
4024 Route::set_phase_invert (boost::dynamic_bitset<> p)
4025 {
4026         if (_phase_invert != p) {
4027                 _phase_invert = p;
4028                 phase_invert_changed (); /* EMIT SIGNAL */
4029                 _session.set_dirty ();
4030         }
4031 }
4032
4033 bool
4034 Route::phase_invert (uint32_t c) const
4035 {
4036         return _phase_invert[c];
4037 }
4038
4039 boost::dynamic_bitset<>
4040 Route::phase_invert () const
4041 {
4042         return _phase_invert;
4043 }
4044
4045 void
4046 Route::set_denormal_protection (bool yn)
4047 {
4048         if (_denormal_protection != yn) {
4049                 _denormal_protection = yn;
4050                 denormal_protection_changed (); /* EMIT SIGNAL */
4051         }
4052 }
4053
4054 bool
4055 Route::denormal_protection () const
4056 {
4057         return _denormal_protection;
4058 }
4059
4060 void
4061 Route::set_active (bool yn, void* src)
4062 {
4063         if (_session.transport_rolling()) {
4064                 return;
4065         }
4066
4067         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
4068                 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
4069                 return;
4070         }
4071
4072         if (_active != yn) {
4073                 _active = yn;
4074                 _input->set_active (yn);
4075                 _output->set_active (yn);
4076                 active_changed (); // EMIT SIGNAL
4077                 _session.set_dirty ();
4078         }
4079 }
4080
4081 boost::shared_ptr<Pannable>
4082 Route::pannable() const
4083 {
4084         return _pannable;
4085 }
4086
4087 boost::shared_ptr<Panner>
4088 Route::panner() const
4089 {
4090         /* may be null ! */
4091         return _main_outs->panner_shell()->panner();
4092 }
4093
4094 boost::shared_ptr<PannerShell>
4095 Route::panner_shell() const
4096 {
4097         return _main_outs->panner_shell();
4098 }
4099
4100 boost::shared_ptr<AutomationControl>
4101 Route::gain_control() const
4102 {
4103         return _amp->gain_control();
4104 }
4105
4106 boost::shared_ptr<AutomationControl>
4107 Route::get_control (const Evoral::Parameter& param)
4108 {
4109         /* either we own the control or .... */
4110
4111         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
4112
4113         if (!c) {
4114
4115                 /* maybe one of our processors does or ... */
4116
4117                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
4118                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4119                         if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
4120                                 break;
4121                         }
4122                 }
4123         }
4124
4125         if (!c) {
4126
4127                 /* nobody does so we'll make a new one */
4128
4129                 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
4130                 add_control(c);
4131         }
4132
4133         return c;
4134 }
4135
4136 boost::shared_ptr<Processor>
4137 Route::nth_plugin (uint32_t n)
4138 {
4139         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4140         ProcessorList::iterator i;
4141
4142         for (i = _processors.begin(); i != _processors.end(); ++i) {
4143                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
4144                         if (n-- == 0) {
4145                                 return *i;
4146                         }
4147                 }
4148         }
4149
4150         return boost::shared_ptr<Processor> ();
4151 }
4152
4153 boost::shared_ptr<Processor>
4154 Route::nth_send (uint32_t n)
4155 {
4156         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4157         ProcessorList::iterator i;
4158
4159         for (i = _processors.begin(); i != _processors.end(); ++i) {
4160                 if (boost::dynamic_pointer_cast<Send> (*i)) {
4161                         if (n-- == 0) {
4162                                 return *i;
4163                         }
4164                 }
4165         }
4166
4167         return boost::shared_ptr<Processor> ();
4168 }
4169
4170 bool
4171 Route::has_io_processor_named (const string& name)
4172 {
4173         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4174         ProcessorList::iterator i;
4175
4176         for (i = _processors.begin(); i != _processors.end(); ++i) {
4177                 if (boost::dynamic_pointer_cast<Send> (*i) ||
4178                     boost::dynamic_pointer_cast<PortInsert> (*i)) {
4179                         if ((*i)->name() == name) {
4180                                 return true;
4181                         }
4182                 }
4183         }
4184
4185         return false;
4186 }
4187
4188 MuteMaster::MutePoint
4189 Route::mute_points () const
4190 {
4191         return _mute_master->mute_points ();
4192 }
4193
4194 void
4195 Route::set_processor_positions ()
4196 {
4197         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4198
4199         bool had_amp = false;
4200         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4201                 (*i)->set_pre_fader (!had_amp);
4202                 if (*i == _amp) {
4203                         had_amp = true;
4204                 }
4205         }
4206 }
4207
4208 /** Called when there is a proposed change to the input port count */
4209 bool
4210 Route::input_port_count_changing (ChanCount to)
4211 {
4212         list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
4213         if (c.empty()) {
4214                 /* The processors cannot be configured with the new input arrangement, so
4215                    block the change.
4216                 */
4217                 return true;
4218         }
4219
4220         /* The change is ok */
4221         return false;
4222 }
4223
4224 /** Called when there is a proposed change to the output port count */
4225 bool
4226 Route::output_port_count_changing (ChanCount to)
4227 {
4228         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
4229                 if (processor_out_streams.get(*t) > to.get(*t)) {
4230                         return true;
4231                 }
4232         }
4233         /* The change is ok */
4234         return false;
4235 }
4236
4237 list<string>
4238 Route::unknown_processors () const
4239 {
4240         list<string> p;
4241
4242         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4243         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4244                 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
4245                         p.push_back ((*i)->name ());
4246                 }
4247         }
4248
4249         return p;
4250 }
4251
4252
4253 framecnt_t
4254 Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecnt_t our_latency) const
4255 {
4256         /* we assume that all our input ports feed all our output ports. its not
4257            universally true, but the alternative is way too corner-case to worry about.
4258         */
4259
4260         LatencyRange all_connections;
4261
4262         if (from.empty()) {
4263                 all_connections.min = 0;
4264                 all_connections.max = 0;
4265         } else {
4266                 all_connections.min = ~((pframes_t) 0);
4267                 all_connections.max = 0;
4268                 
4269                 /* iterate over all "from" ports and determine the latency range for all of their
4270                    connections to the "outside" (outside of this Route).
4271                 */
4272                 
4273                 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
4274                         
4275                         LatencyRange range;
4276                         
4277                         p->get_connected_latency_range (range, playback);
4278                         
4279                         all_connections.min = min (all_connections.min, range.min);
4280                         all_connections.max = max (all_connections.max, range.max);
4281                 }
4282         }
4283
4284         /* set the "from" port latencies to the max/min range of all their connections */
4285
4286         for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
4287                 p->set_private_latency_range (all_connections, playback);
4288         }
4289
4290         /* set the ports "in the direction of the flow" to the same value as above plus our own signal latency */
4291
4292         all_connections.min += our_latency;
4293         all_connections.max += our_latency;
4294
4295         for (PortSet::iterator p = to.begin(); p != to.end(); ++p) {
4296                 p->set_private_latency_range (all_connections, playback);
4297         }
4298
4299         return all_connections.max;
4300 }
4301
4302 framecnt_t
4303 Route::set_private_port_latencies (bool playback) const
4304 {
4305         framecnt_t own_latency = 0;
4306
4307         /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD
4308            OR LATENCY CALLBACK.
4309
4310            This is called (early) from the latency callback. It computes the REAL
4311            latency associated with each port and stores the result as the "private"
4312            latency of the port. A later call to Route::set_public_port_latencies()
4313            sets all ports to the same value to reflect the fact that we do latency
4314            compensation and so all signals are delayed by the same amount as they
4315            flow through ardour.
4316         */
4317
4318         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4319                 if ((*i)->active ()) {
4320                         own_latency += (*i)->signal_latency ();
4321                 }
4322         }
4323
4324         if (playback) {
4325                 /* playback: propagate latency from "outside the route" to outputs to inputs */
4326                 return update_port_latencies (_output->ports (), _input->ports (), true, own_latency);
4327         } else {
4328                 /* capture: propagate latency from "outside the route" to inputs to outputs */
4329                 return update_port_latencies (_input->ports (), _output->ports (), false, own_latency);
4330         }
4331 }
4332
4333 void
4334 Route::set_public_port_latencies (framecnt_t value, bool playback) const
4335 {
4336         /* this is called to set the JACK-visible port latencies, which take
4337            latency compensation into account.
4338         */
4339
4340         LatencyRange range;
4341
4342         range.min = value;
4343         range.max = value;
4344
4345         {
4346                 const PortSet& ports (_input->ports());
4347                 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
4348                         p->set_public_latency_range (range, playback);
4349                 }
4350         }
4351
4352         {
4353                 const PortSet& ports (_output->ports());
4354                 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
4355                         p->set_public_latency_range (range, playback);
4356                 }
4357         }
4358 }
4359
4360 /** Put the invisible processors in the right place in _processors.
4361  *  Must be called with a writer lock on _processor_lock held.
4362  */
4363 #ifdef __clang__
4364 __attribute__((annotate("realtime")))
4365 #endif
4366 void
4367 Route::setup_invisible_processors ()
4368 {
4369 #ifndef NDEBUG
4370         Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
4371         assert (!lm.locked ());
4372 #endif
4373
4374         if (!_main_outs) {
4375                 /* too early to be doing this stuff */
4376                 return;
4377         }
4378
4379         /* we'll build this new list here and then use it
4380          *
4381          * TODO put the ProcessorList is on the stack for RT-safety. 
4382          */
4383
4384         ProcessorList new_processors;
4385
4386         /* find visible processors */
4387
4388         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4389                 if ((*i)->display_to_user ()) {
4390                         new_processors.push_back (*i);
4391                 }
4392         }
4393
4394         /* find the amp */
4395
4396         ProcessorList::iterator amp = new_processors.begin ();
4397         while (amp != new_processors.end() && *amp != _amp) {
4398                 ++amp;
4399         }
4400
4401         assert (amp != new_processors.end ());
4402
4403         /* and the processor after the amp */
4404
4405         ProcessorList::iterator after_amp = amp;
4406         ++after_amp;
4407
4408         /* METER */
4409
4410         if (_meter) {
4411                 switch (_meter_point) {
4412                 case MeterInput:
4413                         assert (!_meter->display_to_user ());
4414                         new_processors.push_front (_meter);
4415                         break;
4416                 case MeterPreFader:
4417                         assert (!_meter->display_to_user ());
4418                         new_processors.insert (amp, _meter);
4419                         break;
4420                 case MeterPostFader:
4421                         /* do nothing here */
4422                         break;
4423                 case MeterOutput:
4424                         /* do nothing here */
4425                         break;
4426                 case MeterCustom:
4427                         /* the meter is visible, so we don't touch it here */
4428                         break;
4429                 }
4430         }
4431
4432         /* MAIN OUTS */
4433
4434         assert (_main_outs);
4435         assert (!_main_outs->display_to_user ());
4436         new_processors.push_back (_main_outs);
4437
4438         /* iterator for the main outs */
4439
4440         ProcessorList::iterator main = new_processors.end();
4441         --main;
4442
4443         /* OUTPUT METERING */
4444
4445         if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
4446                 assert (!_meter->display_to_user ());
4447
4448                 /* add the processor just before or just after the main outs */
4449
4450                 ProcessorList::iterator meter_point = main;
4451
4452                 if (_meter_point == MeterOutput) {
4453                         ++meter_point;
4454                 }
4455                 new_processors.insert (meter_point, _meter);
4456         }
4457
4458         /* MONITOR SEND */
4459
4460         if (_monitor_send && !is_monitor ()) {
4461                 assert (!_monitor_send->display_to_user ());
4462                 if (Config->get_solo_control_is_listen_control()) {
4463                         switch (Config->get_listen_position ()) {
4464                         case PreFaderListen:
4465                                 switch (Config->get_pfl_position ()) {
4466                                 case PFLFromBeforeProcessors:
4467                                         new_processors.push_front (_monitor_send);
4468                                         break;
4469                                 case PFLFromAfterProcessors:
4470                                         new_processors.insert (amp, _monitor_send);
4471                                         break;
4472                                 }
4473                                 _monitor_send->set_can_pan (false);
4474                                 break;
4475                         case AfterFaderListen:
4476                                 switch (Config->get_afl_position ()) {
4477                                 case AFLFromBeforeProcessors:
4478                                         new_processors.insert (after_amp, _monitor_send);
4479                                         break;
4480                                 case AFLFromAfterProcessors:
4481                                         new_processors.insert (new_processors.end(), _monitor_send);
4482                                         break;
4483                                 }
4484                                 _monitor_send->set_can_pan (true);
4485                                 break;
4486                         }
4487                 }  else {
4488                         new_processors.insert (new_processors.end(), _monitor_send);
4489                         _monitor_send->set_can_pan (false);
4490                 }
4491         }
4492
4493 #if 0 // not used - just yet
4494         if (!is_master() && !is_monitor() && !is_auditioner()) {
4495                 new_processors.push_front (_delayline);
4496         }
4497 #endif
4498
4499         /* MONITOR CONTROL */
4500
4501         if (_monitor_control && is_monitor ()) {
4502                 assert (!_monitor_control->display_to_user ());
4503                 new_processors.push_front (_monitor_control);
4504         }
4505
4506         /* INTERNAL RETURN */
4507
4508         /* doing this here means that any monitor control will come just after
4509            the return.
4510         */
4511
4512         if (_intreturn) {
4513                 assert (!_intreturn->display_to_user ());
4514                 new_processors.push_front (_intreturn);
4515         }
4516
4517         if (_trim && _trim->active()) {
4518                 assert (!_trim->display_to_user ());
4519                 new_processors.push_front (_trim);
4520         }
4521         /* EXPORT PROCESSOR */
4522
4523         if (_capturing_processor) {
4524                 assert (!_capturing_processor->display_to_user ());
4525                 new_processors.push_front (_capturing_processor);
4526         }
4527
4528         _processors = new_processors;
4529
4530         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4531                 if (!(*i)->display_to_user () && !(*i)->active ()) {
4532                         (*i)->activate ();
4533                 }
4534         }
4535
4536         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
4537         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4538                 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
4539         }
4540 }
4541
4542 void
4543 Route::unpan ()
4544 {
4545         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
4546         Glib::Threads::RWLock::ReaderLock lp (_processor_lock);
4547
4548         _pannable.reset ();
4549
4550         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4551                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery>(*i);
4552                 if (d) {
4553                         d->unpan ();
4554                 }
4555         }
4556 }
4557
4558 /** If the meter point is `Custom', make a note of where the meter is.
4559  *  This is so that if the meter point is subsequently set to something else,
4560  *  and then back to custom, we can put the meter back where it was last time
4561  *  custom was enabled.
4562  *
4563  *  Must be called with the _processor_lock held.
4564  */
4565 void
4566 Route::maybe_note_meter_position ()
4567 {
4568         if (_meter_point != MeterCustom) {
4569                 return;
4570         }
4571         
4572         _custom_meter_position_noted = true;
4573         /* custom meter points range from after trim to before panner/main_outs
4574          * this is a limitation by the current processor UI
4575          */
4576         bool seen_trim = false;
4577         _processor_after_last_custom_meter.reset();
4578         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4579                 if ((*i) == _trim) {
4580                         seen_trim = true;
4581                 }
4582                 if ((*i) == _main_outs) {
4583                         _processor_after_last_custom_meter = *i;
4584                         break;
4585                 }
4586                 if (boost::dynamic_pointer_cast<PeakMeter> (*i)) {
4587                         if (!seen_trim) {
4588                                 _processor_after_last_custom_meter = _trim;
4589                         } else {
4590                                 ProcessorList::iterator j = i;
4591                                 ++j;
4592                                 assert(j != _processors.end ()); // main_outs should be before
4593                                 _processor_after_last_custom_meter = *j;
4594                         }
4595                         break;
4596                 }
4597         }
4598         assert(_processor_after_last_custom_meter.lock());
4599 }
4600
4601 boost::shared_ptr<Processor>
4602 Route::processor_by_id (PBD::ID id) const
4603 {
4604         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4605         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4606                 if ((*i)->id() == id) {
4607                         return *i;
4608                 }
4609         }
4610
4611         return boost::shared_ptr<Processor> ();
4612 }
4613
4614 /** @return the monitoring state, or in other words what data we are pushing
4615  *  into the route (data from the inputs, data from disk or silence)
4616  */
4617 MonitorState
4618 Route::monitoring_state () const
4619 {
4620         return MonitoringInput;
4621 }
4622
4623 /** @return what we should be metering; either the data coming from the input
4624  *  IO or the data that is flowing through the route.
4625  */
4626 MeterState
4627 Route::metering_state () const
4628 {
4629         return MeteringRoute;
4630 }
4631
4632 bool
4633 Route::has_external_redirects () const
4634 {
4635         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4636
4637                 /* ignore inactive processors and obviously ignore the main
4638                  * outs since everything has them and we don't care.
4639                  */
4640                  
4641                 if ((*i)->active() && (*i) != _main_outs && (*i)->does_routing()) {
4642                         return true;;
4643                 }
4644         }
4645
4646         return false;
4647 }
4648
4649 boost::shared_ptr<Processor>
4650 Route::the_instrument () const
4651 {
4652         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4653         return the_instrument_unlocked ();
4654 }
4655
4656 boost::shared_ptr<Processor>
4657 Route::the_instrument_unlocked () const
4658 {
4659         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4660                 if (boost::dynamic_pointer_cast<PluginInsert>(*i)) {
4661                         if ((*i)->input_streams().n_midi() > 0 &&
4662                             (*i)->output_streams().n_audio() > 0) {
4663                                 return (*i);
4664                         }
4665                 }
4666         }
4667         return boost::shared_ptr<Processor>();
4668 }
4669
4670
4671
4672 void
4673 Route::non_realtime_locate (framepos_t pos)
4674 {
4675         if (_pannable) {
4676                 _pannable->transport_located (pos);
4677         }
4678
4679         if (_delayline.get()) {
4680                 _delayline.get()->flush();
4681         }
4682
4683         {
4684                 //Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
4685                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4686                 
4687                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4688                         (*i)->transport_located (pos);
4689                 }
4690         }
4691 }
4692
4693 void
4694 Route::fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes)
4695 {
4696         size_t n_buffers;
4697         size_t i;
4698         
4699         /* MIDI 
4700          *  
4701          * We don't currently mix MIDI input together, so we don't need the
4702          * complex logic of the audio case.
4703          */
4704
4705         n_buffers = bufs.count().n_midi ();
4706
4707         for (i = 0; i < n_buffers; ++i) {
4708
4709                 boost::shared_ptr<MidiPort> source_port = io->midi (i);
4710                 MidiBuffer& buf (bufs.get_midi (i));
4711                 
4712                 if (source_port) {
4713                         buf.copy (source_port->get_midi_buffer(nframes));
4714                 } else {
4715                         buf.silence (nframes);
4716                 }
4717         }
4718
4719         /* AUDIO */
4720
4721         n_buffers = bufs.count().n_audio();
4722
4723         size_t n_ports = io->n_ports().n_audio();
4724         float scaling = 1.0f;
4725
4726         if (n_ports > n_buffers) {
4727                 scaling = ((float) n_buffers) / n_ports;
4728         }
4729         
4730         for (i = 0; i < n_ports; ++i) {
4731                 
4732                 /* if there are more ports than buffers, map them onto buffers
4733                  * in a round-robin fashion
4734                  */
4735
4736                 boost::shared_ptr<AudioPort> source_port = io->audio (i);
4737                 AudioBuffer& buf (bufs.get_audio (i%n_buffers));
4738                         
4739
4740                 if (i < n_buffers) {
4741                         
4742                         /* first time through just copy a channel into
4743                            the output buffer.
4744                         */
4745
4746                         buf.read_from (source_port->get_audio_buffer (nframes), nframes);
4747
4748                         if (scaling != 1.0f) {
4749                                 buf.apply_gain (scaling, nframes);
4750                         }
4751                         
4752                 } else {
4753                         
4754                         /* on subsequent times around, merge data from
4755                          * the port with what is already there 
4756                          */
4757
4758                         if (scaling != 1.0f) {
4759                                 buf.accumulate_with_gain_from (source_port->get_audio_buffer (nframes), nframes, 0, scaling);
4760                         } else {
4761                                 buf.accumulate_from (source_port->get_audio_buffer (nframes), nframes);
4762                         }
4763                 }
4764         }
4765
4766         /* silence any remaining buffers */
4767
4768         for (; i < n_buffers; ++i) {
4769                 AudioBuffer& buf (bufs.get_audio (i));
4770                 buf.silence (nframes);
4771         }
4772
4773         /* establish the initial setup of the buffer set, reflecting what was
4774            copied into it. unless, of course, we are the auditioner, in which
4775            case nothing was fed into it from the inputs at all.
4776         */
4777
4778         if (!is_auditioner()) {
4779                 bufs.set_count (io->n_ports());
4780         }
4781 }