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/route.h"
64 #include "ardour/route_group.h"
65 #include "ardour/send.h"
66 #include "ardour/session.h"
67 #include "ardour/unknown_processor.h"
68 #include "ardour/utils.h"
73 using namespace ARDOUR;
76 PBD::Signal0<void> Route::SyncOrderKeys;
77 PBD::Signal0<void> Route::RemoteControlIDChange;
79 Route::Route (Session& sess, string name, Flag flg, DataType default_type)
80 : SessionObject (sess, name)
82 , GraphNode (sess._process_graph)
85 , _signal_latency_at_amp_position (0)
86 , _signal_latency_at_trim_position (0)
89 , _pending_process_reorder (0)
91 , _pending_declick (true)
92 , _meter_point (MeterPostFader)
93 , _pending_meter_point (MeterPostFader)
94 , _meter_type (MeterPeak)
96 , _soloed_by_others_upstream (0)
97 , _soloed_by_others_downstream (0)
99 , _denormal_protection (false)
102 , _declickable (false)
103 , _mute_master (new MuteMaster (sess, name))
104 , _have_internal_generator (false)
106 , _default_type (default_type)
108 , _has_order_key (false)
109 , _remote_control_id (0)
111 , _in_configure_processors (false)
112 , _initial_io_setup (false)
113 , _custom_meter_position_noted (false)
114 , _last_custom_meter_was_at_end (false)
117 _meter_type = MeterK20;
119 processor_max_streams.reset();
125 /* add standard controls */
127 _solo_control.reset (new SoloControllable (X_("solo"), shared_from_this ()));
128 _mute_control.reset (new MuteControllable (X_("mute"), shared_from_this ()));
130 _solo_control->set_flags (Controllable::Flag (_solo_control->flags() | Controllable::Toggle));
131 _mute_control->set_flags (Controllable::Flag (_mute_control->flags() | Controllable::Toggle));
133 add_control (_solo_control);
134 add_control (_mute_control);
138 if (!(_flags & Route::MonitorOut)) {
139 _pannable.reset (new Pannable (_session));
142 /* input and output objects */
144 _input.reset (new IO (_session, _name, IO::Input, _default_type));
145 _output.reset (new IO (_session, _name, IO::Output, _default_type));
147 _input->changed.connect_same_thread (*this, boost::bind (&Route::input_change_handler, this, _1, _2));
148 _input->PortCountChanging.connect_same_thread (*this, boost::bind (&Route::input_port_count_changing, this, _1));
150 _output->changed.connect_same_thread (*this, boost::bind (&Route::output_change_handler, this, _1, _2));
151 _output->PortCountChanging.connect_same_thread (*this, boost::bind (&Route::output_port_count_changing, this, _1));
153 #if 0 // not used - just yet
154 if (!is_master() && !is_monitor() && !is_auditioner()) {
155 _delayline.reset (new DelayLine (_session, _name));
156 add_processor (_delayline, PreFader);
160 /* add amp processor */
162 _amp.reset (new Amp (_session));
163 add_processor (_amp, PostFader);
166 _trim.reset (new Amp (_session, "trim"));
167 _trim->set_display_to_user (false);
169 if (dynamic_cast<AudioTrack*>(this)) {
170 /* we can't do this in the AudioTrack's constructor
171 * because _trim does not exit then
175 else if (!dynamic_cast<Track*>(this) && ! ( is_monitor() || is_auditioner() )) {
180 /* create standard processors: meter, main outs, monitor out;
181 they will be added to _processors by setup_invisible_processors ()
184 _meter.reset (new PeakMeter (_session, _name));
185 _meter->set_owner (this);
186 _meter->set_display_to_user (false);
189 _main_outs.reset (new Delivery (_session, _output, _pannable, _mute_master, _name, Delivery::Main));
190 _main_outs->activate ();
193 /* where we listen to tracks */
194 _intreturn.reset (new InternalReturn (_session));
195 _intreturn->activate ();
197 /* the thing that provides proper control over a control/monitor/listen bus
198 (such as per-channel cut, dim, solo, invert, etc).
200 _monitor_control.reset (new MonitorProcessor (_session));
201 _monitor_control->activate ();
204 if (is_master() || is_monitor() || is_auditioner()) {
205 _mute_master->set_solo_ignore (true);
208 /* now that we have _meter, its safe to connect to this */
210 Metering::Meter.connect_same_thread (*this, (boost::bind (&Route::meter, this)));
213 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
214 configure_processors (0);
222 DEBUG_TRACE (DEBUG::Destruction, string_compose ("route %1 destructor\n", _name));
224 /* do this early so that we don't get incoming signals as we are going through destruction
229 /* don't use clear_processors here, as it depends on the session which may
230 be half-destroyed by now
233 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
234 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
235 (*i)->drop_references ();
238 _processors.clear ();
242 Route::set_remote_control_id (uint32_t id, bool notify_class_listeners)
244 if (Config->get_remote_model() != UserOrdered) {
248 set_remote_control_id_internal (id, notify_class_listeners);
252 Route::set_remote_control_id_internal (uint32_t id, bool notify_class_listeners)
254 /* force IDs for master/monitor busses and prevent
255 any other route from accidentally getting these IDs
256 (i.e. legacy sessions)
259 if (is_master() && id != MasterBusRemoteControlID) {
260 id = MasterBusRemoteControlID;
263 if (is_monitor() && id != MonitorBusRemoteControlID) {
264 id = MonitorBusRemoteControlID;
271 /* don't allow it to collide */
273 if (!is_master () && !is_monitor() &&
274 (id == MasterBusRemoteControlID || id == MonitorBusRemoteControlID)) {
275 id += MonitorBusRemoteControlID;
278 if (id != remote_control_id()) {
279 _remote_control_id = id;
280 RemoteControlIDChanged ();
282 if (notify_class_listeners) {
283 RemoteControlIDChange ();
289 Route::remote_control_id() const
292 return MasterBusRemoteControlID;
296 return MonitorBusRemoteControlID;
299 return _remote_control_id;
303 Route::has_order_key () const
305 return _has_order_key;
309 Route::order_key () const
315 Route::set_remote_control_id_explicit (uint32_t rid)
317 if (is_master() || is_monitor() || is_auditioner()) {
318 /* hard-coded remote IDs, or no remote ID */
322 if (_remote_control_id != rid) {
323 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("%1: set edit-based RID to %2\n", name(), rid));
324 _remote_control_id = rid;
325 RemoteControlIDChanged (); /* EMIT SIGNAL (per-route) */
328 /* don't emit the class-level RID signal RemoteControlIDChange here,
329 leave that to the entity that changed the order key, so that we
330 don't get lots of emissions for no good reasons (e.g. when changing
331 all route order keys).
333 See Session::sync_remote_id_from_order_keys() for the (primary|only)
334 spot where that is emitted.
339 Route::set_order_key (uint32_t n)
341 _has_order_key = true;
343 if (_order_key == n) {
349 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("%1 order key set to %2\n",
350 name(), order_key ()));
352 _session.set_dirty ();
356 Route::ensure_track_or_route_name(string name, Session &session)
358 string newname = name;
360 while (!session.io_name_is_legal (newname)) {
361 newname = bump_name_once (newname, '.');
368 Route::inc_gain (gain_t fraction, void *src)
370 _amp->inc_gain (fraction, src);
374 Route::set_gain (gain_t val, void *src)
376 if (src != 0 && _route_group && src != _route_group && _route_group->is_active() && _route_group->is_gain()) {
378 if (_route_group->is_relative()) {
380 gain_t usable_gain = _amp->gain();
381 if (usable_gain < 0.000001f) {
382 usable_gain = 0.000001f;
386 if (delta < 0.000001f) {
390 delta -= usable_gain;
395 gain_t factor = delta / usable_gain;
398 factor = _route_group->get_max_factor(factor);
399 if (factor == 0.0f) {
400 _amp->gain_control()->Changed(); /* EMIT SIGNAL */
404 factor = _route_group->get_min_factor(factor);
405 if (factor == 0.0f) {
406 _amp->gain_control()->Changed(); /* EMIT SIGNAL */
411 _route_group->foreach_route (boost::bind (&Route::inc_gain, _1, factor, _route_group));
415 _route_group->foreach_route (boost::bind (&Route::set_gain, _1, val, _route_group));
421 if (val == _amp->gain()) {
425 _amp->set_gain (val, src);
429 Route::inc_trim (gain_t fraction, void *src)
431 _trim->inc_gain (fraction, src);
435 Route::set_trim (gain_t val, void * /* src */)
437 // TODO route group, see set_gain()
438 _trim->set_gain (val, 0);
442 Route::maybe_declick (BufferSet&, framecnt_t, int)
444 /* this is the "bus" implementation and they never declick.
449 /** Process this route for one (sub) cycle (process thread)
451 * @param bufs Scratch buffers to use for the signal path
452 * @param start_frame Initial transport frame
453 * @param end_frame Final transport frame
454 * @param nframes Number of frames to output (to ports)
456 * Note that (end_frame - start_frame) may not be equal to nframes when the
457 * transport speed isn't 1.0 (eg varispeed).
460 Route::process_output_buffers (BufferSet& bufs,
461 framepos_t start_frame, framepos_t end_frame, pframes_t nframes,
462 int declick, bool gain_automation_ok)
464 /* Caller must hold process lock */
465 assert (!AudioEngine::instance()->process_lock().trylock());
467 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
469 // can this actually happen? functions calling process_output_buffers()
470 // already take a reader-lock.
471 bufs.silence (nframes, 0);
475 /* figure out if we're going to use gain automation */
476 if (gain_automation_ok) {
477 _amp->set_gain_automation_buffer (_session.gain_automation_buffer ());
478 _amp->setup_gain_automation (
479 start_frame + _signal_latency_at_amp_position,
480 end_frame + _signal_latency_at_amp_position,
483 _trim->set_gain_automation_buffer (_session.trim_automation_buffer ());
484 _trim->setup_gain_automation (
485 start_frame + _signal_latency_at_trim_position,
486 end_frame + _signal_latency_at_trim_position,
489 _amp->apply_gain_automation (false);
490 _trim->apply_gain_automation (false);
493 /* Tell main outs what to do about monitoring. We do this so that
494 on a transition between monitoring states we get a de-clicking gain
495 change in the _main_outs delivery.
497 bool silence = monitoring_state () == MonitoringSilence;
499 //but we override this in the case where we have an internal generator
500 if ( _have_internal_generator )
503 _main_outs->no_outs_cuz_we_no_monitor (silence);
505 /* -------------------------------------------------------------------------------------------
506 GLOBAL DECLICK (for transport changes etc.)
507 ----------------------------------------------------------------------------------------- */
509 maybe_declick (bufs, nframes, declick);
510 _pending_declick = 0;
512 /* -------------------------------------------------------------------------------------------
513 DENORMAL CONTROL/PHASE INVERT
514 ----------------------------------------------------------------------------------------- */
516 if (_phase_invert.any ()) {
520 if (_denormal_protection || Config->get_denormal_protection()) {
522 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
523 Sample* const sp = i->data();
525 if (_phase_invert[chn]) {
526 for (pframes_t nx = 0; nx < nframes; ++nx) {
531 for (pframes_t nx = 0; nx < nframes; ++nx) {
539 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
540 Sample* const sp = i->data();
542 if (_phase_invert[chn]) {
543 for (pframes_t nx = 0; nx < nframes; ++nx) {
552 if (_denormal_protection || Config->get_denormal_protection()) {
554 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
555 Sample* const sp = i->data();
556 for (pframes_t nx = 0; nx < nframes; ++nx) {
564 /* -------------------------------------------------------------------------------------------
566 ----------------------------------------------------------------------------------------- */
568 /* set this to be true if the meter will already have been ::run() earlier */
569 bool const meter_already_run = metering_state() == MeteringInput;
571 framecnt_t latency = 0;
573 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
575 if (meter_already_run && boost::dynamic_pointer_cast<PeakMeter> (*i)) {
576 /* don't ::run() the meter, otherwise it will have its previous peak corrupted */
581 /* if it has any inputs, make sure they match */
582 if (boost::dynamic_pointer_cast<UnknownProcessor> (*i) == 0 && (*i)->input_streams() != ChanCount::ZERO) {
583 if (bufs.count() != (*i)->input_streams()) {
585 DEBUG::Processors, string_compose (
586 "input port mismatch %1 bufs = %2 input for %3 = %4\n",
587 _name, bufs.count(), (*i)->name(), (*i)->input_streams()
594 /* should we NOT run plugins here if the route is inactive?
595 do we catch route != active somewhere higher?
598 if (boost::dynamic_pointer_cast<Send>(*i) != 0) {
599 boost::dynamic_pointer_cast<Send>(*i)->set_delay_in(_signal_latency - latency);
602 (*i)->run (bufs, start_frame - latency, end_frame - latency, nframes, *i != _processors.back());
603 bufs.set_count ((*i)->output_streams());
605 if ((*i)->active ()) {
606 latency += (*i)->signal_latency ();
612 Route::bounce_process (BufferSet& buffers, framepos_t start, framecnt_t nframes,
613 boost::shared_ptr<Processor> endpoint,
614 bool include_endpoint, bool for_export, bool for_freeze)
616 /* If no processing is required, there's no need to go any further. */
617 if (!endpoint && !include_endpoint) {
621 framecnt_t latency = bounce_get_latency(_amp, false, for_export, for_freeze);
622 _amp->set_gain_automation_buffer (_session.gain_automation_buffer ());
623 _amp->setup_gain_automation (start - latency, start - latency + nframes, nframes);
625 /* trim is always at the top, for bounce no latency compensation is needed */
626 _trim->set_gain_automation_buffer (_session.trim_automation_buffer ());
627 _trim->setup_gain_automation (start, start + nframes, nframes);
630 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
632 if (!include_endpoint && (*i) == endpoint) {
636 /* if we're not exporting, stop processing if we come across a routing processor. */
637 if (!for_export && boost::dynamic_pointer_cast<PortInsert>(*i)) {
640 if (!for_export && for_freeze && (*i)->does_routing() && (*i)->active()) {
644 /* don't run any processors that does routing.
645 * oh, and don't bother with the peak meter either.
647 if (!(*i)->does_routing() && !boost::dynamic_pointer_cast<PeakMeter>(*i)) {
648 (*i)->run (buffers, start - latency, start - latency + nframes, nframes, true);
649 buffers.set_count ((*i)->output_streams());
650 latency += (*i)->signal_latency ();
653 if ((*i) == endpoint) {
660 Route::bounce_get_latency (boost::shared_ptr<Processor> endpoint,
661 bool include_endpoint, bool for_export, bool for_freeze) const
663 framecnt_t latency = 0;
664 if (!endpoint && !include_endpoint) {
668 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
669 if (!include_endpoint && (*i) == endpoint) {
672 if (!for_export && boost::dynamic_pointer_cast<PortInsert>(*i)) {
675 if (!for_export && for_freeze && (*i)->does_routing() && (*i)->active()) {
678 if (!(*i)->does_routing() && !boost::dynamic_pointer_cast<PeakMeter>(*i)) {
679 latency += (*i)->signal_latency ();
681 if ((*i) == endpoint) {
689 Route::bounce_get_output_streams (ChanCount &cc, boost::shared_ptr<Processor> endpoint,
690 bool include_endpoint, bool for_export, bool for_freeze) const
692 if (!endpoint && !include_endpoint) {
696 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
697 if (!include_endpoint && (*i) == endpoint) {
700 if (!for_export && boost::dynamic_pointer_cast<PortInsert>(*i)) {
703 if (!for_export && for_freeze && (*i)->does_routing() && (*i)->active()) {
706 if (!(*i)->does_routing() && !boost::dynamic_pointer_cast<PeakMeter>(*i)) {
707 cc = (*i)->output_streams();
709 if ((*i) == endpoint) {
717 Route::n_process_buffers ()
719 return max (_input->n_ports(), processor_max_streams);
723 Route::monitor_run (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
725 assert (is_monitor());
726 BufferSet& bufs (_session.get_route_buffers (n_process_buffers()));
727 fill_buffers_with_input (bufs, _input, nframes);
728 passthru (bufs, start_frame, end_frame, nframes, declick);
732 Route::passthru (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
736 if (is_monitor() && _session.listening() && !_session.is_auditioning()) {
738 /* control/monitor bus ignores input ports when something is
739 feeding the listen "stream". data will "arrive" into the
740 route from the intreturn processor element.
743 bufs.silence (nframes, 0);
746 write_out_of_band_data (bufs, start_frame, end_frame, nframes);
747 process_output_buffers (bufs, start_frame, end_frame, nframes, declick, true);
751 Route::passthru_silence (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
753 BufferSet& bufs (_session.get_route_buffers (n_process_buffers(), true));
755 bufs.set_count (_input->n_ports());
756 write_out_of_band_data (bufs, start_frame, end_frame, nframes);
757 process_output_buffers (bufs, start_frame, end_frame, nframes, declick, false);
761 Route::set_listen (bool yn, void* src)
767 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
768 _route_group->foreach_route (boost::bind (&Route::set_listen, _1, yn, _route_group));
773 if (yn != _monitor_send->active()) {
775 _monitor_send->activate ();
776 _mute_master->set_soloed (true);
778 _monitor_send->deactivate ();
779 _mute_master->set_soloed (false);
782 listen_changed (src); /* EMIT SIGNAL */
788 Route::listening_via_monitor () const
791 return _monitor_send->active ();
798 Route::set_solo_safe (bool yn, void *src)
800 if (_solo_safe != yn) {
802 solo_safe_changed (src);
807 Route::solo_safe() const
813 Route::set_solo (bool yn, void *src)
816 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 ignore solo change due to solo-safe\n", name()));
820 if (is_master() || is_monitor() || is_auditioner()) {
821 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 ignore solo change (master, monitor or auditioner)\n", name()));
825 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
826 _route_group->foreach_route (boost::bind (&Route::set_solo, _1, yn, _route_group));
830 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1: set solo => %2, src: %3 grp ? %4 currently self-soloed ? %5\n",
831 name(), yn, src, (src == _route_group), self_soloed()));
833 if (self_soloed() != yn) {
835 set_mute_master_solo ();
836 solo_changed (true, src); /* EMIT SIGNAL */
837 _solo_control->Changed (); /* EMIT SIGNAL */
842 Route::set_self_solo (bool yn)
844 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1: set SELF solo => %2\n", name(), yn));
849 Route::mod_solo_by_others_upstream (int32_t delta)
852 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 ignore solo-by-upstream due to solo-safe\n", name()));
856 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 mod solo-by-upstream by %2, current up = %3 down = %4\n",
857 name(), delta, _soloed_by_others_upstream, _soloed_by_others_downstream));
859 uint32_t old_sbu = _soloed_by_others_upstream;
862 if (_soloed_by_others_upstream >= (uint32_t) abs (delta)) {
863 _soloed_by_others_upstream += delta;
865 _soloed_by_others_upstream = 0;
868 _soloed_by_others_upstream += delta;
871 DEBUG_TRACE (DEBUG::Solo, string_compose (
872 "%1 SbU delta %2 = %3 old = %4 sbd %5 ss %6 exclusive %7\n",
873 name(), delta, _soloed_by_others_upstream, old_sbu,
874 _soloed_by_others_downstream, _self_solo, Config->get_exclusive_solo()));
876 /* push the inverse solo change to everything that feeds us.
878 This is important for solo-within-group. When we solo 1 track out of N that
879 feed a bus, that track will cause mod_solo_by_upstream (+1) to be called
880 on the bus. The bus then needs to call mod_solo_by_downstream (-1) on all
881 tracks that feed it. This will silence them if they were audible because
882 of a bus solo, but the newly soloed track will still be audible (because
885 but .. do this only when we are being told to solo-by-upstream (i.e delta = +1),
889 if ((_self_solo || _soloed_by_others_downstream) &&
890 ((old_sbu == 0 && _soloed_by_others_upstream > 0) ||
891 (old_sbu > 0 && _soloed_by_others_upstream == 0))) {
893 if (delta > 0 || !Config->get_exclusive_solo()) {
894 DEBUG_TRACE (DEBUG::Solo, "\t ... INVERT push\n");
895 for (FedBy::iterator i = _fed_by.begin(); i != _fed_by.end(); ++i) {
896 boost::shared_ptr<Route> sr = i->r.lock();
898 sr->mod_solo_by_others_downstream (-delta);
904 set_mute_master_solo ();
905 solo_changed (false, this);
909 Route::mod_solo_by_others_downstream (int32_t delta)
912 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 ignore solo-by-downstream due to solo safe\n", name()));
916 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 mod solo-by-downstream by %2, current up = %3 down = %4\n",
917 name(), delta, _soloed_by_others_upstream, _soloed_by_others_downstream));
920 if (_soloed_by_others_downstream >= (uint32_t) abs (delta)) {
921 _soloed_by_others_downstream += delta;
923 _soloed_by_others_downstream = 0;
926 _soloed_by_others_downstream += delta;
929 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 SbD delta %2 = %3\n", name(), delta, _soloed_by_others_downstream));
931 set_mute_master_solo ();
932 solo_changed (false, this);
936 Route::set_mute_master_solo ()
938 _mute_master->set_soloed (self_soloed() || soloed_by_others_downstream() || soloed_by_others_upstream());
942 Route::set_solo_isolated (bool yn, void *src)
944 if (is_master() || is_monitor() || is_auditioner()) {
948 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
949 _route_group->foreach_route (boost::bind (&Route::set_solo_isolated, _1, yn, _route_group));
953 /* forward propagate solo-isolate status to everything fed by this route, but not those via sends only */
955 boost::shared_ptr<RouteList> routes = _session.get_routes ();
956 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
958 if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
963 bool does_feed = direct_feeds_according_to_graph (*i, &sends_only); // we will recurse anyway, so don't use ::feeds()
965 if (does_feed && !sends_only) {
966 (*i)->set_solo_isolated (yn, (*i)->route_group());
970 /* XXX should we back-propagate as well? (April 2010: myself and chris goddard think not) */
972 bool changed = false;
975 if (_solo_isolated == 0) {
976 _mute_master->set_solo_ignore (true);
981 if (_solo_isolated > 0) {
983 if (_solo_isolated == 0) {
984 _mute_master->set_solo_ignore (false);
991 solo_isolated_changed (src);
996 Route::solo_isolated () const
998 return _solo_isolated > 0;
1002 Route::set_mute_points (MuteMaster::MutePoint mp)
1004 _mute_master->set_mute_points (mp);
1005 mute_points_changed (); /* EMIT SIGNAL */
1007 if (_mute_master->muted_by_self()) {
1008 mute_changed (this); /* EMIT SIGNAL */
1009 _mute_control->Changed (); /* EMIT SIGNAL */
1014 Route::set_mute (bool yn, void *src)
1016 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_mute()) {
1017 _route_group->foreach_route (boost::bind (&Route::set_mute, _1, yn, _route_group));
1021 if (muted() != yn) {
1022 _mute_master->set_muted_by_self (yn);
1023 /* allow any derived classes to respond to the mute change
1024 before anybody else knows about it.
1027 /* tell everyone else */
1028 mute_changed (src); /* EMIT SIGNAL */
1029 _mute_control->Changed (); /* EMIT SIGNAL */
1034 Route::muted () const
1036 return _mute_master->muted_by_self();
1041 dump_processors(const string& name, const list<boost::shared_ptr<Processor> >& procs)
1043 cerr << name << " {" << endl;
1044 for (list<boost::shared_ptr<Processor> >::const_iterator p = procs.begin();
1045 p != procs.end(); ++p) {
1046 cerr << "\t" << (*p)->name() << " ID = " << (*p)->id() << " @ " << (*p) << endl;
1048 cerr << "}" << endl;
1052 /** Supposing that we want to insert a Processor at a given Placement, return
1053 * the processor to add the new one before (or 0 to add at the end).
1055 boost::shared_ptr<Processor>
1056 Route::before_processor_for_placement (Placement p)
1058 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1060 ProcessorList::iterator loc;
1062 if (p == PreFader) {
1063 /* generic pre-fader: insert immediately before the amp */
1064 loc = find (_processors.begin(), _processors.end(), _amp);
1066 /* generic post-fader: insert right before the main outs */
1067 loc = find (_processors.begin(), _processors.end(), _main_outs);
1070 return loc != _processors.end() ? *loc : boost::shared_ptr<Processor> ();
1073 /** Supposing that we want to insert a Processor at a given index, return
1074 * the processor to add the new one before (or 0 to add at the end).
1076 boost::shared_ptr<Processor>
1077 Route::before_processor_for_index (int index)
1080 return boost::shared_ptr<Processor> ();
1083 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1085 ProcessorList::iterator i = _processors.begin ();
1087 while (i != _processors.end() && j < index) {
1088 if ((*i)->display_to_user()) {
1095 return (i != _processors.end() ? *i : boost::shared_ptr<Processor> ());
1098 /** Add a processor either pre- or post-fader
1099 * @return 0 on success, non-0 on failure.
1102 Route::add_processor (boost::shared_ptr<Processor> processor, Placement placement, ProcessorStreams* err, bool activation_allowed)
1104 return add_processor (processor, before_processor_for_placement (placement), err, activation_allowed);
1108 /** Add a processor to a route such that it ends up with a given index into the visible processors.
1109 * @param index Index to add the processor at, or -1 to add at the end of the list.
1110 * @return 0 on success, non-0 on failure.
1113 Route::add_processor_by_index (boost::shared_ptr<Processor> processor, int index, ProcessorStreams* err, bool activation_allowed)
1115 return add_processor (processor, before_processor_for_index (index), err, activation_allowed);
1118 /** Add a processor to the route.
1119 * @param before An existing processor in the list, or 0; the new processor will be inserted immediately before it (or at the end).
1120 * @return 0 on success, non-0 on failure.
1123 Route::add_processor (boost::shared_ptr<Processor> processor, boost::shared_ptr<Processor> before, ProcessorStreams* err, bool activation_allowed)
1125 assert (processor != _meter);
1126 assert (processor != _main_outs);
1128 DEBUG_TRACE (DEBUG::Processors, string_compose (
1129 "%1 adding processor %2\n", name(), processor->name()));
1131 if (!AudioEngine::instance()->connected() || !processor) {
1136 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1137 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1138 ProcessorState pstate (this);
1140 boost::shared_ptr<PluginInsert> pi;
1141 boost::shared_ptr<PortInsert> porti;
1143 if (processor == _amp) {
1144 /* Ensure that only one amp is in the list at any time */
1145 ProcessorList::iterator check = find (_processors.begin(), _processors.end(), processor);
1146 if (check != _processors.end()) {
1147 if (before == _amp) {
1148 /* Already in position; all is well */
1151 _processors.erase (check);
1156 assert (find (_processors.begin(), _processors.end(), processor) == _processors.end ());
1158 ProcessorList::iterator loc;
1160 /* inserting before a processor; find it */
1161 loc = find (_processors.begin(), _processors.end(), before);
1162 if (loc == _processors.end ()) {
1167 /* inserting at end */
1168 loc = _processors.end ();
1171 _processors.insert (loc, processor);
1172 processor->set_owner (this);
1174 // Set up processor list channels. This will set processor->[input|output]_streams(),
1175 // configure redirect ports properly, etc.
1178 if (configure_processors_unlocked (err)) {
1180 configure_processors_unlocked (0); // it worked before we tried to add it ...
1185 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(processor)) != 0) {
1187 if (pi->has_no_inputs ()) {
1188 /* generator plugin */
1189 _have_internal_generator = true;
1194 if (activation_allowed && !_session.get_disable_all_loaded_plugins()) {
1195 processor->activate ();
1198 processor->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
1200 _output->set_user_latency (0);
1203 reset_instrument_info ();
1204 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1205 set_processor_positions ();
1211 Route::add_processor_from_xml_2X (const XMLNode& node, int version)
1213 const XMLProperty *prop;
1216 boost::shared_ptr<Processor> processor;
1218 /* bit of a hack: get the `placement' property from the <Redirect> tag here
1219 so that we can add the processor in the right place (pre/post-fader)
1222 XMLNodeList const & children = node.children ();
1223 XMLNodeList::const_iterator i = children.begin ();
1225 while (i != children.end() && (*i)->name() != X_("Redirect")) {
1229 Placement placement = PreFader;
1231 if (i != children.end()) {
1232 if ((prop = (*i)->property (X_("placement"))) != 0) {
1233 placement = Placement (string_2_enum (prop->value(), placement));
1237 if (node.name() == "Insert") {
1239 if ((prop = node.property ("type")) != 0) {
1241 if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
1242 prop->value() == "lv2" ||
1243 prop->value() == "windows-vst" ||
1244 prop->value() == "lxvst" ||
1245 prop->value() == "audiounit") {
1247 processor.reset (new PluginInsert (_session));
1251 processor.reset (new PortInsert (_session, _pannable, _mute_master));
1256 } else if (node.name() == "Send") {
1258 boost::shared_ptr<Pannable> sendpan (new Pannable (_session));
1259 processor.reset (new Send (_session, sendpan, _mute_master));
1263 error << string_compose(_("unknown Processor type \"%1\"; ignored"), node.name()) << endmsg;
1267 if (processor->set_state (node, version)) {
1271 //A2 uses the "active" flag in the toplevel redirect node, not in the child plugin/IO
1272 if (i != children.end()) {
1273 if ((prop = (*i)->property (X_("active"))) != 0) {
1274 if ( string_is_affirmative (prop->value()) && !_session.get_disable_all_loaded_plugins() )
1275 processor->activate();
1277 processor->deactivate();
1281 return (add_processor (processor, placement, 0, false) == 0);
1284 catch (failed_constructor &err) {
1285 warning << _("processor could not be created. Ignored.") << endmsg;
1291 Route::add_processors (const ProcessorList& others, boost::shared_ptr<Processor> before, ProcessorStreams* err)
1293 /* NOTE: this is intended to be used ONLY when copying
1294 processors from another Route. Hence the subtle
1295 differences between this and ::add_processor()
1298 ProcessorList::iterator loc;
1301 loc = find(_processors.begin(), _processors.end(), before);
1303 /* nothing specified - at end */
1304 loc = _processors.end ();
1307 if (!_session.engine().connected()) {
1311 if (others.empty()) {
1316 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1317 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1318 ProcessorState pstate (this);
1320 for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
1326 boost::shared_ptr<PluginInsert> pi;
1328 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1332 _processors.insert (loc, *i);
1333 (*i)->set_owner (this);
1335 if ((*i)->active()) {
1339 /* Think: does this really need to be called for every processor in the loop? */
1341 if (configure_processors_unlocked (err)) {
1343 configure_processors_unlocked (0); // it worked before we tried to add it ...
1348 (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
1351 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
1352 boost::shared_ptr<PluginInsert> pi;
1354 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1355 if (pi->has_no_inputs ()) {
1356 _have_internal_generator = true;
1362 _output->set_user_latency (0);
1365 reset_instrument_info ();
1366 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1367 set_processor_positions ();
1373 Route::placement_range(Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end)
1375 if (p == PreFader) {
1376 start = _processors.begin();
1377 end = find(_processors.begin(), _processors.end(), _amp);
1379 start = find(_processors.begin(), _processors.end(), _amp);
1381 end = _processors.end();
1385 /** Turn off all processors with a given placement
1386 * @param p Placement of processors to disable
1389 Route::disable_processors (Placement p)
1391 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1393 ProcessorList::iterator start, end;
1394 placement_range(p, start, end);
1396 for (ProcessorList::iterator i = start; i != end; ++i) {
1397 (*i)->deactivate ();
1400 _session.set_dirty ();
1403 /** Turn off all redirects
1406 Route::disable_processors ()
1408 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1410 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1411 (*i)->deactivate ();
1414 _session.set_dirty ();
1417 /** Turn off all redirects with a given placement
1418 * @param p Placement of redirects to disable
1421 Route::disable_plugins (Placement p)
1423 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1425 ProcessorList::iterator start, end;
1426 placement_range(p, start, end);
1428 for (ProcessorList::iterator i = start; i != end; ++i) {
1429 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1430 (*i)->deactivate ();
1434 _session.set_dirty ();
1437 /** Turn off all plugins
1440 Route::disable_plugins ()
1442 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1444 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1445 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1446 (*i)->deactivate ();
1450 _session.set_dirty ();
1455 Route::ab_plugins (bool forward)
1457 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1461 /* forward = turn off all active redirects, and mark them so that the next time
1462 we go the other way, we will revert them
1465 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1466 if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1470 if ((*i)->active()) {
1471 (*i)->deactivate ();
1472 (*i)->set_next_ab_is_active (true);
1474 (*i)->set_next_ab_is_active (false);
1480 /* backward = if the redirect was marked to go active on the next ab, do so */
1482 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1484 if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1488 if ((*i)->get_next_ab_is_active()) {
1491 (*i)->deactivate ();
1496 _session.set_dirty ();
1500 /** Remove processors with a given placement.
1501 * @param p Placement of processors to remove.
1504 Route::clear_processors (Placement p)
1506 if (!_session.engine().connected()) {
1510 bool already_deleting = _session.deletion_in_progress();
1511 if (!already_deleting) {
1512 _session.set_deletion_in_progress();
1516 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1517 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1518 ProcessorList new_list;
1519 ProcessorStreams err;
1520 bool seen_amp = false;
1522 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1528 if ((*i) == _amp || (*i) == _meter || (*i) == _main_outs || (*i) == _delayline || (*i) == _trim) {
1530 /* you can't remove these */
1532 new_list.push_back (*i);
1539 new_list.push_back (*i);
1542 (*i)->drop_references ();
1550 (*i)->drop_references ();
1553 new_list.push_back (*i);
1560 _processors = new_list;
1561 configure_processors_unlocked (&err); // this can't fail
1564 processor_max_streams.reset();
1565 _have_internal_generator = false;
1566 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1567 set_processor_positions ();
1569 reset_instrument_info ();
1571 if (!already_deleting) {
1572 _session.clear_deletion_in_progress();
1577 Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err, bool need_process_lock)
1579 // TODO once the export point can be configured properly, do something smarter here
1580 if (processor == _capturing_processor) {
1581 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1582 if (need_process_lock) {
1586 _capturing_processor.reset();
1588 if (need_process_lock) {
1593 /* these can never be removed */
1595 if (processor == _amp || processor == _meter || processor == _main_outs || processor == _delayline || processor == _trim) {
1599 if (!_session.engine().connected()) {
1603 processor_max_streams.reset();
1606 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1607 if (need_process_lock) {
1611 /* Caller must hold process lock */
1612 assert (!AudioEngine::instance()->process_lock().trylock());
1614 Glib::Threads::RWLock::WriterLock lm (_processor_lock); // XXX deadlock after export
1616 ProcessorState pstate (this);
1618 ProcessorList::iterator i;
1619 bool removed = false;
1621 for (i = _processors.begin(); i != _processors.end(); ) {
1622 if (*i == processor) {
1624 /* move along, see failure case for configure_processors()
1625 where we may need to reconfigure the processor.
1628 /* stop redirects that send signals to JACK ports
1629 from causing noise as a result of no longer being
1633 boost::shared_ptr<IOProcessor> iop;
1635 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (*i)) != 0) {
1639 i = _processors.erase (i);
1647 _output->set_user_latency (0);
1655 if (configure_processors_unlocked (err)) {
1657 /* we know this will work, because it worked before :) */
1658 configure_processors_unlocked (0);
1662 _have_internal_generator = false;
1664 for (i = _processors.begin(); i != _processors.end(); ++i) {
1665 boost::shared_ptr<PluginInsert> pi;
1667 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1668 if (pi->has_no_inputs ()) {
1669 _have_internal_generator = true;
1674 if (need_process_lock) {
1679 reset_instrument_info ();
1680 processor->drop_references ();
1681 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1682 set_processor_positions ();
1688 Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
1690 ProcessorList deleted;
1692 if (!_session.engine().connected()) {
1696 processor_max_streams.reset();
1699 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1700 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1701 ProcessorState pstate (this);
1703 ProcessorList::iterator i;
1704 boost::shared_ptr<Processor> processor;
1706 for (i = _processors.begin(); i != _processors.end(); ) {
1710 /* these can never be removed */
1712 if (processor == _amp || processor == _meter || processor == _main_outs || processor == _delayline || processor == _trim) {
1717 /* see if its in the list of processors to delete */
1719 if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
1724 /* stop IOProcessors that send to JACK ports
1725 from causing noise as a result of no longer being
1729 boost::shared_ptr<IOProcessor> iop;
1731 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (processor)) != 0) {
1735 deleted.push_back (processor);
1736 i = _processors.erase (i);
1739 if (deleted.empty()) {
1740 /* none of those in the requested list were found */
1744 _output->set_user_latency (0);
1746 if (configure_processors_unlocked (err)) {
1748 /* we know this will work, because it worked before :) */
1749 configure_processors_unlocked (0);
1754 _have_internal_generator = false;
1756 for (i = _processors.begin(); i != _processors.end(); ++i) {
1757 boost::shared_ptr<PluginInsert> pi;
1759 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1760 if (pi->has_no_inputs ()) {
1761 _have_internal_generator = true;
1768 /* now try to do what we need to so that those that were removed will be deleted */
1770 for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
1771 (*i)->drop_references ();
1774 reset_instrument_info ();
1775 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1776 set_processor_positions ();
1782 Route::reset_instrument_info ()
1784 boost::shared_ptr<Processor> instr = the_instrument();
1786 _instrument_info.set_internal_instrument (instr);
1790 /** Caller must hold process lock */
1792 Route::configure_processors (ProcessorStreams* err)
1794 #ifndef PLATFORM_WINDOWS
1795 assert (!AudioEngine::instance()->process_lock().trylock());
1798 if (!_in_configure_processors) {
1799 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1800 return configure_processors_unlocked (err);
1807 Route::input_streams () const
1809 return _input->n_ports ();
1812 list<pair<ChanCount, ChanCount> >
1813 Route::try_configure_processors (ChanCount in, ProcessorStreams* err)
1815 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1817 return try_configure_processors_unlocked (in, err);
1820 list<pair<ChanCount, ChanCount> >
1821 Route::try_configure_processors_unlocked (ChanCount in, ProcessorStreams* err)
1823 // Check each processor in order to see if we can configure as requested
1825 list<pair<ChanCount, ChanCount> > configuration;
1828 DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
1829 DEBUG_TRACE (DEBUG::Processors, "{\n");
1831 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1833 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1834 DEBUG_TRACE (DEBUG::Processors, "--- CONFIGURE ABORTED due to unknown processor.\n");
1835 DEBUG_TRACE (DEBUG::Processors, "}\n");
1836 return list<pair<ChanCount, ChanCount> > ();
1839 if ((*p)->can_support_io_configuration(in, out)) {
1840 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID=%2 in=%3 out=%4\n",(*p)->name(), (*p)->id(), in, out));
1841 configuration.push_back(make_pair(in, out));
1848 DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
1849 DEBUG_TRACE (DEBUG::Processors, string_compose ("---- %1 cannot support in=%2 out=%3\n", (*p)->name(), in, out));
1850 DEBUG_TRACE (DEBUG::Processors, "}\n");
1851 return list<pair<ChanCount, ChanCount> > ();
1855 DEBUG_TRACE (DEBUG::Processors, "}\n");
1857 return configuration;
1860 /** Set the input/output configuration of each processor in the processors list.
1861 * Caller must hold process lock.
1862 * Return 0 on success, otherwise configuration is impossible.
1865 Route::configure_processors_unlocked (ProcessorStreams* err)
1867 #ifndef PLATFORM_WINDOWS
1868 assert (!AudioEngine::instance()->process_lock().trylock());
1871 if (_in_configure_processors) {
1875 /* put invisible processors where they should be */
1876 setup_invisible_processors ();
1878 _in_configure_processors = true;
1880 list<pair<ChanCount, ChanCount> > configuration = try_configure_processors_unlocked (input_streams (), err);
1882 if (configuration.empty ()) {
1883 _in_configure_processors = false;
1888 bool seen_mains_out = false;
1889 processor_out_streams = _input->n_ports();
1890 processor_max_streams.reset();
1892 list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1893 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1895 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1899 (*p)->configure_io(c->first, c->second);
1900 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1901 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1904 if (boost::dynamic_pointer_cast<Delivery> (*p)
1905 && boost::dynamic_pointer_cast<Delivery> (*p)->role() == Delivery::Main) {
1906 /* main delivery will increase port count to match input.
1907 * the Delivery::Main is usually the last processor - followed only by
1910 seen_mains_out = true;
1912 if (!seen_mains_out) {
1913 processor_out_streams = out;
1919 _meter->reset_max_channels (processor_max_streams);
1922 /* make sure we have sufficient scratch buffers to cope with the new processor
1925 _session.ensure_buffers (n_process_buffers ());
1927 DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
1929 _in_configure_processors = false;
1933 /** Set all visible processors to a given active state (except Fader, whose state is not changed)
1934 * @param state New active state for those processors.
1937 Route::all_visible_processors_active (bool state)
1939 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1941 if (_processors.empty()) {
1945 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1946 if (!(*i)->display_to_user() || boost::dynamic_pointer_cast<Amp> (*i)) {
1953 (*i)->deactivate ();
1957 _session.set_dirty ();
1961 Route::processors_reorder_needs_configure (const ProcessorList& new_order)
1963 /* check if re-order requires re-configuration of any processors
1964 * -> compare channel configuration for all processors
1966 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1967 ChanCount c = input_streams ();
1969 for (ProcessorList::const_iterator j = new_order.begin(); j != new_order.end(); ++j) {
1971 if (c != (*j)->input_streams()) {
1974 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
1977 if ((*i)->input_streams() != c) {
1980 c = (*i)->output_streams();
1992 __attribute__((annotate("realtime")))
1995 Route::apply_processor_order (const ProcessorList& new_order)
1997 /* need to hold processor_lock; either read or write lock
1998 * and the engine process_lock.
1999 * Due to r/w lock ambiguity we can only assert the latter
2001 assert (!AudioEngine::instance()->process_lock().trylock());
2004 /* "new_order" is an ordered list of processors to be positioned according to "placement".
2005 * NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
2006 * processors in the current actual processor list that are hidden. Any visible processors
2007 * in the current list but not in "new_order" will be assumed to be deleted.
2010 /* "as_it_will_be" and "_processors" are lists of shared pointers.
2011 * actual memory usage is small, but insert/erase is not actually rt-safe :(
2012 * (note though that ::processors_reorder_needs_configure() ensured that
2013 * this function will only ever be called from the rt-thread if no processor were removed)
2015 * either way, I can't proove it, but an x-run due to re-order here is less likley
2016 * than an x-run-less 'ardour-silent cycle' both of which effectively "click".
2019 ProcessorList as_it_will_be;
2020 ProcessorList::iterator oiter;
2021 ProcessorList::const_iterator niter;
2023 oiter = _processors.begin();
2024 niter = new_order.begin();
2026 while (niter != new_order.end()) {
2028 /* if the next processor in the old list is invisible (i.e. should not be in the new order)
2029 then append it to the temp list.
2031 Otherwise, see if the next processor in the old list is in the new list. if not,
2032 its been deleted. If its there, append it to the temp list.
2035 if (oiter == _processors.end()) {
2037 /* no more elements in the old list, so just stick the rest of
2038 the new order onto the temp list.
2041 as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
2042 while (niter != new_order.end()) {
2049 if (!(*oiter)->display_to_user()) {
2051 as_it_will_be.push_back (*oiter);
2055 /* visible processor: check that its in the new order */
2057 if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
2058 /* deleted: do nothing, shared_ptr<> will clean up */
2060 /* ignore this one, and add the next item from the new order instead */
2061 as_it_will_be.push_back (*niter);
2066 /* now remove from old order - its taken care of no matter what */
2067 oiter = _processors.erase (oiter);
2071 _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
2073 /* If the meter is in a custom position, find it and make a rough note of its position */
2074 maybe_note_meter_position ();
2078 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
2080 // it a change is already queued, wait for it
2081 // (unless engine is stopped. apply immediately and proceed
2082 while (g_atomic_int_get (&_pending_process_reorder)) {
2083 if (!AudioEngine::instance()->running()) {
2084 DEBUG_TRACE (DEBUG::Processors, "offline apply queued processor re-order.\n");
2085 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2087 apply_processor_order(_pending_processor_order);
2088 setup_invisible_processors ();
2090 g_atomic_int_set (&_pending_process_reorder, 0);
2092 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2093 set_processor_positions ();
2095 // TODO rather use a semaphore or something.
2096 // but since ::reorder_processors() is called
2097 // from the GUI thread, this is fine..
2102 if (processors_reorder_needs_configure (new_order) || !AudioEngine::instance()->running()) {
2104 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2105 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2106 ProcessorState pstate (this);
2108 apply_processor_order (new_order);
2110 if (configure_processors_unlocked (err)) {
2118 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2119 set_processor_positions ();
2122 DEBUG_TRACE (DEBUG::Processors, "Queue clickless processor re-order.\n");
2123 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2125 // _pending_processor_order is protected by _processor_lock
2126 _pending_processor_order = new_order;
2127 g_atomic_int_set (&_pending_process_reorder, 1);
2140 Route::get_template()
2142 return state(false);
2146 Route::state(bool full_state)
2148 XMLNode *node = new XMLNode("Route");
2149 ProcessorList::iterator i;
2152 id().print (buf, sizeof (buf));
2153 node->add_property("id", buf);
2154 node->add_property ("name", _name);
2155 node->add_property("default-type", _default_type.to_string());
2158 node->add_property("flags", enum_2_string (_flags));
2161 node->add_property("active", _active?"yes":"no");
2163 boost::to_string (_phase_invert, p);
2164 node->add_property("phase-invert", p);
2165 node->add_property("denormal-protection", _denormal_protection?"yes":"no");
2166 node->add_property("meter-point", enum_2_string (_meter_point));
2168 node->add_property("meter-type", enum_2_string (_meter_type));
2171 node->add_property("route-group", _route_group->name());
2174 snprintf (buf, sizeof (buf), "%d", _order_key);
2175 node->add_property ("order-key", buf);
2176 node->add_property ("self-solo", (_self_solo ? "yes" : "no"));
2177 snprintf (buf, sizeof (buf), "%d", _soloed_by_others_upstream);
2178 node->add_property ("soloed-by-upstream", buf);
2179 snprintf (buf, sizeof (buf), "%d", _soloed_by_others_downstream);
2180 node->add_property ("soloed-by-downstream", buf);
2181 node->add_property ("solo-isolated", solo_isolated() ? "yes" : "no");
2182 node->add_property ("solo-safe", _solo_safe ? "yes" : "no");
2184 node->add_child_nocopy (_input->state (full_state));
2185 node->add_child_nocopy (_output->state (full_state));
2186 node->add_child_nocopy (_solo_control->get_state ());
2187 node->add_child_nocopy (_mute_control->get_state ());
2188 node->add_child_nocopy (_mute_master->get_state ());
2191 node->add_child_nocopy (Automatable::get_automation_xml_state ());
2194 XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
2195 snprintf (buf, sizeof (buf), "%d", _remote_control_id);
2196 remote_control_node->add_property (X_("id"), buf);
2197 node->add_child_nocopy (*remote_control_node);
2199 if (_comment.length()) {
2200 XMLNode *cmt = node->add_child ("Comment");
2201 cmt->add_content (_comment);
2205 node->add_child_nocopy (_pannable->state (full_state));
2208 for (i = _processors.begin(); i != _processors.end(); ++i) {
2210 /* template save: do not include internal sends functioning as
2211 aux sends because the chance of the target ID
2212 in the session where this template is used
2215 similarly, do not save listen sends which connect to
2216 the monitor section, because these will always be
2219 boost::shared_ptr<InternalSend> is;
2221 if ((is = boost::dynamic_pointer_cast<InternalSend> (*i)) != 0) {
2222 if (is->role() == Delivery::Listen) {
2227 node->add_child_nocopy((*i)->state (full_state));
2231 node->add_child_copy (*_extra_xml);
2234 if (_custom_meter_position_noted) {
2235 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
2237 after->id().print (buf, sizeof (buf));
2238 node->add_property (X_("processor-after-last-custom-meter"), buf);
2241 node->add_property (X_("last-custom-meter-was-at-end"), _last_custom_meter_was_at_end ? "yes" : "no");
2248 Route::set_state (const XMLNode& node, int version)
2250 if (version < 3000) {
2251 return set_state_2X (node, version);
2255 XMLNodeConstIterator niter;
2257 const XMLProperty *prop;
2259 if (node.name() != "Route"){
2260 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2264 if ((prop = node.property (X_("name"))) != 0) {
2265 Route::set_name (prop->value());
2269 _initial_io_setup = true;
2271 if ((prop = node.property (X_("flags"))) != 0) {
2272 _flags = Flag (string_2_enum (prop->value(), _flags));
2277 if (is_master() || is_monitor() || is_auditioner()) {
2278 _mute_master->set_solo_ignore (true);
2282 /* monitor bus does not get a panner, but if (re)created
2283 via XML, it will already have one by the time we
2284 call ::set_state(). so ... remove it.
2289 /* add all processors (except amp, which is always present) */
2291 nlist = node.children();
2292 XMLNode processor_state (X_("processor_state"));
2294 Stateful::save_extra_xml (node);
2296 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2300 if (child->name() == IO::state_node_name) {
2301 if ((prop = child->property (X_("direction"))) == 0) {
2305 if (prop->value() == "Input") {
2306 _input->set_state (*child, version);
2307 } else if (prop->value() == "Output") {
2308 _output->set_state (*child, version);
2312 if (child->name() == X_("Processor")) {
2313 processor_state.add_child_copy (*child);
2316 if (child->name() == X_("Pannable")) {
2318 _pannable->set_state (*child, version);
2320 warning << string_compose (_("Pannable state found for route (%1) without a panner!"), name()) << endmsg;
2325 if ((prop = node.property (X_("meter-point"))) != 0) {
2326 MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
2327 set_meter_point (mp, true);
2329 _meter->set_display_to_user (_meter_point == MeterCustom);
2333 if ((prop = node.property (X_("meter-type"))) != 0) {
2334 _meter_type = MeterType (string_2_enum (prop->value (), _meter_type));
2337 _initial_io_setup = false;
2339 set_processor_state (processor_state);
2341 // this looks up the internal instrument in processors
2342 reset_instrument_info();
2344 if ((prop = node.property ("self-solo")) != 0) {
2345 set_self_solo (string_is_affirmative (prop->value()));
2348 if ((prop = node.property ("soloed-by-upstream")) != 0) {
2349 _soloed_by_others_upstream = 0; // needed for mod_.... () to work
2350 mod_solo_by_others_upstream (atoi (prop->value()));
2353 if ((prop = node.property ("soloed-by-downstream")) != 0) {
2354 _soloed_by_others_downstream = 0; // needed for mod_.... () to work
2355 mod_solo_by_others_downstream (atoi (prop->value()));
2358 if ((prop = node.property ("solo-isolated")) != 0) {
2359 set_solo_isolated (string_is_affirmative (prop->value()), this);
2362 if ((prop = node.property ("solo-safe")) != 0) {
2363 set_solo_safe (string_is_affirmative (prop->value()), this);
2366 if ((prop = node.property (X_("phase-invert"))) != 0) {
2367 set_phase_invert (boost::dynamic_bitset<> (prop->value ()));
2370 if ((prop = node.property (X_("denormal-protection"))) != 0) {
2371 set_denormal_protection (string_is_affirmative (prop->value()));
2374 if ((prop = node.property (X_("active"))) != 0) {
2375 bool yn = string_is_affirmative (prop->value());
2376 _active = !yn; // force switch
2377 set_active (yn, this);
2380 if ((prop = node.property (X_("order-key"))) != 0) { // New order key (no separate mixer/editor ordering)
2381 set_order_key (atoi(prop->value()));
2384 if ((prop = node.property (X_("order-keys"))) != 0) { // Deprecated order keys
2388 string::size_type colon, equal;
2389 string remaining = prop->value();
2391 while (remaining.length()) {
2393 if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2394 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2397 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2398 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2401 string keyname = remaining.substr (0, equal);
2403 if ((keyname == "EditorSort") || (keyname == "editor")) {
2404 cerr << "Setting " << name() << " order key to " << n << " using saved Editor order." << endl;
2410 colon = remaining.find_first_of (':');
2412 if (colon != string::npos) {
2413 remaining = remaining.substr (colon+1);
2420 if ((prop = node.property (X_("processor-after-last-custom-meter"))) != 0) {
2421 PBD::ID id (prop->value ());
2422 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2423 ProcessorList::const_iterator i = _processors.begin ();
2424 while (i != _processors.end() && (*i)->id() != id) {
2428 if (i != _processors.end ()) {
2429 _processor_after_last_custom_meter = *i;
2430 _custom_meter_position_noted = true;
2434 if ((prop = node.property (X_("last-custom-meter-was-at-end"))) != 0) {
2435 _last_custom_meter_was_at_end = string_is_affirmative (prop->value ());
2438 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2441 if (child->name() == X_("Comment")) {
2443 /* XXX this is a terrible API design in libxml++ */
2445 XMLNode *cmt = *(child->children().begin());
2446 _comment = cmt->content();
2448 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2449 if (prop->value() == "solo") {
2450 _solo_control->set_state (*child, version);
2451 } else if (prop->value() == "mute") {
2452 _mute_control->set_state (*child, version);
2455 } else if (child->name() == X_("RemoteControl")) {
2456 if ((prop = child->property (X_("id"))) != 0) {
2458 sscanf (prop->value().c_str(), "%d", &x);
2459 set_remote_control_id_internal (x);
2462 } else if (child->name() == X_("MuteMaster")) {
2463 _mute_master->set_state (*child, version);
2465 } else if (child->name() == Automatable::xml_node_name) {
2466 set_automation_xml_state (*child, Evoral::Parameter(NullAutomation));
2474 Route::set_state_2X (const XMLNode& node, int version)
2476 LocaleGuard lg (X_("C"));
2478 XMLNodeConstIterator niter;
2480 const XMLProperty *prop;
2482 /* 2X things which still remain to be handled:
2488 if (node.name() != "Route") {
2489 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2493 if ((prop = node.property (X_("flags"))) != 0) {
2494 string f = prop->value ();
2495 boost::replace_all (f, "ControlOut", "MonitorOut");
2496 _flags = Flag (string_2_enum (f, _flags));
2501 if (is_master() || is_monitor() || is_auditioner()) {
2502 _mute_master->set_solo_ignore (true);
2505 if ((prop = node.property (X_("phase-invert"))) != 0) {
2506 boost::dynamic_bitset<> p (_input->n_ports().n_audio ());
2507 if (string_is_affirmative (prop->value ())) {
2510 set_phase_invert (p);
2513 if ((prop = node.property (X_("denormal-protection"))) != 0) {
2514 set_denormal_protection (string_is_affirmative (prop->value()));
2517 if ((prop = node.property (X_("soloed"))) != 0) {
2518 bool yn = string_is_affirmative (prop->value());
2520 /* XXX force reset of solo status */
2522 set_solo (yn, this);
2525 if ((prop = node.property (X_("muted"))) != 0) {
2528 bool muted = string_is_affirmative (prop->value());
2534 if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
2536 if (string_is_affirmative (prop->value())){
2537 mute_point = mute_point + "PreFader";
2542 if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
2544 if (string_is_affirmative (prop->value())){
2547 mute_point = mute_point + ",";
2550 mute_point = mute_point + "PostFader";
2555 if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
2557 if (string_is_affirmative (prop->value())){
2560 mute_point = mute_point + ",";
2563 mute_point = mute_point + "Listen";
2568 if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
2570 if (string_is_affirmative (prop->value())){
2573 mute_point = mute_point + ",";
2576 mute_point = mute_point + "Main";
2580 _mute_master->set_mute_points (mute_point);
2581 _mute_master->set_muted_by_self (true);
2585 if ((prop = node.property (X_("meter-point"))) != 0) {
2586 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2589 /* do not carry over edit/mix groups from 2.X because (a) its hard (b) they
2590 don't mean the same thing.
2593 if ((prop = node.property (X_("order-keys"))) != 0) {
2597 string::size_type colon, equal;
2598 string remaining = prop->value();
2600 while (remaining.length()) {
2602 if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2603 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2606 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2607 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2610 string keyname = remaining.substr (0, equal);
2612 if (keyname == "EditorSort" || keyname == "editor") {
2613 info << string_compose(_("Converting deprecated order key for %1 using Editor order %2"), name (), n) << endmsg;
2619 colon = remaining.find_first_of (':');
2621 if (colon != string::npos) {
2622 remaining = remaining.substr (colon+1);
2631 nlist = node.children ();
2632 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2636 if (child->name() == IO::state_node_name) {
2638 /* there is a note in IO::set_state_2X() about why we have to call
2642 _input->set_state_2X (*child, version, true);
2643 _output->set_state_2X (*child, version, false);
2645 if ((prop = child->property (X_("name"))) != 0) {
2646 Route::set_name (prop->value ());
2651 if ((prop = child->property (X_("active"))) != 0) {
2652 bool yn = string_is_affirmative (prop->value());
2653 _active = !yn; // force switch
2654 set_active (yn, this);
2657 if ((prop = child->property (X_("gain"))) != 0) {
2660 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2661 _amp->gain_control()->set_value (val);
2665 /* Set up Panners in the IO */
2666 XMLNodeList io_nlist = child->children ();
2668 XMLNodeConstIterator io_niter;
2671 for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2673 io_child = *io_niter;
2675 if (io_child->name() == X_("Panner")) {
2676 _main_outs->panner_shell()->set_state(*io_child, version);
2677 } else if (io_child->name() == X_("Automation")) {
2678 /* IO's automation is for the fader */
2679 _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
2685 XMLNodeList redirect_nodes;
2687 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2691 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2692 redirect_nodes.push_back(child);
2697 set_processor_state_2X (redirect_nodes, version);
2699 Stateful::save_extra_xml (node);
2701 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2704 if (child->name() == X_("Comment")) {
2706 /* XXX this is a terrible API design in libxml++ */
2708 XMLNode *cmt = *(child->children().begin());
2709 _comment = cmt->content();
2711 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2712 if (prop->value() == X_("solo")) {
2713 _solo_control->set_state (*child, version);
2714 } else if (prop->value() == X_("mute")) {
2715 _mute_control->set_state (*child, version);
2718 } else if (child->name() == X_("RemoteControl")) {
2719 if ((prop = child->property (X_("id"))) != 0) {
2721 sscanf (prop->value().c_str(), "%d", &x);
2722 set_remote_control_id_internal (x);
2732 Route::get_processor_state ()
2734 XMLNode* root = new XMLNode (X_("redirects"));
2735 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2736 root->add_child_nocopy ((*i)->state (true));
2743 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2745 /* We don't bother removing existing processors not in nList, as this
2746 method will only be called when creating a Route from scratch, not
2747 for undo purposes. Just put processors in at the appropriate place
2751 for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2752 add_processor_from_xml_2X (**i, version);
2757 Route::set_processor_state (const XMLNode& node)
2759 const XMLNodeList &nlist = node.children();
2760 XMLNodeConstIterator niter;
2761 ProcessorList new_order;
2762 bool must_configure = false;
2764 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2766 XMLProperty* prop = (*niter)->property ("type");
2768 if (prop->value() == "amp") {
2769 _amp->set_state (**niter, Stateful::current_state_version);
2770 new_order.push_back (_amp);
2771 } else if (prop->value() == "trim") {
2772 _trim->set_state (**niter, Stateful::current_state_version);
2773 new_order.push_back (_trim);
2774 } else if (prop->value() == "meter") {
2775 _meter->set_state (**niter, Stateful::current_state_version);
2776 new_order.push_back (_meter);
2777 } else if (prop->value() == "delay") {
2779 _delayline->set_state (**niter, Stateful::current_state_version);
2780 new_order.push_back (_delayline);
2782 } else if (prop->value() == "main-outs") {
2783 _main_outs->set_state (**niter, Stateful::current_state_version);
2784 } else if (prop->value() == "intreturn") {
2786 _intreturn.reset (new InternalReturn (_session));
2787 must_configure = true;
2789 _intreturn->set_state (**niter, Stateful::current_state_version);
2790 } else if (is_monitor() && prop->value() == "monitor") {
2791 if (!_monitor_control) {
2792 _monitor_control.reset (new MonitorProcessor (_session));
2793 must_configure = true;
2795 _monitor_control->set_state (**niter, Stateful::current_state_version);
2796 } else if (prop->value() == "capture") {
2797 /* CapturingProcessor should never be restored, it's always
2798 added explicitly when needed */
2800 ProcessorList::iterator o;
2802 for (o = _processors.begin(); o != _processors.end(); ++o) {
2803 XMLProperty* id_prop = (*niter)->property(X_("id"));
2804 if (id_prop && (*o)->id() == id_prop->value()) {
2805 (*o)->set_state (**niter, Stateful::current_state_version);
2806 new_order.push_back (*o);
2811 // If the processor (*niter) is not on the route then create it
2813 if (o == _processors.end()) {
2815 boost::shared_ptr<Processor> processor;
2817 if (prop->value() == "intsend") {
2819 processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), boost::shared_ptr<Route>(), Delivery::Aux, true));
2821 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2822 prop->value() == "lv2" ||
2823 prop->value() == "windows-vst" ||
2824 prop->value() == "lxvst" ||
2825 prop->value() == "audiounit") {
2827 processor.reset (new PluginInsert(_session));
2829 } else if (prop->value() == "port") {
2831 processor.reset (new PortInsert (_session, _pannable, _mute_master));
2833 } else if (prop->value() == "send") {
2835 processor.reset (new Send (_session, _pannable, _mute_master, Delivery::Send, true));
2838 error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2842 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2843 /* This processor could not be configured. Turn it into a UnknownProcessor */
2844 processor.reset (new UnknownProcessor (_session, **niter));
2847 /* we have to note the monitor send here, otherwise a new one will be created
2848 and the state of this one will be lost.
2850 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
2851 if (isend && isend->role() == Delivery::Listen) {
2852 _monitor_send = isend;
2855 /* it doesn't matter if invisible processors are added here, as they
2856 will be sorted out by setup_invisible_processors () shortly.
2859 new_order.push_back (processor);
2860 must_configure = true;
2866 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2867 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2868 _processors = new_order;
2870 if (must_configure) {
2871 configure_processors_unlocked (0);
2874 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2876 (*i)->set_owner (this);
2877 (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
2879 boost::shared_ptr<PluginInsert> pi;
2881 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
2882 if (pi->has_no_inputs ()) {
2883 _have_internal_generator = true;
2890 reset_instrument_info ();
2891 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2892 set_processor_positions ();
2896 Route::curve_reallocate ()
2898 // _gain_automation_curve.finish_resize ();
2899 // _pan_automation_curve.finish_resize ();
2903 Route::silence (framecnt_t nframes)
2905 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
2910 silence_unlocked (nframes);
2914 Route::silence_unlocked (framecnt_t nframes)
2916 /* Must be called with the processor lock held */
2920 _output->silence (nframes);
2922 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2923 boost::shared_ptr<PluginInsert> pi;
2925 if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2926 // skip plugins, they don't need anything when we're not active
2930 (*i)->silence (nframes);
2933 if (nframes == _session.get_block_size()) {
2940 Route::add_internal_return ()
2943 _intreturn.reset (new InternalReturn (_session));
2944 add_processor (_intreturn, PreFader);
2949 Route::add_send_to_internal_return (InternalSend* send)
2951 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
2953 for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2954 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2957 return d->add_send (send);
2963 Route::remove_send_from_internal_return (InternalSend* send)
2965 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
2967 for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2968 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2971 return d->remove_send (send);
2977 Route::enable_monitor_send ()
2979 /* Caller must hold process lock */
2980 assert (!AudioEngine::instance()->process_lock().trylock());
2982 /* master never sends to monitor section via the normal mechanism */
2983 assert (!is_master ());
2984 assert (!is_monitor ());
2986 /* make sure we have one */
2987 if (!_monitor_send) {
2988 _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), _session.monitor_out(), Delivery::Listen));
2989 _monitor_send->set_display_to_user (false);
2993 configure_processors (0);
2996 /** Add an aux send to a route.
2997 * @param route route to send to.
2998 * @param before Processor to insert before, or 0 to insert at the end.
3001 Route::add_aux_send (boost::shared_ptr<Route> route, boost::shared_ptr<Processor> before)
3003 assert (route != _session.monitor_out ());
3006 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3008 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3010 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
3012 if (d && d->target_route() == route) {
3013 /* already listening via the specified IO: do nothing */
3021 boost::shared_ptr<InternalSend> listener;
3024 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3025 boost::shared_ptr<Pannable> sendpan (new Pannable (_session));
3026 listener.reset (new InternalSend (_session, sendpan, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), route, Delivery::Aux));
3029 add_processor (listener, before);
3031 } catch (failed_constructor& err) {
3039 Route::remove_aux_or_listen (boost::shared_ptr<Route> route)
3041 ProcessorStreams err;
3042 ProcessorList::iterator tmp;
3045 Glib::Threads::RWLock::ReaderLock rl(_processor_lock);
3047 /* have to do this early because otherwise processor reconfig
3048 * will put _monitor_send back in the list
3051 if (route == _session.monitor_out()) {
3052 _monitor_send.reset ();
3056 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3058 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
3060 if (d && d->target_route() == route) {
3062 remove_processor (*x, &err, false);
3065 /* list could have been demolished while we dropped the lock
3076 Route::set_comment (string cmt, void *src)
3079 comment_changed (src);
3080 _session.set_dirty ();
3084 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
3086 FeedRecord fr (other, via_sends_only);
3088 pair<FedBy::iterator,bool> result = _fed_by.insert (fr);
3090 if (!result.second) {
3092 /* already a record for "other" - make sure sends-only information is correct */
3093 if (!via_sends_only && result.first->sends_only) {
3094 FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
3095 frp->sends_only = false;
3099 return result.second;
3103 Route::clear_fed_by ()
3109 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
3111 const FedBy& fed_by (other->fed_by());
3113 for (FedBy::const_iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
3114 boost::shared_ptr<Route> sr = f->r.lock();
3116 if (sr && (sr.get() == this)) {
3118 if (via_sends_only) {
3119 *via_sends_only = f->sends_only;
3130 Route::direct_feeds_according_to_reality (boost::shared_ptr<Route> other, bool* via_send_only)
3132 DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
3134 if (_output->connected_to (other->input())) {
3135 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
3136 if (via_send_only) {
3137 *via_send_only = false;
3144 for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
3146 boost::shared_ptr<IOProcessor> iop;
3148 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
3149 if (iop->feeds (other)) {
3150 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
3151 if (via_send_only) {
3152 *via_send_only = true;
3156 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
3159 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
3164 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdoes NOT feed %1\n", other->name()));
3169 Route::direct_feeds_according_to_graph (boost::shared_ptr<Route> other, bool* via_send_only)
3171 return _session._current_route_graph.has (shared_from_this (), other, via_send_only);
3174 /** Called from the (non-realtime) butler thread when the transport is stopped */
3176 Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool /*did_locate*/, bool can_flush_processors)
3178 framepos_t now = _session.transport_frame();
3181 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3183 Automatable::transport_stopped (now);
3185 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3187 if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && can_flush_processors)) {
3191 (*i)->transport_stopped (now);
3195 _roll_delay = _initial_delay;
3199 Route::input_change_handler (IOChange change, void * /*src*/)
3201 bool need_to_queue_solo_change = true;
3203 if ((change.type & IOChange::ConfigurationChanged)) {
3204 /* This is called with the process lock held if change
3205 contains ConfigurationChanged
3207 need_to_queue_solo_change = false;
3208 configure_processors (0);
3209 _phase_invert.resize (_input->n_ports().n_audio ());
3210 io_changed (); /* EMIT SIGNAL */
3213 if (!_input->connected() && _soloed_by_others_upstream) {
3214 if (need_to_queue_solo_change) {
3215 _session.cancel_solo_after_disconnect (shared_from_this(), true);
3217 cancel_solo_after_disconnect (true);
3223 Route::output_change_handler (IOChange change, void * /*src*/)
3225 bool need_to_queue_solo_change = true;
3226 if (_initial_io_setup) {
3230 if ((change.type & IOChange::ConfigurationChanged)) {
3231 /* This is called with the process lock held if change
3232 contains ConfigurationChanged
3234 need_to_queue_solo_change = false;
3235 configure_processors (0);
3238 _session.reset_monitor_section();
3241 io_changed (); /* EMIT SIGNAL */
3244 if (!_output->connected() && _soloed_by_others_downstream) {
3245 if (need_to_queue_solo_change) {
3246 _session.cancel_solo_after_disconnect (shared_from_this(), false);
3248 cancel_solo_after_disconnect (false);
3254 Route::cancel_solo_after_disconnect (bool upstream)
3257 _soloed_by_others_upstream = 0;
3259 _soloed_by_others_downstream = 0;
3261 set_mute_master_solo ();
3262 solo_changed (false, this);
3266 Route::pans_required () const
3268 if (n_outputs().n_audio() < 2) {
3272 return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
3276 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
3278 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3284 if (n_outputs().n_total() == 0) {
3288 if (!_active || n_inputs() == ChanCount::ZERO) {
3289 silence_unlocked (nframes);
3293 if (session_state_changing) {
3294 if (_session.transport_speed() != 0.0f) {
3295 /* we're rolling but some state is changing (e.g. our diskstream contents)
3296 so we cannot use them. Be silent till this is over.
3298 XXX note the absurdity of ::no_roll() being called when we ARE rolling!
3300 silence_unlocked (nframes);
3303 /* we're really not rolling, so we're either delivery silence or actually
3304 monitoring, both of which are safe to do while session_state_changing is true.
3308 BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
3310 fill_buffers_with_input (bufs, _input, nframes);
3312 if (_meter_point == MeterInput) {
3313 _meter->run (bufs, start_frame, end_frame, nframes, true);
3316 _amp->apply_gain_automation (false);
3317 _trim->apply_gain_automation (false);
3318 passthru (bufs, start_frame, end_frame, nframes, 0);
3324 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& /* need_butler */)
3326 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3331 if (n_outputs().n_total() == 0) {
3335 if (!_active || n_inputs().n_total() == 0) {
3336 silence_unlocked (nframes);
3340 framepos_t unused = 0;
3342 if ((nframes = check_initial_delay (nframes, unused)) == 0) {
3348 BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
3350 fill_buffers_with_input (bufs, _input, nframes);
3352 if (_meter_point == MeterInput) {
3353 _meter->run (bufs, start_frame, end_frame, nframes, true);
3356 passthru (bufs, start_frame, end_frame, nframes, declick);
3362 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& /* need_butler */)
3369 Route::flush_processors ()
3371 /* XXX shouldn't really try to take this lock, since
3372 this is called from the RT audio thread.
3375 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3377 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3383 __attribute__((annotate("realtime")))
3386 Route::apply_processor_changes_rt ()
3388 if (_pending_meter_point != _meter_point) {
3389 Glib::Threads::RWLock::WriterLock pwl (_processor_lock, Glib::Threads::TRY_LOCK);
3391 /* meters always have buffers for 'processor_max_streams'
3392 * they can be re-positioned without re-allocation */
3393 set_meter_point_unlocked();
3397 bool changed = false;
3399 if (g_atomic_int_get (&_pending_process_reorder)) {
3400 Glib::Threads::RWLock::WriterLock pwl (_processor_lock, Glib::Threads::TRY_LOCK);
3402 apply_processor_order (_pending_processor_order);
3403 setup_invisible_processors ();
3406 g_atomic_int_set (&_pending_process_reorder, 0);
3410 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
3411 set_processor_positions ();
3416 Route::set_meter_point (MeterPoint p, bool force)
3418 if (_pending_meter_point == p && !force) {
3422 if (force || !AudioEngine::instance()->running()) {
3423 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3424 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3425 _pending_meter_point = p;
3426 set_meter_point_unlocked();
3428 _pending_meter_point = p;
3434 __attribute__((annotate("realtime")))
3437 Route::set_meter_point_unlocked ()
3440 /* Caller must hold process and processor write lock */
3441 assert (!AudioEngine::instance()->process_lock().trylock());
3442 Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3443 assert (!lm.locked ());
3446 _meter_point = _pending_meter_point;
3448 bool meter_was_visible_to_user = _meter->display_to_user ();
3450 maybe_note_meter_position ();
3452 if (_meter_point != MeterCustom) {
3454 _meter->set_display_to_user (false);
3456 setup_invisible_processors ();
3460 _meter->set_display_to_user (true);
3462 /* If we have a previous position for the custom meter, try to put it there */
3463 if (_custom_meter_position_noted) {
3464 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
3467 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), after);
3468 if (i != _processors.end ()) {
3469 _processors.remove (_meter);
3470 _processors.insert (i, _meter);
3472 } else if (_last_custom_meter_was_at_end) {
3473 _processors.remove (_meter);
3474 _processors.push_back (_meter);
3479 /* Set up the meter for its new position */
3481 ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
3485 if (loc == _processors.begin()) {
3486 m_in = _input->n_ports();
3488 ProcessorList::iterator before = loc;
3490 m_in = (*before)->output_streams ();
3493 _meter->reflect_inputs (m_in);
3495 /* we do not need to reconfigure the processors, because the meter
3496 (a) is always ready to handle processor_max_streams
3497 (b) is always an N-in/N-out processor, and thus moving
3498 it doesn't require any changes to the other processors.
3501 /* these should really be done after releasing the lock
3502 * but all those signals are subscribed to with gui_thread()
3505 meter_change (); /* EMIT SIGNAL */
3506 bool const meter_visibly_changed = (_meter->display_to_user() != meter_was_visible_to_user);
3507 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
3511 Route::listen_position_changed ()
3514 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3515 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3516 ProcessorState pstate (this);
3518 if (configure_processors_unlocked (0)) {
3520 configure_processors_unlocked (0); // it worked before we tried to add it ...
3525 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
3526 _session.set_dirty ();
3529 boost::shared_ptr<CapturingProcessor>
3530 Route::add_export_point()
3532 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3533 if (!_capturing_processor) {
3535 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3536 Glib::Threads::RWLock::WriterLock lw (_processor_lock);
3538 _capturing_processor.reset (new CapturingProcessor (_session));
3539 _capturing_processor->activate ();
3541 configure_processors_unlocked (0);
3545 return _capturing_processor;
3549 Route::update_signal_latency ()
3551 framecnt_t l = _output->user_latency();
3552 framecnt_t lamp = 0;
3553 bool before_amp = true;
3554 framecnt_t ltrim = 0;
3555 bool before_trim = true;
3557 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3558 if ((*i)->active ()) {
3559 l += (*i)->signal_latency ();
3564 if ((*i) == _trim) {
3575 DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l));
3577 // TODO: (lamp - _signal_latency) to sync to output (read-ahed), currently _roll_delay shifts this around
3578 _signal_latency_at_amp_position = lamp;
3579 _signal_latency_at_trim_position = ltrim;
3581 if (_signal_latency != l) {
3582 _signal_latency = l;
3583 signal_latency_changed (); /* EMIT SIGNAL */
3586 return _signal_latency;
3590 Route::set_user_latency (framecnt_t nframes)
3592 _output->set_user_latency (nframes);
3593 _session.update_latency_compensation ();
3597 Route::set_latency_compensation (framecnt_t longest_session_latency)
3599 framecnt_t old = _initial_delay;
3601 if (_signal_latency < longest_session_latency) {
3602 _initial_delay = longest_session_latency - _signal_latency;
3607 DEBUG_TRACE (DEBUG::Latency, string_compose (
3608 "%1: compensate for maximum latency of %2,"
3609 "given own latency of %3, using initial delay of %4\n",
3610 name(), longest_session_latency, _signal_latency, _initial_delay));
3612 if (_initial_delay != old) {
3613 initial_delay_changed (); /* EMIT SIGNAL */
3616 if (_session.transport_stopped()) {
3617 _roll_delay = _initial_delay;
3621 Route::SoloControllable::SoloControllable (std::string name, boost::shared_ptr<Route> r)
3622 : AutomationControl (r->session(),
3623 Evoral::Parameter (SoloAutomation),
3624 ParameterDescriptor(Evoral::Parameter (SoloAutomation)),
3625 boost::shared_ptr<AutomationList>(), name)
3628 boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
3629 gl->set_interpolation(Evoral::ControlList::Discrete);
3634 Route::SoloControllable::set_value (double val)
3636 const bool bval = ((val >= 0.5) ? true : false);
3638 boost::shared_ptr<RouteList> rl (new RouteList);
3640 boost::shared_ptr<Route> r = _route.lock ();
3647 if (Config->get_solo_control_is_listen_control()) {
3648 _session.set_listen (rl, bval);
3650 _session.set_solo (rl, bval);
3655 Route::SoloControllable::get_value () const
3657 boost::shared_ptr<Route> r = _route.lock ();
3662 if (Config->get_solo_control_is_listen_control()) {
3663 return r->listening_via_monitor() ? GAIN_COEFF_UNITY : GAIN_COEFF_ZERO;
3665 return r->self_soloed() ? GAIN_COEFF_UNITY : GAIN_COEFF_ZERO;
3669 Route::MuteControllable::MuteControllable (std::string name, boost::shared_ptr<Route> r)
3670 : AutomationControl (r->session(),
3671 Evoral::Parameter (MuteAutomation),
3672 ParameterDescriptor (Evoral::Parameter (MuteAutomation)),
3673 boost::shared_ptr<AutomationList>(),
3677 boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MuteAutomation)));
3678 gl->set_interpolation(Evoral::ControlList::Discrete);
3683 Route::MuteControllable::set_superficial_value(bool muted)
3685 /* Note we can not use AutomationControl::set_value here since it will emit
3686 Changed(), but the value will not be correct to the observer. */
3688 bool to_list = _list && ((AutomationList*)_list.get())->automation_write();
3690 Control::set_double (muted, _session.transport_frame(), to_list);
3694 Route::MuteControllable::set_value (double val)
3696 const bool bval = ((val >= 0.5) ? true : false);
3698 boost::shared_ptr<Route> r = _route.lock ();
3703 if (_list && ((AutomationList*)_list.get())->automation_playback()) {
3704 // Playing back automation, set route mute directly
3705 r->set_mute (bval, this);
3707 // Set from user, queue mute event
3708 boost::shared_ptr<RouteList> rl (new RouteList);
3710 _session.set_mute (rl, bval, Session::rt_cleanup);
3713 // Set superficial/automation value to drive controller (and possibly record)
3714 set_superficial_value(bval);
3718 Route::MuteControllable::get_value () const
3720 if (_list && ((AutomationList*)_list.get())->automation_playback()) {
3721 // Playing back automation, get the value from the list
3722 return AutomationControl::get_value();
3725 // Not playing back automation, get the actual route mute value
3726 boost::shared_ptr<Route> r = _route.lock ();
3727 return (r && r->muted()) ? GAIN_COEFF_UNITY : GAIN_COEFF_ZERO;
3731 Route::set_block_size (pframes_t nframes)
3733 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3734 (*i)->set_block_size (nframes);
3737 _session.ensure_buffers (n_process_buffers ());
3741 Route::protect_automation ()
3743 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3744 (*i)->protect_automation();
3747 /** @param declick 1 to set a pending declick fade-in,
3748 * -1 to set a pending declick fade-out
3751 Route::set_pending_declick (int declick)
3754 /* this call is not allowed to turn off a pending declick */
3756 _pending_declick = declick;
3759 _pending_declick = 0;
3763 /** Shift automation forwards from a particular place, thereby inserting time.
3764 * Adds undo commands for any shifts that are performed.
3766 * @param pos Position to start shifting from.
3767 * @param frames Amount to shift forwards by.
3771 Route::shift (framepos_t pos, framecnt_t frames)
3773 /* gain automation */
3775 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
3777 XMLNode &before = gc->alist()->get_state ();
3778 gc->alist()->shift (pos, frames);
3779 XMLNode &after = gc->alist()->get_state ();
3780 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3783 /* gain automation */
3785 boost::shared_ptr<AutomationControl> gc = _trim->gain_control();
3787 XMLNode &before = gc->alist()->get_state ();
3788 gc->alist()->shift (pos, frames);
3789 XMLNode &after = gc->alist()->get_state ();
3790 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3793 // TODO mute automation ??
3795 /* pan automation */
3797 ControlSet::Controls& c (_pannable->controls());
3799 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
3800 boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
3802 boost::shared_ptr<AutomationList> al = pc->alist();
3803 XMLNode& before = al->get_state ();
3804 al->shift (pos, frames);
3805 XMLNode& after = al->get_state ();
3806 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3811 /* redirect automation */
3813 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3814 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
3816 set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
3818 for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
3819 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
3821 boost::shared_ptr<AutomationList> al = ac->alist();
3822 XMLNode &before = al->get_state ();
3823 al->shift (pos, frames);
3824 XMLNode &after = al->get_state ();
3825 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3834 Route::save_as_template (const string& path, const string& name)
3836 XMLNode& node (state (false));
3839 IO::set_name_in_state (*node.children().front(), name);
3841 tree.set_root (&node);
3842 return tree.write (path.c_str());
3847 Route::set_name (const string& str)
3849 if (str == name()) {
3853 string name = Route::ensure_track_or_route_name (str, _session);
3854 SessionObject::set_name (name);
3856 bool ret = (_input->set_name(name) && _output->set_name(name));
3859 /* rename the main outs. Leave other IO processors
3860 * with whatever name they already have, because its
3861 * just fine as it is (it will not contain the route
3862 * name if its a port insert, port send or port return).
3866 if (_main_outs->set_name (name)) {
3867 /* XXX returning false here is stupid because
3868 we already changed the route name.
3878 /** Set the name of a route in an XML description.
3879 * @param node XML <Route> node to set the name in.
3880 * @param name New name.
3883 Route::set_name_in_state (XMLNode& node, string const & name)
3885 node.add_property (X_("name"), name);
3887 XMLNodeList children = node.children();
3888 for (XMLNodeIterator i = children.begin(); i != children.end(); ++i) {
3890 if ((*i)->name() == X_("IO")) {
3892 IO::set_name_in_state (**i, name);
3894 } else if ((*i)->name() == X_("Processor")) {
3896 XMLProperty* role = (*i)->property (X_("role"));
3897 if (role && role->value() == X_("Main")) {
3898 (*i)->add_property (X_("name"), name);
3901 } else if ((*i)->name() == X_("Diskstream")) {
3903 (*i)->add_property (X_("playlist"), string_compose ("%1.1", name).c_str());
3904 (*i)->add_property (X_("name"), name);
3910 boost::shared_ptr<Send>
3911 Route::internal_send_for (boost::shared_ptr<const Route> target) const
3913 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3915 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3916 boost::shared_ptr<InternalSend> send;
3918 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
3919 if (send->target_route() == target) {
3925 return boost::shared_ptr<Send>();
3928 /** @param c Audio channel index.
3929 * @param yn true to invert phase, otherwise false.
3932 Route::set_phase_invert (uint32_t c, bool yn)
3934 if (_phase_invert[c] != yn) {
3935 _phase_invert[c] = yn;
3936 phase_invert_changed (); /* EMIT SIGNAL */
3937 _session.set_dirty ();
3942 Route::set_phase_invert (boost::dynamic_bitset<> p)
3944 if (_phase_invert != p) {
3946 phase_invert_changed (); /* EMIT SIGNAL */
3947 _session.set_dirty ();
3952 Route::phase_invert (uint32_t c) const
3954 return _phase_invert[c];
3957 boost::dynamic_bitset<>
3958 Route::phase_invert () const
3960 return _phase_invert;
3964 Route::set_denormal_protection (bool yn)
3966 if (_denormal_protection != yn) {
3967 _denormal_protection = yn;
3968 denormal_protection_changed (); /* EMIT SIGNAL */
3973 Route::denormal_protection () const
3975 return _denormal_protection;
3979 Route::set_active (bool yn, void* src)
3981 if (_session.transport_rolling()) {
3985 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
3986 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
3990 if (_active != yn) {
3992 _input->set_active (yn);
3993 _output->set_active (yn);
3994 active_changed (); // EMIT SIGNAL
3995 _session.set_dirty ();
4002 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
4008 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4010 boost::shared_ptr<Send> s;
4011 boost::shared_ptr<Return> r;
4013 if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
4014 s->meter()->meter();
4015 } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
4016 r->meter()->meter ();
4021 boost::shared_ptr<Pannable>
4022 Route::pannable() const
4027 boost::shared_ptr<Panner>
4028 Route::panner() const
4031 return _main_outs->panner_shell()->panner();
4034 boost::shared_ptr<PannerShell>
4035 Route::panner_shell() const
4037 return _main_outs->panner_shell();
4040 boost::shared_ptr<AutomationControl>
4041 Route::gain_control() const
4043 return _amp->gain_control();
4046 boost::shared_ptr<AutomationControl>
4047 Route::get_control (const Evoral::Parameter& param)
4049 /* either we own the control or .... */
4051 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
4055 /* maybe one of our processors does or ... */
4057 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
4058 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4059 if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
4067 /* nobody does so we'll make a new one */
4069 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
4076 boost::shared_ptr<Processor>
4077 Route::nth_plugin (uint32_t n)
4079 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4080 ProcessorList::iterator i;
4082 for (i = _processors.begin(); i != _processors.end(); ++i) {
4083 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
4090 return boost::shared_ptr<Processor> ();
4093 boost::shared_ptr<Processor>
4094 Route::nth_send (uint32_t n)
4096 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4097 ProcessorList::iterator i;
4099 for (i = _processors.begin(); i != _processors.end(); ++i) {
4100 if (boost::dynamic_pointer_cast<Send> (*i)) {
4107 return boost::shared_ptr<Processor> ();
4111 Route::has_io_processor_named (const string& name)
4113 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4114 ProcessorList::iterator i;
4116 for (i = _processors.begin(); i != _processors.end(); ++i) {
4117 if (boost::dynamic_pointer_cast<Send> (*i) ||
4118 boost::dynamic_pointer_cast<PortInsert> (*i)) {
4119 if ((*i)->name() == name) {
4128 MuteMaster::MutePoint
4129 Route::mute_points () const
4131 return _mute_master->mute_points ();
4135 Route::set_processor_positions ()
4137 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4139 bool had_amp = false;
4140 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4141 (*i)->set_pre_fader (!had_amp);
4142 if (boost::dynamic_pointer_cast<Amp> (*i)) {
4148 /** Called when there is a proposed change to the input port count */
4150 Route::input_port_count_changing (ChanCount to)
4152 list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
4154 /* The processors cannot be configured with the new input arrangement, so
4160 /* The change is ok */
4164 /** Called when there is a proposed change to the output port count */
4166 Route::output_port_count_changing (ChanCount to)
4168 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
4169 if (processor_out_streams.get(*t) > to.get(*t)) {
4173 /* The change is ok */
4178 Route::unknown_processors () const
4182 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4183 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4184 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
4185 p.push_back ((*i)->name ());
4194 Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecnt_t our_latency) const
4196 /* we assume that all our input ports feed all our output ports. its not
4197 universally true, but the alternative is way too corner-case to worry about.
4200 LatencyRange all_connections;
4203 all_connections.min = 0;
4204 all_connections.max = 0;
4206 all_connections.min = ~((pframes_t) 0);
4207 all_connections.max = 0;
4209 /* iterate over all "from" ports and determine the latency range for all of their
4210 connections to the "outside" (outside of this Route).
4213 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
4217 p->get_connected_latency_range (range, playback);
4219 all_connections.min = min (all_connections.min, range.min);
4220 all_connections.max = max (all_connections.max, range.max);
4224 /* set the "from" port latencies to the max/min range of all their connections */
4226 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
4227 p->set_private_latency_range (all_connections, playback);
4230 /* set the ports "in the direction of the flow" to the same value as above plus our own signal latency */
4232 all_connections.min += our_latency;
4233 all_connections.max += our_latency;
4235 for (PortSet::iterator p = to.begin(); p != to.end(); ++p) {
4236 p->set_private_latency_range (all_connections, playback);
4239 return all_connections.max;
4243 Route::set_private_port_latencies (bool playback) const
4245 framecnt_t own_latency = 0;
4247 /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD
4248 OR LATENCY CALLBACK.
4250 This is called (early) from the latency callback. It computes the REAL
4251 latency associated with each port and stores the result as the "private"
4252 latency of the port. A later call to Route::set_public_port_latencies()
4253 sets all ports to the same value to reflect the fact that we do latency
4254 compensation and so all signals are delayed by the same amount as they
4255 flow through ardour.
4258 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4259 if ((*i)->active ()) {
4260 own_latency += (*i)->signal_latency ();
4265 /* playback: propagate latency from "outside the route" to outputs to inputs */
4266 return update_port_latencies (_output->ports (), _input->ports (), true, own_latency);
4268 /* capture: propagate latency from "outside the route" to inputs to outputs */
4269 return update_port_latencies (_input->ports (), _output->ports (), false, own_latency);
4274 Route::set_public_port_latencies (framecnt_t value, bool playback) const
4276 /* this is called to set the JACK-visible port latencies, which take
4277 latency compensation into account.
4286 const PortSet& ports (_input->ports());
4287 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
4288 p->set_public_latency_range (range, playback);
4293 const PortSet& ports (_output->ports());
4294 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
4295 p->set_public_latency_range (range, playback);
4300 /** Put the invisible processors in the right place in _processors.
4301 * Must be called with a writer lock on _processor_lock held.
4304 __attribute__((annotate("realtime")))
4307 Route::setup_invisible_processors ()
4310 Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
4311 assert (!lm.locked ());
4315 /* too early to be doing this stuff */
4319 /* we'll build this new list here and then use it
4321 * TODO put the ProcessorList is on the stack for RT-safety.
4324 ProcessorList new_processors;
4326 /* find visible processors */
4328 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4329 if ((*i)->display_to_user ()) {
4330 new_processors.push_back (*i);
4336 ProcessorList::iterator amp = new_processors.begin ();
4337 while (amp != new_processors.end() && boost::dynamic_pointer_cast<Amp> (*amp) == 0) {
4341 assert (amp != new_processors.end ());
4343 /* and the processor after the amp */
4345 ProcessorList::iterator after_amp = amp;
4351 switch (_meter_point) {
4353 assert (!_meter->display_to_user ());
4354 new_processors.push_front (_meter);
4357 assert (!_meter->display_to_user ());
4358 new_processors.insert (amp, _meter);
4360 case MeterPostFader:
4361 /* do nothing here */
4364 /* do nothing here */
4367 /* the meter is visible, so we don't touch it here */
4374 assert (_main_outs);
4375 assert (!_main_outs->display_to_user ());
4376 new_processors.push_back (_main_outs);
4378 /* iterator for the main outs */
4380 ProcessorList::iterator main = new_processors.end();
4383 /* OUTPUT METERING */
4385 if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
4386 assert (!_meter->display_to_user ());
4388 /* add the processor just before or just after the main outs */
4390 ProcessorList::iterator meter_point = main;
4392 if (_meter_point == MeterOutput) {
4395 new_processors.insert (meter_point, _meter);
4400 if (_monitor_send && !is_monitor ()) {
4401 assert (!_monitor_send->display_to_user ());
4402 if (Config->get_solo_control_is_listen_control()) {
4403 switch (Config->get_listen_position ()) {
4404 case PreFaderListen:
4405 switch (Config->get_pfl_position ()) {
4406 case PFLFromBeforeProcessors:
4407 new_processors.push_front (_monitor_send);
4409 case PFLFromAfterProcessors:
4410 new_processors.insert (amp, _monitor_send);
4413 _monitor_send->set_can_pan (false);
4415 case AfterFaderListen:
4416 switch (Config->get_afl_position ()) {
4417 case AFLFromBeforeProcessors:
4418 new_processors.insert (after_amp, _monitor_send);
4420 case AFLFromAfterProcessors:
4421 new_processors.insert (new_processors.end(), _monitor_send);
4424 _monitor_send->set_can_pan (true);
4428 new_processors.insert (new_processors.end(), _monitor_send);
4429 _monitor_send->set_can_pan (false);
4433 #if 0 // not used - just yet
4434 if (!is_master() && !is_monitor() && !is_auditioner()) {
4435 new_processors.push_front (_delayline);
4439 /* MONITOR CONTROL */
4441 if (_monitor_control && is_monitor ()) {
4442 assert (!_monitor_control->display_to_user ());
4443 new_processors.push_front (_monitor_control);
4446 /* INTERNAL RETURN */
4448 /* doing this here means that any monitor control will come just after
4453 assert (!_intreturn->display_to_user ());
4454 new_processors.push_front (_intreturn);
4457 if (_trim && _trim->active()) {
4458 assert (!_trim->display_to_user ());
4459 new_processors.push_front (_trim);
4461 /* EXPORT PROCESSOR */
4463 if (_capturing_processor) {
4464 assert (!_capturing_processor->display_to_user ());
4465 new_processors.push_front (_capturing_processor);
4468 _processors = new_processors;
4470 DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
4471 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4472 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
4479 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
4480 Glib::Threads::RWLock::ReaderLock lp (_processor_lock);
4484 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4485 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery>(*i);
4492 /** If the meter point is `Custom', make a note of where the meter is.
4493 * This is so that if the meter point is subsequently set to something else,
4494 * and then back to custom, we can put the meter back where it was last time
4495 * custom was enabled.
4497 * Must be called with the _processor_lock held.
4500 Route::maybe_note_meter_position ()
4502 if (_meter_point != MeterCustom) {
4506 _custom_meter_position_noted = true;
4507 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4508 if (boost::dynamic_pointer_cast<PeakMeter> (*i)) {
4509 ProcessorList::iterator j = i;
4511 if (j != _processors.end ()) {
4512 _processor_after_last_custom_meter = *j;
4513 _last_custom_meter_was_at_end = false;
4515 _last_custom_meter_was_at_end = true;
4521 boost::shared_ptr<Processor>
4522 Route::processor_by_id (PBD::ID id) const
4524 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4525 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4526 if ((*i)->id() == id) {
4531 return boost::shared_ptr<Processor> ();
4534 /** @return the monitoring state, or in other words what data we are pushing
4535 * into the route (data from the inputs, data from disk or silence)
4538 Route::monitoring_state () const
4540 return MonitoringInput;
4543 /** @return what we should be metering; either the data coming from the input
4544 * IO or the data that is flowing through the route.
4547 Route::metering_state () const
4549 return MeteringRoute;
4553 Route::has_external_redirects () const
4555 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4557 /* ignore inactive processors and obviously ignore the main
4558 * outs since everything has them and we don't care.
4561 if ((*i)->active() && (*i) != _main_outs && (*i)->does_routing()) {
4569 boost::shared_ptr<Processor>
4570 Route::the_instrument () const
4572 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4573 return the_instrument_unlocked ();
4576 boost::shared_ptr<Processor>
4577 Route::the_instrument_unlocked () const
4579 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4580 if (boost::dynamic_pointer_cast<PluginInsert>(*i)) {
4581 if ((*i)->input_streams().n_midi() > 0 &&
4582 (*i)->output_streams().n_audio() > 0) {
4587 return boost::shared_ptr<Processor>();
4593 Route::non_realtime_locate (framepos_t pos)
4596 _pannable->transport_located (pos);
4599 if (_delayline.get()) {
4600 _delayline.get()->flush();
4604 //Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
4605 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4607 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4608 (*i)->transport_located (pos);
4614 Route::fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes)
4621 * We don't currently mix MIDI input together, so we don't need the
4622 * complex logic of the audio case.
4625 n_buffers = bufs.count().n_midi ();
4627 for (i = 0; i < n_buffers; ++i) {
4629 boost::shared_ptr<MidiPort> source_port = io->midi (i);
4630 MidiBuffer& buf (bufs.get_midi (i));
4633 buf.copy (source_port->get_midi_buffer(nframes));
4635 buf.silence (nframes);
4641 n_buffers = bufs.count().n_audio();
4643 size_t n_ports = io->n_ports().n_audio();
4644 float scaling = 1.0f;
4646 if (n_ports > n_buffers) {
4647 scaling = ((float) n_buffers) / n_ports;
4650 for (i = 0; i < n_ports; ++i) {
4652 /* if there are more ports than buffers, map them onto buffers
4653 * in a round-robin fashion
4656 boost::shared_ptr<AudioPort> source_port = io->audio (i);
4657 AudioBuffer& buf (bufs.get_audio (i%n_buffers));
4660 if (i < n_buffers) {
4662 /* first time through just copy a channel into
4666 buf.read_from (source_port->get_audio_buffer (nframes), nframes);
4668 if (scaling != 1.0f) {
4669 buf.apply_gain (scaling, nframes);
4674 /* on subsequent times around, merge data from
4675 * the port with what is already there
4678 if (scaling != 1.0f) {
4679 buf.accumulate_with_gain_from (source_port->get_audio_buffer (nframes), nframes, 0, scaling);
4681 buf.accumulate_from (source_port->get_audio_buffer (nframes), nframes);
4686 /* silence any remaining buffers */
4688 for (; i < n_buffers; ++i) {
4689 AudioBuffer& buf (bufs.get_audio (i));
4690 buf.silence (nframes);
4693 /* establish the initial setup of the buffer set, reflecting what was
4694 copied into it. unless, of course, we are the auditioner, in which
4695 case nothing was fed into it from the inputs at all.
4698 if (!is_auditioner()) {
4699 bufs.set_count (io->n_ports());