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"
29 #include <boost/algorithm/string.hpp>
31 #include "pbd/xml++.h"
32 #include "pbd/enumwriter.h"
33 #include "pbd/memento_command.h"
34 #include "pbd/stacktrace.h"
35 #include "pbd/convert.h"
36 #include "pbd/unwind.h"
38 #include "ardour/amp.h"
39 #include "ardour/audio_buffer.h"
40 #include "ardour/audio_track.h"
41 #include "ardour/audio_port.h"
42 #include "ardour/audioengine.h"
43 #include "ardour/boost_debug.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/gain_control.h"
50 #include "ardour/internal_return.h"
51 #include "ardour/internal_send.h"
52 #include "ardour/meter.h"
53 #include "ardour/delayline.h"
54 #include "ardour/midi_buffer.h"
55 #include "ardour/midi_port.h"
56 #include "ardour/monitor_processor.h"
57 #include "ardour/pannable.h"
58 #include "ardour/panner.h"
59 #include "ardour/panner_shell.h"
60 #include "ardour/parameter_descriptor.h"
61 #include "ardour/phase_control.h"
62 #include "ardour/plugin_insert.h"
63 #include "ardour/port.h"
64 #include "ardour/port_insert.h"
65 #include "ardour/processor.h"
66 #include "ardour/profile.h"
67 #include "ardour/route.h"
68 #include "ardour/route_group.h"
69 #include "ardour/send.h"
70 #include "ardour/session.h"
71 #include "ardour/solo_control.h"
72 #include "ardour/solo_isolate_control.h"
73 #include "ardour/unknown_processor.h"
74 #include "ardour/utils.h"
75 #include "ardour/vca.h"
80 using namespace ARDOUR;
83 PBD::Signal3<int,boost::shared_ptr<Route>, boost::shared_ptr<PluginInsert>, Route::PluginSetupOptions > Route::PluginSetup;
85 /** Base class for all routable/mixable objects (tracks and busses) */
86 Route::Route (Session& sess, string name, PresentationInfo::Flag flag, DataType default_type)
87 : Stripable (sess, name, PresentationInfo (flag))
88 , GraphNode (sess._process_graph)
89 , Muteable (sess, name)
93 , _signal_latency_at_amp_position (0)
94 , _signal_latency_at_trim_position (0)
97 , _pending_process_reorder (0)
98 , _pending_signals (0)
99 , _pending_declick (true)
100 , _meter_point (MeterPostFader)
101 , _pending_meter_point (MeterPostFader)
102 , _meter_type (MeterPeak)
103 , _denormal_protection (false)
106 , _declickable (false)
107 , _have_internal_generator (false)
108 , _default_type (default_type)
110 , _in_configure_processors (false)
111 , _initial_io_setup (false)
112 , _in_sidechain_setup (false)
114 , _custom_meter_position_noted (false)
117 processor_max_streams.reset();
123 /* set default meter type */
125 _meter_type = Config->get_meter_type_master ();
127 else if (dynamic_cast<Track*>(this)) {
128 _meter_type = Config->get_meter_type_track ();
130 _meter_type = Config->get_meter_type_bus ();
133 /* add standard controls */
135 _gain_control.reset (new GainControl (_session, GainAutomation));
136 add_control (_gain_control);
138 _trim_control.reset (new GainControl (_session, TrimAutomation));
139 add_control (_trim_control);
141 _solo_control.reset (new SoloControl (_session, X_("solo"), *this, *this));
142 add_control (_solo_control);
143 _solo_control->Changed.connect_same_thread (*this, boost::bind (&Route::solo_control_changed, this, _1, _2));
145 _mute_control.reset (new MuteControl (_session, X_("mute"), *this));
146 add_control (_mute_control);
148 _phase_control.reset (new PhaseControl (_session, X_("phase")));
149 add_control (_phase_control);
151 _solo_isolate_control.reset (new SoloIsolateControl (_session, X_("solo-iso"), *this, *this));
152 add_control (_solo_isolate_control);
154 _solo_safe_control.reset (new SoloSafeControl (_session, X_("solo-safe")));
155 add_control (_solo_safe_control);
159 if (!(_presentation_info.flags() & PresentationInfo::MonitorOut)) {
160 _pannable.reset (new Pannable (_session));
163 /* input and output objects */
165 _input.reset (new IO (_session, _name, IO::Input, _default_type));
166 _output.reset (new IO (_session, _name, IO::Output, _default_type));
168 _input->changed.connect_same_thread (*this, boost::bind (&Route::input_change_handler, this, _1, _2));
169 _input->PortCountChanging.connect_same_thread (*this, boost::bind (&Route::input_port_count_changing, this, _1));
171 _output->changed.connect_same_thread (*this, boost::bind (&Route::output_change_handler, this, _1, _2));
172 _output->PortCountChanging.connect_same_thread (*this, boost::bind (&Route::output_port_count_changing, this, _1));
174 /* add the amp/fader processor.
175 * it should be the first processor to be added on every route.
178 _amp.reset (new Amp (_session, X_("Fader"), _gain_control, true));
179 add_processor (_amp, PostFader);
182 _amp->set_display_name (_("Monitor"));
185 #if 0 // not used - just yet
186 if (!is_master() && !is_monitor() && !is_auditioner()) {
187 _delayline.reset (new DelayLine (_session, _name));
188 add_processor (_delayline, PreFader);
194 _trim.reset (new Amp (_session, X_("Trim"), _trim_control, false));
195 _trim->set_display_to_user (false);
197 if (dynamic_cast<AudioTrack*>(this)) {
198 /* we can't do this in the AudioTrack's constructor
199 * because _trim does not exit then
203 else if (!dynamic_cast<Track*>(this) && ! ( is_monitor() || is_auditioner() )) {
208 /* create standard processors: meter, main outs, monitor out;
209 they will be added to _processors by setup_invisible_processors ()
212 _meter.reset (new PeakMeter (_session, _name));
213 _meter->set_owner (this);
214 _meter->set_display_to_user (false);
217 _main_outs.reset (new Delivery (_session, _output, _pannable, _mute_master, _name, Delivery::Main));
218 _main_outs->activate ();
221 /* where we listen to tracks */
222 _intreturn.reset (new InternalReturn (_session));
223 _intreturn->activate ();
225 /* the thing that provides proper control over a control/monitor/listen bus
226 (such as per-channel cut, dim, solo, invert, etc).
228 _monitor_control.reset (new MonitorProcessor (_session));
229 _monitor_control->activate ();
232 if (is_master() || is_monitor() || is_auditioner()) {
233 _mute_master->set_solo_ignore (true);
236 /* now that we have _meter, its safe to connect to this */
239 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
240 configure_processors (0);
248 DEBUG_TRACE (DEBUG::Destruction, string_compose ("route %1 destructor\n", _name));
250 /* do this early so that we don't get incoming signals as we are going through destruction
255 /* don't use clear_processors here, as it depends on the session which may
256 be half-destroyed by now
259 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
260 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
261 (*i)->drop_references ();
264 _processors.clear ();
268 Route::ensure_track_or_route_name(string name, Session &session)
270 string newname = name;
272 while (!session.io_name_is_legal (newname)) {
273 newname = bump_name_once (newname, ' ');
280 Route::set_trim (gain_t val, Controllable::GroupControlDisposition /* group override */)
282 // TODO route group, see set_gain()
283 // _trim_control->route_set_value (val);
287 Route::maybe_declick (BufferSet&, framecnt_t, int)
289 /* this is the "bus" implementation and they never declick.
294 /** Process this route for one (sub) cycle (process thread)
296 * @param bufs Scratch buffers to use for the signal path
297 * @param start_frame Initial transport frame
298 * @param end_frame Final transport frame
299 * @param nframes Number of frames to output (to ports)
301 * Note that (end_frame - start_frame) may not be equal to nframes when the
302 * transport speed isn't 1.0 (eg varispeed).
305 Route::process_output_buffers (BufferSet& bufs,
306 framepos_t start_frame, framepos_t end_frame, pframes_t nframes,
307 int declick, bool gain_automation_ok)
309 /* Caller must hold process lock */
310 assert (!AudioEngine::instance()->process_lock().trylock());
312 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
314 // can this actually happen? functions calling process_output_buffers()
315 // already take a reader-lock.
316 bufs.silence (nframes, 0);
320 _mute_control->automation_run (start_frame, nframes);
322 /* figure out if we're going to use gain automation */
323 if (gain_automation_ok) {
324 _amp->set_gain_automation_buffer (_session.gain_automation_buffer ());
325 _amp->setup_gain_automation (
326 start_frame + _signal_latency_at_amp_position,
327 end_frame + _signal_latency_at_amp_position,
330 _trim->set_gain_automation_buffer (_session.trim_automation_buffer ());
331 _trim->setup_gain_automation (
332 start_frame + _signal_latency_at_trim_position,
333 end_frame + _signal_latency_at_trim_position,
336 _amp->apply_gain_automation (false);
337 _trim->apply_gain_automation (false);
340 /* Tell main outs what to do about monitoring. We do this so that
341 on a transition between monitoring states we get a de-clicking gain
342 change in the _main_outs delivery, if config.get_use_monitor_fades()
345 We override this in the case where we have an internal generator.
347 bool silence = _have_internal_generator ? false : (monitoring_state () == MonitoringSilence);
349 _main_outs->no_outs_cuz_we_no_monitor (silence);
351 /* -------------------------------------------------------------------------------------------
352 GLOBAL DECLICK (for transport changes etc.)
353 ----------------------------------------------------------------------------------------- */
355 maybe_declick (bufs, nframes, declick);
356 _pending_declick = 0;
358 /* -------------------------------------------------------------------------------------------
359 DENORMAL CONTROL/PHASE INVERT
360 ----------------------------------------------------------------------------------------- */
362 if (!_phase_control->none()) {
366 if (_denormal_protection || Config->get_denormal_protection()) {
368 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
369 Sample* const sp = i->data();
371 if (_phase_control->inverted (chn)) {
372 for (pframes_t nx = 0; nx < nframes; ++nx) {
377 for (pframes_t nx = 0; nx < nframes; ++nx) {
385 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
386 Sample* const sp = i->data();
388 if (_phase_control->inverted (chn)) {
389 for (pframes_t nx = 0; nx < nframes; ++nx) {
398 if (_denormal_protection || Config->get_denormal_protection()) {
400 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
401 Sample* const sp = i->data();
402 for (pframes_t nx = 0; nx < nframes; ++nx) {
410 /* -------------------------------------------------------------------------------------------
412 ----------------------------------------------------------------------------------------- */
414 /* set this to be true if the meter will already have been ::run() earlier */
415 bool const meter_already_run = metering_state() == MeteringInput;
417 framecnt_t latency = 0;
418 const double speed = _session.transport_speed ();
420 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
422 if (meter_already_run && boost::dynamic_pointer_cast<PeakMeter> (*i)) {
423 /* don't ::run() the meter, otherwise it will have its previous peak corrupted */
428 /* if it has any inputs, make sure they match */
429 if (boost::dynamic_pointer_cast<UnknownProcessor> (*i) == 0 && (*i)->input_streams() != ChanCount::ZERO) {
430 if (bufs.count() != (*i)->input_streams()) {
432 DEBUG::Processors, string_compose (
433 "input port mismatch %1 bufs = %2 input for %3 = %4\n",
434 _name, bufs.count(), (*i)->name(), (*i)->input_streams()
441 /* should we NOT run plugins here if the route is inactive?
442 do we catch route != active somewhere higher?
445 if (boost::dynamic_pointer_cast<Send>(*i) != 0) {
446 boost::dynamic_pointer_cast<Send>(*i)->set_delay_in(_signal_latency - latency);
448 if (boost::dynamic_pointer_cast<PluginInsert>(*i) != 0) {
449 const framecnt_t longest_session_latency = _initial_delay + _signal_latency;
450 boost::dynamic_pointer_cast<PluginInsert>(*i)->set_sidechain_latency (
451 _initial_delay + latency, longest_session_latency - latency);
454 (*i)->run (bufs, start_frame - latency, end_frame - latency, speed, nframes, *i != _processors.back());
455 bufs.set_count ((*i)->output_streams());
457 if ((*i)->active ()) {
458 latency += (*i)->signal_latency ();
464 Route::bounce_process (BufferSet& buffers, framepos_t start, framecnt_t nframes,
465 boost::shared_ptr<Processor> endpoint,
466 bool include_endpoint, bool for_export, bool for_freeze)
468 /* If no processing is required, there's no need to go any further. */
469 if (!endpoint && !include_endpoint) {
473 framecnt_t latency = bounce_get_latency(_amp, false, for_export, for_freeze);
474 _amp->set_gain_automation_buffer (_session.gain_automation_buffer ());
475 _amp->setup_gain_automation (start - latency, start - latency + nframes, nframes);
477 /* trim is always at the top, for bounce no latency compensation is needed */
478 _trim->set_gain_automation_buffer (_session.trim_automation_buffer ());
479 _trim->setup_gain_automation (start, start + nframes, nframes);
482 const double speed = _session.transport_speed ();
483 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
485 if (!include_endpoint && (*i) == endpoint) {
489 /* if we're *not* exporting, stop processing if we come across a routing processor. */
490 if (!for_export && boost::dynamic_pointer_cast<PortInsert>(*i)) {
493 if (!for_export && for_freeze && (*i)->does_routing() && (*i)->active()) {
497 /* special case the panner (export outputs)
498 * Ideally we'd only run the panner, not the delivery itself...
499 * but panners need separate input/output buffers and some context
500 * (panshell, panner type, etc). AFAICT there is no ill side effect
501 * of re-using the main delivery when freewheeling/exporting a region.
503 if ((*i) == _main_outs) {
504 assert ((*i)->does_routing());
505 (*i)->run (buffers, start - latency, start - latency + nframes, speed, nframes, true);
506 buffers.set_count ((*i)->output_streams());
509 /* don't run any processors that do routing.
510 * Also don't bother with metering.
512 if (!(*i)->does_routing() && !boost::dynamic_pointer_cast<PeakMeter>(*i)) {
513 (*i)->run (buffers, start - latency, start - latency + nframes, 1.0, nframes, true);
514 buffers.set_count ((*i)->output_streams());
515 latency += (*i)->signal_latency ();
518 if ((*i) == endpoint) {
525 Route::bounce_get_latency (boost::shared_ptr<Processor> endpoint,
526 bool include_endpoint, bool for_export, bool for_freeze) const
528 framecnt_t latency = 0;
529 if (!endpoint && !include_endpoint) {
533 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
534 if (!include_endpoint && (*i) == endpoint) {
537 if (!for_export && boost::dynamic_pointer_cast<PortInsert>(*i)) {
540 if (!for_export && for_freeze && (*i)->does_routing() && (*i)->active()) {
543 if (!(*i)->does_routing() && !boost::dynamic_pointer_cast<PeakMeter>(*i)) {
544 latency += (*i)->signal_latency ();
546 if ((*i) == endpoint) {
554 Route::bounce_get_output_streams (ChanCount &cc, boost::shared_ptr<Processor> endpoint,
555 bool include_endpoint, bool for_export, bool for_freeze) const
557 if (!endpoint && !include_endpoint) {
561 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
562 if (!include_endpoint && (*i) == endpoint) {
565 if (!for_export && boost::dynamic_pointer_cast<PortInsert>(*i)) {
568 if (!for_export && for_freeze && (*i)->does_routing() && (*i)->active()) {
571 if (!(*i)->does_routing() && !boost::dynamic_pointer_cast<PeakMeter>(*i)) {
572 cc = (*i)->output_streams();
574 if ((*i) == endpoint) {
582 Route::n_process_buffers ()
584 return max (_input->n_ports(), processor_max_streams);
588 Route::monitor_run (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
590 assert (is_monitor());
591 BufferSet& bufs (_session.get_route_buffers (n_process_buffers()));
592 fill_buffers_with_input (bufs, _input, nframes);
593 passthru (bufs, start_frame, end_frame, nframes, declick);
597 Route::passthru (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
601 if (is_monitor() && _session.listening() && !_session.is_auditioning()) {
603 /* control/monitor bus ignores input ports when something is
604 feeding the listen "stream". data will "arrive" into the
605 route from the intreturn processor element.
608 bufs.silence (nframes, 0);
611 write_out_of_band_data (bufs, start_frame, end_frame, nframes);
612 process_output_buffers (bufs, start_frame, end_frame, nframes, declick, true);
616 Route::passthru_silence (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
618 BufferSet& bufs (_session.get_route_buffers (n_process_buffers(), true));
620 bufs.set_count (_input->n_ports());
621 write_out_of_band_data (bufs, start_frame, end_frame, nframes);
622 process_output_buffers (bufs, start_frame, end_frame, nframes, declick, false);
626 Route::set_listen (bool yn)
630 _monitor_send->activate ();
632 _monitor_send->deactivate ();
638 Route::solo_control_changed (bool, Controllable::GroupControlDisposition)
640 /* nothing to do if we're not using AFL/PFL. But if we are, we need
641 to alter the active state of the monitor send.
644 if (Config->get_solo_control_is_listen_control ()) {
645 set_listen (_solo_control->self_soloed() || _solo_control->get_masters_value());
650 Route::push_solo_isolate_upstream (int32_t delta)
652 /* forward propagate solo-isolate status to everything fed by this route, but not those via sends only */
654 boost::shared_ptr<RouteList> routes = _session.get_routes ();
655 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
657 if ((*i).get() == this || !(*i)->can_solo()) {
662 bool does_feed = feeds (*i, &sends_only);
664 if (does_feed && !sends_only) {
665 (*i)->solo_isolate_control()->mod_solo_isolated_by_upstream (delta);
671 Route::push_solo_upstream (int delta)
673 DEBUG_TRACE (DEBUG::Solo, string_compose("\t ... INVERT push from %1\n", _name));
674 for (FedBy::iterator i = _fed_by.begin(); i != _fed_by.end(); ++i) {
678 boost::shared_ptr<Route> sr (i->r.lock());
680 sr->solo_control()->mod_solo_by_others_downstream (-delta);
687 dump_processors(const string& name, const list<boost::shared_ptr<Processor> >& procs)
689 cerr << name << " {" << endl;
690 for (list<boost::shared_ptr<Processor> >::const_iterator p = procs.begin();
691 p != procs.end(); ++p) {
692 cerr << "\t" << (*p)->name() << " ID = " << (*p)->id() << " @ " << (*p) << endl;
698 /** Supposing that we want to insert a Processor at a given Placement, return
699 * the processor to add the new one before (or 0 to add at the end).
701 boost::shared_ptr<Processor>
702 Route::before_processor_for_placement (Placement p)
704 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
706 ProcessorList::iterator loc;
709 /* generic pre-fader: insert immediately before the amp */
710 loc = find (_processors.begin(), _processors.end(), _amp);
712 /* generic post-fader: insert right before the main outs */
713 loc = find (_processors.begin(), _processors.end(), _main_outs);
716 return loc != _processors.end() ? *loc : boost::shared_ptr<Processor> ();
719 /** Supposing that we want to insert a Processor at a given index, return
720 * the processor to add the new one before (or 0 to add at the end).
722 boost::shared_ptr<Processor>
723 Route::before_processor_for_index (int index)
726 return boost::shared_ptr<Processor> ();
729 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
731 ProcessorList::iterator i = _processors.begin ();
733 while (i != _processors.end() && j < index) {
734 if ((*i)->display_to_user()) {
741 return (i != _processors.end() ? *i : boost::shared_ptr<Processor> ());
744 /** Add a processor either pre- or post-fader
745 * @return 0 on success, non-0 on failure.
748 Route::add_processor (boost::shared_ptr<Processor> processor, Placement placement, ProcessorStreams* err, bool activation_allowed)
750 return add_processor (processor, before_processor_for_placement (placement), err, activation_allowed);
754 /** Add a processor to a route such that it ends up with a given index into the visible processors.
755 * @param index Index to add the processor at, or -1 to add at the end of the list.
756 * @return 0 on success, non-0 on failure.
759 Route::add_processor_by_index (boost::shared_ptr<Processor> processor, int index, ProcessorStreams* err, bool activation_allowed)
761 return add_processor (processor, before_processor_for_index (index), err, activation_allowed);
764 /** Add a processor to the route.
765 * @param before An existing processor in the list, or 0; the new processor will be inserted immediately before it (or at the end).
766 * @return 0 on success, non-0 on failure.
769 Route::add_processor (boost::shared_ptr<Processor> processor, boost::shared_ptr<Processor> before, ProcessorStreams* err, bool activation_allowed)
771 assert (processor != _meter);
772 assert (processor != _main_outs);
774 DEBUG_TRACE (DEBUG::Processors, string_compose (
775 "%1 adding processor %2\n", name(), processor->name()));
779 pl.push_back (processor);
780 int rv = add_processors (pl, before, err);
786 if (activation_allowed && (!_session.get_bypass_all_loaded_plugins () || !processor->display_to_user ())) {
787 processor->activate ();
794 Route::processor_selfdestruct (boost::weak_ptr<Processor> wp)
796 /* We cannot destruct the processor here (usually RT-thread
797 * with various locks held - in case of sends also io_locks).
798 * Queue for deletion in low-priority thread.
800 Glib::Threads::Mutex::Lock lx (selfdestruct_lock);
801 selfdestruct_sequence.push_back (wp);
805 Route::add_processor_from_xml_2X (const XMLNode& node, int version)
807 XMLProperty const * prop;
810 boost::shared_ptr<Processor> processor;
812 /* bit of a hack: get the `placement' property from the <Redirect> tag here
813 so that we can add the processor in the right place (pre/post-fader)
816 XMLNodeList const & children = node.children ();
817 XMLNodeList::const_iterator i = children.begin ();
819 while (i != children.end() && (*i)->name() != X_("Redirect")) {
823 Placement placement = PreFader;
825 if (i != children.end()) {
826 if ((prop = (*i)->property (X_("placement"))) != 0) {
827 placement = Placement (string_2_enum (prop->value(), placement));
831 if (node.name() == "Insert") {
833 if ((prop = node.property ("type")) != 0) {
835 if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
836 prop->value() == "lv2" ||
837 prop->value() == "windows-vst" ||
838 prop->value() == "lxvst" ||
839 prop->value() == "audiounit") {
841 if (_session.get_disable_all_loaded_plugins ()) {
842 processor.reset (new UnknownProcessor (_session, node));
844 processor.reset (new PluginInsert (_session));
845 processor->set_owner (this);
850 processor.reset (new PortInsert (_session, _pannable, _mute_master));
855 } else if (node.name() == "Send") {
857 boost::shared_ptr<Pannable> sendpan (new Pannable (_session));
858 processor.reset (new Send (_session, sendpan, _mute_master));
862 error << string_compose(_("unknown Processor type \"%1\"; ignored"), node.name()) << endmsg;
866 if (processor->set_state (node, version)) {
870 //A2 uses the "active" flag in the toplevel redirect node, not in the child plugin/IO
871 if (i != children.end()) {
872 if ((prop = (*i)->property (X_("active"))) != 0) {
873 if ( string_is_affirmative (prop->value()) && (!_session.get_bypass_all_loaded_plugins () || !processor->display_to_user () ) )
874 processor->activate();
876 processor->deactivate();
880 return (add_processor (processor, placement, 0, false) == 0);
883 catch (failed_constructor &err) {
884 warning << _("processor could not be created. Ignored.") << endmsg;
890 inline Route::PluginSetupOptions operator|= (Route::PluginSetupOptions& a, const Route::PluginSetupOptions& b) {
891 return a = static_cast<Route::PluginSetupOptions> (static_cast <int>(a) | static_cast<int> (b));
894 inline Route::PluginSetupOptions operator&= (Route::PluginSetupOptions& a, const Route::PluginSetupOptions& b) {
895 return a = static_cast<Route::PluginSetupOptions> (static_cast <int>(a) & static_cast<int> (b));
899 Route::add_processors (const ProcessorList& others, boost::shared_ptr<Processor> before, ProcessorStreams* err)
901 ProcessorList::iterator loc;
904 loc = find(_processors.begin(), _processors.end(), before);
905 if (loc == _processors.end ()) {
909 /* nothing specified - at end */
910 loc = _processors.end ();
913 if (!AudioEngine::instance()->connected()) {
917 if (others.empty()) {
921 ProcessorList to_skip;
923 // check if there's an instrument to replace or configure
924 for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
925 boost::shared_ptr<PluginInsert> pi;
926 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) == 0) {
929 if (!pi->plugin ()->get_info ()->is_instrument ()) {
932 boost::shared_ptr<Processor> instrument = the_instrument ();
933 ChanCount in (DataType::MIDI, 1);
934 ChanCount out (DataType::AUDIO, 2); // XXX route's out?!
936 PluginSetupOptions flags = None;
939 in = instrument->input_streams ();
940 out = instrument->output_streams ();
942 if (pi->has_output_presets (in, out)) {
946 pi->set_strict_io (_strict_io);
948 PluginSetupOptions mask = None;
949 if (Config->get_ask_replace_instrument ()) {
952 if (Config->get_ask_setup_instrument ()) {
959 boost::optional<int> rv = PluginSetup (shared_from_this (), pi, flags); /* EMIT SIGNAL */
960 switch (rv.get_value_or (0)) {
962 to_skip.push_back (*i); // don't add this one;
965 replace_processor (instrument, *i, err);
966 to_skip.push_back (*i);
975 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
976 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
977 ProcessorState pstate (this);
979 for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
984 ProcessorList::iterator check = find (to_skip.begin(), to_skip.end(), *i);
985 if (check != to_skip.end()) {
989 boost::shared_ptr<PluginInsert> pi;
991 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
992 pi->set_strict_io (_strict_io);
996 /* Ensure that only one amp is in the list at any time */
997 ProcessorList::iterator check = find (_processors.begin(), _processors.end(), *i);
998 if (check != _processors.end()) {
999 if (before == _amp) {
1000 /* Already in position; all is well */
1003 _processors.erase (check);
1008 assert (find (_processors.begin(), _processors.end(), *i) == _processors.end ());
1010 _processors.insert (loc, *i);
1011 (*i)->set_owner (this);
1014 if (configure_processors_unlocked (err, &lm)) {
1016 configure_processors_unlocked (0, &lm); // it worked before we tried to add it ...
1021 if ((*i)->active()) {
1025 (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
1027 boost::shared_ptr<Send> send;
1028 if ((send = boost::dynamic_pointer_cast<Send> (*i))) {
1029 send->SelfDestruct.connect_same_thread (*this,
1030 boost::bind (&Route::processor_selfdestruct, this, boost::weak_ptr<Processor> (*i)));
1034 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
1035 boost::shared_ptr<PluginInsert> pi;
1037 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1038 if (pi->has_no_inputs ()) {
1039 _have_internal_generator = true;
1045 _output->set_user_latency (0);
1048 reset_instrument_info ();
1049 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1050 set_processor_positions ();
1056 Route::placement_range(Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end)
1058 if (p == PreFader) {
1059 start = _processors.begin();
1060 end = find(_processors.begin(), _processors.end(), _amp);
1062 start = find(_processors.begin(), _processors.end(), _amp);
1064 end = _processors.end();
1068 /** Turn off all processors with a given placement
1069 * @param p Placement of processors to disable
1072 Route::disable_processors (Placement p)
1074 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1076 ProcessorList::iterator start, end;
1077 placement_range(p, start, end);
1079 for (ProcessorList::iterator i = start; i != end; ++i) {
1080 (*i)->deactivate ();
1083 _session.set_dirty ();
1086 /** Turn off all redirects
1089 Route::disable_processors ()
1091 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1093 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1094 (*i)->deactivate ();
1097 _session.set_dirty ();
1100 /** Turn off all redirects with a given placement
1101 * @param p Placement of redirects to disable
1104 Route::disable_plugins (Placement p)
1106 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1108 ProcessorList::iterator start, end;
1109 placement_range(p, start, end);
1111 for (ProcessorList::iterator i = start; i != end; ++i) {
1112 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1113 (*i)->deactivate ();
1117 _session.set_dirty ();
1120 /** Turn off all plugins
1123 Route::disable_plugins ()
1125 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1127 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1128 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1129 (*i)->deactivate ();
1133 _session.set_dirty ();
1138 Route::ab_plugins (bool forward)
1140 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1144 /* forward = turn off all active redirects, and mark them so that the next time
1145 we go the other way, we will revert them
1148 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1149 if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1153 if ((*i)->active()) {
1154 (*i)->deactivate ();
1155 (*i)->set_next_ab_is_active (true);
1157 (*i)->set_next_ab_is_active (false);
1163 /* backward = if the redirect was marked to go active on the next ab, do so */
1165 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1167 if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1171 if ((*i)->get_next_ab_is_active()) {
1174 (*i)->deactivate ();
1179 _session.set_dirty ();
1183 /** Remove processors with a given placement.
1184 * @param p Placement of processors to remove.
1187 Route::clear_processors (Placement p)
1189 if (!_session.engine().connected()) {
1193 bool already_deleting = _session.deletion_in_progress();
1194 if (!already_deleting) {
1195 _session.set_deletion_in_progress();
1199 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1200 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1201 ProcessorList new_list;
1202 ProcessorStreams err;
1203 bool seen_amp = false;
1205 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1211 if ((*i) == _amp || (*i) == _meter || (*i) == _main_outs || (*i) == _delayline || (*i) == _trim) {
1213 /* you can't remove these */
1215 new_list.push_back (*i);
1222 new_list.push_back (*i);
1225 (*i)->drop_references ();
1233 (*i)->drop_references ();
1236 new_list.push_back (*i);
1243 _processors = new_list;
1244 configure_processors_unlocked (&err, &lm); // this can't fail
1247 processor_max_streams.reset();
1248 _have_internal_generator = false;
1249 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1250 set_processor_positions ();
1252 reset_instrument_info ();
1254 if (!already_deleting) {
1255 _session.clear_deletion_in_progress();
1260 Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err, bool need_process_lock)
1262 // TODO once the export point can be configured properly, do something smarter here
1263 if (processor == _capturing_processor) {
1264 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1265 if (need_process_lock) {
1269 _capturing_processor.reset();
1271 if (need_process_lock) {
1276 /* these can never be removed */
1278 if (processor == _amp || processor == _meter || processor == _main_outs || processor == _delayline || processor == _trim) {
1282 if (!_session.engine().connected()) {
1286 processor_max_streams.reset();
1289 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1290 if (need_process_lock) {
1294 /* Caller must hold process lock */
1295 assert (!AudioEngine::instance()->process_lock().trylock());
1297 Glib::Threads::RWLock::WriterLock lm (_processor_lock); // XXX deadlock after export
1299 ProcessorState pstate (this);
1301 ProcessorList::iterator i;
1302 bool removed = false;
1304 for (i = _processors.begin(); i != _processors.end(); ) {
1305 if (*i == processor) {
1307 /* move along, see failure case for configure_processors()
1308 where we may need to reconfigure the processor.
1311 /* stop redirects that send signals to JACK ports
1312 from causing noise as a result of no longer being
1316 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
1317 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*i);
1321 iop = pi->sidechain();
1328 i = _processors.erase (i);
1336 _output->set_user_latency (0);
1344 if (configure_processors_unlocked (err, &lm)) {
1346 /* we know this will work, because it worked before :) */
1347 configure_processors_unlocked (0, &lm);
1351 _have_internal_generator = false;
1353 for (i = _processors.begin(); i != _processors.end(); ++i) {
1354 boost::shared_ptr<PluginInsert> pi;
1356 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1357 if (pi->has_no_inputs ()) {
1358 _have_internal_generator = true;
1363 if (need_process_lock) {
1368 reset_instrument_info ();
1369 processor->drop_references ();
1370 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1371 set_processor_positions ();
1377 Route::replace_processor (boost::shared_ptr<Processor> old, boost::shared_ptr<Processor> sub, ProcessorStreams* err)
1379 /* these can never be removed */
1380 if (old == _amp || old == _meter || old == _main_outs || old == _delayline || old == _trim) {
1383 /* and can't be used as substitute, either */
1384 if (sub == _amp || sub == _meter || sub == _main_outs || sub == _delayline || sub == _trim) {
1388 /* I/Os are out, too */
1389 if (boost::dynamic_pointer_cast<IOProcessor> (old) || boost::dynamic_pointer_cast<IOProcessor> (sub)) {
1393 /* this function cannot be used to swap/reorder processors */
1394 if (find (_processors.begin(), _processors.end(), sub) != _processors.end ()) {
1398 if (!AudioEngine::instance()->connected() || !old || !sub) {
1402 /* ensure that sub is not owned by another route */
1403 if (sub->owner ()) {
1408 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1409 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1410 ProcessorState pstate (this);
1412 assert (find (_processors.begin(), _processors.end(), sub) == _processors.end ());
1414 ProcessorList::iterator i;
1415 bool replaced = false;
1416 bool enable = old->active ();
1418 for (i = _processors.begin(); i != _processors.end(); ) {
1420 i = _processors.erase (i);
1421 _processors.insert (i, sub);
1422 sub->set_owner (this);
1435 boost::shared_ptr<PluginInsert> pi;
1436 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(sub)) != 0) {
1437 pi->set_strict_io (true);
1441 if (configure_processors_unlocked (err, &lm)) {
1443 configure_processors_unlocked (0, &lm);
1447 _have_internal_generator = false;
1449 for (i = _processors.begin(); i != _processors.end(); ++i) {
1450 boost::shared_ptr<PluginInsert> pi;
1451 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1452 if (pi->has_no_inputs ()) {
1453 _have_internal_generator = true;
1463 sub->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
1464 _output->set_user_latency (0);
1467 reset_instrument_info ();
1468 old->drop_references ();
1469 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1470 set_processor_positions ();
1475 Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
1477 ProcessorList deleted;
1479 if (!_session.engine().connected()) {
1483 processor_max_streams.reset();
1486 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1487 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1488 ProcessorState pstate (this);
1490 ProcessorList::iterator i;
1491 boost::shared_ptr<Processor> processor;
1493 for (i = _processors.begin(); i != _processors.end(); ) {
1497 /* these can never be removed */
1499 if (processor == _amp || processor == _meter || processor == _main_outs || processor == _delayline || processor == _trim) {
1504 /* see if its in the list of processors to delete */
1506 if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
1511 /* stop IOProcessors that send to JACK ports
1512 from causing noise as a result of no longer being
1516 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(processor);
1517 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(processor);
1520 iop = pi->sidechain();
1527 deleted.push_back (processor);
1528 i = _processors.erase (i);
1531 if (deleted.empty()) {
1532 /* none of those in the requested list were found */
1536 _output->set_user_latency (0);
1538 if (configure_processors_unlocked (err, &lm)) {
1540 /* we know this will work, because it worked before :) */
1541 configure_processors_unlocked (0, &lm);
1546 _have_internal_generator = false;
1548 for (i = _processors.begin(); i != _processors.end(); ++i) {
1549 boost::shared_ptr<PluginInsert> pi;
1551 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1552 if (pi->has_no_inputs ()) {
1553 _have_internal_generator = true;
1560 /* now try to do what we need to so that those that were removed will be deleted */
1562 for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
1563 (*i)->drop_references ();
1566 reset_instrument_info ();
1567 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1568 set_processor_positions ();
1574 Route::reset_instrument_info ()
1576 boost::shared_ptr<Processor> instr = the_instrument();
1578 _instrument_info.set_internal_instrument (instr);
1582 /** Caller must hold process lock */
1584 Route::configure_processors (ProcessorStreams* err)
1586 #ifndef PLATFORM_WINDOWS
1587 assert (!AudioEngine::instance()->process_lock().trylock());
1590 if (!_in_configure_processors) {
1591 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1592 return configure_processors_unlocked (err, &lm);
1599 Route::input_streams () const
1601 return _input->n_ports ();
1604 list<pair<ChanCount, ChanCount> >
1605 Route::try_configure_processors (ChanCount in, ProcessorStreams* err)
1607 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1609 return try_configure_processors_unlocked (in, err);
1612 list<pair<ChanCount, ChanCount> >
1613 Route::try_configure_processors_unlocked (ChanCount in, ProcessorStreams* err)
1615 // Check each processor in order to see if we can configure as requested
1617 list<pair<ChanCount, ChanCount> > configuration;
1620 DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
1621 DEBUG_TRACE (DEBUG::Processors, "{\n");
1623 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1625 if ((*p)->can_support_io_configuration(in, out)) {
1627 if (boost::dynamic_pointer_cast<Delivery> (*p)
1628 && boost::dynamic_pointer_cast<Delivery> (*p)->role() == Delivery::Main
1630 && (is_monitor() || _strict_io || Profile->get_mixbus ())) {
1631 /* with strict I/O the panner + output are forced to
1632 * follow the last processor's output.
1634 * Delivery::can_support_io_configuration() will only add ports,
1635 * but not remove excess ports.
1637 * This works because the delivery only requires
1638 * as many outputs as there are inputs.
1639 * Delivery::configure_io() will do the actual removal
1640 * by calling _output->ensure_io()
1642 if (!is_master() && _session.master_out ()) {
1643 /* ..but at least as many as there are master-inputs */
1644 // XXX this may need special-casing for mixbus (master-outputs)
1645 // and should maybe be a preference anyway ?!
1646 out = ChanCount::max (in, _session.master_out ()->n_inputs ());
1652 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID=%2 in=%3 out=%4\n",(*p)->name(), (*p)->id(), in, out));
1653 configuration.push_back(make_pair(in, out));
1656 // restriction for Monitor Section Processors
1657 if (in.n_audio() != out.n_audio() || out.n_midi() > 0) {
1658 /* do not allow to add/remove channels (for now)
1659 * The Monitor follows the master-bus and has no panner (unpan)
1660 * but do allow processors with midi-in to be added (e.g VSTs with control that
1661 * will remain unconnected)
1663 DEBUG_TRACE (DEBUG::Processors, "Monitor: Channel configuration not allowed.\n");
1664 return list<pair<ChanCount, ChanCount> > ();
1666 if (boost::dynamic_pointer_cast<InternalSend> (*p)) {
1667 // internal sends make no sense, only feedback
1668 DEBUG_TRACE (DEBUG::Processors, "Monitor: No Sends allowed.\n");
1669 return list<pair<ChanCount, ChanCount> > ();
1671 if (boost::dynamic_pointer_cast<PortInsert> (*p)) {
1672 /* External Sends can be problematic. one can add/remove ports
1673 * there signal leaves the DAW to external monitors anyway, so there's
1674 * no real use for allowing them here anyway.
1676 DEBUG_TRACE (DEBUG::Processors, "Monitor: No External Sends allowed.\n");
1677 return list<pair<ChanCount, ChanCount> > ();
1679 if (boost::dynamic_pointer_cast<Send> (*p)) {
1681 DEBUG_TRACE (DEBUG::Processors, "Monitor: No Sends allowed.\n");
1682 return list<pair<ChanCount, ChanCount> > ();
1691 DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
1692 DEBUG_TRACE (DEBUG::Processors, string_compose ("---- %1 cannot support in=%2 out=%3\n", (*p)->name(), in, out));
1693 DEBUG_TRACE (DEBUG::Processors, "}\n");
1694 return list<pair<ChanCount, ChanCount> > ();
1698 DEBUG_TRACE (DEBUG::Processors, "}\n");
1700 return configuration;
1703 /** Set the input/output configuration of each processor in the processors list.
1704 * Caller must hold process lock.
1705 * Return 0 on success, otherwise configuration is impossible.
1708 Route::configure_processors_unlocked (ProcessorStreams* err, Glib::Threads::RWLock::WriterLock* lm)
1710 #ifndef PLATFORM_WINDOWS
1711 assert (!AudioEngine::instance()->process_lock().trylock());
1714 if (_in_configure_processors) {
1718 /* put invisible processors where they should be */
1719 setup_invisible_processors ();
1721 _in_configure_processors = true;
1723 list<pair<ChanCount, ChanCount> > configuration = try_configure_processors_unlocked (input_streams (), err);
1725 if (configuration.empty ()) {
1726 _in_configure_processors = false;
1731 bool seen_mains_out = false;
1732 processor_out_streams = _input->n_ports();
1733 processor_max_streams.reset();
1735 /* processor configure_io() may result in adding ports
1736 * e.g. Delivery::configure_io -> ARDOUR::IO::ensure_io ()
1738 * with jack2 adding ports results in a graph-order callback,
1739 * which calls Session::resort_routes() and eventually
1740 * Route::direct_feeds_according_to_reality()
1741 * which takes a ReaderLock (_processor_lock).
1743 * so we can't hold a WriterLock here until jack2 threading
1746 * NB. we still hold the process lock
1748 * (ardour's own engines do call graph-order from the
1749 * process-thread and hence do not have this issue; besides
1750 * merely adding ports won't trigger a graph-order, only
1751 * making connections does)
1755 // TODO check for a potential ReaderLock after ReaderLock ??
1756 Glib::Threads::RWLock::ReaderLock lr (_processor_lock);
1758 list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1759 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1761 if (!(*p)->configure_io(c->first, c->second)) {
1762 DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration failed\n", _name));
1763 _in_configure_processors = false;
1768 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1769 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1771 boost::shared_ptr<IOProcessor> iop;
1772 boost::shared_ptr<PluginInsert> pi;
1773 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
1774 /* plugins connected via Split or Hide Match may have more channels.
1775 * route/scratch buffers are needed for all of them
1776 * The configuration may only be a subset (both input and output)
1778 processor_max_streams = ChanCount::max(processor_max_streams, pi->required_buffers());
1780 else if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*p)) != 0) {
1781 processor_max_streams = ChanCount::max(processor_max_streams, iop->natural_input_streams());
1782 processor_max_streams = ChanCount::max(processor_max_streams, iop->natural_output_streams());
1786 if (boost::dynamic_pointer_cast<Delivery> (*p)
1787 && boost::dynamic_pointer_cast<Delivery> (*p)->role() == Delivery::Main) {
1788 /* main delivery will increase port count to match input.
1789 * the Delivery::Main is usually the last processor - followed only by
1792 seen_mains_out = true;
1794 if (!seen_mains_out) {
1795 processor_out_streams = out;
1804 _meter->set_max_channels (processor_max_streams);
1807 /* make sure we have sufficient scratch buffers to cope with the new processor
1810 _session.ensure_buffers (n_process_buffers ());
1812 DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
1814 _in_configure_processors = false;
1818 /** Set all visible processors to a given active state (except Fader, whose state is not changed)
1819 * @param state New active state for those processors.
1822 Route::all_visible_processors_active (bool state)
1824 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1826 if (_processors.empty()) {
1830 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1831 if (!(*i)->display_to_user() || boost::dynamic_pointer_cast<Amp> (*i)) {
1838 (*i)->deactivate ();
1842 _session.set_dirty ();
1846 Route::processors_reorder_needs_configure (const ProcessorList& new_order)
1848 /* check if re-order requires re-configuration of any processors
1849 * -> compare channel configuration for all processors
1851 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1852 ChanCount c = input_streams ();
1854 for (ProcessorList::const_iterator j = new_order.begin(); j != new_order.end(); ++j) {
1856 if (c != (*j)->input_streams()) {
1859 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
1862 if ((*i)->input_streams() != c) {
1865 c = (*i)->output_streams();
1877 __attribute__((annotate("realtime")))
1880 Route::apply_processor_order (const ProcessorList& new_order)
1882 /* need to hold processor_lock; either read or write lock
1883 * and the engine process_lock.
1884 * Due to r/w lock ambiguity we can only assert the latter
1886 assert (!AudioEngine::instance()->process_lock().trylock());
1889 /* "new_order" is an ordered list of processors to be positioned according to "placement".
1890 * NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
1891 * processors in the current actual processor list that are hidden. Any visible processors
1892 * in the current list but not in "new_order" will be assumed to be deleted.
1895 /* "as_it_will_be" and "_processors" are lists of shared pointers.
1896 * actual memory usage is small, but insert/erase is not actually rt-safe :(
1897 * (note though that ::processors_reorder_needs_configure() ensured that
1898 * this function will only ever be called from the rt-thread if no processor were removed)
1900 * either way, I can't proove it, but an x-run due to re-order here is less likley
1901 * than an x-run-less 'ardour-silent cycle' both of which effectively "click".
1904 ProcessorList as_it_will_be;
1905 ProcessorList::iterator oiter;
1906 ProcessorList::const_iterator niter;
1908 oiter = _processors.begin();
1909 niter = new_order.begin();
1911 while (niter != new_order.end()) {
1913 /* if the next processor in the old list is invisible (i.e. should not be in the new order)
1914 then append it to the temp list.
1916 Otherwise, see if the next processor in the old list is in the new list. if not,
1917 its been deleted. If its there, append it to the temp list.
1920 if (oiter == _processors.end()) {
1922 /* no more elements in the old list, so just stick the rest of
1923 the new order onto the temp list.
1926 as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
1927 while (niter != new_order.end()) {
1934 if (!(*oiter)->display_to_user()) {
1936 as_it_will_be.push_back (*oiter);
1940 /* visible processor: check that its in the new order */
1942 if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
1943 /* deleted: do nothing, shared_ptr<> will clean up */
1945 /* ignore this one, and add the next item from the new order instead */
1946 as_it_will_be.push_back (*niter);
1951 /* now remove from old order - its taken care of no matter what */
1952 oiter = _processors.erase (oiter);
1956 _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
1958 /* If the meter is in a custom position, find it and make a rough note of its position */
1959 maybe_note_meter_position ();
1963 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
1965 // it a change is already queued, wait for it
1966 // (unless engine is stopped. apply immediately and proceed
1967 while (g_atomic_int_get (&_pending_process_reorder)) {
1968 if (!AudioEngine::instance()->running()) {
1969 DEBUG_TRACE (DEBUG::Processors, "offline apply queued processor re-order.\n");
1970 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1972 apply_processor_order(_pending_processor_order);
1973 setup_invisible_processors ();
1975 g_atomic_int_set (&_pending_process_reorder, 0);
1977 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1978 set_processor_positions ();
1980 // TODO rather use a semaphore or something.
1981 // but since ::reorder_processors() is called
1982 // from the GUI thread, this is fine..
1987 if (processors_reorder_needs_configure (new_order) || !AudioEngine::instance()->running()) {
1989 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1990 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1991 ProcessorState pstate (this);
1993 apply_processor_order (new_order);
1995 if (configure_processors_unlocked (err, &lm)) {
2003 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2004 set_processor_positions ();
2007 DEBUG_TRACE (DEBUG::Processors, "Queue clickless processor re-order.\n");
2008 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2010 // _pending_processor_order is protected by _processor_lock
2011 _pending_processor_order = new_order;
2012 g_atomic_int_set (&_pending_process_reorder, 1);
2019 Route::add_remove_sidechain (boost::shared_ptr<Processor> proc, bool add)
2021 boost::shared_ptr<PluginInsert> pi;
2022 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
2026 if (pi->has_sidechain () == add) {
2027 return true; // ?? call failed, but result is as expected.
2031 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2032 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), proc);
2033 if (i == _processors.end ()) {
2039 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ()); // take before Writerlock to avoid deadlock
2040 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2041 PBD::Unwinder<bool> uw (_in_sidechain_setup, true);
2043 lx.release (); // IO::add_port() and ~IO takes process lock - XXX check if this is safe
2045 if (!pi->add_sidechain ()) {
2049 if (!pi->del_sidechain ()) {
2055 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2060 pi->del_sidechain ();
2062 pi->add_sidechain ();
2063 // TODO restore side-chain's state.
2068 configure_processors_unlocked (0, &lm);
2071 if (pi->has_sidechain ()) {
2072 pi->sidechain_input ()->changed.connect_same_thread (*this, boost::bind (&Route::sidechain_change_handler, this, _1, _2));
2075 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2076 _session.set_dirty ();
2081 Route::plugin_preset_output (boost::shared_ptr<Processor> proc, ChanCount outs)
2083 boost::shared_ptr<PluginInsert> pi;
2084 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
2089 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2090 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), proc);
2091 if (i == _processors.end ()) {
2097 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2098 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2100 const ChanCount& old (pi->preset_out ());
2101 if (!pi->set_preset_out (outs)) {
2102 return true; // no change, OK
2105 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2108 pi->set_preset_out (old);
2111 configure_processors_unlocked (0, &lm);
2114 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2115 _session.set_dirty ();
2120 Route::reset_plugin_insert (boost::shared_ptr<Processor> proc)
2123 return customize_plugin_insert (proc, 0, unused, unused);
2127 Route::customize_plugin_insert (boost::shared_ptr<Processor> proc, uint32_t count, ChanCount outs, ChanCount sinks)
2129 boost::shared_ptr<PluginInsert> pi;
2130 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
2135 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2136 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), proc);
2137 if (i == _processors.end ()) {
2143 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2144 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2146 bool old_cust = pi->custom_cfg ();
2147 uint32_t old_cnt = pi->get_count ();
2148 ChanCount old_chan = pi->output_streams ();
2149 ChanCount old_sinks = pi->natural_input_streams ();
2152 pi->set_custom_cfg (false);
2154 pi->set_custom_cfg (true);
2155 pi->set_count (count);
2156 pi->set_outputs (outs);
2157 pi->set_sinks (sinks);
2160 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2164 pi->set_count (old_cnt);
2165 pi->set_sinks (old_sinks);
2166 pi->set_outputs (old_chan);
2167 pi->set_custom_cfg (old_cust);
2171 configure_processors_unlocked (0, &lm);
2174 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2175 _session.set_dirty ();
2180 Route::set_strict_io (const bool enable)
2182 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2184 if (_strict_io != enable) {
2185 _strict_io = enable;
2186 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2187 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p) {
2188 boost::shared_ptr<PluginInsert> pi;
2189 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
2190 pi->set_strict_io (_strict_io);
2194 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2198 _strict_io = !enable; // restore old value
2199 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p) {
2200 boost::shared_ptr<PluginInsert> pi;
2201 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
2202 pi->set_strict_io (_strict_io);
2209 configure_processors (0);
2212 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2213 _session.set_dirty ();
2225 Route::get_template()
2227 return state(false);
2231 Route::state(bool full_state)
2234 if (!_session._template_state_dir.empty()) {
2235 assert (!full_state); // only for templates
2236 foreach_processor (sigc::bind (sigc::mem_fun (*this, &Route::set_plugin_state_dir), _session._template_state_dir));
2239 XMLNode *node = new XMLNode("Route");
2240 ProcessorList::iterator i;
2243 id().print (buf, sizeof (buf));
2244 node->add_property("id", buf);
2245 node->add_property ("name", _name);
2246 node->add_property("default-type", _default_type.to_string());
2247 node->add_property ("strict-io", _strict_io);
2249 node->add_child_nocopy (_presentation_info.get_state());
2251 node->add_property("active", _active?"yes":"no");
2253 node->add_property("denormal-protection", _denormal_protection?"yes":"no");
2254 node->add_property("meter-point", enum_2_string (_meter_point));
2256 node->add_property("meter-type", enum_2_string (_meter_type));
2259 node->add_property("route-group", _route_group->name());
2262 node->add_child_nocopy (_solo_control->get_state ());
2263 node->add_child_nocopy (_solo_isolate_control->get_state ());
2264 node->add_child_nocopy (_solo_safe_control->get_state ());
2266 node->add_child_nocopy (_input->state (full_state));
2267 node->add_child_nocopy (_output->state (full_state));
2268 node->add_child_nocopy (_mute_master->get_state ());
2270 node->add_child_nocopy (_mute_control->get_state ());
2271 node->add_child_nocopy (_phase_control->get_state ());
2274 node->add_child_nocopy (Automatable::get_automation_xml_state ());
2277 if (_comment.length()) {
2278 XMLNode *cmt = node->add_child ("Comment");
2279 cmt->add_content (_comment);
2283 node->add_child_nocopy (_pannable->state (full_state));
2287 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2288 for (i = _processors.begin(); i != _processors.end(); ++i) {
2290 /* template save: do not include internal sends functioning as
2291 aux sends because the chance of the target ID
2292 in the session where this template is used
2295 similarly, do not save listen sends which connect to
2296 the monitor section, because these will always be
2299 boost::shared_ptr<InternalSend> is;
2301 if ((is = boost::dynamic_pointer_cast<InternalSend> (*i)) != 0) {
2302 if (is->role() == Delivery::Listen) {
2307 node->add_child_nocopy((*i)->state (full_state));
2312 node->add_child_copy (*_extra_xml);
2315 if (_custom_meter_position_noted) {
2316 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
2318 after->id().print (buf, sizeof (buf));
2319 node->add_property (X_("processor-after-last-custom-meter"), buf);
2323 if (!_session._template_state_dir.empty()) {
2324 foreach_processor (sigc::bind (sigc::mem_fun (*this, &Route::set_plugin_state_dir), ""));
2327 node->add_child_copy (Slavable::get_state());
2333 Route::set_state (const XMLNode& node, int version)
2335 if (version < 3000) {
2336 return set_state_2X (node, version);
2340 XMLNodeConstIterator niter;
2342 XMLProperty const * prop;
2344 if (node.name() != "Route"){
2345 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2349 if ((prop = node.property (X_("name"))) != 0) {
2350 Route::set_name (prop->value());
2354 _initial_io_setup = true;
2356 Stripable::set_state (node, version);
2358 if ((prop = node.property (X_("strict-io"))) != 0) {
2359 _strict_io = string_is_affirmative (prop->value());
2363 _mute_master->set_solo_ignore (true);
2367 /* monitor bus does not get a panner, but if (re)created
2368 via XML, it will already have one by the time we
2369 call ::set_state(). so ... remove it.
2374 /* add all processors (except amp, which is always present) */
2376 nlist = node.children();
2377 XMLNode processor_state (X_("processor_state"));
2379 Stateful::save_extra_xml (node);
2381 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2385 if (child->name() == IO::state_node_name) {
2386 if ((prop = child->property (X_("direction"))) == 0) {
2390 if (prop->value() == "Input") {
2391 _input->set_state (*child, version);
2392 } else if (prop->value() == "Output") {
2393 _output->set_state (*child, version);
2396 } else if (child->name() == X_("Processor")) {
2397 processor_state.add_child_copy (*child);
2398 } else if (child->name() == X_("Pannable")) {
2400 _pannable->set_state (*child, version);
2402 warning << string_compose (_("Pannable state found for route (%1) without a panner!"), name()) << endmsg;
2404 } else if (child->name() == Controllable::xml_node_name) {
2405 if ((prop = child->property (X_("name"))) == 0) {
2409 if (prop->value() == _gain_control->name()) {
2410 _gain_control->set_state (*child, version);
2411 } else if (prop->value() == _solo_control->name()) {
2412 _solo_control->set_state (*child, version);
2413 } else if (prop->value() == _solo_safe_control->name()) {
2414 _solo_safe_control->set_state (*child, version);
2415 } else if (prop->value() == _solo_isolate_control->name()) {
2416 _solo_isolate_control->set_state (*child, version);
2417 } else if (prop->value() == _solo_control->name()) {
2418 _mute_control->set_state (*child, version);
2420 } else if (child->name() == Slavable::xml_node_name) {
2421 Slavable::set_state (*child, version);
2425 if ((prop = node.property (X_("meter-point"))) != 0) {
2426 MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
2427 set_meter_point (mp, true);
2429 _meter->set_display_to_user (_meter_point == MeterCustom);
2433 if ((prop = node.property (X_("meter-type"))) != 0) {
2434 _meter_type = MeterType (string_2_enum (prop->value (), _meter_type));
2437 _initial_io_setup = false;
2439 set_processor_state (processor_state);
2441 // this looks up the internal instrument in processors
2442 reset_instrument_info();
2444 if ((prop = node.property (X_("denormal-protection"))) != 0) {
2445 set_denormal_protection (string_is_affirmative (prop->value()));
2448 if ((prop = node.property (X_("active"))) != 0) {
2449 bool yn = string_is_affirmative (prop->value());
2450 set_active (yn, this);
2453 if ((prop = node.property (X_("processor-after-last-custom-meter"))) != 0) {
2454 PBD::ID id (prop->value ());
2455 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2456 ProcessorList::const_iterator i = _processors.begin ();
2457 while (i != _processors.end() && (*i)->id() != id) {
2461 if (i != _processors.end ()) {
2462 _processor_after_last_custom_meter = *i;
2463 _custom_meter_position_noted = true;
2467 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2470 if (child->name() == X_("Comment")) {
2472 /* XXX this is a terrible API design in libxml++ */
2474 XMLNode *cmt = *(child->children().begin());
2475 _comment = cmt->content();
2477 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2478 if (prop->value() == "solo") {
2479 _solo_control->set_state (*child, version);
2480 } else if (prop->value() == "mute") {
2481 _mute_control->set_state (*child, version);
2484 } else if (child->name() == MuteMaster::xml_node_name) {
2485 _mute_master->set_state (*child, version);
2487 } else if (child->name() == Automatable::xml_node_name) {
2488 set_automation_xml_state (*child, Evoral::Parameter(NullAutomation));
2496 Route::set_state_2X (const XMLNode& node, int version)
2500 XMLNodeConstIterator niter;
2502 XMLProperty const * prop;
2504 /* 2X things which still remain to be handled:
2510 if (node.name() != "Route") {
2511 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2515 Stripable::set_state (node, version);
2517 if (is_master() || is_monitor() || is_auditioner()) {
2518 _mute_master->set_solo_ignore (true);
2521 if ((prop = node.property (X_("denormal-protection"))) != 0) {
2522 set_denormal_protection (string_is_affirmative (prop->value()));
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));
2591 nlist = node.children ();
2592 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2596 if (child->name() == IO::state_node_name) {
2598 /* there is a note in IO::set_state_2X() about why we have to call
2602 _input->set_state_2X (*child, version, true);
2603 _output->set_state_2X (*child, version, false);
2605 if ((prop = child->property (X_("name"))) != 0) {
2606 Route::set_name (prop->value ());
2611 if ((prop = child->property (X_("active"))) != 0) {
2612 bool yn = string_is_affirmative (prop->value());
2613 _active = !yn; // force switch
2614 set_active (yn, this);
2617 if ((prop = child->property (X_("gain"))) != 0) {
2620 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2621 _amp->gain_control()->set_value (val, Controllable::NoGroup);
2625 /* Set up Panners in the IO */
2626 XMLNodeList io_nlist = child->children ();
2628 XMLNodeConstIterator io_niter;
2631 for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2633 io_child = *io_niter;
2635 if (io_child->name() == X_("Panner")) {
2636 _main_outs->panner_shell()->set_state(*io_child, version);
2637 } else if (io_child->name() == X_("Automation")) {
2638 /* IO's automation is for the fader */
2639 _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
2645 XMLNodeList redirect_nodes;
2647 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2651 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2652 redirect_nodes.push_back(child);
2657 set_processor_state_2X (redirect_nodes, version);
2659 Stateful::save_extra_xml (node);
2661 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2664 if (child->name() == X_("Comment")) {
2666 /* XXX this is a terrible API design in libxml++ */
2668 XMLNode *cmt = *(child->children().begin());
2669 _comment = cmt->content();
2671 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2672 if (prop->value() == X_("solo")) {
2673 _solo_control->set_state (*child, version);
2674 } else if (prop->value() == X_("mute")) {
2675 _mute_control->set_state (*child, version);
2685 Route::get_processor_state ()
2687 XMLNode* root = new XMLNode (X_("redirects"));
2688 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2689 root->add_child_nocopy ((*i)->state (true));
2696 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2698 /* We don't bother removing existing processors not in nList, as this
2699 method will only be called when creating a Route from scratch, not
2700 for undo purposes. Just put processors in at the appropriate place
2704 for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2705 add_processor_from_xml_2X (**i, version);
2710 Route::set_processor_state (const XMLNode& node)
2712 const XMLNodeList &nlist = node.children();
2713 XMLNodeConstIterator niter;
2714 ProcessorList new_order;
2715 bool must_configure = false;
2717 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2719 XMLProperty* prop = (*niter)->property ("type");
2721 if (prop->value() == "amp") {
2722 _amp->set_state (**niter, Stateful::current_state_version);
2723 new_order.push_back (_amp);
2724 } else if (prop->value() == "trim") {
2725 _trim->set_state (**niter, Stateful::current_state_version);
2726 new_order.push_back (_trim);
2727 } else if (prop->value() == "meter") {
2728 _meter->set_state (**niter, Stateful::current_state_version);
2729 new_order.push_back (_meter);
2730 } else if (prop->value() == "delay") {
2732 _delayline->set_state (**niter, Stateful::current_state_version);
2733 new_order.push_back (_delayline);
2735 } else if (prop->value() == "main-outs") {
2736 _main_outs->set_state (**niter, Stateful::current_state_version);
2737 } else if (prop->value() == "intreturn") {
2739 _intreturn.reset (new InternalReturn (_session));
2740 must_configure = true;
2742 _intreturn->set_state (**niter, Stateful::current_state_version);
2743 } else if (is_monitor() && prop->value() == "monitor") {
2744 if (!_monitor_control) {
2745 _monitor_control.reset (new MonitorProcessor (_session));
2746 must_configure = true;
2748 _monitor_control->set_state (**niter, Stateful::current_state_version);
2749 } else if (prop->value() == "capture") {
2750 /* CapturingProcessor should never be restored, it's always
2751 added explicitly when needed */
2753 ProcessorList::iterator o;
2755 for (o = _processors.begin(); o != _processors.end(); ++o) {
2756 XMLProperty const * id_prop = (*niter)->property(X_("id"));
2757 if (id_prop && (*o)->id() == id_prop->value()) {
2758 (*o)->set_state (**niter, Stateful::current_state_version);
2759 new_order.push_back (*o);
2764 // If the processor (*niter) is not on the route then create it
2766 if (o == _processors.end()) {
2768 boost::shared_ptr<Processor> processor;
2770 if (prop->value() == "intsend") {
2772 processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), boost::shared_ptr<Route>(), Delivery::Aux, true));
2774 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2775 prop->value() == "lv2" ||
2776 prop->value() == "windows-vst" ||
2777 prop->value() == "lxvst" ||
2778 prop->value() == "luaproc" ||
2779 prop->value() == "audiounit") {
2781 if (_session.get_disable_all_loaded_plugins ()) {
2782 processor.reset (new UnknownProcessor (_session, **niter));
2784 processor.reset (new PluginInsert (_session));
2785 processor->set_owner (this);
2787 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(processor);
2788 pi->set_strict_io (true);
2792 } else if (prop->value() == "port") {
2794 processor.reset (new PortInsert (_session, _pannable, _mute_master));
2796 } else if (prop->value() == "send") {
2798 processor.reset (new Send (_session, _pannable, _mute_master, Delivery::Send, true));
2799 boost::shared_ptr<Send> send = boost::dynamic_pointer_cast<Send> (processor);
2800 send->SelfDestruct.connect_same_thread (*this,
2801 boost::bind (&Route::processor_selfdestruct, this, boost::weak_ptr<Processor> (processor)));
2804 error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2808 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2809 /* This processor could not be configured. Turn it into a UnknownProcessor */
2810 processor.reset (new UnknownProcessor (_session, **niter));
2813 /* subscribe to Sidechain IO changes */
2814 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (processor);
2815 if (pi && pi->has_sidechain ()) {
2816 pi->sidechain_input ()->changed.connect_same_thread (*this, boost::bind (&Route::sidechain_change_handler, this, _1, _2));
2819 /* we have to note the monitor send here, otherwise a new one will be created
2820 and the state of this one will be lost.
2822 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
2823 if (isend && isend->role() == Delivery::Listen) {
2824 _monitor_send = isend;
2827 /* it doesn't matter if invisible processors are added here, as they
2828 will be sorted out by setup_invisible_processors () shortly.
2831 new_order.push_back (processor);
2832 must_configure = true;
2838 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2839 /* re-assign _processors w/o process-lock.
2840 * if there's an IO-processor present in _processors but
2841 * not in new_order, it will be deleted and ~IO takes
2844 _processors = new_order;
2845 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2847 if (must_configure) {
2848 configure_processors_unlocked (0, &lm);
2851 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2853 (*i)->set_owner (this);
2854 (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
2856 boost::shared_ptr<PluginInsert> pi;
2858 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
2859 if (pi->has_no_inputs ()) {
2860 _have_internal_generator = true;
2867 reset_instrument_info ();
2868 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2869 set_processor_positions ();
2873 Route::curve_reallocate ()
2875 // _gain_automation_curve.finish_resize ();
2876 // _pan_automation_curve.finish_resize ();
2880 Route::silence (framecnt_t nframes)
2882 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
2887 silence_unlocked (nframes);
2891 Route::silence_unlocked (framecnt_t nframes)
2893 /* Must be called with the processor lock held */
2895 const framepos_t now = _session.transport_frame ();
2899 _output->silence (nframes);
2901 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2902 boost::shared_ptr<PluginInsert> pi;
2904 if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2905 // skip plugins, they don't need anything when we're not active
2909 (*i)->silence (nframes, now);
2912 if (nframes == _session.get_block_size()) {
2919 Route::add_internal_return ()
2922 _intreturn.reset (new InternalReturn (_session));
2923 add_processor (_intreturn, PreFader);
2928 Route::add_send_to_internal_return (InternalSend* send)
2930 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
2932 for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2933 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2936 return d->add_send (send);
2942 Route::remove_send_from_internal_return (InternalSend* send)
2944 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
2946 for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2947 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2950 return d->remove_send (send);
2956 Route::enable_monitor_send ()
2958 /* Caller must hold process lock */
2959 assert (!AudioEngine::instance()->process_lock().trylock());
2961 /* master never sends to monitor section via the normal mechanism */
2962 assert (!is_master ());
2963 assert (!is_monitor ());
2965 /* make sure we have one */
2966 if (!_monitor_send) {
2967 _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), _session.monitor_out(), Delivery::Listen));
2968 _monitor_send->set_display_to_user (false);
2972 configure_processors (0);
2975 /** Add an aux send to a route.
2976 * @param route route to send to.
2977 * @param before Processor to insert before, or 0 to insert at the end.
2980 Route::add_aux_send (boost::shared_ptr<Route> route, boost::shared_ptr<Processor> before)
2982 assert (route != _session.monitor_out ());
2985 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
2987 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2989 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
2991 if (d && d->target_route() == route) {
2992 /* already listening via the specified IO: do nothing */
3000 boost::shared_ptr<InternalSend> listener;
3003 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3004 boost::shared_ptr<Pannable> sendpan (new Pannable (_session));
3005 listener.reset (new InternalSend (_session, sendpan, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), route, Delivery::Aux));
3008 add_processor (listener, before);
3010 } catch (failed_constructor& err) {
3018 Route::remove_aux_or_listen (boost::shared_ptr<Route> route)
3020 ProcessorStreams err;
3021 ProcessorList::iterator tmp;
3024 Glib::Threads::RWLock::ReaderLock rl(_processor_lock);
3026 /* have to do this early because otherwise processor reconfig
3027 * will put _monitor_send back in the list
3030 if (route == _session.monitor_out()) {
3031 _monitor_send.reset ();
3035 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3037 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
3039 if (d && d->target_route() == route) {
3041 if (remove_processor (*x, &err, false) > 0) {
3047 /* list could have been demolished while we dropped the lock
3050 if (_session.engine().connected()) {
3051 /* i/o processors cannot be removed if the engine is not running
3052 * so don't live-loop in case the engine is N/A or dies
3062 Route::set_comment (string cmt, void *src)
3066 _session.set_dirty ();
3070 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
3072 FeedRecord fr (other, via_sends_only);
3074 pair<FedBy::iterator,bool> result = _fed_by.insert (fr);
3076 if (!result.second) {
3078 /* already a record for "other" - make sure sends-only information is correct */
3079 if (!via_sends_only && result.first->sends_only) {
3080 FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
3081 frp->sends_only = false;
3085 return result.second;
3089 Route::clear_fed_by ()
3095 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
3097 const FedBy& fed_by (other->fed_by());
3099 for (FedBy::const_iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
3100 boost::shared_ptr<Route> sr = f->r.lock();
3102 if (sr && (sr.get() == this)) {
3104 if (via_sends_only) {
3105 *via_sends_only = f->sends_only;
3116 Route::all_inputs () const
3118 /* TODO, if this works as expected,
3119 * cache the IOVector and maintain it via
3120 * input_change_handler(), sidechain_change_handler() etc
3123 ios.push_back (_input);
3125 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3126 for (ProcessorList::const_iterator r = _processors.begin(); r != _processors.end(); ++r) {
3128 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3129 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*r);
3132 iop = pi->sidechain();
3135 if (iop != 0 && iop->input()) {
3136 ios.push_back (iop->input());
3143 Route::all_outputs () const
3146 // _output is included via Delivery
3147 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3148 for (ProcessorList::const_iterator r = _processors.begin(); r != _processors.end(); ++r) {
3149 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3150 if (iop != 0 && iop->output()) {
3151 ios.push_back (iop->output());
3158 Route::direct_feeds_according_to_reality (boost::shared_ptr<Route> other, bool* via_send_only)
3160 DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
3161 if (other->all_inputs().fed_by (_output)) {
3162 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
3163 if (via_send_only) {
3164 *via_send_only = false;
3170 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3172 for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
3174 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3175 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*r);
3178 iop = pi->sidechain();
3182 boost::shared_ptr<const IO> iop_out = iop->output();
3183 if ((iop_out && other->all_inputs().fed_by (iop_out)) || iop->feeds (other)) {
3184 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
3185 if (via_send_only) {
3186 *via_send_only = true;
3190 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
3193 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
3198 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdoes NOT feed %1\n", other->name()));
3203 Route::direct_feeds_according_to_graph (boost::shared_ptr<Route> other, bool* via_send_only)
3205 return _session._current_route_graph.has (shared_from_this (), other, via_send_only);
3209 Route::feeds_according_to_graph (boost::shared_ptr<Route> other)
3211 return _session._current_route_graph.feeds (shared_from_this (), other);
3214 /** Called from the (non-realtime) butler thread when the transport is stopped */
3216 Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool /*did_locate*/, bool can_flush_processors)
3218 framepos_t now = _session.transport_frame();
3221 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3223 Automatable::transport_stopped (now);
3225 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3227 if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && can_flush_processors)) {
3231 (*i)->transport_stopped (now);
3235 _roll_delay = _initial_delay;
3239 Route::input_change_handler (IOChange change, void * /*src*/)
3241 if ((change.type & IOChange::ConfigurationChanged)) {
3242 /* This is called with the process lock held if change
3243 contains ConfigurationChanged
3245 configure_processors (0);
3246 _phase_control->resize (_input->n_ports().n_audio ());
3247 io_changed (); /* EMIT SIGNAL */
3250 if (_solo_control->soloed_by_others_upstream() || _solo_isolate_control->solo_isolated_by_upstream()) {
3253 boost::shared_ptr<RouteList> routes = _session.get_routes ();
3254 if (_input->connected()) {
3255 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3256 if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3260 bool does_feed = (*i)->direct_feeds_according_to_reality (shared_from_this(), &sends_only);
3261 if (does_feed && !sends_only) {
3262 if ((*i)->soloed()) {
3265 if ((*i)->solo_isolate_control()->solo_isolated()) {
3272 int delta = sbou - _solo_control->soloed_by_others_upstream();
3273 int idelta = ibou - _solo_isolate_control->solo_isolated_by_upstream();
3276 PBD::warning << string_compose (
3277 _("Invalid Solo-Isolate propagation: from:%1 new:%2 - old:%3 = delta:%4"),
3278 _name, ibou, _solo_isolate_control->solo_isolated_by_upstream(), idelta)
3283 if (_solo_control->soloed_by_others_upstream()) {
3284 // ignore new connections (they're not propagated)
3286 _solo_control->mod_solo_by_others_upstream (delta);
3290 if (_solo_isolate_control->solo_isolated_by_upstream()) {
3291 // solo-isolate currently only propagates downstream
3293 _solo_isolate_control->mod_solo_isolated_by_upstream (1);
3295 //_solo_isolated_by_upstream = ibou;
3298 // Session::route_solo_changed does not propagate indirect solo-changes
3299 // propagate downstream to tracks
3300 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3301 if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3305 bool does_feed = feeds (*i, &sends_only);
3306 if (delta <= 0 && does_feed && !sends_only) {
3307 (*i)->solo_control()->mod_solo_by_others_upstream (delta);
3310 if (idelta < 0 && does_feed && !sends_only) {
3311 (*i)->solo_isolate_control()->mod_solo_isolated_by_upstream (-1);
3318 Route::output_change_handler (IOChange change, void * /*src*/)
3320 if (_initial_io_setup) {
3324 if ((change.type & IOChange::ConfigurationChanged)) {
3325 /* This is called with the process lock held if change
3326 contains ConfigurationChanged
3328 configure_processors (0);
3331 _session.reset_monitor_section();
3334 io_changed (); /* EMIT SIGNAL */
3337 if (_solo_control->soloed_by_others_downstream()) {
3339 /* checking all all downstream routes for
3340 * explicit of implict solo is a rather drastic measure,
3341 * ideally the input_change_handler() of the other route
3342 * would propagate the change to us.
3344 boost::shared_ptr<RouteList> routes = _session.get_routes ();
3345 if (_output->connected()) {
3346 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3347 if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3351 bool does_feed = direct_feeds_according_to_reality (*i, &sends_only);
3352 if (does_feed && !sends_only) {
3353 if ((*i)->soloed()) {
3360 int delta = sbod - _solo_control->soloed_by_others_downstream();
3362 // do not allow new connections to change implicit solo (no propagation)
3363 _solo_control->mod_solo_by_others_downstream (delta);
3364 // Session::route_solo_changed() does not propagate indirect solo-changes
3365 // propagate upstream to tracks
3366 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3367 if ((*i).get() == this || !can_solo()) {
3371 bool does_feed = (*i)->feeds (shared_from_this(), &sends_only);
3372 if (delta != 0 && does_feed && !sends_only) {
3373 (*i)->solo_control()->mod_solo_by_others_downstream (delta);
3382 Route::sidechain_change_handler (IOChange change, void* src)
3384 if (_initial_io_setup || _in_sidechain_setup) {
3388 input_change_handler (change, src);
3392 Route::pans_required () const
3394 if (n_outputs().n_audio() < 2) {
3398 return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
3402 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
3404 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3410 if (n_outputs().n_total() == 0) {
3414 if (!_active || n_inputs() == ChanCount::ZERO) {
3415 silence_unlocked (nframes);
3419 if (session_state_changing) {
3420 if (_session.transport_speed() != 0.0f) {
3421 /* we're rolling but some state is changing (e.g. our diskstream contents)
3422 so we cannot use them. Be silent till this is over.
3424 XXX note the absurdity of ::no_roll() being called when we ARE rolling!
3426 silence_unlocked (nframes);
3429 /* we're really not rolling, so we're either delivery silence or actually
3430 monitoring, both of which are safe to do while session_state_changing is true.
3434 BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
3436 fill_buffers_with_input (bufs, _input, nframes);
3438 if (_meter_point == MeterInput) {
3439 _meter->run (bufs, start_frame, end_frame, 0.0, nframes, true);
3442 _amp->apply_gain_automation (false);
3443 _trim->apply_gain_automation (false);
3444 passthru (bufs, start_frame, end_frame, nframes, 0);
3450 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& /* need_butler */)
3452 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3457 if (n_outputs().n_total() == 0) {
3461 if (!_active || n_inputs().n_total() == 0) {
3462 silence_unlocked (nframes);
3466 framepos_t unused = 0;
3468 if ((nframes = check_initial_delay (nframes, unused)) == 0) {
3474 BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
3476 fill_buffers_with_input (bufs, _input, nframes);
3478 if (_meter_point == MeterInput) {
3479 _meter->run (bufs, start_frame, end_frame, 1.0, nframes, true);
3482 passthru (bufs, start_frame, end_frame, nframes, declick);
3488 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& /* need_butler */)
3495 Route::flush_processors ()
3497 /* XXX shouldn't really try to take this lock, since
3498 this is called from the RT audio thread.
3501 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3503 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3509 __attribute__((annotate("realtime")))
3512 Route::apply_processor_changes_rt ()
3514 int emissions = EmitNone;
3516 if (_pending_meter_point != _meter_point) {
3517 Glib::Threads::RWLock::WriterLock pwl (_processor_lock, Glib::Threads::TRY_LOCK);
3519 /* meters always have buffers for 'processor_max_streams'
3520 * they can be re-positioned without re-allocation */
3521 if (set_meter_point_unlocked()) {
3522 emissions |= EmitMeterChanged | EmitMeterVisibilityChange;;
3524 emissions |= EmitMeterChanged;
3529 bool changed = false;
3531 if (g_atomic_int_get (&_pending_process_reorder)) {
3532 Glib::Threads::RWLock::WriterLock pwl (_processor_lock, Glib::Threads::TRY_LOCK);
3534 apply_processor_order (_pending_processor_order);
3535 setup_invisible_processors ();
3537 g_atomic_int_set (&_pending_process_reorder, 0);
3538 emissions |= EmitRtProcessorChange;
3542 set_processor_positions ();
3544 if (emissions != 0) {
3545 g_atomic_int_set (&_pending_signals, emissions);
3548 return (!selfdestruct_sequence.empty ());
3552 Route::emit_pending_signals ()
3554 int sig = g_atomic_int_and (&_pending_signals, 0);
3555 if (sig & EmitMeterChanged) {
3556 _meter->emit_configuration_changed();
3557 meter_change (); /* EMIT SIGNAL */
3558 if (sig & EmitMeterVisibilityChange) {
3559 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, true)); /* EMIT SIGNAL */
3561 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, false)); /* EMIT SIGNAL */
3564 if (sig & EmitRtProcessorChange) {
3565 processors_changed (RouteProcessorChange (RouteProcessorChange::RealTimeChange)); /* EMIT SIGNAL */
3568 /* this would be a job for the butler.
3569 * Conceptually we should not take processe/processor locks here.
3570 * OTOH its more efficient (less overhead for summoning the butler and
3571 * telling her what do do) and signal emission is called
3572 * directly after the process callback, which decreases the chance
3573 * of x-runs when taking the locks.
3575 while (!selfdestruct_sequence.empty ()) {
3576 Glib::Threads::Mutex::Lock lx (selfdestruct_lock);
3577 if (selfdestruct_sequence.empty ()) { break; } // re-check with lock
3578 boost::shared_ptr<Processor> proc = selfdestruct_sequence.back ().lock ();
3579 selfdestruct_sequence.pop_back ();
3582 remove_processor (proc);
3588 Route::set_meter_point (MeterPoint p, bool force)
3590 if (_pending_meter_point == p && !force) {
3594 if (force || !AudioEngine::instance()->running()) {
3595 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3596 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3597 _pending_meter_point = p;
3598 _meter->emit_configuration_changed();
3599 meter_change (); /* EMIT SIGNAL */
3600 if (set_meter_point_unlocked()) {
3601 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, true)); /* EMIT SIGNAL */
3603 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, false)); /* EMIT SIGNAL */
3606 _pending_meter_point = p;
3612 __attribute__((annotate("realtime")))
3615 Route::set_meter_point_unlocked ()
3618 /* Caller must hold process and processor write lock */
3619 assert (!AudioEngine::instance()->process_lock().trylock());
3620 Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3621 assert (!lm.locked ());
3624 _meter_point = _pending_meter_point;
3626 bool meter_was_visible_to_user = _meter->display_to_user ();
3628 if (!_custom_meter_position_noted) {
3629 maybe_note_meter_position ();
3632 if (_meter_point != MeterCustom) {
3634 _meter->set_display_to_user (false);
3636 setup_invisible_processors ();
3639 _meter->set_display_to_user (true);
3641 /* If we have a previous position for the custom meter, try to put it there */
3642 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
3644 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), after);
3645 if (i != _processors.end ()) {
3646 _processors.remove (_meter);
3647 _processors.insert (i, _meter);
3649 } else {// at end, right before the mains_out/panner
3650 _processors.remove (_meter);
3651 ProcessorList::iterator main = _processors.end();
3652 _processors.insert (--main, _meter);
3656 /* Set up the meter for its new position */
3658 ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
3662 if (loc == _processors.begin()) {
3663 m_in = _input->n_ports();
3665 ProcessorList::iterator before = loc;
3667 m_in = (*before)->output_streams ();
3670 _meter->reflect_inputs (m_in);
3672 /* we do not need to reconfigure the processors, because the meter
3673 (a) is always ready to handle processor_max_streams
3674 (b) is always an N-in/N-out processor, and thus moving
3675 it doesn't require any changes to the other processors.
3678 /* these should really be done after releasing the lock
3679 * but all those signals are subscribed to with gui_thread()
3682 return (_meter->display_to_user() != meter_was_visible_to_user);
3686 Route::listen_position_changed ()
3689 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3690 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3691 ProcessorState pstate (this);
3693 if (configure_processors_unlocked (0, &lm)) {
3694 DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
3696 configure_processors_unlocked (0, &lm); // it worked before we tried to add it ...
3701 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
3702 _session.set_dirty ();
3705 boost::shared_ptr<CapturingProcessor>
3706 Route::add_export_point()
3708 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3709 if (!_capturing_processor) {
3711 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3712 Glib::Threads::RWLock::WriterLock lw (_processor_lock);
3714 _capturing_processor.reset (new CapturingProcessor (_session));
3715 _capturing_processor->activate ();
3717 configure_processors_unlocked (0, &lw);
3721 return _capturing_processor;
3725 Route::update_signal_latency ()
3727 framecnt_t l = _output->user_latency();
3728 framecnt_t lamp = 0;
3729 bool before_amp = true;
3730 framecnt_t ltrim = 0;
3731 bool before_trim = true;
3733 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3734 if ((*i)->active ()) {
3735 l += (*i)->signal_latency ();
3740 if ((*i) == _trim) {
3751 DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l));
3753 // TODO: (lamp - _signal_latency) to sync to output (read-ahed), currently _roll_delay shifts this around
3754 _signal_latency_at_amp_position = lamp;
3755 _signal_latency_at_trim_position = ltrim;
3757 if (_signal_latency != l) {
3758 _signal_latency = l;
3759 signal_latency_changed (); /* EMIT SIGNAL */
3762 return _signal_latency;
3766 Route::set_user_latency (framecnt_t nframes)
3768 _output->set_user_latency (nframes);
3769 _session.update_latency_compensation ();
3773 Route::set_latency_compensation (framecnt_t longest_session_latency)
3775 framecnt_t old = _initial_delay;
3777 if (_signal_latency < longest_session_latency) {
3778 _initial_delay = longest_session_latency - _signal_latency;
3783 DEBUG_TRACE (DEBUG::Latency, string_compose (
3784 "%1: compensate for maximum latency of %2,"
3785 "given own latency of %3, using initial delay of %4\n",
3786 name(), longest_session_latency, _signal_latency, _initial_delay));
3788 if (_initial_delay != old) {
3789 initial_delay_changed (); /* EMIT SIGNAL */
3792 if (_session.transport_stopped()) {
3793 _roll_delay = _initial_delay;
3798 Route::set_block_size (pframes_t nframes)
3800 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3801 (*i)->set_block_size (nframes);
3804 _session.ensure_buffers (n_process_buffers ());
3808 Route::protect_automation ()
3810 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3811 (*i)->protect_automation();
3814 /** @param declick 1 to set a pending declick fade-in,
3815 * -1 to set a pending declick fade-out
3818 Route::set_pending_declick (int declick)
3821 /* this call is not allowed to turn off a pending declick */
3823 _pending_declick = declick;
3826 _pending_declick = 0;
3830 /** Shift automation forwards from a particular place, thereby inserting time.
3831 * Adds undo commands for any shifts that are performed.
3833 * @param pos Position to start shifting from.
3834 * @param frames Amount to shift forwards by.
3838 Route::shift (framepos_t pos, framecnt_t frames)
3840 /* gain automation */
3842 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
3844 XMLNode &before = gc->alist()->get_state ();
3845 gc->alist()->shift (pos, frames);
3846 XMLNode &after = gc->alist()->get_state ();
3847 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3850 /* gain automation */
3852 boost::shared_ptr<AutomationControl> gc = _trim->gain_control();
3854 XMLNode &before = gc->alist()->get_state ();
3855 gc->alist()->shift (pos, frames);
3856 XMLNode &after = gc->alist()->get_state ();
3857 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3860 // TODO mute automation ??
3862 /* pan automation */
3864 ControlSet::Controls& c (_pannable->controls());
3866 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
3867 boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
3869 boost::shared_ptr<AutomationList> al = pc->alist();
3870 XMLNode& before = al->get_state ();
3871 al->shift (pos, frames);
3872 XMLNode& after = al->get_state ();
3873 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3878 /* redirect automation */
3880 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3881 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
3883 set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
3885 for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
3886 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
3888 boost::shared_ptr<AutomationList> al = ac->alist();
3889 XMLNode &before = al->get_state ();
3890 al->shift (pos, frames);
3891 XMLNode &after = al->get_state ();
3892 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3900 Route::set_plugin_state_dir (boost::weak_ptr<Processor> p, const std::string& d)
3902 boost::shared_ptr<Processor> processor (p.lock ());
3903 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (processor);
3907 pi->set_state_dir (d);
3911 Route::save_as_template (const string& path, const string& name)
3913 std::string state_dir = path.substr (0, path.find_last_of ('.')); // strip template_suffix
3914 PBD::Unwinder<std::string> uw (_session._template_state_dir, state_dir);
3916 XMLNode& node (state (false));
3920 IO::set_name_in_state (*node.children().front(), name);
3922 tree.set_root (&node);
3924 /* return zero on success, non-zero otherwise */
3925 return !tree.write (path.c_str());
3930 Route::set_name (const string& str)
3932 if (str == name()) {
3936 string name = Route::ensure_track_or_route_name (str, _session);
3937 SessionObject::set_name (name);
3939 bool ret = (_input->set_name(name) && _output->set_name(name));
3942 /* rename the main outs. Leave other IO processors
3943 * with whatever name they already have, because its
3944 * just fine as it is (it will not contain the route
3945 * name if its a port insert, port send or port return).
3949 if (_main_outs->set_name (name)) {
3950 /* XXX returning false here is stupid because
3951 we already changed the route name.
3961 /** Set the name of a route in an XML description.
3962 * @param node XML <Route> node to set the name in.
3963 * @param name New name.
3966 Route::set_name_in_state (XMLNode& node, string const & name, bool rename_playlist)
3968 node.add_property (X_("name"), name);
3970 XMLNodeList children = node.children();
3971 for (XMLNodeIterator i = children.begin(); i != children.end(); ++i) {
3973 if ((*i)->name() == X_("IO")) {
3975 IO::set_name_in_state (**i, name);
3977 } else if ((*i)->name() == X_("Processor")) {
3979 XMLProperty const * role = (*i)->property (X_("role"));
3980 if (role && role->value() == X_("Main")) {
3981 (*i)->add_property (X_("name"), name);
3984 } else if ((*i)->name() == X_("Diskstream")) {
3986 if (rename_playlist) {
3987 (*i)->add_property (X_("playlist"), string_compose ("%1.1", name).c_str());
3989 (*i)->add_property (X_("name"), name);
3995 boost::shared_ptr<Send>
3996 Route::internal_send_for (boost::shared_ptr<const Route> target) const
3998 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4000 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4001 boost::shared_ptr<InternalSend> send;
4003 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
4004 if (send->target_route() == target) {
4010 return boost::shared_ptr<Send>();
4014 Route::set_denormal_protection (bool yn)
4016 if (_denormal_protection != yn) {
4017 _denormal_protection = yn;
4018 denormal_protection_changed (); /* EMIT SIGNAL */
4023 Route::denormal_protection () const
4025 return _denormal_protection;
4029 Route::set_active (bool yn, void* src)
4031 if (_session.transport_rolling()) {
4035 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
4036 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
4040 if (_active != yn) {
4042 _input->set_active (yn);
4043 _output->set_active (yn);
4044 active_changed (); // EMIT SIGNAL
4045 _session.set_dirty ();
4049 boost::shared_ptr<Pannable>
4050 Route::pannable() const
4055 boost::shared_ptr<Panner>
4056 Route::panner() const
4059 return _main_outs->panner_shell()->panner();
4062 boost::shared_ptr<PannerShell>
4063 Route::panner_shell() const
4065 return _main_outs->panner_shell();
4068 boost::shared_ptr<GainControl>
4069 Route::gain_control() const
4071 return _gain_control;
4074 boost::shared_ptr<GainControl>
4075 Route::trim_control() const
4077 return _trim_control;
4080 boost::shared_ptr<PhaseControl>
4081 Route::phase_control() const
4083 return _phase_control;
4086 boost::shared_ptr<AutomationControl>
4087 Route::get_control (const Evoral::Parameter& param)
4089 /* either we own the control or .... */
4091 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
4095 /* maybe one of our processors does or ... */
4097 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
4098 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4099 if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
4107 /* nobody does so we'll make a new one */
4109 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
4116 boost::shared_ptr<Processor>
4117 Route::nth_plugin (uint32_t n) const
4119 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4120 ProcessorList::const_iterator i;
4122 for (i = _processors.begin(); i != _processors.end(); ++i) {
4123 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
4130 return boost::shared_ptr<Processor> ();
4133 boost::shared_ptr<Processor>
4134 Route::nth_send (uint32_t n) const
4136 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4137 ProcessorList::const_iterator i;
4139 for (i = _processors.begin(); i != _processors.end(); ++i) {
4140 if (boost::dynamic_pointer_cast<Send> (*i)) {
4142 if ((*i)->name().find (_("Monitor")) == 0) {
4143 /* send to monitor section is not considered
4144 to be an accessible send.
4155 return boost::shared_ptr<Processor> ();
4159 Route::has_io_processor_named (const string& name)
4161 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4162 ProcessorList::iterator i;
4164 for (i = _processors.begin(); i != _processors.end(); ++i) {
4165 if (boost::dynamic_pointer_cast<Send> (*i) ||
4166 boost::dynamic_pointer_cast<PortInsert> (*i)) {
4167 if ((*i)->name() == name) {
4177 Route::set_processor_positions ()
4179 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4181 bool had_amp = false;
4182 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4183 (*i)->set_pre_fader (!had_amp);
4190 /** Called when there is a proposed change to the input port count */
4192 Route::input_port_count_changing (ChanCount to)
4194 list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
4196 /* The processors cannot be configured with the new input arrangement, so
4202 /* The change is ok */
4206 /** Called when there is a proposed change to the output port count */
4208 Route::output_port_count_changing (ChanCount to)
4210 if (_strict_io && !_in_configure_processors) {
4213 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
4214 if (processor_out_streams.get(*t) > to.get(*t)) {
4218 /* The change is ok */
4223 Route::unknown_processors () const
4227 if (_session.get_disable_all_loaded_plugins ()) {
4228 // Do not list "missing plugins" if they are explicitly disabled
4232 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4233 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4234 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
4235 p.push_back ((*i)->name ());
4244 Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecnt_t our_latency) const
4246 /* we assume that all our input ports feed all our output ports. its not
4247 universally true, but the alternative is way too corner-case to worry about.
4250 LatencyRange all_connections;
4253 all_connections.min = 0;
4254 all_connections.max = 0;
4256 all_connections.min = ~((pframes_t) 0);
4257 all_connections.max = 0;
4259 /* iterate over all "from" ports and determine the latency range for all of their
4260 connections to the "outside" (outside of this Route).
4263 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
4267 p->get_connected_latency_range (range, playback);
4269 all_connections.min = min (all_connections.min, range.min);
4270 all_connections.max = max (all_connections.max, range.max);
4274 /* set the "from" port latencies to the max/min range of all their connections */
4276 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
4277 p->set_private_latency_range (all_connections, playback);
4280 /* set the ports "in the direction of the flow" to the same value as above plus our own signal latency */
4282 all_connections.min += our_latency;
4283 all_connections.max += our_latency;
4285 for (PortSet::iterator p = to.begin(); p != to.end(); ++p) {
4286 p->set_private_latency_range (all_connections, playback);
4289 return all_connections.max;
4293 Route::set_private_port_latencies (bool playback) const
4295 framecnt_t own_latency = 0;
4297 /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD
4298 OR LATENCY CALLBACK.
4300 This is called (early) from the latency callback. It computes the REAL
4301 latency associated with each port and stores the result as the "private"
4302 latency of the port. A later call to Route::set_public_port_latencies()
4303 sets all ports to the same value to reflect the fact that we do latency
4304 compensation and so all signals are delayed by the same amount as they
4305 flow through ardour.
4308 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4309 if ((*i)->active ()) {
4310 own_latency += (*i)->signal_latency ();
4315 /* playback: propagate latency from "outside the route" to outputs to inputs */
4316 return update_port_latencies (_output->ports (), _input->ports (), true, own_latency);
4318 /* capture: propagate latency from "outside the route" to inputs to outputs */
4319 return update_port_latencies (_input->ports (), _output->ports (), false, own_latency);
4324 Route::set_public_port_latencies (framecnt_t value, bool playback) const
4326 /* this is called to set the JACK-visible port latencies, which take
4327 latency compensation into account.
4336 const PortSet& ports (_input->ports());
4337 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
4338 p->set_public_latency_range (range, playback);
4343 const PortSet& ports (_output->ports());
4344 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
4345 p->set_public_latency_range (range, playback);
4350 /** Put the invisible processors in the right place in _processors.
4351 * Must be called with a writer lock on _processor_lock held.
4354 __attribute__((annotate("realtime")))
4357 Route::setup_invisible_processors ()
4360 Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
4361 assert (!lm.locked ());
4365 /* too early to be doing this stuff */
4369 /* we'll build this new list here and then use it
4371 * TODO put the ProcessorList is on the stack for RT-safety.
4374 ProcessorList new_processors;
4376 /* find visible processors */
4378 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4379 if ((*i)->display_to_user ()) {
4380 new_processors.push_back (*i);
4386 ProcessorList::iterator amp = find (new_processors.begin(), new_processors.end(), _amp);
4388 if (amp == new_processors.end ()) {
4389 error << string_compose (_("Amp/Fader on Route '%1' went AWOL. Re-added."), name()) << endmsg;
4390 new_processors.push_front (_amp);
4391 amp = find (new_processors.begin(), new_processors.end(), _amp);
4394 /* and the processor after the amp */
4396 ProcessorList::iterator after_amp = amp;
4402 switch (_meter_point) {
4404 assert (!_meter->display_to_user ());
4405 new_processors.push_front (_meter);
4408 assert (!_meter->display_to_user ());
4409 new_processors.insert (amp, _meter);
4411 case MeterPostFader:
4412 /* do nothing here */
4415 /* do nothing here */
4418 /* the meter is visible, so we don't touch it here */
4425 assert (_main_outs);
4426 assert (!_main_outs->display_to_user ());
4427 new_processors.push_back (_main_outs);
4429 /* iterator for the main outs */
4431 ProcessorList::iterator main = new_processors.end();
4434 /* OUTPUT METERING */
4436 if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
4437 assert (!_meter->display_to_user ());
4439 /* add the processor just before or just after the main outs */
4441 ProcessorList::iterator meter_point = main;
4443 if (_meter_point == MeterOutput) {
4446 new_processors.insert (meter_point, _meter);
4451 if (_monitor_send && !is_monitor ()) {
4452 assert (!_monitor_send->display_to_user ());
4453 switch (Config->get_listen_position ()) {
4454 case PreFaderListen:
4455 switch (Config->get_pfl_position ()) {
4456 case PFLFromBeforeProcessors:
4457 new_processors.push_front (_monitor_send);
4459 case PFLFromAfterProcessors:
4460 new_processors.insert (amp, _monitor_send);
4463 _monitor_send->set_can_pan (false);
4465 case AfterFaderListen:
4466 switch (Config->get_afl_position ()) {
4467 case AFLFromBeforeProcessors:
4468 new_processors.insert (after_amp, _monitor_send);
4470 case AFLFromAfterProcessors:
4471 new_processors.insert (new_processors.end(), _monitor_send);
4474 _monitor_send->set_can_pan (true);
4479 #if 0 // not used - just yet
4480 if (!is_master() && !is_monitor() && !is_auditioner()) {
4481 new_processors.push_front (_delayline);
4485 /* MONITOR CONTROL */
4487 if (_monitor_control && is_monitor ()) {
4488 assert (!_monitor_control->display_to_user ());
4489 new_processors.insert (amp, _monitor_control);
4492 /* INTERNAL RETURN */
4494 /* doing this here means that any monitor control will come just after
4499 assert (!_intreturn->display_to_user ());
4500 new_processors.push_front (_intreturn);
4503 if (_trim && _trim->active()) {
4504 assert (!_trim->display_to_user ());
4505 new_processors.push_front (_trim);
4507 /* EXPORT PROCESSOR */
4509 if (_capturing_processor) {
4510 assert (!_capturing_processor->display_to_user ());
4511 new_processors.push_front (_capturing_processor);
4514 _processors = new_processors;
4516 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4517 if (!(*i)->display_to_user () && !(*i)->active () && (*i) != _monitor_send) {
4522 DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
4523 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4524 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
4531 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
4532 Glib::Threads::RWLock::ReaderLock lp (_processor_lock);
4536 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4537 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery>(*i);
4544 /** If the meter point is `Custom', make a note of where the meter is.
4545 * This is so that if the meter point is subsequently set to something else,
4546 * and then back to custom, we can put the meter back where it was last time
4547 * custom was enabled.
4549 * Must be called with the _processor_lock held.
4552 Route::maybe_note_meter_position ()
4554 if (_meter_point != MeterCustom) {
4558 _custom_meter_position_noted = true;
4559 /* custom meter points range from after trim to before panner/main_outs
4560 * this is a limitation by the current processor UI
4562 bool seen_trim = false;
4563 _processor_after_last_custom_meter.reset();
4564 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4565 if ((*i) == _trim) {
4568 if ((*i) == _main_outs) {
4569 _processor_after_last_custom_meter = *i;
4572 if (boost::dynamic_pointer_cast<PeakMeter> (*i)) {
4574 _processor_after_last_custom_meter = _trim;
4576 ProcessorList::iterator j = i;
4578 assert(j != _processors.end ()); // main_outs should be before
4579 _processor_after_last_custom_meter = *j;
4584 assert(_processor_after_last_custom_meter.lock());
4587 boost::shared_ptr<Processor>
4588 Route::processor_by_id (PBD::ID id) const
4590 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4591 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4592 if ((*i)->id() == id) {
4597 return boost::shared_ptr<Processor> ();
4600 /** @return the monitoring state, or in other words what data we are pushing
4601 * into the route (data from the inputs, data from disk or silence)
4604 Route::monitoring_state () const
4606 return MonitoringInput;
4609 /** @return what we should be metering; either the data coming from the input
4610 * IO or the data that is flowing through the route.
4613 Route::metering_state () const
4615 return MeteringRoute;
4619 Route::has_external_redirects () const
4621 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4623 /* ignore inactive processors and obviously ignore the main
4624 * outs since everything has them and we don't care.
4627 if ((*i)->active() && (*i) != _main_outs && (*i)->does_routing()) {
4635 boost::shared_ptr<Processor>
4636 Route::the_instrument () const
4638 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4639 return the_instrument_unlocked ();
4642 boost::shared_ptr<Processor>
4643 Route::the_instrument_unlocked () const
4645 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4646 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*i);
4647 if (pi && pi->plugin ()->get_info ()->is_instrument ()) {
4651 return boost::shared_ptr<Processor>();
4657 Route::non_realtime_locate (framepos_t pos)
4660 _pannable->transport_located (pos);
4663 if (_delayline.get()) {
4664 _delayline.get()->flush();
4668 //Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
4669 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4671 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4672 (*i)->transport_located (pos);
4675 _roll_delay = _initial_delay;
4679 Route::fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes)
4686 * We don't currently mix MIDI input together, so we don't need the
4687 * complex logic of the audio case.
4690 n_buffers = bufs.count().n_midi ();
4692 for (i = 0; i < n_buffers; ++i) {
4694 boost::shared_ptr<MidiPort> source_port = io->midi (i);
4695 MidiBuffer& buf (bufs.get_midi (i));
4698 buf.copy (source_port->get_midi_buffer(nframes));
4700 buf.silence (nframes);
4706 n_buffers = bufs.count().n_audio();
4708 size_t n_ports = io->n_ports().n_audio();
4709 float scaling = 1.0f;
4711 if (n_ports > n_buffers) {
4712 scaling = ((float) n_buffers) / n_ports;
4715 for (i = 0; i < n_ports; ++i) {
4717 /* if there are more ports than buffers, map them onto buffers
4718 * in a round-robin fashion
4721 boost::shared_ptr<AudioPort> source_port = io->audio (i);
4722 AudioBuffer& buf (bufs.get_audio (i%n_buffers));
4725 if (i < n_buffers) {
4727 /* first time through just copy a channel into
4731 buf.read_from (source_port->get_audio_buffer (nframes), nframes);
4733 if (scaling != 1.0f) {
4734 buf.apply_gain (scaling, nframes);
4739 /* on subsequent times around, merge data from
4740 * the port with what is already there
4743 if (scaling != 1.0f) {
4744 buf.accumulate_with_gain_from (source_port->get_audio_buffer (nframes), nframes, 0, scaling);
4746 buf.accumulate_from (source_port->get_audio_buffer (nframes), nframes);
4751 /* silence any remaining buffers */
4753 for (; i < n_buffers; ++i) {
4754 AudioBuffer& buf (bufs.get_audio (i));
4755 buf.silence (nframes);
4758 /* establish the initial setup of the buffer set, reflecting what was
4759 copied into it. unless, of course, we are the auditioner, in which
4760 case nothing was fed into it from the inputs at all.
4763 if (!is_auditioner()) {
4764 bufs.set_count (io->n_ports());
4768 boost::shared_ptr<AutomationControl>
4769 Route::pan_azimuth_control() const
4772 boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
4774 return boost::shared_ptr<AutomationControl>();
4776 const uint32_t port_channel_post_pan = 2; // gtk2_ardour/mixbus_ports.h
4777 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_channel_post_pan)));
4779 if (!_pannable || !panner()) {
4780 return boost::shared_ptr<AutomationControl>();
4782 return _pannable->pan_azimuth_control;
4786 boost::shared_ptr<AutomationControl>
4787 Route::pan_elevation_control() const
4789 if (Profile->get_mixbus() || !_pannable || !panner()) {
4790 return boost::shared_ptr<AutomationControl>();
4793 set<Evoral::Parameter> c = panner()->what_can_be_automated ();
4795 if (c.find (PanElevationAutomation) != c.end()) {
4796 return _pannable->pan_elevation_control;
4798 return boost::shared_ptr<AutomationControl>();
4801 boost::shared_ptr<AutomationControl>
4802 Route::pan_width_control() const
4804 if (Profile->get_mixbus() || !_pannable || !panner()) {
4805 return boost::shared_ptr<AutomationControl>();
4808 set<Evoral::Parameter> c = panner()->what_can_be_automated ();
4810 if (c.find (PanWidthAutomation) != c.end()) {
4811 return _pannable->pan_width_control;
4813 return boost::shared_ptr<AutomationControl>();
4816 boost::shared_ptr<AutomationControl>
4817 Route::pan_frontback_control() const
4819 if (Profile->get_mixbus() || !_pannable || !panner()) {
4820 return boost::shared_ptr<AutomationControl>();
4823 set<Evoral::Parameter> c = panner()->what_can_be_automated ();
4825 if (c.find (PanFrontBackAutomation) != c.end()) {
4826 return _pannable->pan_frontback_control;
4828 return boost::shared_ptr<AutomationControl>();
4831 boost::shared_ptr<AutomationControl>
4832 Route::pan_lfe_control() const
4834 if (Profile->get_mixbus() || !_pannable || !panner()) {
4835 return boost::shared_ptr<AutomationControl>();
4838 set<Evoral::Parameter> c = panner()->what_can_be_automated ();
4840 if (c.find (PanLFEAutomation) != c.end()) {
4841 return _pannable->pan_lfe_control;
4843 return boost::shared_ptr<AutomationControl>();
4848 Route::eq_band_cnt () const
4850 if (Profile->get_mixbus()) {
4853 /* Ardour has no well-known EQ object */
4858 boost::shared_ptr<AutomationControl>
4859 Route::eq_gain_controllable (uint32_t band) const
4862 boost::shared_ptr<PluginInsert> eq = ch_eq();
4865 return boost::shared_ptr<AutomationControl>();
4868 uint32_t port_number;
4871 if (is_master() || mixbus()) {
4878 if (is_master() || mixbus()) {
4885 if (is_master() || mixbus()) {
4892 return boost::shared_ptr<AutomationControl>();
4895 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_number)));
4897 return boost::shared_ptr<AutomationControl>();
4900 boost::shared_ptr<AutomationControl>
4901 Route::eq_freq_controllable (uint32_t band) const
4905 if (mixbus() || is_master()) {
4906 /* no frequency controls for mixbusses or master */
4907 return boost::shared_ptr<AutomationControl>();
4910 boost::shared_ptr<PluginInsert> eq = ch_eq();
4913 return boost::shared_ptr<AutomationControl>();
4916 uint32_t port_number;
4928 return boost::shared_ptr<AutomationControl>();
4931 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_number)));
4933 return boost::shared_ptr<AutomationControl>();
4937 boost::shared_ptr<AutomationControl>
4938 Route::eq_q_controllable (uint32_t band) const
4940 return boost::shared_ptr<AutomationControl>();
4943 boost::shared_ptr<AutomationControl>
4944 Route::eq_shape_controllable (uint32_t band) const
4946 return boost::shared_ptr<AutomationControl>();
4949 boost::shared_ptr<AutomationControl>
4950 Route::eq_enable_controllable () const
4953 boost::shared_ptr<PluginInsert> eq = ch_eq();
4956 return boost::shared_ptr<AutomationControl>();
4959 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 1)));
4961 return boost::shared_ptr<AutomationControl>();
4965 boost::shared_ptr<AutomationControl>
4966 Route::eq_hpf_controllable () const
4969 boost::shared_ptr<PluginInsert> eq = ch_eq();
4972 return boost::shared_ptr<AutomationControl>();
4975 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
4977 return boost::shared_ptr<AutomationControl>();
4982 Route::eq_band_name (uint32_t band) const
4984 if (Profile->get_mixbus()) {
5000 boost::shared_ptr<AutomationControl>
5001 Route::comp_enable_controllable () const
5004 boost::shared_ptr<PluginInsert> comp = ch_comp();
5007 return boost::shared_ptr<AutomationControl>();
5010 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 1)));
5012 return boost::shared_ptr<AutomationControl>();
5015 boost::shared_ptr<AutomationControl>
5016 Route::comp_threshold_controllable () const
5019 boost::shared_ptr<PluginInsert> comp = ch_comp();
5022 return boost::shared_ptr<AutomationControl>();
5025 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
5028 return boost::shared_ptr<AutomationControl>();
5031 boost::shared_ptr<AutomationControl>
5032 Route::comp_speed_controllable () const
5035 boost::shared_ptr<PluginInsert> comp = ch_comp();
5038 return boost::shared_ptr<AutomationControl>();
5041 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 3)));
5043 return boost::shared_ptr<AutomationControl>();
5046 boost::shared_ptr<AutomationControl>
5047 Route::comp_mode_controllable () const
5050 boost::shared_ptr<PluginInsert> comp = ch_comp();
5053 return boost::shared_ptr<AutomationControl>();
5056 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 4)));
5058 return boost::shared_ptr<AutomationControl>();
5061 boost::shared_ptr<AutomationControl>
5062 Route::comp_makeup_controllable () const
5065 boost::shared_ptr<PluginInsert> comp = ch_comp();
5068 return boost::shared_ptr<AutomationControl>();
5071 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 5)));
5073 return boost::shared_ptr<AutomationControl>();
5076 boost::shared_ptr<AutomationControl>
5077 Route::comp_redux_controllable () const
5080 boost::shared_ptr<PluginInsert> comp = ch_comp();
5083 return boost::shared_ptr<AutomationControl>();
5086 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 6)));
5088 return boost::shared_ptr<AutomationControl>();
5093 Route::comp_mode_name (uint32_t mode) const
5098 return _("Leveler");
5100 return _("Compressor");
5102 return _("Limiter");
5104 return mixbus() ? _("Sidechain") : _("Limiter");
5114 Route::comp_speed_name (uint32_t mode) const
5132 boost::shared_ptr<AutomationControl>
5133 Route::send_level_controllable (uint32_t n) const
5136 boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5138 return boost::shared_ptr<AutomationControl>();
5143 return boost::shared_ptr<AutomationControl>();
5146 const uint32_t port_id = port_channel_post_aux1_level + (2*n); // gtk2_ardour/mixbus_ports.h
5147 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_id)));
5149 boost::shared_ptr<Send> s = boost::dynamic_pointer_cast<Send>(nth_send (n));
5151 return boost::shared_ptr<AutomationControl>();
5153 return s->gain_control ();
5157 boost::shared_ptr<AutomationControl>
5158 Route::send_enable_controllable (uint32_t n) const
5161 boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5163 return boost::shared_ptr<AutomationControl>();
5168 return boost::shared_ptr<AutomationControl>();
5171 const uint32_t port_id = port_channel_post_aux1_asgn + (2*n); // gtk2_ardour/mixbus_ports.h
5172 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_id)));
5174 /* although Ardour sends have enable/disable as part of the Processor
5175 API, it is not exposed as a controllable.
5177 XXX: we should fix this.
5179 return boost::shared_ptr<AutomationControl>();
5184 Route::send_name (uint32_t n) const
5190 boost::shared_ptr<Route> r = _session.get_mixbus (n);
5194 boost::shared_ptr<Processor> p = nth_send (n);
5203 boost::shared_ptr<AutomationControl>
5204 Route::master_send_enable_controllable () const
5207 boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5209 return boost::shared_ptr<AutomationControl>();
5211 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_channel_post_mstr_assign)));
5213 return boost::shared_ptr<AutomationControl>();
5218 Route::slaved () const
5220 if (!_gain_control) {
5223 /* just test one particular control, not all of them */
5224 return _gain_control->slaved ();
5228 Route::slaved_to (boost::shared_ptr<VCA> vca) const
5230 if (!vca || !_gain_control) {
5234 /* just test one particular control, not all of them */
5236 return _gain_control->slaved_to (vca->gain_control());
5240 Route::muted_by_others_soloing () const
5242 if (!can_be_muted_by_others ()) {
5246 return _session.soloing() && !_solo_control->soloed() && !_solo_isolate_control->solo_isolated();
5250 Route::clear_all_solo_state ()
5252 double v = _solo_safe_control->get_value ();
5254 _solo_control->clear_all_solo_state ();
5257 _solo_safe_control->set_value (v, Controllable::NoGroup);