2 Copyright (C) 2000 Paul Davis
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.
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.
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.
21 #include "libardour-config.h"
30 #include <boost/algorithm/string.hpp>
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"
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"
74 using namespace ARDOUR;
77 PBD::Signal0<void> Route::SyncOrderKeys;
78 PBD::Signal0<void> Route::RemoteControlIDChange;
80 Route::Route (Session& sess, string name, Flag flg, DataType default_type)
81 : SessionObject (sess, name)
83 , GraphNode (sess._process_graph)
86 , _signal_latency_at_amp_position (0)
87 , _signal_latency_at_trim_position (0)
90 , _pending_process_reorder (0)
92 , _pending_declick (true)
93 , _meter_point (MeterPostFader)
94 , _pending_meter_point (MeterPostFader)
95 , _meter_type (MeterPeak)
97 , _soloed_by_others_upstream (0)
98 , _soloed_by_others_downstream (0)
100 , _denormal_protection (false)
103 , _declickable (false)
104 , _mute_master (new MuteMaster (sess, name))
105 , _have_internal_generator (false)
107 , _default_type (default_type)
109 , _has_order_key (false)
110 , _remote_control_id (0)
112 , _in_configure_processors (false)
113 , _initial_io_setup (false)
114 , _custom_meter_position_noted (false)
116 processor_max_streams.reset();
122 /* set default meter type */
124 _meter_type = Config->get_meter_type_master ();
126 else if (dynamic_cast<Track*>(this)) {
127 _meter_type = Config->get_meter_type_track ();
129 _meter_type = Config->get_meter_type_bus ();
132 /* add standard controls */
134 _solo_control.reset (new SoloControllable (X_("solo"), shared_from_this ()));
135 _mute_control.reset (new MuteControllable (X_("mute"), shared_from_this ()));
137 _solo_control->set_flags (Controllable::Flag (_solo_control->flags() | Controllable::Toggle));
138 _mute_control->set_flags (Controllable::Flag (_mute_control->flags() | Controllable::Toggle));
140 add_control (_solo_control);
141 add_control (_mute_control);
145 if (!(_flags & Route::MonitorOut)) {
146 _pannable.reset (new Pannable (_session));
149 /* input and output objects */
151 _input.reset (new IO (_session, _name, IO::Input, _default_type));
152 _output.reset (new IO (_session, _name, IO::Output, _default_type));
154 _input->changed.connect_same_thread (*this, boost::bind (&Route::input_change_handler, this, _1, _2));
155 _input->PortCountChanging.connect_same_thread (*this, boost::bind (&Route::input_port_count_changing, this, _1));
157 _output->changed.connect_same_thread (*this, boost::bind (&Route::output_change_handler, this, _1, _2));
158 _output->PortCountChanging.connect_same_thread (*this, boost::bind (&Route::output_port_count_changing, this, _1));
160 #if 0 // not used - just yet
161 if (!is_master() && !is_monitor() && !is_auditioner()) {
162 _delayline.reset (new DelayLine (_session, _name));
163 add_processor (_delayline, PreFader);
167 /* add amp processor */
169 _amp.reset (new Amp (_session));
170 add_processor (_amp, PostFader);
173 _trim.reset (new Amp (_session, "trim"));
174 _trim->set_display_to_user (false);
176 if (dynamic_cast<AudioTrack*>(this)) {
177 /* we can't do this in the AudioTrack's constructor
178 * because _trim does not exit then
182 else if (!dynamic_cast<Track*>(this) && ! ( is_monitor() || is_auditioner() )) {
187 /* create standard processors: meter, main outs, monitor out;
188 they will be added to _processors by setup_invisible_processors ()
191 _meter.reset (new PeakMeter (_session, _name));
192 _meter->set_owner (this);
193 _meter->set_display_to_user (false);
196 _main_outs.reset (new Delivery (_session, _output, _pannable, _mute_master, _name, Delivery::Main));
197 _main_outs->activate ();
200 /* where we listen to tracks */
201 _intreturn.reset (new InternalReturn (_session));
202 _intreturn->activate ();
204 /* the thing that provides proper control over a control/monitor/listen bus
205 (such as per-channel cut, dim, solo, invert, etc).
207 _monitor_control.reset (new MonitorProcessor (_session));
208 _monitor_control->activate ();
211 if (is_master() || is_monitor() || is_auditioner()) {
212 _mute_master->set_solo_ignore (true);
215 /* now that we have _meter, its safe to connect to this */
218 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
219 configure_processors (0);
227 DEBUG_TRACE (DEBUG::Destruction, string_compose ("route %1 destructor\n", _name));
229 /* do this early so that we don't get incoming signals as we are going through destruction
234 /* don't use clear_processors here, as it depends on the session which may
235 be half-destroyed by now
238 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
239 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
240 (*i)->drop_references ();
243 _processors.clear ();
247 Route::set_remote_control_id (uint32_t id, bool notify_class_listeners)
249 if (Config->get_remote_model() != UserOrdered) {
253 set_remote_control_id_internal (id, notify_class_listeners);
257 Route::set_remote_control_id_internal (uint32_t id, bool notify_class_listeners)
259 /* force IDs for master/monitor busses and prevent
260 any other route from accidentally getting these IDs
261 (i.e. legacy sessions)
264 if (is_master() && id != MasterBusRemoteControlID) {
265 id = MasterBusRemoteControlID;
268 if (is_monitor() && id != MonitorBusRemoteControlID) {
269 id = MonitorBusRemoteControlID;
276 /* don't allow it to collide */
278 if (!is_master () && !is_monitor() &&
279 (id == MasterBusRemoteControlID || id == MonitorBusRemoteControlID)) {
280 id += MonitorBusRemoteControlID;
283 if (id != remote_control_id()) {
284 _remote_control_id = id;
285 RemoteControlIDChanged ();
287 if (notify_class_listeners) {
288 RemoteControlIDChange ();
294 Route::remote_control_id() const
297 return MasterBusRemoteControlID;
301 return MonitorBusRemoteControlID;
304 return _remote_control_id;
308 Route::has_order_key () const
310 return _has_order_key;
314 Route::order_key () const
320 Route::set_remote_control_id_explicit (uint32_t rid)
322 if (is_master() || is_monitor() || is_auditioner()) {
323 /* hard-coded remote IDs, or no remote ID */
327 if (_remote_control_id != rid) {
328 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("%1: set edit-based RID to %2\n", name(), rid));
329 _remote_control_id = rid;
330 RemoteControlIDChanged (); /* EMIT SIGNAL (per-route) */
333 /* don't emit the class-level RID signal RemoteControlIDChange here,
334 leave that to the entity that changed the order key, so that we
335 don't get lots of emissions for no good reasons (e.g. when changing
336 all route order keys).
338 See Session::sync_remote_id_from_order_keys() for the (primary|only)
339 spot where that is emitted.
344 Route::set_order_key (uint32_t n)
346 _has_order_key = true;
348 if (_order_key == n) {
354 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("%1 order key set to %2\n",
355 name(), order_key ()));
357 _session.set_dirty ();
361 Route::ensure_track_or_route_name(string name, Session &session)
363 string newname = name;
365 while (!session.io_name_is_legal (newname)) {
366 newname = bump_name_once (newname, '.');
373 Route::inc_gain (gain_t fraction, void *src)
375 _amp->inc_gain (fraction, src);
379 Route::set_gain (gain_t val, void *src)
381 if (src != 0 && _route_group && src != _route_group && _route_group->is_active() && _route_group->is_gain()) {
383 if (_route_group->is_relative()) {
385 gain_t usable_gain = _amp->gain();
386 if (usable_gain < 0.000001f) {
387 usable_gain = 0.000001f;
391 if (delta < 0.000001f) {
395 delta -= usable_gain;
400 gain_t factor = delta / usable_gain;
403 factor = _route_group->get_max_factor(factor);
404 if (factor == 0.0f) {
405 _amp->gain_control()->Changed(); /* EMIT SIGNAL */
409 factor = _route_group->get_min_factor(factor);
410 if (factor == 0.0f) {
411 _amp->gain_control()->Changed(); /* EMIT SIGNAL */
416 _route_group->foreach_route (boost::bind (&Route::inc_gain, _1, factor, _route_group));
420 _route_group->foreach_route (boost::bind (&Route::set_gain, _1, val, _route_group));
426 if (val == _amp->gain()) {
430 _amp->set_gain (val, src);
434 Route::inc_trim (gain_t fraction, void *src)
436 _trim->inc_gain (fraction, src);
440 Route::set_trim (gain_t val, void * /* src */)
442 // TODO route group, see set_gain()
443 _trim->set_gain (val, 0);
447 Route::maybe_declick (BufferSet&, framecnt_t, int)
449 /* this is the "bus" implementation and they never declick.
454 /** Process this route for one (sub) cycle (process thread)
456 * @param bufs Scratch buffers to use for the signal path
457 * @param start_frame Initial transport frame
458 * @param end_frame Final transport frame
459 * @param nframes Number of frames to output (to ports)
461 * Note that (end_frame - start_frame) may not be equal to nframes when the
462 * transport speed isn't 1.0 (eg varispeed).
465 Route::process_output_buffers (BufferSet& bufs,
466 framepos_t start_frame, framepos_t end_frame, pframes_t nframes,
467 int declick, bool gain_automation_ok)
469 /* Caller must hold process lock */
470 assert (!AudioEngine::instance()->process_lock().trylock());
472 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
474 // can this actually happen? functions calling process_output_buffers()
475 // already take a reader-lock.
476 bufs.silence (nframes, 0);
480 /* figure out if we're going to use gain automation */
481 if (gain_automation_ok) {
482 _amp->set_gain_automation_buffer (_session.gain_automation_buffer ());
483 _amp->setup_gain_automation (
484 start_frame + _signal_latency_at_amp_position,
485 end_frame + _signal_latency_at_amp_position,
488 _trim->set_gain_automation_buffer (_session.trim_automation_buffer ());
489 _trim->setup_gain_automation (
490 start_frame + _signal_latency_at_trim_position,
491 end_frame + _signal_latency_at_trim_position,
494 _amp->apply_gain_automation (false);
495 _trim->apply_gain_automation (false);
498 /* Tell main outs what to do about monitoring. We do this so that
499 on a transition between monitoring states we get a de-clicking gain
500 change in the _main_outs delivery.
502 bool silence = monitoring_state () == MonitoringSilence;
504 //but we override this in the case where we have an internal generator
505 if ( _have_internal_generator )
508 _main_outs->no_outs_cuz_we_no_monitor (silence);
510 /* -------------------------------------------------------------------------------------------
511 GLOBAL DECLICK (for transport changes etc.)
512 ----------------------------------------------------------------------------------------- */
514 maybe_declick (bufs, nframes, declick);
515 _pending_declick = 0;
517 /* -------------------------------------------------------------------------------------------
518 DENORMAL CONTROL/PHASE INVERT
519 ----------------------------------------------------------------------------------------- */
521 if (_phase_invert.any ()) {
525 if (_denormal_protection || Config->get_denormal_protection()) {
527 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
528 Sample* const sp = i->data();
530 if (_phase_invert[chn]) {
531 for (pframes_t nx = 0; nx < nframes; ++nx) {
536 for (pframes_t nx = 0; nx < nframes; ++nx) {
544 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
545 Sample* const sp = i->data();
547 if (_phase_invert[chn]) {
548 for (pframes_t nx = 0; nx < nframes; ++nx) {
557 if (_denormal_protection || Config->get_denormal_protection()) {
559 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
560 Sample* const sp = i->data();
561 for (pframes_t nx = 0; nx < nframes; ++nx) {
569 /* -------------------------------------------------------------------------------------------
571 ----------------------------------------------------------------------------------------- */
573 /* set this to be true if the meter will already have been ::run() earlier */
574 bool const meter_already_run = metering_state() == MeteringInput;
576 framecnt_t latency = 0;
578 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
580 if (meter_already_run && boost::dynamic_pointer_cast<PeakMeter> (*i)) {
581 /* don't ::run() the meter, otherwise it will have its previous peak corrupted */
586 /* if it has any inputs, make sure they match */
587 if (boost::dynamic_pointer_cast<UnknownProcessor> (*i) == 0 && (*i)->input_streams() != ChanCount::ZERO) {
588 if (bufs.count() != (*i)->input_streams()) {
590 DEBUG::Processors, string_compose (
591 "input port mismatch %1 bufs = %2 input for %3 = %4\n",
592 _name, bufs.count(), (*i)->name(), (*i)->input_streams()
599 /* should we NOT run plugins here if the route is inactive?
600 do we catch route != active somewhere higher?
603 if (boost::dynamic_pointer_cast<Send>(*i) != 0) {
604 boost::dynamic_pointer_cast<Send>(*i)->set_delay_in(_signal_latency - latency);
607 (*i)->run (bufs, start_frame - latency, end_frame - latency, nframes, *i != _processors.back());
608 bufs.set_count ((*i)->output_streams());
610 if ((*i)->active ()) {
611 latency += (*i)->signal_latency ();
617 Route::bounce_process (BufferSet& buffers, framepos_t start, framecnt_t nframes,
618 boost::shared_ptr<Processor> endpoint,
619 bool include_endpoint, bool for_export, bool for_freeze)
621 /* If no processing is required, there's no need to go any further. */
622 if (!endpoint && !include_endpoint) {
626 framecnt_t latency = bounce_get_latency(_amp, false, for_export, for_freeze);
627 _amp->set_gain_automation_buffer (_session.gain_automation_buffer ());
628 _amp->setup_gain_automation (start - latency, start - latency + nframes, nframes);
630 /* trim is always at the top, for bounce no latency compensation is needed */
631 _trim->set_gain_automation_buffer (_session.trim_automation_buffer ());
632 _trim->setup_gain_automation (start, start + nframes, nframes);
635 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
637 if (!include_endpoint && (*i) == endpoint) {
641 /* if we're not exporting, stop processing if we come across a routing processor. */
642 if (!for_export && boost::dynamic_pointer_cast<PortInsert>(*i)) {
645 if (!for_export && for_freeze && (*i)->does_routing() && (*i)->active()) {
649 /* don't run any processors that does routing.
650 * oh, and don't bother with the peak meter either.
652 if (!(*i)->does_routing() && !boost::dynamic_pointer_cast<PeakMeter>(*i)) {
653 (*i)->run (buffers, start - latency, start - latency + nframes, nframes, true);
654 buffers.set_count ((*i)->output_streams());
655 latency += (*i)->signal_latency ();
658 if ((*i) == endpoint) {
665 Route::bounce_get_latency (boost::shared_ptr<Processor> endpoint,
666 bool include_endpoint, bool for_export, bool for_freeze) const
668 framecnt_t latency = 0;
669 if (!endpoint && !include_endpoint) {
673 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
674 if (!include_endpoint && (*i) == endpoint) {
677 if (!for_export && boost::dynamic_pointer_cast<PortInsert>(*i)) {
680 if (!for_export && for_freeze && (*i)->does_routing() && (*i)->active()) {
683 if (!(*i)->does_routing() && !boost::dynamic_pointer_cast<PeakMeter>(*i)) {
684 latency += (*i)->signal_latency ();
686 if ((*i) == endpoint) {
694 Route::bounce_get_output_streams (ChanCount &cc, boost::shared_ptr<Processor> endpoint,
695 bool include_endpoint, bool for_export, bool for_freeze) const
697 if (!endpoint && !include_endpoint) {
701 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
702 if (!include_endpoint && (*i) == endpoint) {
705 if (!for_export && boost::dynamic_pointer_cast<PortInsert>(*i)) {
708 if (!for_export && for_freeze && (*i)->does_routing() && (*i)->active()) {
711 if (!(*i)->does_routing() && !boost::dynamic_pointer_cast<PeakMeter>(*i)) {
712 cc = (*i)->output_streams();
714 if ((*i) == endpoint) {
722 Route::n_process_buffers ()
724 return max (_input->n_ports(), processor_max_streams);
728 Route::monitor_run (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
730 assert (is_monitor());
731 BufferSet& bufs (_session.get_route_buffers (n_process_buffers()));
732 fill_buffers_with_input (bufs, _input, nframes);
733 passthru (bufs, start_frame, end_frame, nframes, declick);
737 Route::passthru (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
741 if (is_monitor() && _session.listening() && !_session.is_auditioning()) {
743 /* control/monitor bus ignores input ports when something is
744 feeding the listen "stream". data will "arrive" into the
745 route from the intreturn processor element.
748 bufs.silence (nframes, 0);
751 write_out_of_band_data (bufs, start_frame, end_frame, nframes);
752 process_output_buffers (bufs, start_frame, end_frame, nframes, declick, true);
756 Route::passthru_silence (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
758 BufferSet& bufs (_session.get_route_buffers (n_process_buffers(), true));
760 bufs.set_count (_input->n_ports());
761 write_out_of_band_data (bufs, start_frame, end_frame, nframes);
762 process_output_buffers (bufs, start_frame, end_frame, nframes, declick, false);
766 Route::set_listen (bool yn, void* src)
772 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
773 _route_group->foreach_route (boost::bind (&Route::set_listen, _1, yn, _route_group));
778 if (yn != _monitor_send->active()) {
780 _monitor_send->activate ();
781 _mute_master->set_soloed (true);
783 _monitor_send->deactivate ();
784 _mute_master->set_soloed (false);
787 listen_changed (src); /* EMIT SIGNAL */
793 Route::listening_via_monitor () const
796 return _monitor_send->active ();
803 Route::set_solo_safe (bool yn, void *src)
805 if (_solo_safe != yn) {
807 solo_safe_changed (src);
812 Route::solo_safe() const
818 Route::set_solo (bool yn, void *src)
821 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 ignore solo change due to solo-safe\n", name()));
825 if (is_master() || is_monitor() || is_auditioner()) {
826 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 ignore solo change (master, monitor or auditioner)\n", name()));
830 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
831 _route_group->foreach_route (boost::bind (&Route::set_solo, _1, yn, _route_group));
835 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1: set solo => %2, src: %3 grp ? %4 currently self-soloed ? %5\n",
836 name(), yn, src, (src == _route_group), self_soloed()));
838 if (self_soloed() != yn) {
840 set_mute_master_solo ();
841 solo_changed (true, src); /* EMIT SIGNAL */
842 _solo_control->Changed (); /* EMIT SIGNAL */
845 /* XXX TRACKS DEVELOPERS: THIS LOGIC SUGGESTS THAT YOU ARE NOT AWARE OF
846 Config->get_solo_mute_overrride().
849 if (yn && Profile->get_trx()) {
850 set_mute (false, src);
855 Route::set_self_solo (bool yn)
857 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1: set SELF solo => %2\n", name(), yn));
862 Route::mod_solo_by_others_upstream (int32_t delta)
865 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 ignore solo-by-upstream due to solo-safe\n", name()));
869 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 mod solo-by-upstream by %2, current up = %3 down = %4\n",
870 name(), delta, _soloed_by_others_upstream, _soloed_by_others_downstream));
872 uint32_t old_sbu = _soloed_by_others_upstream;
875 if (_soloed_by_others_upstream >= (uint32_t) abs (delta)) {
876 _soloed_by_others_upstream += delta;
878 _soloed_by_others_upstream = 0;
881 _soloed_by_others_upstream += delta;
884 DEBUG_TRACE (DEBUG::Solo, string_compose (
885 "%1 SbU delta %2 = %3 old = %4 sbd %5 ss %6 exclusive %7\n",
886 name(), delta, _soloed_by_others_upstream, old_sbu,
887 _soloed_by_others_downstream, _self_solo, Config->get_exclusive_solo()));
889 /* push the inverse solo change to everything that feeds us.
891 This is important for solo-within-group. When we solo 1 track out of N that
892 feed a bus, that track will cause mod_solo_by_upstream (+1) to be called
893 on the bus. The bus then needs to call mod_solo_by_downstream (-1) on all
894 tracks that feed it. This will silence them if they were audible because
895 of a bus solo, but the newly soloed track will still be audible (because
898 but .. do this only when we are being told to solo-by-upstream (i.e delta = +1),
902 if ((_self_solo || _soloed_by_others_downstream) &&
903 ((old_sbu == 0 && _soloed_by_others_upstream > 0) ||
904 (old_sbu > 0 && _soloed_by_others_upstream == 0))) {
906 if (delta > 0 || !Config->get_exclusive_solo()) {
907 DEBUG_TRACE (DEBUG::Solo, "\t ... INVERT push\n");
908 for (FedBy::iterator i = _fed_by.begin(); i != _fed_by.end(); ++i) {
909 boost::shared_ptr<Route> sr = i->r.lock();
911 sr->mod_solo_by_others_downstream (-delta);
917 set_mute_master_solo ();
918 solo_changed (false, this);
922 Route::mod_solo_by_others_downstream (int32_t delta)
925 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 ignore solo-by-downstream due to solo safe\n", name()));
929 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 mod solo-by-downstream by %2, current up = %3 down = %4\n",
930 name(), delta, _soloed_by_others_upstream, _soloed_by_others_downstream));
933 if (_soloed_by_others_downstream >= (uint32_t) abs (delta)) {
934 _soloed_by_others_downstream += delta;
936 _soloed_by_others_downstream = 0;
939 _soloed_by_others_downstream += delta;
942 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 SbD delta %2 = %3\n", name(), delta, _soloed_by_others_downstream));
944 set_mute_master_solo ();
945 solo_changed (false, this);
949 Route::set_mute_master_solo ()
951 _mute_master->set_soloed (self_soloed() || soloed_by_others_downstream() || soloed_by_others_upstream());
955 Route::set_solo_isolated (bool yn, void *src)
957 if (is_master() || is_monitor() || is_auditioner()) {
961 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
962 _route_group->foreach_route (boost::bind (&Route::set_solo_isolated, _1, yn, _route_group));
966 /* forward propagate solo-isolate status to everything fed by this route, but not those via sends only */
968 boost::shared_ptr<RouteList> routes = _session.get_routes ();
969 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
971 if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
976 bool does_feed = direct_feeds_according_to_graph (*i, &sends_only); // we will recurse anyway, so don't use ::feeds()
978 if (does_feed && !sends_only) {
979 (*i)->set_solo_isolated (yn, (*i)->route_group());
983 /* XXX should we back-propagate as well? (April 2010: myself and chris goddard think not) */
985 bool changed = false;
988 if (_solo_isolated == 0) {
989 _mute_master->set_solo_ignore (true);
994 if (_solo_isolated > 0) {
996 if (_solo_isolated == 0) {
997 _mute_master->set_solo_ignore (false);
1004 solo_isolated_changed (src);
1009 Route::solo_isolated () const
1011 return _solo_isolated > 0;
1015 Route::set_mute_points (MuteMaster::MutePoint mp)
1017 _mute_master->set_mute_points (mp);
1018 mute_points_changed (); /* EMIT SIGNAL */
1020 if (_mute_master->muted_by_self()) {
1021 mute_changed (this); /* EMIT SIGNAL */
1022 _mute_control->Changed (); /* EMIT SIGNAL */
1027 Route::set_mute (bool yn, void *src)
1029 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_mute()) {
1030 _route_group->foreach_route (boost::bind (&Route::set_mute, _1, yn, _route_group));
1034 if (muted() != yn) {
1035 _mute_master->set_muted_by_self (yn);
1036 /* allow any derived classes to respond to the mute change
1037 before anybody else knows about it.
1040 /* tell everyone else */
1041 mute_changed (src); /* EMIT SIGNAL */
1042 _mute_control->Changed (); /* EMIT SIGNAL */
1047 Route::muted () const
1049 return _mute_master->muted_by_self();
1053 Route::muted_by_others () const
1055 //master is never muted by others
1059 //now check to see if something is soloed (and I am not)
1060 return (_session.soloing() && !self_soloed() && !solo_isolated());
1065 dump_processors(const string& name, const list<boost::shared_ptr<Processor> >& procs)
1067 cerr << name << " {" << endl;
1068 for (list<boost::shared_ptr<Processor> >::const_iterator p = procs.begin();
1069 p != procs.end(); ++p) {
1070 cerr << "\t" << (*p)->name() << " ID = " << (*p)->id() << " @ " << (*p) << endl;
1072 cerr << "}" << endl;
1076 /** Supposing that we want to insert a Processor at a given Placement, return
1077 * the processor to add the new one before (or 0 to add at the end).
1079 boost::shared_ptr<Processor>
1080 Route::before_processor_for_placement (Placement p)
1082 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1084 ProcessorList::iterator loc;
1086 if (p == PreFader) {
1087 /* generic pre-fader: insert immediately before the amp */
1088 loc = find (_processors.begin(), _processors.end(), _amp);
1090 /* generic post-fader: insert right before the main outs */
1091 loc = find (_processors.begin(), _processors.end(), _main_outs);
1094 return loc != _processors.end() ? *loc : boost::shared_ptr<Processor> ();
1097 /** Supposing that we want to insert a Processor at a given index, return
1098 * the processor to add the new one before (or 0 to add at the end).
1100 boost::shared_ptr<Processor>
1101 Route::before_processor_for_index (int index)
1104 return boost::shared_ptr<Processor> ();
1107 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1109 ProcessorList::iterator i = _processors.begin ();
1111 while (i != _processors.end() && j < index) {
1112 if ((*i)->display_to_user()) {
1119 return (i != _processors.end() ? *i : boost::shared_ptr<Processor> ());
1122 /** Add a processor either pre- or post-fader
1123 * @return 0 on success, non-0 on failure.
1126 Route::add_processor (boost::shared_ptr<Processor> processor, Placement placement, ProcessorStreams* err, bool activation_allowed)
1128 return add_processor (processor, before_processor_for_placement (placement), err, activation_allowed);
1132 /** Add a processor to a route such that it ends up with a given index into the visible processors.
1133 * @param index Index to add the processor at, or -1 to add at the end of the list.
1134 * @return 0 on success, non-0 on failure.
1137 Route::add_processor_by_index (boost::shared_ptr<Processor> processor, int index, ProcessorStreams* err, bool activation_allowed)
1139 return add_processor (processor, before_processor_for_index (index), err, activation_allowed);
1142 /** Add a processor to the route.
1143 * @param before An existing processor in the list, or 0; the new processor will be inserted immediately before it (or at the end).
1144 * @return 0 on success, non-0 on failure.
1147 Route::add_processor (boost::shared_ptr<Processor> processor, boost::shared_ptr<Processor> before, ProcessorStreams* err, bool activation_allowed)
1149 assert (processor != _meter);
1150 assert (processor != _main_outs);
1152 DEBUG_TRACE (DEBUG::Processors, string_compose (
1153 "%1 adding processor %2\n", name(), processor->name()));
1155 if (!AudioEngine::instance()->connected() || !processor) {
1160 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1161 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1162 ProcessorState pstate (this);
1164 boost::shared_ptr<PluginInsert> pi;
1165 boost::shared_ptr<PortInsert> porti;
1167 if (processor == _amp) {
1168 /* Ensure that only one amp is in the list at any time */
1169 ProcessorList::iterator check = find (_processors.begin(), _processors.end(), processor);
1170 if (check != _processors.end()) {
1171 if (before == _amp) {
1172 /* Already in position; all is well */
1175 _processors.erase (check);
1180 assert (find (_processors.begin(), _processors.end(), processor) == _processors.end ());
1182 ProcessorList::iterator loc;
1184 /* inserting before a processor; find it */
1185 loc = find (_processors.begin(), _processors.end(), before);
1186 if (loc == _processors.end ()) {
1191 /* inserting at end */
1192 loc = _processors.end ();
1195 _processors.insert (loc, processor);
1196 processor->set_owner (this);
1198 // Set up processor list channels. This will set processor->[input|output]_streams(),
1199 // configure redirect ports properly, etc.
1202 if (configure_processors_unlocked (err)) {
1204 configure_processors_unlocked (0); // it worked before we tried to add it ...
1209 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(processor)) != 0) {
1211 if (pi->has_no_inputs ()) {
1212 /* generator plugin */
1213 _have_internal_generator = true;
1218 if (activation_allowed && (!_session.get_disable_all_loaded_plugins () || !processor->display_to_user ())) {
1219 processor->activate ();
1222 processor->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
1224 _output->set_user_latency (0);
1227 reset_instrument_info ();
1228 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1229 set_processor_positions ();
1235 Route::add_processor_from_xml_2X (const XMLNode& node, int version)
1237 const XMLProperty *prop;
1240 boost::shared_ptr<Processor> processor;
1242 /* bit of a hack: get the `placement' property from the <Redirect> tag here
1243 so that we can add the processor in the right place (pre/post-fader)
1246 XMLNodeList const & children = node.children ();
1247 XMLNodeList::const_iterator i = children.begin ();
1249 while (i != children.end() && (*i)->name() != X_("Redirect")) {
1253 Placement placement = PreFader;
1255 if (i != children.end()) {
1256 if ((prop = (*i)->property (X_("placement"))) != 0) {
1257 placement = Placement (string_2_enum (prop->value(), placement));
1261 if (node.name() == "Insert") {
1263 if ((prop = node.property ("type")) != 0) {
1265 if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
1266 prop->value() == "lv2" ||
1267 prop->value() == "windows-vst" ||
1268 prop->value() == "lxvst" ||
1269 prop->value() == "audiounit") {
1271 processor.reset (new PluginInsert (_session));
1275 processor.reset (new PortInsert (_session, _pannable, _mute_master));
1280 } else if (node.name() == "Send") {
1282 boost::shared_ptr<Pannable> sendpan (new Pannable (_session));
1283 processor.reset (new Send (_session, sendpan, _mute_master));
1287 error << string_compose(_("unknown Processor type \"%1\"; ignored"), node.name()) << endmsg;
1291 if (processor->set_state (node, version)) {
1295 //A2 uses the "active" flag in the toplevel redirect node, not in the child plugin/IO
1296 if (i != children.end()) {
1297 if ((prop = (*i)->property (X_("active"))) != 0) {
1298 if ( string_is_affirmative (prop->value()) && (!_session.get_disable_all_loaded_plugins () || !processor->display_to_user () ) )
1299 processor->activate();
1301 processor->deactivate();
1305 return (add_processor (processor, placement, 0, false) == 0);
1308 catch (failed_constructor &err) {
1309 warning << _("processor could not be created. Ignored.") << endmsg;
1315 Route::add_processors (const ProcessorList& others, boost::shared_ptr<Processor> before, ProcessorStreams* err)
1317 /* NOTE: this is intended to be used ONLY when copying
1318 processors from another Route. Hence the subtle
1319 differences between this and ::add_processor()
1322 ProcessorList::iterator loc;
1325 loc = find(_processors.begin(), _processors.end(), before);
1327 /* nothing specified - at end */
1328 loc = _processors.end ();
1331 if (!_session.engine().connected()) {
1335 if (others.empty()) {
1340 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1341 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1342 ProcessorState pstate (this);
1344 for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
1350 boost::shared_ptr<PluginInsert> pi;
1352 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1356 _processors.insert (loc, *i);
1357 (*i)->set_owner (this);
1359 if ((*i)->active()) {
1363 /* Think: does this really need to be called for every processor in the loop? */
1365 if (configure_processors_unlocked (err)) {
1367 configure_processors_unlocked (0); // it worked before we tried to add it ...
1372 (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
1375 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
1376 boost::shared_ptr<PluginInsert> pi;
1378 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1379 if (pi->has_no_inputs ()) {
1380 _have_internal_generator = true;
1386 _output->set_user_latency (0);
1389 reset_instrument_info ();
1390 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1391 set_processor_positions ();
1397 Route::placement_range(Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end)
1399 if (p == PreFader) {
1400 start = _processors.begin();
1401 end = find(_processors.begin(), _processors.end(), _amp);
1403 start = find(_processors.begin(), _processors.end(), _amp);
1405 end = _processors.end();
1409 /** Turn off all processors with a given placement
1410 * @param p Placement of processors to disable
1413 Route::disable_processors (Placement p)
1415 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1417 ProcessorList::iterator start, end;
1418 placement_range(p, start, end);
1420 for (ProcessorList::iterator i = start; i != end; ++i) {
1421 (*i)->deactivate ();
1424 _session.set_dirty ();
1427 /** Turn off all redirects
1430 Route::disable_processors ()
1432 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1434 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1435 (*i)->deactivate ();
1438 _session.set_dirty ();
1441 /** Turn off all redirects with a given placement
1442 * @param p Placement of redirects to disable
1445 Route::disable_plugins (Placement p)
1447 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1449 ProcessorList::iterator start, end;
1450 placement_range(p, start, end);
1452 for (ProcessorList::iterator i = start; i != end; ++i) {
1453 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1454 (*i)->deactivate ();
1458 _session.set_dirty ();
1461 /** Turn off all plugins
1464 Route::disable_plugins ()
1466 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1468 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1469 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1470 (*i)->deactivate ();
1474 _session.set_dirty ();
1479 Route::ab_plugins (bool forward)
1481 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1485 /* forward = turn off all active redirects, and mark them so that the next time
1486 we go the other way, we will revert them
1489 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1490 if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1494 if ((*i)->active()) {
1495 (*i)->deactivate ();
1496 (*i)->set_next_ab_is_active (true);
1498 (*i)->set_next_ab_is_active (false);
1504 /* backward = if the redirect was marked to go active on the next ab, do so */
1506 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1508 if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1512 if ((*i)->get_next_ab_is_active()) {
1515 (*i)->deactivate ();
1520 _session.set_dirty ();
1524 /** Remove processors with a given placement.
1525 * @param p Placement of processors to remove.
1528 Route::clear_processors (Placement p)
1530 if (!_session.engine().connected()) {
1534 bool already_deleting = _session.deletion_in_progress();
1535 if (!already_deleting) {
1536 _session.set_deletion_in_progress();
1540 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1541 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1542 ProcessorList new_list;
1543 ProcessorStreams err;
1544 bool seen_amp = false;
1546 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1552 if ((*i) == _amp || (*i) == _meter || (*i) == _main_outs || (*i) == _delayline || (*i) == _trim) {
1554 /* you can't remove these */
1556 new_list.push_back (*i);
1563 new_list.push_back (*i);
1566 (*i)->drop_references ();
1574 (*i)->drop_references ();
1577 new_list.push_back (*i);
1584 _processors = new_list;
1585 configure_processors_unlocked (&err); // this can't fail
1588 processor_max_streams.reset();
1589 _have_internal_generator = false;
1590 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1591 set_processor_positions ();
1593 reset_instrument_info ();
1595 if (!already_deleting) {
1596 _session.clear_deletion_in_progress();
1601 Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err, bool need_process_lock)
1603 // TODO once the export point can be configured properly, do something smarter here
1604 if (processor == _capturing_processor) {
1605 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1606 if (need_process_lock) {
1610 _capturing_processor.reset();
1612 if (need_process_lock) {
1617 /* these can never be removed */
1619 if (processor == _amp || processor == _meter || processor == _main_outs || processor == _delayline || processor == _trim) {
1623 if (!_session.engine().connected()) {
1627 processor_max_streams.reset();
1630 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1631 if (need_process_lock) {
1635 /* Caller must hold process lock */
1636 assert (!AudioEngine::instance()->process_lock().trylock());
1638 Glib::Threads::RWLock::WriterLock lm (_processor_lock); // XXX deadlock after export
1640 ProcessorState pstate (this);
1642 ProcessorList::iterator i;
1643 bool removed = false;
1645 for (i = _processors.begin(); i != _processors.end(); ) {
1646 if (*i == processor) {
1648 /* move along, see failure case for configure_processors()
1649 where we may need to reconfigure the processor.
1652 /* stop redirects that send signals to JACK ports
1653 from causing noise as a result of no longer being
1657 boost::shared_ptr<IOProcessor> iop;
1659 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (*i)) != 0) {
1663 i = _processors.erase (i);
1671 _output->set_user_latency (0);
1679 if (configure_processors_unlocked (err)) {
1681 /* we know this will work, because it worked before :) */
1682 configure_processors_unlocked (0);
1686 _have_internal_generator = false;
1688 for (i = _processors.begin(); i != _processors.end(); ++i) {
1689 boost::shared_ptr<PluginInsert> pi;
1691 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1692 if (pi->has_no_inputs ()) {
1693 _have_internal_generator = true;
1698 if (need_process_lock) {
1703 reset_instrument_info ();
1704 processor->drop_references ();
1705 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1706 set_processor_positions ();
1712 Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
1714 ProcessorList deleted;
1716 if (!_session.engine().connected()) {
1720 processor_max_streams.reset();
1723 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1724 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1725 ProcessorState pstate (this);
1727 ProcessorList::iterator i;
1728 boost::shared_ptr<Processor> processor;
1730 for (i = _processors.begin(); i != _processors.end(); ) {
1734 /* these can never be removed */
1736 if (processor == _amp || processor == _meter || processor == _main_outs || processor == _delayline || processor == _trim) {
1741 /* see if its in the list of processors to delete */
1743 if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
1748 /* stop IOProcessors that send to JACK ports
1749 from causing noise as a result of no longer being
1753 boost::shared_ptr<IOProcessor> iop;
1755 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (processor)) != 0) {
1759 deleted.push_back (processor);
1760 i = _processors.erase (i);
1763 if (deleted.empty()) {
1764 /* none of those in the requested list were found */
1768 _output->set_user_latency (0);
1770 if (configure_processors_unlocked (err)) {
1772 /* we know this will work, because it worked before :) */
1773 configure_processors_unlocked (0);
1778 _have_internal_generator = false;
1780 for (i = _processors.begin(); i != _processors.end(); ++i) {
1781 boost::shared_ptr<PluginInsert> pi;
1783 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1784 if (pi->has_no_inputs ()) {
1785 _have_internal_generator = true;
1792 /* now try to do what we need to so that those that were removed will be deleted */
1794 for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
1795 (*i)->drop_references ();
1798 reset_instrument_info ();
1799 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1800 set_processor_positions ();
1806 Route::reset_instrument_info ()
1808 boost::shared_ptr<Processor> instr = the_instrument();
1810 _instrument_info.set_internal_instrument (instr);
1814 /** Caller must hold process lock */
1816 Route::configure_processors (ProcessorStreams* err)
1818 #ifndef PLATFORM_WINDOWS
1819 assert (!AudioEngine::instance()->process_lock().trylock());
1822 if (!_in_configure_processors) {
1823 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1824 return configure_processors_unlocked (err);
1831 Route::input_streams () const
1833 return _input->n_ports ();
1836 list<pair<ChanCount, ChanCount> >
1837 Route::try_configure_processors (ChanCount in, ProcessorStreams* err)
1839 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1841 return try_configure_processors_unlocked (in, err);
1844 list<pair<ChanCount, ChanCount> >
1845 Route::try_configure_processors_unlocked (ChanCount in, ProcessorStreams* err)
1847 // Check each processor in order to see if we can configure as requested
1849 list<pair<ChanCount, ChanCount> > configuration;
1852 DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
1853 DEBUG_TRACE (DEBUG::Processors, "{\n");
1855 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1857 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1858 DEBUG_TRACE (DEBUG::Processors, "--- CONFIGURE ABORTED due to unknown processor.\n");
1859 DEBUG_TRACE (DEBUG::Processors, "}\n");
1860 return list<pair<ChanCount, ChanCount> > ();
1863 if ((*p)->can_support_io_configuration(in, out)) {
1864 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID=%2 in=%3 out=%4\n",(*p)->name(), (*p)->id(), in, out));
1865 configuration.push_back(make_pair(in, out));
1872 DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
1873 DEBUG_TRACE (DEBUG::Processors, string_compose ("---- %1 cannot support in=%2 out=%3\n", (*p)->name(), in, out));
1874 DEBUG_TRACE (DEBUG::Processors, "}\n");
1875 return list<pair<ChanCount, ChanCount> > ();
1879 DEBUG_TRACE (DEBUG::Processors, "}\n");
1881 return configuration;
1884 /** Set the input/output configuration of each processor in the processors list.
1885 * Caller must hold process lock.
1886 * Return 0 on success, otherwise configuration is impossible.
1889 Route::configure_processors_unlocked (ProcessorStreams* err)
1891 #ifndef PLATFORM_WINDOWS
1892 assert (!AudioEngine::instance()->process_lock().trylock());
1895 if (_in_configure_processors) {
1899 /* put invisible processors where they should be */
1900 setup_invisible_processors ();
1902 _in_configure_processors = true;
1904 list<pair<ChanCount, ChanCount> > configuration = try_configure_processors_unlocked (input_streams (), err);
1906 if (configuration.empty ()) {
1907 _in_configure_processors = false;
1912 bool seen_mains_out = false;
1913 processor_out_streams = _input->n_ports();
1914 processor_max_streams.reset();
1916 list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1917 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1919 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1923 (*p)->configure_io(c->first, c->second);
1924 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1925 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1927 boost::shared_ptr<PluginInsert> pi;
1928 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
1929 /* plugins connected via Split Match may have more channels.
1930 * route/scratch buffers are needed for all of them*/
1931 processor_max_streams = ChanCount::max(processor_max_streams, pi->input_streams());
1932 processor_max_streams = ChanCount::max(processor_max_streams, pi->natural_input_streams());
1936 if (boost::dynamic_pointer_cast<Delivery> (*p)
1937 && boost::dynamic_pointer_cast<Delivery> (*p)->role() == Delivery::Main) {
1938 /* main delivery will increase port count to match input.
1939 * the Delivery::Main is usually the last processor - followed only by
1942 seen_mains_out = true;
1944 if (!seen_mains_out) {
1945 processor_out_streams = out;
1951 _meter->set_max_channels (processor_max_streams);
1954 /* make sure we have sufficient scratch buffers to cope with the new processor
1957 _session.ensure_buffers (n_process_buffers ());
1959 DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
1961 _in_configure_processors = false;
1965 /** Set all visible processors to a given active state (except Fader, whose state is not changed)
1966 * @param state New active state for those processors.
1969 Route::all_visible_processors_active (bool state)
1971 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1973 if (_processors.empty()) {
1977 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1978 if (!(*i)->display_to_user() || boost::dynamic_pointer_cast<Amp> (*i)) {
1985 (*i)->deactivate ();
1989 _session.set_dirty ();
1993 Route::processors_reorder_needs_configure (const ProcessorList& new_order)
1995 /* check if re-order requires re-configuration of any processors
1996 * -> compare channel configuration for all processors
1998 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1999 ChanCount c = input_streams ();
2001 for (ProcessorList::const_iterator j = new_order.begin(); j != new_order.end(); ++j) {
2003 if (c != (*j)->input_streams()) {
2006 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2009 if ((*i)->input_streams() != c) {
2012 c = (*i)->output_streams();
2024 __attribute__((annotate("realtime")))
2027 Route::apply_processor_order (const ProcessorList& new_order)
2029 /* need to hold processor_lock; either read or write lock
2030 * and the engine process_lock.
2031 * Due to r/w lock ambiguity we can only assert the latter
2033 assert (!AudioEngine::instance()->process_lock().trylock());
2036 /* "new_order" is an ordered list of processors to be positioned according to "placement".
2037 * NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
2038 * processors in the current actual processor list that are hidden. Any visible processors
2039 * in the current list but not in "new_order" will be assumed to be deleted.
2042 /* "as_it_will_be" and "_processors" are lists of shared pointers.
2043 * actual memory usage is small, but insert/erase is not actually rt-safe :(
2044 * (note though that ::processors_reorder_needs_configure() ensured that
2045 * this function will only ever be called from the rt-thread if no processor were removed)
2047 * either way, I can't proove it, but an x-run due to re-order here is less likley
2048 * than an x-run-less 'ardour-silent cycle' both of which effectively "click".
2051 ProcessorList as_it_will_be;
2052 ProcessorList::iterator oiter;
2053 ProcessorList::const_iterator niter;
2055 oiter = _processors.begin();
2056 niter = new_order.begin();
2058 while (niter != new_order.end()) {
2060 /* if the next processor in the old list is invisible (i.e. should not be in the new order)
2061 then append it to the temp list.
2063 Otherwise, see if the next processor in the old list is in the new list. if not,
2064 its been deleted. If its there, append it to the temp list.
2067 if (oiter == _processors.end()) {
2069 /* no more elements in the old list, so just stick the rest of
2070 the new order onto the temp list.
2073 as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
2074 while (niter != new_order.end()) {
2081 if (!(*oiter)->display_to_user()) {
2083 as_it_will_be.push_back (*oiter);
2087 /* visible processor: check that its in the new order */
2089 if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
2090 /* deleted: do nothing, shared_ptr<> will clean up */
2092 /* ignore this one, and add the next item from the new order instead */
2093 as_it_will_be.push_back (*niter);
2098 /* now remove from old order - its taken care of no matter what */
2099 oiter = _processors.erase (oiter);
2103 _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
2105 /* If the meter is in a custom position, find it and make a rough note of its position */
2106 maybe_note_meter_position ();
2110 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
2112 // it a change is already queued, wait for it
2113 // (unless engine is stopped. apply immediately and proceed
2114 while (g_atomic_int_get (&_pending_process_reorder)) {
2115 if (!AudioEngine::instance()->running()) {
2116 DEBUG_TRACE (DEBUG::Processors, "offline apply queued processor re-order.\n");
2117 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2119 apply_processor_order(_pending_processor_order);
2120 setup_invisible_processors ();
2122 g_atomic_int_set (&_pending_process_reorder, 0);
2124 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2125 set_processor_positions ();
2127 // TODO rather use a semaphore or something.
2128 // but since ::reorder_processors() is called
2129 // from the GUI thread, this is fine..
2134 if (processors_reorder_needs_configure (new_order) || !AudioEngine::instance()->running()) {
2136 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2137 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2138 ProcessorState pstate (this);
2140 apply_processor_order (new_order);
2142 if (configure_processors_unlocked (err)) {
2150 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2151 set_processor_positions ();
2154 DEBUG_TRACE (DEBUG::Processors, "Queue clickless processor re-order.\n");
2155 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2157 // _pending_processor_order is protected by _processor_lock
2158 _pending_processor_order = new_order;
2159 g_atomic_int_set (&_pending_process_reorder, 1);
2172 Route::get_template()
2174 return state(false);
2178 Route::state(bool full_state)
2180 XMLNode *node = new XMLNode("Route");
2181 ProcessorList::iterator i;
2184 id().print (buf, sizeof (buf));
2185 node->add_property("id", buf);
2186 node->add_property ("name", _name);
2187 node->add_property("default-type", _default_type.to_string());
2190 node->add_property("flags", enum_2_string (_flags));
2193 node->add_property("active", _active?"yes":"no");
2195 boost::to_string (_phase_invert, p);
2196 node->add_property("phase-invert", p);
2197 node->add_property("denormal-protection", _denormal_protection?"yes":"no");
2198 node->add_property("meter-point", enum_2_string (_meter_point));
2200 node->add_property("meter-type", enum_2_string (_meter_type));
2203 node->add_property("route-group", _route_group->name());
2206 snprintf (buf, sizeof (buf), "%d", _order_key);
2207 node->add_property ("order-key", buf);
2208 node->add_property ("self-solo", (_self_solo ? "yes" : "no"));
2209 snprintf (buf, sizeof (buf), "%d", _soloed_by_others_upstream);
2210 node->add_property ("soloed-by-upstream", buf);
2211 snprintf (buf, sizeof (buf), "%d", _soloed_by_others_downstream);
2212 node->add_property ("soloed-by-downstream", buf);
2213 node->add_property ("solo-isolated", solo_isolated() ? "yes" : "no");
2214 node->add_property ("solo-safe", _solo_safe ? "yes" : "no");
2216 node->add_child_nocopy (_input->state (full_state));
2217 node->add_child_nocopy (_output->state (full_state));
2218 node->add_child_nocopy (_solo_control->get_state ());
2219 node->add_child_nocopy (_mute_control->get_state ());
2220 node->add_child_nocopy (_mute_master->get_state ());
2223 node->add_child_nocopy (Automatable::get_automation_xml_state ());
2226 XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
2227 snprintf (buf, sizeof (buf), "%d", _remote_control_id);
2228 remote_control_node->add_property (X_("id"), buf);
2229 node->add_child_nocopy (*remote_control_node);
2231 if (_comment.length()) {
2232 XMLNode *cmt = node->add_child ("Comment");
2233 cmt->add_content (_comment);
2237 node->add_child_nocopy (_pannable->state (full_state));
2240 for (i = _processors.begin(); i != _processors.end(); ++i) {
2242 /* template save: do not include internal sends functioning as
2243 aux sends because the chance of the target ID
2244 in the session where this template is used
2247 similarly, do not save listen sends which connect to
2248 the monitor section, because these will always be
2251 boost::shared_ptr<InternalSend> is;
2253 if ((is = boost::dynamic_pointer_cast<InternalSend> (*i)) != 0) {
2254 if (is->role() == Delivery::Listen) {
2259 node->add_child_nocopy((*i)->state (full_state));
2263 node->add_child_copy (*_extra_xml);
2266 if (_custom_meter_position_noted) {
2267 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
2269 after->id().print (buf, sizeof (buf));
2270 node->add_property (X_("processor-after-last-custom-meter"), buf);
2278 Route::set_state (const XMLNode& node, int version)
2280 if (version < 3000) {
2281 return set_state_2X (node, version);
2285 XMLNodeConstIterator niter;
2287 const XMLProperty *prop;
2289 if (node.name() != "Route"){
2290 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2294 if ((prop = node.property (X_("name"))) != 0) {
2295 Route::set_name (prop->value());
2299 _initial_io_setup = true;
2301 if ((prop = node.property (X_("flags"))) != 0) {
2302 _flags = Flag (string_2_enum (prop->value(), _flags));
2307 if (is_master() || is_monitor() || is_auditioner()) {
2308 _mute_master->set_solo_ignore (true);
2312 /* monitor bus does not get a panner, but if (re)created
2313 via XML, it will already have one by the time we
2314 call ::set_state(). so ... remove it.
2319 /* add all processors (except amp, which is always present) */
2321 nlist = node.children();
2322 XMLNode processor_state (X_("processor_state"));
2324 Stateful::save_extra_xml (node);
2326 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2330 if (child->name() == IO::state_node_name) {
2331 if ((prop = child->property (X_("direction"))) == 0) {
2335 if (prop->value() == "Input") {
2336 _input->set_state (*child, version);
2337 } else if (prop->value() == "Output") {
2338 _output->set_state (*child, version);
2342 if (child->name() == X_("Processor")) {
2343 processor_state.add_child_copy (*child);
2346 if (child->name() == X_("Pannable")) {
2348 _pannable->set_state (*child, version);
2350 warning << string_compose (_("Pannable state found for route (%1) without a panner!"), name()) << endmsg;
2355 if ((prop = node.property (X_("meter-point"))) != 0) {
2356 MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
2357 set_meter_point (mp, true);
2359 _meter->set_display_to_user (_meter_point == MeterCustom);
2363 if ((prop = node.property (X_("meter-type"))) != 0) {
2364 _meter_type = MeterType (string_2_enum (prop->value (), _meter_type));
2367 _initial_io_setup = false;
2369 set_processor_state (processor_state);
2371 // this looks up the internal instrument in processors
2372 reset_instrument_info();
2374 if ((prop = node.property ("self-solo")) != 0) {
2375 set_self_solo (string_is_affirmative (prop->value()));
2378 if ((prop = node.property ("soloed-by-upstream")) != 0) {
2379 _soloed_by_others_upstream = 0; // needed for mod_.... () to work
2380 mod_solo_by_others_upstream (atoi (prop->value()));
2383 if ((prop = node.property ("soloed-by-downstream")) != 0) {
2384 _soloed_by_others_downstream = 0; // needed for mod_.... () to work
2385 mod_solo_by_others_downstream (atoi (prop->value()));
2388 if ((prop = node.property ("solo-isolated")) != 0) {
2389 set_solo_isolated (string_is_affirmative (prop->value()), this);
2392 if ((prop = node.property ("solo-safe")) != 0) {
2393 set_solo_safe (string_is_affirmative (prop->value()), this);
2396 if ((prop = node.property (X_("phase-invert"))) != 0) {
2397 set_phase_invert (boost::dynamic_bitset<> (prop->value ()));
2400 if ((prop = node.property (X_("denormal-protection"))) != 0) {
2401 set_denormal_protection (string_is_affirmative (prop->value()));
2404 if ((prop = node.property (X_("active"))) != 0) {
2405 bool yn = string_is_affirmative (prop->value());
2406 _active = !yn; // force switch
2407 set_active (yn, this);
2410 if ((prop = node.property (X_("order-key"))) != 0) { // New order key (no separate mixer/editor ordering)
2411 set_order_key (atoi(prop->value()));
2414 if ((prop = node.property (X_("order-keys"))) != 0) { // Deprecated order keys
2418 string::size_type colon, equal;
2419 string remaining = prop->value();
2421 while (remaining.length()) {
2423 if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2424 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2427 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2428 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2431 string keyname = remaining.substr (0, equal);
2433 if ((keyname == "EditorSort") || (keyname == "editor")) {
2434 cerr << "Setting " << name() << " order key to " << n << " using saved Editor order." << endl;
2440 colon = remaining.find_first_of (':');
2442 if (colon != string::npos) {
2443 remaining = remaining.substr (colon+1);
2450 if ((prop = node.property (X_("processor-after-last-custom-meter"))) != 0) {
2451 PBD::ID id (prop->value ());
2452 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2453 ProcessorList::const_iterator i = _processors.begin ();
2454 while (i != _processors.end() && (*i)->id() != id) {
2458 if (i != _processors.end ()) {
2459 _processor_after_last_custom_meter = *i;
2460 _custom_meter_position_noted = true;
2464 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2467 if (child->name() == X_("Comment")) {
2469 /* XXX this is a terrible API design in libxml++ */
2471 XMLNode *cmt = *(child->children().begin());
2472 _comment = cmt->content();
2474 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2475 if (prop->value() == "solo") {
2476 _solo_control->set_state (*child, version);
2477 } else if (prop->value() == "mute") {
2478 _mute_control->set_state (*child, version);
2481 } else if (child->name() == X_("RemoteControl")) {
2482 if ((prop = child->property (X_("id"))) != 0) {
2484 sscanf (prop->value().c_str(), "%d", &x);
2485 set_remote_control_id_internal (x);
2488 } else if (child->name() == X_("MuteMaster")) {
2489 _mute_master->set_state (*child, version);
2491 } else if (child->name() == Automatable::xml_node_name) {
2492 set_automation_xml_state (*child, Evoral::Parameter(NullAutomation));
2500 Route::set_state_2X (const XMLNode& node, int version)
2502 LocaleGuard lg (X_("C"));
2504 XMLNodeConstIterator niter;
2506 const XMLProperty *prop;
2508 /* 2X things which still remain to be handled:
2514 if (node.name() != "Route") {
2515 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2519 if ((prop = node.property (X_("flags"))) != 0) {
2520 string f = prop->value ();
2521 boost::replace_all (f, "ControlOut", "MonitorOut");
2522 _flags = Flag (string_2_enum (f, _flags));
2527 if (is_master() || is_monitor() || is_auditioner()) {
2528 _mute_master->set_solo_ignore (true);
2531 if ((prop = node.property (X_("phase-invert"))) != 0) {
2532 boost::dynamic_bitset<> p (_input->n_ports().n_audio ());
2533 if (string_is_affirmative (prop->value ())) {
2536 set_phase_invert (p);
2539 if ((prop = node.property (X_("denormal-protection"))) != 0) {
2540 set_denormal_protection (string_is_affirmative (prop->value()));
2543 if ((prop = node.property (X_("soloed"))) != 0) {
2544 bool yn = string_is_affirmative (prop->value());
2546 /* XXX force reset of solo status */
2548 set_solo (yn, this);
2551 if ((prop = node.property (X_("muted"))) != 0) {
2554 bool muted = string_is_affirmative (prop->value());
2560 if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
2562 if (string_is_affirmative (prop->value())){
2563 mute_point = mute_point + "PreFader";
2568 if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
2570 if (string_is_affirmative (prop->value())){
2573 mute_point = mute_point + ",";
2576 mute_point = mute_point + "PostFader";
2581 if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
2583 if (string_is_affirmative (prop->value())){
2586 mute_point = mute_point + ",";
2589 mute_point = mute_point + "Listen";
2594 if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
2596 if (string_is_affirmative (prop->value())){
2599 mute_point = mute_point + ",";
2602 mute_point = mute_point + "Main";
2606 _mute_master->set_mute_points (mute_point);
2607 _mute_master->set_muted_by_self (true);
2611 if ((prop = node.property (X_("meter-point"))) != 0) {
2612 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2615 /* do not carry over edit/mix groups from 2.X because (a) its hard (b) they
2616 don't mean the same thing.
2619 if ((prop = node.property (X_("order-keys"))) != 0) {
2623 string::size_type colon, equal;
2624 string remaining = prop->value();
2626 while (remaining.length()) {
2628 if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2629 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2632 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2633 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2636 string keyname = remaining.substr (0, equal);
2638 if (keyname == "EditorSort" || keyname == "editor") {
2639 info << string_compose(_("Converting deprecated order key for %1 using Editor order %2"), name (), n) << endmsg;
2645 colon = remaining.find_first_of (':');
2647 if (colon != string::npos) {
2648 remaining = remaining.substr (colon+1);
2657 nlist = node.children ();
2658 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2662 if (child->name() == IO::state_node_name) {
2664 /* there is a note in IO::set_state_2X() about why we have to call
2668 _input->set_state_2X (*child, version, true);
2669 _output->set_state_2X (*child, version, false);
2671 if ((prop = child->property (X_("name"))) != 0) {
2672 Route::set_name (prop->value ());
2677 if ((prop = child->property (X_("active"))) != 0) {
2678 bool yn = string_is_affirmative (prop->value());
2679 _active = !yn; // force switch
2680 set_active (yn, this);
2683 if ((prop = child->property (X_("gain"))) != 0) {
2686 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2687 _amp->gain_control()->set_value (val);
2691 /* Set up Panners in the IO */
2692 XMLNodeList io_nlist = child->children ();
2694 XMLNodeConstIterator io_niter;
2697 for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2699 io_child = *io_niter;
2701 if (io_child->name() == X_("Panner")) {
2702 _main_outs->panner_shell()->set_state(*io_child, version);
2703 } else if (io_child->name() == X_("Automation")) {
2704 /* IO's automation is for the fader */
2705 _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
2711 XMLNodeList redirect_nodes;
2713 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2717 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2718 redirect_nodes.push_back(child);
2723 set_processor_state_2X (redirect_nodes, version);
2725 Stateful::save_extra_xml (node);
2727 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2730 if (child->name() == X_("Comment")) {
2732 /* XXX this is a terrible API design in libxml++ */
2734 XMLNode *cmt = *(child->children().begin());
2735 _comment = cmt->content();
2737 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2738 if (prop->value() == X_("solo")) {
2739 _solo_control->set_state (*child, version);
2740 } else if (prop->value() == X_("mute")) {
2741 _mute_control->set_state (*child, version);
2744 } else if (child->name() == X_("RemoteControl")) {
2745 if ((prop = child->property (X_("id"))) != 0) {
2747 sscanf (prop->value().c_str(), "%d", &x);
2748 set_remote_control_id_internal (x);
2758 Route::get_processor_state ()
2760 XMLNode* root = new XMLNode (X_("redirects"));
2761 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2762 root->add_child_nocopy ((*i)->state (true));
2769 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2771 /* We don't bother removing existing processors not in nList, as this
2772 method will only be called when creating a Route from scratch, not
2773 for undo purposes. Just put processors in at the appropriate place
2777 for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2778 add_processor_from_xml_2X (**i, version);
2783 Route::set_processor_state (const XMLNode& node)
2785 const XMLNodeList &nlist = node.children();
2786 XMLNodeConstIterator niter;
2787 ProcessorList new_order;
2788 bool must_configure = false;
2790 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2792 XMLProperty* prop = (*niter)->property ("type");
2794 if (prop->value() == "amp") {
2795 _amp->set_state (**niter, Stateful::current_state_version);
2796 new_order.push_back (_amp);
2797 } else if (prop->value() == "trim") {
2798 _trim->set_state (**niter, Stateful::current_state_version);
2799 new_order.push_back (_trim);
2800 } else if (prop->value() == "meter") {
2801 _meter->set_state (**niter, Stateful::current_state_version);
2802 new_order.push_back (_meter);
2803 } else if (prop->value() == "delay") {
2805 _delayline->set_state (**niter, Stateful::current_state_version);
2806 new_order.push_back (_delayline);
2808 } else if (prop->value() == "main-outs") {
2809 _main_outs->set_state (**niter, Stateful::current_state_version);
2810 } else if (prop->value() == "intreturn") {
2812 _intreturn.reset (new InternalReturn (_session));
2813 must_configure = true;
2815 _intreturn->set_state (**niter, Stateful::current_state_version);
2816 } else if (is_monitor() && prop->value() == "monitor") {
2817 if (!_monitor_control) {
2818 _monitor_control.reset (new MonitorProcessor (_session));
2819 must_configure = true;
2821 _monitor_control->set_state (**niter, Stateful::current_state_version);
2822 } else if (prop->value() == "capture") {
2823 /* CapturingProcessor should never be restored, it's always
2824 added explicitly when needed */
2826 ProcessorList::iterator o;
2828 for (o = _processors.begin(); o != _processors.end(); ++o) {
2829 XMLProperty* id_prop = (*niter)->property(X_("id"));
2830 if (id_prop && (*o)->id() == id_prop->value()) {
2831 (*o)->set_state (**niter, Stateful::current_state_version);
2832 new_order.push_back (*o);
2837 // If the processor (*niter) is not on the route then create it
2839 if (o == _processors.end()) {
2841 boost::shared_ptr<Processor> processor;
2843 if (prop->value() == "intsend") {
2845 processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), boost::shared_ptr<Route>(), Delivery::Aux, true));
2847 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2848 prop->value() == "lv2" ||
2849 prop->value() == "windows-vst" ||
2850 prop->value() == "lxvst" ||
2851 prop->value() == "audiounit") {
2853 processor.reset (new PluginInsert(_session));
2855 } else if (prop->value() == "port") {
2857 processor.reset (new PortInsert (_session, _pannable, _mute_master));
2859 } else if (prop->value() == "send") {
2861 processor.reset (new Send (_session, _pannable, _mute_master, Delivery::Send, true));
2864 error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2868 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2869 /* This processor could not be configured. Turn it into a UnknownProcessor */
2870 processor.reset (new UnknownProcessor (_session, **niter));
2873 /* we have to note the monitor send here, otherwise a new one will be created
2874 and the state of this one will be lost.
2876 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
2877 if (isend && isend->role() == Delivery::Listen) {
2878 _monitor_send = isend;
2881 /* it doesn't matter if invisible processors are added here, as they
2882 will be sorted out by setup_invisible_processors () shortly.
2885 new_order.push_back (processor);
2886 must_configure = true;
2892 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2893 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2894 _processors = new_order;
2896 if (must_configure) {
2897 configure_processors_unlocked (0);
2900 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2902 (*i)->set_owner (this);
2903 (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
2905 boost::shared_ptr<PluginInsert> pi;
2907 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
2908 if (pi->has_no_inputs ()) {
2909 _have_internal_generator = true;
2916 reset_instrument_info ();
2917 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2918 set_processor_positions ();
2922 Route::curve_reallocate ()
2924 // _gain_automation_curve.finish_resize ();
2925 // _pan_automation_curve.finish_resize ();
2929 Route::silence (framecnt_t nframes)
2931 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
2936 silence_unlocked (nframes);
2940 Route::silence_unlocked (framecnt_t nframes)
2942 /* Must be called with the processor lock held */
2946 _output->silence (nframes);
2948 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2949 boost::shared_ptr<PluginInsert> pi;
2951 if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2952 // skip plugins, they don't need anything when we're not active
2956 (*i)->silence (nframes);
2959 if (nframes == _session.get_block_size()) {
2966 Route::add_internal_return ()
2969 _intreturn.reset (new InternalReturn (_session));
2970 add_processor (_intreturn, PreFader);
2975 Route::add_send_to_internal_return (InternalSend* send)
2977 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
2979 for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2980 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2983 return d->add_send (send);
2989 Route::remove_send_from_internal_return (InternalSend* send)
2991 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
2993 for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2994 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2997 return d->remove_send (send);
3003 Route::enable_monitor_send ()
3005 /* Caller must hold process lock */
3006 assert (!AudioEngine::instance()->process_lock().trylock());
3008 /* master never sends to monitor section via the normal mechanism */
3009 assert (!is_master ());
3010 assert (!is_monitor ());
3012 /* make sure we have one */
3013 if (!_monitor_send) {
3014 _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), _session.monitor_out(), Delivery::Listen));
3015 _monitor_send->set_display_to_user (false);
3019 configure_processors (0);
3022 /** Add an aux send to a route.
3023 * @param route route to send to.
3024 * @param before Processor to insert before, or 0 to insert at the end.
3027 Route::add_aux_send (boost::shared_ptr<Route> route, boost::shared_ptr<Processor> before)
3029 assert (route != _session.monitor_out ());
3032 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3034 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3036 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
3038 if (d && d->target_route() == route) {
3039 /* already listening via the specified IO: do nothing */
3047 boost::shared_ptr<InternalSend> listener;
3050 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3051 boost::shared_ptr<Pannable> sendpan (new Pannable (_session));
3052 listener.reset (new InternalSend (_session, sendpan, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), route, Delivery::Aux));
3055 add_processor (listener, before);
3057 } catch (failed_constructor& err) {
3065 Route::remove_aux_or_listen (boost::shared_ptr<Route> route)
3067 ProcessorStreams err;
3068 ProcessorList::iterator tmp;
3071 Glib::Threads::RWLock::ReaderLock rl(_processor_lock);
3073 /* have to do this early because otherwise processor reconfig
3074 * will put _monitor_send back in the list
3077 if (route == _session.monitor_out()) {
3078 _monitor_send.reset ();
3082 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3084 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
3086 if (d && d->target_route() == route) {
3088 remove_processor (*x, &err, false);
3091 /* list could have been demolished while we dropped the lock
3102 Route::set_comment (string cmt, void *src)
3105 comment_changed (src);
3106 _session.set_dirty ();
3110 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
3112 FeedRecord fr (other, via_sends_only);
3114 pair<FedBy::iterator,bool> result = _fed_by.insert (fr);
3116 if (!result.second) {
3118 /* already a record for "other" - make sure sends-only information is correct */
3119 if (!via_sends_only && result.first->sends_only) {
3120 FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
3121 frp->sends_only = false;
3125 return result.second;
3129 Route::clear_fed_by ()
3135 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
3137 const FedBy& fed_by (other->fed_by());
3139 for (FedBy::const_iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
3140 boost::shared_ptr<Route> sr = f->r.lock();
3142 if (sr && (sr.get() == this)) {
3144 if (via_sends_only) {
3145 *via_sends_only = f->sends_only;
3156 Route::direct_feeds_according_to_reality (boost::shared_ptr<Route> other, bool* via_send_only)
3158 DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
3160 if (_output->connected_to (other->input())) {
3161 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
3162 if (via_send_only) {
3163 *via_send_only = false;
3170 for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
3172 boost::shared_ptr<IOProcessor> iop;
3174 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
3175 if (iop->feeds (other)) {
3176 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
3177 if (via_send_only) {
3178 *via_send_only = true;
3182 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
3185 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
3190 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdoes NOT feed %1\n", other->name()));
3195 Route::direct_feeds_according_to_graph (boost::shared_ptr<Route> other, bool* via_send_only)
3197 return _session._current_route_graph.has (shared_from_this (), other, via_send_only);
3200 /** Called from the (non-realtime) butler thread when the transport is stopped */
3202 Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool /*did_locate*/, bool can_flush_processors)
3204 framepos_t now = _session.transport_frame();
3207 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3209 Automatable::transport_stopped (now);
3211 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3213 if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && can_flush_processors)) {
3217 (*i)->transport_stopped (now);
3221 _roll_delay = _initial_delay;
3225 Route::input_change_handler (IOChange change, void * /*src*/)
3227 bool need_to_queue_solo_change = true;
3229 if ((change.type & IOChange::ConfigurationChanged)) {
3230 /* This is called with the process lock held if change
3231 contains ConfigurationChanged
3233 need_to_queue_solo_change = false;
3234 configure_processors (0);
3235 _phase_invert.resize (_input->n_ports().n_audio ());
3236 io_changed (); /* EMIT SIGNAL */
3239 if (!_input->connected() && _soloed_by_others_upstream) {
3240 if (need_to_queue_solo_change) {
3241 _session.cancel_solo_after_disconnect (shared_from_this(), true);
3243 cancel_solo_after_disconnect (true);
3249 Route::output_change_handler (IOChange change, void * /*src*/)
3251 bool need_to_queue_solo_change = true;
3252 if (_initial_io_setup) {
3256 if ((change.type & IOChange::ConfigurationChanged)) {
3257 /* This is called with the process lock held if change
3258 contains ConfigurationChanged
3260 need_to_queue_solo_change = false;
3261 configure_processors (0);
3264 _session.reset_monitor_section();
3267 io_changed (); /* EMIT SIGNAL */
3270 if (!_output->connected() && _soloed_by_others_downstream) {
3271 if (need_to_queue_solo_change) {
3272 _session.cancel_solo_after_disconnect (shared_from_this(), false);
3274 cancel_solo_after_disconnect (false);
3280 Route::cancel_solo_after_disconnect (bool upstream)
3283 _soloed_by_others_upstream = 0;
3285 _soloed_by_others_downstream = 0;
3287 set_mute_master_solo ();
3288 solo_changed (false, this);
3292 Route::pans_required () const
3294 if (n_outputs().n_audio() < 2) {
3298 return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
3302 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
3304 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3310 if (n_outputs().n_total() == 0) {
3314 if (!_active || n_inputs() == ChanCount::ZERO) {
3315 silence_unlocked (nframes);
3319 if (session_state_changing) {
3320 if (_session.transport_speed() != 0.0f) {
3321 /* we're rolling but some state is changing (e.g. our diskstream contents)
3322 so we cannot use them. Be silent till this is over.
3324 XXX note the absurdity of ::no_roll() being called when we ARE rolling!
3326 silence_unlocked (nframes);
3329 /* we're really not rolling, so we're either delivery silence or actually
3330 monitoring, both of which are safe to do while session_state_changing is true.
3334 BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
3336 fill_buffers_with_input (bufs, _input, nframes);
3338 if (_meter_point == MeterInput) {
3339 _meter->run (bufs, start_frame, end_frame, nframes, true);
3342 _amp->apply_gain_automation (false);
3343 _trim->apply_gain_automation (false);
3344 passthru (bufs, start_frame, end_frame, nframes, 0);
3350 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& /* need_butler */)
3352 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3357 if (n_outputs().n_total() == 0) {
3361 if (!_active || n_inputs().n_total() == 0) {
3362 silence_unlocked (nframes);
3366 framepos_t unused = 0;
3368 if ((nframes = check_initial_delay (nframes, unused)) == 0) {
3374 BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
3376 fill_buffers_with_input (bufs, _input, nframes);
3378 if (_meter_point == MeterInput) {
3379 _meter->run (bufs, start_frame, end_frame, nframes, true);
3382 passthru (bufs, start_frame, end_frame, nframes, declick);
3388 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& /* need_butler */)
3395 Route::flush_processors ()
3397 /* XXX shouldn't really try to take this lock, since
3398 this is called from the RT audio thread.
3401 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3403 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3409 __attribute__((annotate("realtime")))
3412 Route::apply_processor_changes_rt ()
3414 int emissions = EmitNone;
3416 if (_pending_meter_point != _meter_point) {
3417 Glib::Threads::RWLock::WriterLock pwl (_processor_lock, Glib::Threads::TRY_LOCK);
3419 /* meters always have buffers for 'processor_max_streams'
3420 * they can be re-positioned without re-allocation */
3421 if (set_meter_point_unlocked()) {
3422 emissions |= EmitMeterChanged | EmitMeterVisibilityChange;;
3424 emissions |= EmitMeterChanged;
3429 bool changed = false;
3431 if (g_atomic_int_get (&_pending_process_reorder)) {
3432 Glib::Threads::RWLock::WriterLock pwl (_processor_lock, Glib::Threads::TRY_LOCK);
3434 apply_processor_order (_pending_processor_order);
3435 setup_invisible_processors ();
3437 g_atomic_int_set (&_pending_process_reorder, 0);
3438 emissions |= EmitRtProcessorChange;
3442 set_processor_positions ();
3444 if (emissions != 0) {
3445 g_atomic_int_set (&_pending_signals, emissions);
3452 Route::emit_pending_signals ()
3455 int sig = g_atomic_int_and (&_pending_signals, 0);
3456 if (sig & EmitMeterChanged) {
3457 _meter->emit_configuration_changed();
3458 meter_change (); /* EMIT SIGNAL */
3459 if (sig & EmitMeterVisibilityChange) {
3460 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, true)); /* EMIT SIGNAL */
3462 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, false)); /* EMIT SIGNAL */
3465 if (sig & EmitRtProcessorChange) {
3466 processors_changed (RouteProcessorChange (RouteProcessorChange::RealTimeChange)); /* EMIT SIGNAL */
3471 Route::set_meter_point (MeterPoint p, bool force)
3473 if (_pending_meter_point == p && !force) {
3477 if (force || !AudioEngine::instance()->running()) {
3478 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3479 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3480 _pending_meter_point = p;
3481 _meter->emit_configuration_changed();
3482 meter_change (); /* EMIT SIGNAL */
3483 if (set_meter_point_unlocked()) {
3484 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, true)); /* EMIT SIGNAL */
3486 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, false)); /* EMIT SIGNAL */
3489 _pending_meter_point = p;
3495 __attribute__((annotate("realtime")))
3498 Route::set_meter_point_unlocked ()
3501 /* Caller must hold process and processor write lock */
3502 assert (!AudioEngine::instance()->process_lock().trylock());
3503 Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3504 assert (!lm.locked ());
3507 _meter_point = _pending_meter_point;
3509 bool meter_was_visible_to_user = _meter->display_to_user ();
3511 if (!_custom_meter_position_noted) {
3512 maybe_note_meter_position ();
3515 if (_meter_point != MeterCustom) {
3517 _meter->set_display_to_user (false);
3519 setup_invisible_processors ();
3522 _meter->set_display_to_user (true);
3524 /* If we have a previous position for the custom meter, try to put it there */
3525 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
3527 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), after);
3528 if (i != _processors.end ()) {
3529 _processors.remove (_meter);
3530 _processors.insert (i, _meter);
3532 } else {// at end, right before the mains_out/panner
3533 _processors.remove (_meter);
3534 ProcessorList::iterator main = _processors.end();
3535 _processors.insert (--main, _meter);
3539 /* Set up the meter for its new position */
3541 ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
3545 if (loc == _processors.begin()) {
3546 m_in = _input->n_ports();
3548 ProcessorList::iterator before = loc;
3550 m_in = (*before)->output_streams ();
3553 _meter->reflect_inputs (m_in);
3555 /* we do not need to reconfigure the processors, because the meter
3556 (a) is always ready to handle processor_max_streams
3557 (b) is always an N-in/N-out processor, and thus moving
3558 it doesn't require any changes to the other processors.
3561 /* these should really be done after releasing the lock
3562 * but all those signals are subscribed to with gui_thread()
3565 return (_meter->display_to_user() != meter_was_visible_to_user);
3569 Route::listen_position_changed ()
3572 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3573 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3574 ProcessorState pstate (this);
3576 if (configure_processors_unlocked (0)) {
3578 configure_processors_unlocked (0); // it worked before we tried to add it ...
3583 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
3584 _session.set_dirty ();
3587 boost::shared_ptr<CapturingProcessor>
3588 Route::add_export_point()
3590 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3591 if (!_capturing_processor) {
3593 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3594 Glib::Threads::RWLock::WriterLock lw (_processor_lock);
3596 _capturing_processor.reset (new CapturingProcessor (_session));
3597 _capturing_processor->activate ();
3599 configure_processors_unlocked (0);
3603 return _capturing_processor;
3607 Route::update_signal_latency ()
3609 framecnt_t l = _output->user_latency();
3610 framecnt_t lamp = 0;
3611 bool before_amp = true;
3612 framecnt_t ltrim = 0;
3613 bool before_trim = true;
3615 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3616 if ((*i)->active ()) {
3617 l += (*i)->signal_latency ();
3622 if ((*i) == _trim) {
3633 DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l));
3635 // TODO: (lamp - _signal_latency) to sync to output (read-ahed), currently _roll_delay shifts this around
3636 _signal_latency_at_amp_position = lamp;
3637 _signal_latency_at_trim_position = ltrim;
3639 if (_signal_latency != l) {
3640 _signal_latency = l;
3641 signal_latency_changed (); /* EMIT SIGNAL */
3644 return _signal_latency;
3648 Route::set_user_latency (framecnt_t nframes)
3650 _output->set_user_latency (nframes);
3651 _session.update_latency_compensation ();
3655 Route::set_latency_compensation (framecnt_t longest_session_latency)
3657 framecnt_t old = _initial_delay;
3659 if (_signal_latency < longest_session_latency) {
3660 _initial_delay = longest_session_latency - _signal_latency;
3665 DEBUG_TRACE (DEBUG::Latency, string_compose (
3666 "%1: compensate for maximum latency of %2,"
3667 "given own latency of %3, using initial delay of %4\n",
3668 name(), longest_session_latency, _signal_latency, _initial_delay));
3670 if (_initial_delay != old) {
3671 initial_delay_changed (); /* EMIT SIGNAL */
3674 if (_session.transport_stopped()) {
3675 _roll_delay = _initial_delay;
3679 Route::SoloControllable::SoloControllable (std::string name, boost::shared_ptr<Route> r)
3680 : AutomationControl (r->session(),
3681 Evoral::Parameter (SoloAutomation),
3682 ParameterDescriptor(Evoral::Parameter (SoloAutomation)),
3683 boost::shared_ptr<AutomationList>(), name)
3686 boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
3687 gl->set_interpolation(Evoral::ControlList::Discrete);
3692 Route::SoloControllable::set_value (double val)
3694 const bool bval = ((val >= 0.5) ? true : false);
3696 boost::shared_ptr<RouteList> rl (new RouteList);
3698 boost::shared_ptr<Route> r = _route.lock ();
3705 if (Config->get_solo_control_is_listen_control()) {
3706 _session.set_listen (rl, bval);
3708 _session.set_solo (rl, bval);
3713 Route::SoloControllable::get_value () const
3715 boost::shared_ptr<Route> r = _route.lock ();
3720 if (Config->get_solo_control_is_listen_control()) {
3721 return r->listening_via_monitor() ? GAIN_COEFF_UNITY : GAIN_COEFF_ZERO;
3723 return r->self_soloed() ? GAIN_COEFF_UNITY : GAIN_COEFF_ZERO;
3727 Route::MuteControllable::MuteControllable (std::string name, boost::shared_ptr<Route> r)
3728 : AutomationControl (r->session(),
3729 Evoral::Parameter (MuteAutomation),
3730 ParameterDescriptor (Evoral::Parameter (MuteAutomation)),
3731 boost::shared_ptr<AutomationList>(),
3735 boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MuteAutomation)));
3736 gl->set_interpolation(Evoral::ControlList::Discrete);
3741 Route::MuteControllable::set_superficial_value(bool muted)
3743 /* Note we can not use AutomationControl::set_value here since it will emit
3744 Changed(), but the value will not be correct to the observer. */
3746 bool to_list = _list && ((AutomationList*)_list.get())->automation_write();
3748 Control::set_double (muted, _session.transport_frame(), to_list);
3752 Route::MuteControllable::set_value (double val)
3754 const bool bval = ((val >= 0.5) ? true : false);
3756 boost::shared_ptr<Route> r = _route.lock ();
3761 if (_list && ((AutomationList*)_list.get())->automation_playback()) {
3762 // Playing back automation, set route mute directly
3763 r->set_mute (bval, this);
3765 // Set from user, queue mute event
3766 boost::shared_ptr<RouteList> rl (new RouteList);
3768 _session.set_mute (rl, bval, Session::rt_cleanup);
3771 // Set superficial/automation value to drive controller (and possibly record)
3772 set_superficial_value(bval);
3776 Route::MuteControllable::get_value () const
3778 if (_list && ((AutomationList*)_list.get())->automation_playback()) {
3779 // Playing back automation, get the value from the list
3780 return AutomationControl::get_value();
3783 // Not playing back automation, get the actual route mute value
3784 boost::shared_ptr<Route> r = _route.lock ();
3785 return (r && r->muted()) ? GAIN_COEFF_UNITY : GAIN_COEFF_ZERO;
3789 Route::set_block_size (pframes_t nframes)
3791 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3792 (*i)->set_block_size (nframes);
3795 _session.ensure_buffers (n_process_buffers ());
3799 Route::protect_automation ()
3801 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3802 (*i)->protect_automation();
3805 /** @param declick 1 to set a pending declick fade-in,
3806 * -1 to set a pending declick fade-out
3809 Route::set_pending_declick (int declick)
3812 /* this call is not allowed to turn off a pending declick */
3814 _pending_declick = declick;
3817 _pending_declick = 0;
3821 /** Shift automation forwards from a particular place, thereby inserting time.
3822 * Adds undo commands for any shifts that are performed.
3824 * @param pos Position to start shifting from.
3825 * @param frames Amount to shift forwards by.
3829 Route::shift (framepos_t pos, framecnt_t frames)
3831 /* gain automation */
3833 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
3835 XMLNode &before = gc->alist()->get_state ();
3836 gc->alist()->shift (pos, frames);
3837 XMLNode &after = gc->alist()->get_state ();
3838 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3841 /* gain automation */
3843 boost::shared_ptr<AutomationControl> gc = _trim->gain_control();
3845 XMLNode &before = gc->alist()->get_state ();
3846 gc->alist()->shift (pos, frames);
3847 XMLNode &after = gc->alist()->get_state ();
3848 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3851 // TODO mute automation ??
3853 /* pan automation */
3855 ControlSet::Controls& c (_pannable->controls());
3857 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
3858 boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
3860 boost::shared_ptr<AutomationList> al = pc->alist();
3861 XMLNode& before = al->get_state ();
3862 al->shift (pos, frames);
3863 XMLNode& after = al->get_state ();
3864 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3869 /* redirect automation */
3871 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3872 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
3874 set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
3876 for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
3877 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
3879 boost::shared_ptr<AutomationList> al = ac->alist();
3880 XMLNode &before = al->get_state ();
3881 al->shift (pos, frames);
3882 XMLNode &after = al->get_state ();
3883 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3892 Route::save_as_template (const string& path, const string& name)
3894 XMLNode& node (state (false));
3897 IO::set_name_in_state (*node.children().front(), name);
3899 tree.set_root (&node);
3900 return tree.write (path.c_str());
3905 Route::set_name (const string& str)
3907 if (str == name()) {
3911 string name = Route::ensure_track_or_route_name (str, _session);
3912 SessionObject::set_name (name);
3914 bool ret = (_input->set_name(name) && _output->set_name(name));
3917 /* rename the main outs. Leave other IO processors
3918 * with whatever name they already have, because its
3919 * just fine as it is (it will not contain the route
3920 * name if its a port insert, port send or port return).
3924 if (_main_outs->set_name (name)) {
3925 /* XXX returning false here is stupid because
3926 we already changed the route name.
3936 /** Set the name of a route in an XML description.
3937 * @param node XML <Route> node to set the name in.
3938 * @param name New name.
3941 Route::set_name_in_state (XMLNode& node, string const & name)
3943 node.add_property (X_("name"), name);
3945 XMLNodeList children = node.children();
3946 for (XMLNodeIterator i = children.begin(); i != children.end(); ++i) {
3948 if ((*i)->name() == X_("IO")) {
3950 IO::set_name_in_state (**i, name);
3952 } else if ((*i)->name() == X_("Processor")) {
3954 XMLProperty* role = (*i)->property (X_("role"));
3955 if (role && role->value() == X_("Main")) {
3956 (*i)->add_property (X_("name"), name);
3959 } else if ((*i)->name() == X_("Diskstream")) {
3961 (*i)->add_property (X_("playlist"), string_compose ("%1.1", name).c_str());
3962 (*i)->add_property (X_("name"), name);
3968 boost::shared_ptr<Send>
3969 Route::internal_send_for (boost::shared_ptr<const Route> target) const
3971 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3973 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3974 boost::shared_ptr<InternalSend> send;
3976 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
3977 if (send->target_route() == target) {
3983 return boost::shared_ptr<Send>();
3986 /** @param c Audio channel index.
3987 * @param yn true to invert phase, otherwise false.
3990 Route::set_phase_invert (uint32_t c, bool yn)
3992 if (_phase_invert[c] != yn) {
3993 _phase_invert[c] = yn;
3994 phase_invert_changed (); /* EMIT SIGNAL */
3995 _session.set_dirty ();
4000 Route::set_phase_invert (boost::dynamic_bitset<> p)
4002 if (_phase_invert != p) {
4004 phase_invert_changed (); /* EMIT SIGNAL */
4005 _session.set_dirty ();
4010 Route::phase_invert (uint32_t c) const
4012 return _phase_invert[c];
4015 boost::dynamic_bitset<>
4016 Route::phase_invert () const
4018 return _phase_invert;
4022 Route::set_denormal_protection (bool yn)
4024 if (_denormal_protection != yn) {
4025 _denormal_protection = yn;
4026 denormal_protection_changed (); /* EMIT SIGNAL */
4031 Route::denormal_protection () const
4033 return _denormal_protection;
4037 Route::set_active (bool yn, void* src)
4039 if (_session.transport_rolling()) {
4043 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
4044 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
4048 if (_active != yn) {
4050 _input->set_active (yn);
4051 _output->set_active (yn);
4052 active_changed (); // EMIT SIGNAL
4053 _session.set_dirty ();
4057 boost::shared_ptr<Pannable>
4058 Route::pannable() const
4063 boost::shared_ptr<Panner>
4064 Route::panner() const
4067 return _main_outs->panner_shell()->panner();
4070 boost::shared_ptr<PannerShell>
4071 Route::panner_shell() const
4073 return _main_outs->panner_shell();
4076 boost::shared_ptr<AutomationControl>
4077 Route::gain_control() const
4079 return _amp->gain_control();
4082 boost::shared_ptr<AutomationControl>
4083 Route::get_control (const Evoral::Parameter& param)
4085 /* either we own the control or .... */
4087 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
4091 /* maybe one of our processors does or ... */
4093 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
4094 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4095 if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
4103 /* nobody does so we'll make a new one */
4105 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
4112 boost::shared_ptr<Processor>
4113 Route::nth_plugin (uint32_t n)
4115 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4116 ProcessorList::iterator i;
4118 for (i = _processors.begin(); i != _processors.end(); ++i) {
4119 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
4126 return boost::shared_ptr<Processor> ();
4129 boost::shared_ptr<Processor>
4130 Route::nth_send (uint32_t n)
4132 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4133 ProcessorList::iterator i;
4135 for (i = _processors.begin(); i != _processors.end(); ++i) {
4136 if (boost::dynamic_pointer_cast<Send> (*i)) {
4143 return boost::shared_ptr<Processor> ();
4147 Route::has_io_processor_named (const string& name)
4149 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4150 ProcessorList::iterator i;
4152 for (i = _processors.begin(); i != _processors.end(); ++i) {
4153 if (boost::dynamic_pointer_cast<Send> (*i) ||
4154 boost::dynamic_pointer_cast<PortInsert> (*i)) {
4155 if ((*i)->name() == name) {
4164 MuteMaster::MutePoint
4165 Route::mute_points () const
4167 return _mute_master->mute_points ();
4171 Route::set_processor_positions ()
4173 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4175 bool had_amp = false;
4176 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4177 (*i)->set_pre_fader (!had_amp);
4184 /** Called when there is a proposed change to the input port count */
4186 Route::input_port_count_changing (ChanCount to)
4188 list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
4190 /* The processors cannot be configured with the new input arrangement, so
4196 /* The change is ok */
4200 /** Called when there is a proposed change to the output port count */
4202 Route::output_port_count_changing (ChanCount to)
4204 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
4205 if (processor_out_streams.get(*t) > to.get(*t)) {
4209 /* The change is ok */
4214 Route::unknown_processors () const
4218 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4219 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4220 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
4221 p.push_back ((*i)->name ());
4230 Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecnt_t our_latency) const
4232 /* we assume that all our input ports feed all our output ports. its not
4233 universally true, but the alternative is way too corner-case to worry about.
4236 LatencyRange all_connections;
4239 all_connections.min = 0;
4240 all_connections.max = 0;
4242 all_connections.min = ~((pframes_t) 0);
4243 all_connections.max = 0;
4245 /* iterate over all "from" ports and determine the latency range for all of their
4246 connections to the "outside" (outside of this Route).
4249 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
4253 p->get_connected_latency_range (range, playback);
4255 all_connections.min = min (all_connections.min, range.min);
4256 all_connections.max = max (all_connections.max, range.max);
4260 /* set the "from" port latencies to the max/min range of all their connections */
4262 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
4263 p->set_private_latency_range (all_connections, playback);
4266 /* set the ports "in the direction of the flow" to the same value as above plus our own signal latency */
4268 all_connections.min += our_latency;
4269 all_connections.max += our_latency;
4271 for (PortSet::iterator p = to.begin(); p != to.end(); ++p) {
4272 p->set_private_latency_range (all_connections, playback);
4275 return all_connections.max;
4279 Route::set_private_port_latencies (bool playback) const
4281 framecnt_t own_latency = 0;
4283 /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD
4284 OR LATENCY CALLBACK.
4286 This is called (early) from the latency callback. It computes the REAL
4287 latency associated with each port and stores the result as the "private"
4288 latency of the port. A later call to Route::set_public_port_latencies()
4289 sets all ports to the same value to reflect the fact that we do latency
4290 compensation and so all signals are delayed by the same amount as they
4291 flow through ardour.
4294 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4295 if ((*i)->active ()) {
4296 own_latency += (*i)->signal_latency ();
4301 /* playback: propagate latency from "outside the route" to outputs to inputs */
4302 return update_port_latencies (_output->ports (), _input->ports (), true, own_latency);
4304 /* capture: propagate latency from "outside the route" to inputs to outputs */
4305 return update_port_latencies (_input->ports (), _output->ports (), false, own_latency);
4310 Route::set_public_port_latencies (framecnt_t value, bool playback) const
4312 /* this is called to set the JACK-visible port latencies, which take
4313 latency compensation into account.
4322 const PortSet& ports (_input->ports());
4323 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
4324 p->set_public_latency_range (range, playback);
4329 const PortSet& ports (_output->ports());
4330 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
4331 p->set_public_latency_range (range, playback);
4336 /** Put the invisible processors in the right place in _processors.
4337 * Must be called with a writer lock on _processor_lock held.
4340 __attribute__((annotate("realtime")))
4343 Route::setup_invisible_processors ()
4346 Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
4347 assert (!lm.locked ());
4351 /* too early to be doing this stuff */
4355 /* we'll build this new list here and then use it
4357 * TODO put the ProcessorList is on the stack for RT-safety.
4360 ProcessorList new_processors;
4362 /* find visible processors */
4364 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4365 if ((*i)->display_to_user ()) {
4366 new_processors.push_back (*i);
4372 ProcessorList::iterator amp = new_processors.begin ();
4373 while (amp != new_processors.end() && *amp != _amp) {
4377 assert (amp != new_processors.end ());
4379 /* and the processor after the amp */
4381 ProcessorList::iterator after_amp = amp;
4387 switch (_meter_point) {
4389 assert (!_meter->display_to_user ());
4390 new_processors.push_front (_meter);
4393 assert (!_meter->display_to_user ());
4394 new_processors.insert (amp, _meter);
4396 case MeterPostFader:
4397 /* do nothing here */
4400 /* do nothing here */
4403 /* the meter is visible, so we don't touch it here */
4410 assert (_main_outs);
4411 assert (!_main_outs->display_to_user ());
4412 new_processors.push_back (_main_outs);
4414 /* iterator for the main outs */
4416 ProcessorList::iterator main = new_processors.end();
4419 /* OUTPUT METERING */
4421 if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
4422 assert (!_meter->display_to_user ());
4424 /* add the processor just before or just after the main outs */
4426 ProcessorList::iterator meter_point = main;
4428 if (_meter_point == MeterOutput) {
4431 new_processors.insert (meter_point, _meter);
4436 if (_monitor_send && !is_monitor ()) {
4437 assert (!_monitor_send->display_to_user ());
4438 if (Config->get_solo_control_is_listen_control()) {
4439 switch (Config->get_listen_position ()) {
4440 case PreFaderListen:
4441 switch (Config->get_pfl_position ()) {
4442 case PFLFromBeforeProcessors:
4443 new_processors.push_front (_monitor_send);
4445 case PFLFromAfterProcessors:
4446 new_processors.insert (amp, _monitor_send);
4449 _monitor_send->set_can_pan (false);
4451 case AfterFaderListen:
4452 switch (Config->get_afl_position ()) {
4453 case AFLFromBeforeProcessors:
4454 new_processors.insert (after_amp, _monitor_send);
4456 case AFLFromAfterProcessors:
4457 new_processors.insert (new_processors.end(), _monitor_send);
4460 _monitor_send->set_can_pan (true);
4464 new_processors.insert (new_processors.end(), _monitor_send);
4465 _monitor_send->set_can_pan (false);
4469 #if 0 // not used - just yet
4470 if (!is_master() && !is_monitor() && !is_auditioner()) {
4471 new_processors.push_front (_delayline);
4475 /* MONITOR CONTROL */
4477 if (_monitor_control && is_monitor ()) {
4478 assert (!_monitor_control->display_to_user ());
4479 new_processors.push_front (_monitor_control);
4482 /* INTERNAL RETURN */
4484 /* doing this here means that any monitor control will come just after
4489 assert (!_intreturn->display_to_user ());
4490 new_processors.push_front (_intreturn);
4493 if (_trim && _trim->active()) {
4494 assert (!_trim->display_to_user ());
4495 new_processors.push_front (_trim);
4497 /* EXPORT PROCESSOR */
4499 if (_capturing_processor) {
4500 assert (!_capturing_processor->display_to_user ());
4501 new_processors.push_front (_capturing_processor);
4504 _processors = new_processors;
4506 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4507 if (!(*i)->display_to_user () && !(*i)->active ()) {
4512 DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
4513 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4514 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
4521 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
4522 Glib::Threads::RWLock::ReaderLock lp (_processor_lock);
4526 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4527 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery>(*i);
4534 /** If the meter point is `Custom', make a note of where the meter is.
4535 * This is so that if the meter point is subsequently set to something else,
4536 * and then back to custom, we can put the meter back where it was last time
4537 * custom was enabled.
4539 * Must be called with the _processor_lock held.
4542 Route::maybe_note_meter_position ()
4544 if (_meter_point != MeterCustom) {
4548 _custom_meter_position_noted = true;
4549 /* custom meter points range from after trim to before panner/main_outs
4550 * this is a limitation by the current processor UI
4552 bool seen_trim = false;
4553 _processor_after_last_custom_meter.reset();
4554 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4555 if ((*i) == _trim) {
4558 if ((*i) == _main_outs) {
4559 _processor_after_last_custom_meter = *i;
4562 if (boost::dynamic_pointer_cast<PeakMeter> (*i)) {
4564 _processor_after_last_custom_meter = _trim;
4566 ProcessorList::iterator j = i;
4568 assert(j != _processors.end ()); // main_outs should be before
4569 _processor_after_last_custom_meter = *j;
4574 assert(_processor_after_last_custom_meter.lock());
4577 boost::shared_ptr<Processor>
4578 Route::processor_by_id (PBD::ID id) const
4580 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4581 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4582 if ((*i)->id() == id) {
4587 return boost::shared_ptr<Processor> ();
4590 /** @return the monitoring state, or in other words what data we are pushing
4591 * into the route (data from the inputs, data from disk or silence)
4594 Route::monitoring_state () const
4596 return MonitoringInput;
4599 /** @return what we should be metering; either the data coming from the input
4600 * IO or the data that is flowing through the route.
4603 Route::metering_state () const
4605 return MeteringRoute;
4609 Route::has_external_redirects () const
4611 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4613 /* ignore inactive processors and obviously ignore the main
4614 * outs since everything has them and we don't care.
4617 if ((*i)->active() && (*i) != _main_outs && (*i)->does_routing()) {
4625 boost::shared_ptr<Processor>
4626 Route::the_instrument () const
4628 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4629 return the_instrument_unlocked ();
4632 boost::shared_ptr<Processor>
4633 Route::the_instrument_unlocked () const
4635 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4636 if (boost::dynamic_pointer_cast<PluginInsert>(*i)) {
4637 if ((*i)->input_streams().n_midi() > 0 &&
4638 (*i)->output_streams().n_audio() > 0) {
4643 return boost::shared_ptr<Processor>();
4649 Route::non_realtime_locate (framepos_t pos)
4652 _pannable->transport_located (pos);
4655 if (_delayline.get()) {
4656 _delayline.get()->flush();
4660 //Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
4661 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4663 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4664 (*i)->transport_located (pos);
4670 Route::fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes)
4677 * We don't currently mix MIDI input together, so we don't need the
4678 * complex logic of the audio case.
4681 n_buffers = bufs.count().n_midi ();
4683 for (i = 0; i < n_buffers; ++i) {
4685 boost::shared_ptr<MidiPort> source_port = io->midi (i);
4686 MidiBuffer& buf (bufs.get_midi (i));
4689 buf.copy (source_port->get_midi_buffer(nframes));
4691 buf.silence (nframes);
4697 n_buffers = bufs.count().n_audio();
4699 size_t n_ports = io->n_ports().n_audio();
4700 float scaling = 1.0f;
4702 if (n_ports > n_buffers) {
4703 scaling = ((float) n_buffers) / n_ports;
4706 for (i = 0; i < n_ports; ++i) {
4708 /* if there are more ports than buffers, map them onto buffers
4709 * in a round-robin fashion
4712 boost::shared_ptr<AudioPort> source_port = io->audio (i);
4713 AudioBuffer& buf (bufs.get_audio (i%n_buffers));
4716 if (i < n_buffers) {
4718 /* first time through just copy a channel into
4722 buf.read_from (source_port->get_audio_buffer (nframes), nframes);
4724 if (scaling != 1.0f) {
4725 buf.apply_gain (scaling, nframes);
4730 /* on subsequent times around, merge data from
4731 * the port with what is already there
4734 if (scaling != 1.0f) {
4735 buf.accumulate_with_gain_from (source_port->get_audio_buffer (nframes), nframes, 0, scaling);
4737 buf.accumulate_from (source_port->get_audio_buffer (nframes), nframes);
4742 /* silence any remaining buffers */
4744 for (; i < n_buffers; ++i) {
4745 AudioBuffer& buf (bufs.get_audio (i));
4746 buf.silence (nframes);
4749 /* establish the initial setup of the buffer set, reflecting what was
4750 copied into it. unless, of course, we are the auditioner, in which
4751 case nothing was fed into it from the inputs at all.
4754 if (!is_auditioner()) {
4755 bufs.set_count (io->n_ports());