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/boost_debug.h"
38 #include "ardour/amp.h"
39 #include "ardour/audio_buffer.h"
40 #include "ardour/audio_port.h"
41 #include "ardour/audioengine.h"
42 #include "ardour/buffer.h"
43 #include "ardour/buffer_set.h"
44 #include "ardour/capturing_processor.h"
45 #include "ardour/debug.h"
46 #include "ardour/delivery.h"
47 #include "ardour/internal_return.h"
48 #include "ardour/internal_send.h"
49 #include "ardour/meter.h"
50 #include "ardour/midi_buffer.h"
51 #include "ardour/midi_port.h"
52 #include "ardour/monitor_processor.h"
53 #include "ardour/pannable.h"
54 #include "ardour/panner_shell.h"
55 #include "ardour/plugin_insert.h"
56 #include "ardour/port.h"
57 #include "ardour/port_insert.h"
58 #include "ardour/processor.h"
59 #include "ardour/route.h"
60 #include "ardour/route_group.h"
61 #include "ardour/send.h"
62 #include "ardour/session.h"
63 #include "ardour/unknown_processor.h"
64 #include "ardour/utils.h"
69 using namespace ARDOUR;
72 PBD::Signal1<void,RouteSortOrderKey> Route::SyncOrderKeys;
73 PBD::Signal0<void> Route::RemoteControlIDChange;
75 Route::Route (Session& sess, string name, Flag flg, DataType default_type)
76 : SessionObject (sess, name)
78 , GraphNode (sess._process_graph)
84 , _pending_declick (true)
85 , _meter_point (MeterPostFader)
86 , _meter_type (MeterPeak)
88 , _soloed_by_others_upstream (0)
89 , _soloed_by_others_downstream (0)
91 , _denormal_protection (false)
94 , _declickable (false)
95 , _mute_master (new MuteMaster (sess, name))
96 , _have_internal_generator (false)
98 , _default_type (default_type)
99 , _remote_control_id (0)
100 , _in_configure_processors (false)
101 , _custom_meter_position_noted (false)
102 , _last_custom_meter_was_at_end (false)
104 processor_max_streams.reset();
110 /* add standard controls */
112 _solo_control.reset (new SoloControllable (X_("solo"), shared_from_this ()));
113 _mute_control.reset (new MuteControllable (X_("mute"), shared_from_this ()));
115 _solo_control->set_flags (Controllable::Flag (_solo_control->flags() | Controllable::Toggle));
116 _mute_control->set_flags (Controllable::Flag (_mute_control->flags() | Controllable::Toggle));
118 add_control (_solo_control);
119 add_control (_mute_control);
123 if (!(_flags & Route::MonitorOut)) {
124 _pannable.reset (new Pannable (_session));
127 /* input and output objects */
129 _input.reset (new IO (_session, _name, IO::Input, _default_type));
130 _output.reset (new IO (_session, _name, IO::Output, _default_type));
132 _input->changed.connect_same_thread (*this, boost::bind (&Route::input_change_handler, this, _1, _2));
133 _input->PortCountChanging.connect_same_thread (*this, boost::bind (&Route::input_port_count_changing, this, _1));
135 _output->changed.connect_same_thread (*this, boost::bind (&Route::output_change_handler, this, _1, _2));
137 /* add amp processor */
139 _amp.reset (new Amp (_session));
140 add_processor (_amp, PostFader);
142 /* create standard processors: meter, main outs, monitor out;
143 they will be added to _processors by setup_invisible_processors ()
146 _meter.reset (new PeakMeter (_session, _name));
147 _meter->set_display_to_user (false);
150 _main_outs.reset (new Delivery (_session, _output, _pannable, _mute_master, _name, Delivery::Main));
151 _main_outs->activate ();
154 /* where we listen to tracks */
155 _intreturn.reset (new InternalReturn (_session));
156 _intreturn->activate ();
158 /* the thing that provides proper control over a control/monitor/listen bus
159 (such as per-channel cut, dim, solo, invert, etc).
161 _monitor_control.reset (new MonitorProcessor (_session));
162 _monitor_control->activate ();
165 if (is_master() || is_monitor() || is_auditioner()) {
166 _mute_master->set_solo_ignore (true);
169 /* now that we have _meter, its safe to connect to this */
171 Metering::Meter.connect_same_thread (*this, (boost::bind (&Route::meter, this)));
174 /* run a configure so that the invisible processors get set up */
175 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
176 configure_processors (0);
184 DEBUG_TRACE (DEBUG::Destruction, string_compose ("route %1 destructor\n", _name));
186 /* do this early so that we don't get incoming signals as we are going through destruction
191 /* don't use clear_processors here, as it depends on the session which may
192 be half-destroyed by now
195 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
196 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
197 (*i)->drop_references ();
200 _processors.clear ();
204 Route::set_remote_control_id (uint32_t id, bool notify_class_listeners)
206 if (Config->get_remote_model() != UserOrdered) {
210 set_remote_control_id_internal (id, notify_class_listeners);
214 Route::set_remote_control_id_internal (uint32_t id, bool notify_class_listeners)
216 /* force IDs for master/monitor busses and prevent
217 any other route from accidentally getting these IDs
218 (i.e. legacy sessions)
221 if (is_master() && id != MasterBusRemoteControlID) {
222 id = MasterBusRemoteControlID;
225 if (is_monitor() && id != MonitorBusRemoteControlID) {
226 id = MonitorBusRemoteControlID;
233 /* don't allow it to collide */
235 if (!is_master () && !is_monitor() &&
236 (id == MasterBusRemoteControlID || id == MonitorBusRemoteControlID)) {
237 id += MonitorBusRemoteControlID;
240 if (id != remote_control_id()) {
241 _remote_control_id = id;
242 RemoteControlIDChanged ();
244 if (notify_class_listeners) {
245 RemoteControlIDChange ();
251 Route::remote_control_id() const
254 return MasterBusRemoteControlID;
258 return MonitorBusRemoteControlID;
261 return _remote_control_id;
265 Route::has_order_key (RouteSortOrderKey key) const
267 return (order_keys.find (key) != order_keys.end());
271 Route::order_key (RouteSortOrderKey key) const
273 OrderKeys::const_iterator i = order_keys.find (key);
275 if (i == order_keys.end()) {
283 Route::sync_order_keys (RouteSortOrderKey base)
285 /* this is called after changes to 1 or more route order keys have been
286 * made, and we want to sync up.
289 OrderKeys::iterator i = order_keys.find (base);
291 if (i == order_keys.end()) {
295 for (OrderKeys::iterator k = order_keys.begin(); k != order_keys.end(); ++k) {
297 if (k->first != base) {
298 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("%1 set key for %2 to %3 from %4\n",
300 enum_2_string (k->first),
302 enum_2_string (base)));
304 k->second = i->second;
310 Route::set_remote_control_id_from_order_key (RouteSortOrderKey /*key*/, uint32_t rid)
312 if (is_master() || is_monitor() || is_auditioner()) {
313 /* hard-coded remote IDs, or no remote ID */
317 if (_remote_control_id != rid) {
318 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("%1: set edit-based RID to %2\n", name(), rid));
319 _remote_control_id = rid;
320 RemoteControlIDChanged (); /* EMIT SIGNAL (per-route) */
323 /* don't emit the class-level RID signal RemoteControlIDChange here,
324 leave that to the entity that changed the order key, so that we
325 don't get lots of emissions for no good reasons (e.g. when changing
326 all route order keys).
328 See Session::sync_remote_id_from_order_keys() for the (primary|only)
329 spot where that is emitted.
334 Route::set_order_key (RouteSortOrderKey key, uint32_t n)
336 OrderKeys::iterator i = order_keys.find (key);
338 if (i != order_keys.end() && i->second == n) {
344 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("%1 order key %2 set to %3\n",
345 name(), enum_2_string (key), order_key (key)));
347 _session.set_dirty ();
351 Route::ensure_track_or_route_name(string name, Session &session)
353 string newname = name;
355 while (!session.io_name_is_legal (newname)) {
356 newname = bump_name_once (newname, '.');
364 Route::inc_gain (gain_t fraction, void *src)
366 _amp->inc_gain (fraction, src);
370 Route::set_gain (gain_t val, void *src)
372 if (src != 0 && _route_group && src != _route_group && _route_group->is_active() && _route_group->is_gain()) {
374 if (_route_group->is_relative()) {
376 gain_t usable_gain = _amp->gain();
377 if (usable_gain < 0.000001f) {
378 usable_gain = 0.000001f;
382 if (delta < 0.000001f) {
386 delta -= usable_gain;
391 gain_t factor = delta / usable_gain;
394 factor = _route_group->get_max_factor(factor);
395 if (factor == 0.0f) {
396 _amp->gain_control()->Changed(); /* EMIT SIGNAL */
400 factor = _route_group->get_min_factor(factor);
401 if (factor == 0.0f) {
402 _amp->gain_control()->Changed(); /* EMIT SIGNAL */
407 _route_group->foreach_route (boost::bind (&Route::inc_gain, _1, factor, _route_group));
411 _route_group->foreach_route (boost::bind (&Route::set_gain, _1, val, _route_group));
417 if (val == _amp->gain()) {
421 _amp->set_gain (val, src);
425 Route::maybe_declick (BufferSet&, framecnt_t, int)
427 /* this is the "bus" implementation and they never declick.
432 /** Process this route for one (sub) cycle (process thread)
434 * @param bufs Scratch buffers to use for the signal path
435 * @param start_frame Initial transport frame
436 * @param end_frame Final transport frame
437 * @param nframes Number of frames to output (to ports)
439 * Note that (end_frame - start_frame) may not be equal to nframes when the
440 * transport speed isn't 1.0 (eg varispeed).
443 Route::process_output_buffers (BufferSet& bufs,
444 framepos_t start_frame, framepos_t end_frame, pframes_t nframes,
445 int declick, bool gain_automation_ok)
447 bufs.set_is_silent (false);
449 /* figure out if we're going to use gain automation */
450 if (gain_automation_ok) {
451 _amp->set_gain_automation_buffer (_session.gain_automation_buffer ());
452 _amp->setup_gain_automation (start_frame, end_frame, nframes);
454 _amp->apply_gain_automation (false);
457 /* Tell main outs what to do about monitoring. We do this so that
458 on a transition between monitoring states we get a de-clicking gain
459 change in the _main_outs delivery.
462 _main_outs->no_outs_cuz_we_no_monitor (monitoring_state () == MonitoringSilence);
464 /* -------------------------------------------------------------------------------------------
465 GLOBAL DECLICK (for transport changes etc.)
466 ----------------------------------------------------------------------------------------- */
468 maybe_declick (bufs, nframes, declick);
469 _pending_declick = 0;
471 /* -------------------------------------------------------------------------------------------
472 DENORMAL CONTROL/PHASE INVERT
473 ----------------------------------------------------------------------------------------- */
475 if (_phase_invert.any ()) {
479 if (_denormal_protection || Config->get_denormal_protection()) {
481 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
482 Sample* const sp = i->data();
484 if (_phase_invert[chn]) {
485 for (pframes_t nx = 0; nx < nframes; ++nx) {
490 for (pframes_t nx = 0; nx < nframes; ++nx) {
498 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
499 Sample* const sp = i->data();
501 if (_phase_invert[chn]) {
502 for (pframes_t nx = 0; nx < nframes; ++nx) {
511 if (_denormal_protection || Config->get_denormal_protection()) {
513 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
514 Sample* const sp = i->data();
515 for (pframes_t nx = 0; nx < nframes; ++nx) {
523 /* -------------------------------------------------------------------------------------------
525 ----------------------------------------------------------------------------------------- */
527 /* set this to be true if the meter will already have been ::run() earlier */
528 bool const meter_already_run = metering_state() == MeteringInput;
530 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
532 if (meter_already_run && boost::dynamic_pointer_cast<PeakMeter> (*i)) {
533 /* don't ::run() the meter, otherwise it will have its previous peak corrupted */
538 /* if it has any inputs, make sure they match */
539 if (boost::dynamic_pointer_cast<UnknownProcessor> (*i) == 0 && (*i)->input_streams() != ChanCount::ZERO) {
540 if (bufs.count() != (*i)->input_streams()) {
542 DEBUG::Processors, string_compose (
543 "%1 bufs = %2 input for %3 = %4\n",
544 _name, bufs.count(), (*i)->name(), (*i)->input_streams()
552 /* should we NOT run plugins here if the route is inactive?
553 do we catch route != active somewhere higher?
556 (*i)->run (bufs, start_frame, end_frame, nframes, *i != _processors.back());
557 bufs.set_count ((*i)->output_streams());
562 Route::n_process_buffers ()
564 return max (_input->n_ports(), processor_max_streams);
568 Route::monitor_run (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
570 assert (is_monitor());
571 BufferSet& bufs (_session.get_scratch_buffers (n_process_buffers()));
572 passthru (bufs, start_frame, end_frame, nframes, declick);
576 Route::passthru (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
580 if (is_monitor() && _session.listening() && !_session.is_auditioning()) {
582 /* control/monitor bus ignores input ports when something is
583 feeding the listen "stream". data will "arrive" into the
584 route from the intreturn processor element.
587 bufs.silence (nframes, 0);
590 write_out_of_band_data (bufs, start_frame, end_frame, nframes);
591 process_output_buffers (bufs, start_frame, end_frame, nframes, declick, true);
595 Route::passthru_silence (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
597 BufferSet& bufs (_session.get_silent_buffers (n_process_buffers()));
599 bufs.set_count (_input->n_ports());
600 write_out_of_band_data (bufs, start_frame, end_frame, nframes);
601 process_output_buffers (bufs, start_frame, end_frame, nframes, declick, false);
605 Route::set_listen (bool yn, void* src)
611 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
612 _route_group->foreach_route (boost::bind (&Route::set_listen, _1, yn, _route_group));
617 if (yn != _monitor_send->active()) {
619 _monitor_send->activate ();
620 _mute_master->set_soloed (true);
622 _monitor_send->deactivate ();
623 _mute_master->set_soloed (false);
626 listen_changed (src); /* EMIT SIGNAL */
632 Route::listening_via_monitor () const
635 return _monitor_send->active ();
642 Route::set_solo_safe (bool yn, void *src)
644 if (_solo_safe != yn) {
646 solo_safe_changed (src);
651 Route::solo_safe() const
657 Route::set_solo (bool yn, void *src)
660 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 ignore solo change due to solo-safe\n", name()));
664 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
665 _route_group->foreach_route (boost::bind (&Route::set_solo, _1, yn, _route_group));
669 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1: set solo => %2, src: %3 grp ? %4 currently self-soloed ? %5\n",
670 name(), yn, src, (src == _route_group), self_soloed()));
672 if (self_soloed() != yn) {
674 set_mute_master_solo ();
675 solo_changed (true, src); /* EMIT SIGNAL */
676 _solo_control->Changed (); /* EMIT SIGNAL */
681 Route::set_self_solo (bool yn)
683 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1: set SELF solo => %2\n", name(), yn));
688 Route::mod_solo_by_others_upstream (int32_t delta)
691 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 ignore solo-by-upstream due to solo-safe\n", name()));
695 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 mod solo-by-upstream by %2, current up = %3 down = %4\n",
696 name(), delta, _soloed_by_others_upstream, _soloed_by_others_downstream));
698 uint32_t old_sbu = _soloed_by_others_upstream;
701 if (_soloed_by_others_upstream >= (uint32_t) abs (delta)) {
702 _soloed_by_others_upstream += delta;
704 _soloed_by_others_upstream = 0;
707 _soloed_by_others_upstream += delta;
710 DEBUG_TRACE (DEBUG::Solo, string_compose (
711 "%1 SbU delta %2 = %3 old = %4 sbd %5 ss %6 exclusive %7\n",
712 name(), delta, _soloed_by_others_upstream, old_sbu,
713 _soloed_by_others_downstream, _self_solo, Config->get_exclusive_solo()));
715 /* push the inverse solo change to everything that feeds us.
717 This is important for solo-within-group. When we solo 1 track out of N that
718 feed a bus, that track will cause mod_solo_by_upstream (+1) to be called
719 on the bus. The bus then needs to call mod_solo_by_downstream (-1) on all
720 tracks that feed it. This will silence them if they were audible because
721 of a bus solo, but the newly soloed track will still be audible (because
724 but .. do this only when we are being told to solo-by-upstream (i.e delta = +1),
728 if ((_self_solo || _soloed_by_others_downstream) &&
729 ((old_sbu == 0 && _soloed_by_others_upstream > 0) ||
730 (old_sbu > 0 && _soloed_by_others_upstream == 0))) {
732 if (delta > 0 || !Config->get_exclusive_solo()) {
733 DEBUG_TRACE (DEBUG::Solo, "\t ... INVERT push\n");
734 for (FedBy::iterator i = _fed_by.begin(); i != _fed_by.end(); ++i) {
735 boost::shared_ptr<Route> sr = i->r.lock();
737 sr->mod_solo_by_others_downstream (-delta);
743 set_mute_master_solo ();
744 solo_changed (false, this);
748 Route::mod_solo_by_others_downstream (int32_t delta)
751 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 ignore solo-by-downstream due to solo safe\n", name()));
755 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 mod solo-by-downstream by %2, current up = %3 down = %4\n",
756 name(), delta, _soloed_by_others_upstream, _soloed_by_others_downstream));
759 if (_soloed_by_others_downstream >= (uint32_t) abs (delta)) {
760 _soloed_by_others_downstream += delta;
762 _soloed_by_others_downstream = 0;
765 _soloed_by_others_downstream += delta;
768 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 SbD delta %2 = %3\n", name(), delta, _soloed_by_others_downstream));
770 set_mute_master_solo ();
771 solo_changed (false, this);
775 Route::set_mute_master_solo ()
777 _mute_master->set_soloed (self_soloed() || soloed_by_others_downstream() || soloed_by_others_upstream());
781 Route::set_solo_isolated (bool yn, void *src)
783 if (is_master() || is_monitor() || is_auditioner()) {
787 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
788 _route_group->foreach_route (boost::bind (&Route::set_solo_isolated, _1, yn, _route_group));
792 /* forward propagate solo-isolate status to everything fed by this route, but not those via sends only */
794 boost::shared_ptr<RouteList> routes = _session.get_routes ();
795 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
797 if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
802 bool does_feed = direct_feeds_according_to_graph (*i, &sends_only); // we will recurse anyway, so don't use ::feeds()
804 if (does_feed && !sends_only) {
805 (*i)->set_solo_isolated (yn, (*i)->route_group());
809 /* XXX should we back-propagate as well? (April 2010: myself and chris goddard think not) */
811 bool changed = false;
814 if (_solo_isolated == 0) {
815 _mute_master->set_solo_ignore (true);
820 if (_solo_isolated > 0) {
822 if (_solo_isolated == 0) {
823 _mute_master->set_solo_ignore (false);
830 solo_isolated_changed (src);
835 Route::solo_isolated () const
837 return _solo_isolated > 0;
841 Route::set_mute_points (MuteMaster::MutePoint mp)
843 _mute_master->set_mute_points (mp);
844 mute_points_changed (); /* EMIT SIGNAL */
846 if (_mute_master->muted_by_self()) {
847 mute_changed (this); /* EMIT SIGNAL */
848 _mute_control->Changed (); /* EMIT SIGNAL */
853 Route::set_mute (bool yn, void *src)
855 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_mute()) {
856 _route_group->foreach_route (boost::bind (&Route::set_mute, _1, yn, _route_group));
861 _mute_master->set_muted_by_self (yn);
862 /* allow any derived classes to respond to the mute change
863 before anybody else knows about it.
866 /* tell everyone else */
867 mute_changed (src); /* EMIT SIGNAL */
868 _mute_control->Changed (); /* EMIT SIGNAL */
873 Route::muted () const
875 return _mute_master->muted_by_self();
880 dump_processors(const string& name, const list<boost::shared_ptr<Processor> >& procs)
882 cerr << name << " {" << endl;
883 for (list<boost::shared_ptr<Processor> >::const_iterator p = procs.begin();
884 p != procs.end(); ++p) {
885 cerr << "\t" << (*p)->name() << " ID = " << (*p)->id() << " @ " << (*p) << endl;
891 /** Supposing that we want to insert a Processor at a given Placement, return
892 * the processor to add the new one before (or 0 to add at the end).
894 boost::shared_ptr<Processor>
895 Route::before_processor_for_placement (Placement p)
897 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
899 ProcessorList::iterator loc;
902 /* generic pre-fader: insert immediately before the amp */
903 loc = find (_processors.begin(), _processors.end(), _amp);
905 /* generic post-fader: insert right before the main outs */
906 loc = find (_processors.begin(), _processors.end(), _main_outs);
909 return loc != _processors.end() ? *loc : boost::shared_ptr<Processor> ();
912 /** Supposing that we want to insert a Processor at a given index, return
913 * the processor to add the new one before (or 0 to add at the end).
915 boost::shared_ptr<Processor>
916 Route::before_processor_for_index (int index)
919 return boost::shared_ptr<Processor> ();
922 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
924 ProcessorList::iterator i = _processors.begin ();
926 while (i != _processors.end() && j < index) {
927 if ((*i)->display_to_user()) {
934 return (i != _processors.end() ? *i : boost::shared_ptr<Processor> ());
937 /** Add a processor either pre- or post-fader
938 * @return 0 on success, non-0 on failure.
941 Route::add_processor (boost::shared_ptr<Processor> processor, Placement placement, ProcessorStreams* err, bool activation_allowed)
943 return add_processor (processor, before_processor_for_placement (placement), err, activation_allowed);
947 /** Add a processor to a route such that it ends up with a given index into the visible processors.
948 * @param index Index to add the processor at, or -1 to add at the end of the list.
949 * @return 0 on success, non-0 on failure.
952 Route::add_processor_by_index (boost::shared_ptr<Processor> processor, int index, ProcessorStreams* err, bool activation_allowed)
954 return add_processor (processor, before_processor_for_index (index), err, activation_allowed);
957 /** Add a processor to the route.
958 * @param before An existing processor in the list, or 0; the new processor will be inserted immediately before it (or at the end).
959 * @return 0 on success, non-0 on failure.
962 Route::add_processor (boost::shared_ptr<Processor> processor, boost::shared_ptr<Processor> before, ProcessorStreams* err, bool activation_allowed)
964 assert (processor != _meter);
965 assert (processor != _main_outs);
967 DEBUG_TRACE (DEBUG::Processors, string_compose (
968 "%1 adding processor %2\n", name(), processor->name()));
970 if (!_session.engine().connected() || !processor) {
975 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
976 ProcessorState pstate (this);
978 boost::shared_ptr<PluginInsert> pi;
979 boost::shared_ptr<PortInsert> porti;
981 if (processor == _amp) {
982 /* Ensure that only one amp is in the list at any time */
983 ProcessorList::iterator check = find (_processors.begin(), _processors.end(), processor);
984 if (check != _processors.end()) {
985 if (before == _amp) {
986 /* Already in position; all is well */
989 _processors.erase (check);
994 assert (find (_processors.begin(), _processors.end(), processor) == _processors.end ());
996 ProcessorList::iterator loc;
998 /* inserting before a processor; find it */
999 loc = find (_processors.begin(), _processors.end(), before);
1000 if (loc == _processors.end ()) {
1005 /* inserting at end */
1006 loc = _processors.end ();
1009 _processors.insert (loc, processor);
1011 // Set up processor list channels. This will set processor->[input|output]_streams(),
1012 // configure redirect ports properly, etc.
1015 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1017 if (configure_processors_unlocked (err)) {
1019 configure_processors_unlocked (0); // it worked before we tried to add it ...
1024 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(processor)) != 0) {
1026 if (pi->has_no_inputs ()) {
1027 /* generator plugin */
1028 _have_internal_generator = true;
1033 if (activation_allowed && !_session.get_disable_all_loaded_plugins()) {
1034 processor->activate ();
1037 processor->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
1039 _output->set_user_latency (0);
1042 reset_instrument_info ();
1043 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1044 set_processor_positions ();
1050 Route::add_processor_from_xml_2X (const XMLNode& node, int version)
1052 const XMLProperty *prop;
1055 boost::shared_ptr<Processor> processor;
1057 /* bit of a hack: get the `placement' property from the <Redirect> tag here
1058 so that we can add the processor in the right place (pre/post-fader)
1061 XMLNodeList const & children = node.children ();
1062 XMLNodeList::const_iterator i = children.begin ();
1064 while (i != children.end() && (*i)->name() != X_("Redirect")) {
1068 Placement placement = PreFader;
1070 if (i != children.end()) {
1071 if ((prop = (*i)->property (X_("placement"))) != 0) {
1072 placement = Placement (string_2_enum (prop->value(), placement));
1076 if (node.name() == "Insert") {
1078 if ((prop = node.property ("type")) != 0) {
1080 if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
1081 prop->value() == "lv2" ||
1082 prop->value() == "windows-vst" ||
1083 prop->value() == "lxvst" ||
1084 prop->value() == "audiounit") {
1086 processor.reset (new PluginInsert (_session));
1090 processor.reset (new PortInsert (_session, _pannable, _mute_master));
1095 } else if (node.name() == "Send") {
1097 processor.reset (new Send (_session, _pannable, _mute_master));
1101 error << string_compose(_("unknown Processor type \"%1\"; ignored"), node.name()) << endmsg;
1105 if (processor->set_state (node, version)) {
1109 return (add_processor (processor, placement) == 0);
1112 catch (failed_constructor &err) {
1113 warning << _("processor could not be created. Ignored.") << endmsg;
1119 Route::add_processors (const ProcessorList& others, boost::shared_ptr<Processor> before, ProcessorStreams* err)
1121 /* NOTE: this is intended to be used ONLY when copying
1122 processors from another Route. Hence the subtle
1123 differences between this and ::add_processor()
1126 ProcessorList::iterator loc;
1129 loc = find(_processors.begin(), _processors.end(), before);
1131 /* nothing specified - at end */
1132 loc = _processors.end ();
1135 if (!_session.engine().connected()) {
1139 if (others.empty()) {
1144 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1145 ProcessorState pstate (this);
1147 for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
1153 boost::shared_ptr<PluginInsert> pi;
1155 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1159 _processors.insert (loc, *i);
1161 if ((*i)->active()) {
1166 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1167 if (configure_processors_unlocked (err)) {
1169 configure_processors_unlocked (0); // it worked before we tried to add it ...
1174 (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
1177 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
1178 boost::shared_ptr<PluginInsert> pi;
1180 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1181 if (pi->has_no_inputs ()) {
1182 _have_internal_generator = true;
1188 _output->set_user_latency (0);
1191 reset_instrument_info ();
1192 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1193 set_processor_positions ();
1199 Route::placement_range(Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end)
1201 if (p == PreFader) {
1202 start = _processors.begin();
1203 end = find(_processors.begin(), _processors.end(), _amp);
1205 start = find(_processors.begin(), _processors.end(), _amp);
1207 end = _processors.end();
1211 /** Turn off all processors with a given placement
1212 * @param p Placement of processors to disable
1215 Route::disable_processors (Placement p)
1217 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1219 ProcessorList::iterator start, end;
1220 placement_range(p, start, end);
1222 for (ProcessorList::iterator i = start; i != end; ++i) {
1223 (*i)->deactivate ();
1226 _session.set_dirty ();
1229 /** Turn off all redirects
1232 Route::disable_processors ()
1234 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1236 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1237 (*i)->deactivate ();
1240 _session.set_dirty ();
1243 /** Turn off all redirects with a given placement
1244 * @param p Placement of redirects to disable
1247 Route::disable_plugins (Placement p)
1249 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1251 ProcessorList::iterator start, end;
1252 placement_range(p, start, end);
1254 for (ProcessorList::iterator i = start; i != end; ++i) {
1255 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1256 (*i)->deactivate ();
1260 _session.set_dirty ();
1263 /** Turn off all plugins
1266 Route::disable_plugins ()
1268 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1270 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1271 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1272 (*i)->deactivate ();
1276 _session.set_dirty ();
1281 Route::ab_plugins (bool forward)
1283 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1287 /* forward = turn off all active redirects, and mark them so that the next time
1288 we go the other way, we will revert them
1291 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1292 if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1296 if ((*i)->active()) {
1297 (*i)->deactivate ();
1298 (*i)->set_next_ab_is_active (true);
1300 (*i)->set_next_ab_is_active (false);
1306 /* backward = if the redirect was marked to go active on the next ab, do so */
1308 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1310 if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1314 if ((*i)->get_next_ab_is_active()) {
1317 (*i)->deactivate ();
1322 _session.set_dirty ();
1326 /** Remove processors with a given placement.
1327 * @param p Placement of processors to remove.
1330 Route::clear_processors (Placement p)
1332 if (!_session.engine().connected()) {
1336 bool already_deleting = _session.deletion_in_progress();
1337 if (!already_deleting) {
1338 _session.set_deletion_in_progress();
1342 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1343 ProcessorList new_list;
1344 ProcessorStreams err;
1345 bool seen_amp = false;
1347 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1353 if ((*i) == _amp || (*i) == _meter || (*i) == _main_outs) {
1355 /* you can't remove these */
1357 new_list.push_back (*i);
1364 new_list.push_back (*i);
1367 (*i)->drop_references ();
1375 (*i)->drop_references ();
1378 new_list.push_back (*i);
1385 _processors = new_list;
1388 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1389 configure_processors_unlocked (&err); // this can't fail
1393 processor_max_streams.reset();
1394 _have_internal_generator = false;
1395 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1396 set_processor_positions ();
1398 reset_instrument_info ();
1400 if (!already_deleting) {
1401 _session.clear_deletion_in_progress();
1406 Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err, bool need_process_lock)
1408 // TODO once the export point can be configured properly, do something smarter here
1409 if (processor == _capturing_processor) {
1410 _capturing_processor.reset();
1413 /* these can never be removed */
1415 if (processor == _amp || processor == _meter || processor == _main_outs) {
1419 if (!_session.engine().connected()) {
1423 processor_max_streams.reset();
1426 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1427 ProcessorState pstate (this);
1429 ProcessorList::iterator i;
1430 bool removed = false;
1432 for (i = _processors.begin(); i != _processors.end(); ) {
1433 if (*i == processor) {
1435 /* move along, see failure case for configure_processors()
1436 where we may need to reconfigure the processor.
1439 /* stop redirects that send signals to JACK ports
1440 from causing noise as a result of no longer being
1444 boost::shared_ptr<IOProcessor> iop;
1446 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (*i)) != 0) {
1450 i = _processors.erase (i);
1458 _output->set_user_latency (0);
1466 if (need_process_lock) {
1467 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1469 if (configure_processors_unlocked (err)) {
1471 /* we know this will work, because it worked before :) */
1472 configure_processors_unlocked (0);
1476 if (configure_processors_unlocked (err)) {
1478 /* we know this will work, because it worked before :) */
1479 configure_processors_unlocked (0);
1484 _have_internal_generator = false;
1486 for (i = _processors.begin(); i != _processors.end(); ++i) {
1487 boost::shared_ptr<PluginInsert> pi;
1489 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1490 if (pi->has_no_inputs ()) {
1491 _have_internal_generator = true;
1498 reset_instrument_info ();
1499 processor->drop_references ();
1500 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1501 set_processor_positions ();
1507 Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
1509 ProcessorList deleted;
1511 if (!_session.engine().connected()) {
1515 processor_max_streams.reset();
1518 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1519 ProcessorState pstate (this);
1521 ProcessorList::iterator i;
1522 boost::shared_ptr<Processor> processor;
1524 for (i = _processors.begin(); i != _processors.end(); ) {
1528 /* these can never be removed */
1530 if (processor == _amp || processor == _meter || processor == _main_outs) {
1535 /* see if its in the list of processors to delete */
1537 if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
1542 /* stop IOProcessors that send to JACK ports
1543 from causing noise as a result of no longer being
1547 boost::shared_ptr<IOProcessor> iop;
1549 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (processor)) != 0) {
1553 deleted.push_back (processor);
1554 i = _processors.erase (i);
1557 if (deleted.empty()) {
1558 /* none of those in the requested list were found */
1562 _output->set_user_latency (0);
1565 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1567 if (configure_processors_unlocked (err)) {
1569 /* we know this will work, because it worked before :) */
1570 configure_processors_unlocked (0);
1575 _have_internal_generator = false;
1577 for (i = _processors.begin(); i != _processors.end(); ++i) {
1578 boost::shared_ptr<PluginInsert> pi;
1580 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1581 if (pi->has_no_inputs ()) {
1582 _have_internal_generator = true;
1589 /* now try to do what we need to so that those that were removed will be deleted */
1591 for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
1592 (*i)->drop_references ();
1595 reset_instrument_info ();
1596 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1597 set_processor_positions ();
1603 Route::reset_instrument_info ()
1605 boost::shared_ptr<Processor> instr = the_instrument();
1607 _instrument_info.set_internal_instrument (instr);
1611 /** Caller must hold process lock */
1613 Route::configure_processors (ProcessorStreams* err)
1615 assert (!AudioEngine::instance()->process_lock().trylock());
1617 if (!_in_configure_processors) {
1618 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1619 return configure_processors_unlocked (err);
1626 Route::input_streams () const
1628 return _input->n_ports ();
1631 list<pair<ChanCount, ChanCount> >
1632 Route::try_configure_processors (ChanCount in, ProcessorStreams* err)
1634 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1636 return try_configure_processors_unlocked (in, err);
1639 list<pair<ChanCount, ChanCount> >
1640 Route::try_configure_processors_unlocked (ChanCount in, ProcessorStreams* err)
1642 // Check each processor in order to see if we can configure as requested
1644 list<pair<ChanCount, ChanCount> > configuration;
1647 DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
1648 DEBUG_TRACE (DEBUG::Processors, "{\n");
1650 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1652 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1653 DEBUG_TRACE (DEBUG::Processors, "--- CONFIGURE ABORTED due to unknown processor.\n");
1657 if ((*p)->can_support_io_configuration(in, out)) {
1658 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID=%2 in=%3 out=%4\n",(*p)->name(), (*p)->id(), in, out));
1659 configuration.push_back(make_pair(in, out));
1666 DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
1667 DEBUG_TRACE (DEBUG::Processors, string_compose ("---- %1 cannot support in=%2 out=%3\n", (*p)->name(), in, out));
1668 DEBUG_TRACE (DEBUG::Processors, "}\n");
1669 return list<pair<ChanCount, ChanCount> > ();
1673 DEBUG_TRACE (DEBUG::Processors, "}\n");
1675 return configuration;
1678 /** Set the input/output configuration of each processor in the processors list.
1679 * Caller must hold process lock.
1680 * Return 0 on success, otherwise configuration is impossible.
1683 Route::configure_processors_unlocked (ProcessorStreams* err)
1685 assert (!AudioEngine::instance()->process_lock().trylock());
1687 if (_in_configure_processors) {
1691 /* put invisible processors where they should be */
1692 setup_invisible_processors ();
1694 _in_configure_processors = true;
1696 list<pair<ChanCount, ChanCount> > configuration = try_configure_processors_unlocked (input_streams (), err);
1698 if (configuration.empty ()) {
1699 _in_configure_processors = false;
1705 list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1706 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1708 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1712 (*p)->configure_io(c->first, c->second);
1713 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1714 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1719 _meter->reset_max_channels (processor_max_streams);
1722 /* make sure we have sufficient scratch buffers to cope with the new processor
1725 _session.ensure_buffers (n_process_buffers ());
1727 DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
1729 _in_configure_processors = false;
1733 /** Set all visible processors to a given active state (except Fader, whose state is not changed)
1734 * @param state New active state for those processors.
1737 Route::all_visible_processors_active (bool state)
1739 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1741 if (_processors.empty()) {
1745 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1746 if (!(*i)->display_to_user() || boost::dynamic_pointer_cast<Amp> (*i)) {
1753 (*i)->deactivate ();
1757 _session.set_dirty ();
1761 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
1763 /* "new_order" is an ordered list of processors to be positioned according to "placement".
1764 NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
1765 processors in the current actual processor list that are hidden. Any visible processors
1766 in the current list but not in "new_order" will be assumed to be deleted.
1770 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1771 ProcessorState pstate (this);
1773 ProcessorList::iterator oiter;
1774 ProcessorList::const_iterator niter;
1775 ProcessorList as_it_will_be;
1777 oiter = _processors.begin();
1778 niter = new_order.begin();
1780 while (niter != new_order.end()) {
1782 /* if the next processor in the old list is invisible (i.e. should not be in the new order)
1783 then append it to the temp list.
1785 Otherwise, see if the next processor in the old list is in the new list. if not,
1786 its been deleted. If its there, append it to the temp list.
1789 if (oiter == _processors.end()) {
1791 /* no more elements in the old list, so just stick the rest of
1792 the new order onto the temp list.
1795 as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
1796 while (niter != new_order.end()) {
1803 if (!(*oiter)->display_to_user()) {
1805 as_it_will_be.push_back (*oiter);
1809 /* visible processor: check that its in the new order */
1811 if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
1812 /* deleted: do nothing, shared_ptr<> will clean up */
1814 /* ignore this one, and add the next item from the new order instead */
1815 as_it_will_be.push_back (*niter);
1820 /* now remove from old order - its taken care of no matter what */
1821 oiter = _processors.erase (oiter);
1826 _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
1828 /* If the meter is in a custom position, find it and make a rough note of its position */
1829 maybe_note_meter_position ();
1832 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1834 if (configure_processors_unlocked (err)) {
1841 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1842 set_processor_positions ();
1854 Route::get_template()
1856 return state(false);
1860 Route::state(bool full_state)
1862 XMLNode *node = new XMLNode("Route");
1863 ProcessorList::iterator i;
1866 id().print (buf, sizeof (buf));
1867 node->add_property("id", buf);
1868 node->add_property ("name", _name);
1869 node->add_property("default-type", _default_type.to_string());
1872 node->add_property("flags", enum_2_string (_flags));
1875 node->add_property("active", _active?"yes":"no");
1877 boost::to_string (_phase_invert, p);
1878 node->add_property("phase-invert", p);
1879 node->add_property("denormal-protection", _denormal_protection?"yes":"no");
1880 node->add_property("meter-point", enum_2_string (_meter_point));
1882 node->add_property("meter-type", enum_2_string (_meter_type));
1885 node->add_property("route-group", _route_group->name());
1888 string order_string;
1889 OrderKeys::iterator x = order_keys.begin();
1891 while (x != order_keys.end()) {
1892 order_string += enum_2_string ((*x).first);
1893 order_string += '=';
1894 snprintf (buf, sizeof(buf), "%" PRId32, (*x).second);
1895 order_string += buf;
1899 if (x == order_keys.end()) {
1903 order_string += ':';
1905 node->add_property ("order-keys", order_string);
1906 node->add_property ("self-solo", (_self_solo ? "yes" : "no"));
1907 snprintf (buf, sizeof (buf), "%d", _soloed_by_others_upstream);
1908 node->add_property ("soloed-by-upstream", buf);
1909 snprintf (buf, sizeof (buf), "%d", _soloed_by_others_downstream);
1910 node->add_property ("soloed-by-downstream", buf);
1911 node->add_property ("solo-isolated", solo_isolated() ? "yes" : "no");
1912 node->add_property ("solo-safe", _solo_safe ? "yes" : "no");
1914 node->add_child_nocopy (_input->state (full_state));
1915 node->add_child_nocopy (_output->state (full_state));
1916 node->add_child_nocopy (_solo_control->get_state ());
1917 node->add_child_nocopy (_mute_control->get_state ());
1918 node->add_child_nocopy (_mute_master->get_state ());
1920 XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
1921 snprintf (buf, sizeof (buf), "%d", _remote_control_id);
1922 remote_control_node->add_property (X_("id"), buf);
1923 node->add_child_nocopy (*remote_control_node);
1925 if (_comment.length()) {
1926 XMLNode *cmt = node->add_child ("Comment");
1927 cmt->add_content (_comment);
1931 node->add_child_nocopy (_pannable->state (full_state));
1934 for (i = _processors.begin(); i != _processors.end(); ++i) {
1936 /* template save: do not include internal sends functioning as
1937 aux sends because the chance of the target ID
1938 in the session where this template is used
1941 similarly, do not save listen sends which connect to
1942 the monitor section, because these will always be
1945 boost::shared_ptr<InternalSend> is;
1947 if ((is = boost::dynamic_pointer_cast<InternalSend> (*i)) != 0) {
1948 if (is->role() == Delivery::Listen) {
1953 node->add_child_nocopy((*i)->state (full_state));
1957 node->add_child_copy (*_extra_xml);
1960 if (_custom_meter_position_noted) {
1961 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
1963 after->id().print (buf, sizeof (buf));
1964 node->add_property (X_("processor-after-last-custom-meter"), buf);
1967 node->add_property (X_("last-custom-meter-was-at-end"), _last_custom_meter_was_at_end ? "yes" : "no");
1974 Route::set_state (const XMLNode& node, int version)
1976 if (version < 3000) {
1977 return set_state_2X (node, version);
1981 XMLNodeConstIterator niter;
1983 const XMLProperty *prop;
1985 if (node.name() != "Route"){
1986 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1990 if ((prop = node.property (X_("name"))) != 0) {
1991 Route::set_name (prop->value());
1996 if ((prop = node.property (X_("flags"))) != 0) {
1997 _flags = Flag (string_2_enum (prop->value(), _flags));
2002 if (is_master() || is_monitor() || is_auditioner()) {
2003 _mute_master->set_solo_ignore (true);
2007 /* monitor bus does not get a panner, but if (re)created
2008 via XML, it will already have one by the time we
2009 call ::set_state(). so ... remove it.
2014 /* add all processors (except amp, which is always present) */
2016 nlist = node.children();
2017 XMLNode processor_state (X_("processor_state"));
2019 Stateful::save_extra_xml (node);
2021 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2025 if (child->name() == IO::state_node_name) {
2026 if ((prop = child->property (X_("direction"))) == 0) {
2030 if (prop->value() == "Input") {
2031 _input->set_state (*child, version);
2032 } else if (prop->value() == "Output") {
2033 _output->set_state (*child, version);
2037 if (child->name() == X_("Processor")) {
2038 processor_state.add_child_copy (*child);
2041 if (child->name() == X_("Pannable")) {
2043 _pannable->set_state (*child, version);
2045 warning << string_compose (_("Pannable state found for route (%1) without a panner!"), name()) << endmsg;
2050 if ((prop = node.property (X_("meter-point"))) != 0) {
2051 MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
2052 set_meter_point (mp, true);
2054 _meter->set_display_to_user (_meter_point == MeterCustom);
2058 if ((prop = node.property (X_("meter-type"))) != 0) {
2059 _meter_type = MeterType (string_2_enum (prop->value (), _meter_type));
2062 set_processor_state (processor_state);
2064 // this looks up the internal instrument in processors
2065 reset_instrument_info();
2067 if ((prop = node.property ("self-solo")) != 0) {
2068 set_self_solo (string_is_affirmative (prop->value()));
2071 if ((prop = node.property ("soloed-by-upstream")) != 0) {
2072 _soloed_by_others_upstream = 0; // needed for mod_.... () to work
2073 mod_solo_by_others_upstream (atoi (prop->value()));
2076 if ((prop = node.property ("soloed-by-downstream")) != 0) {
2077 _soloed_by_others_downstream = 0; // needed for mod_.... () to work
2078 mod_solo_by_others_downstream (atoi (prop->value()));
2081 if ((prop = node.property ("solo-isolated")) != 0) {
2082 set_solo_isolated (string_is_affirmative (prop->value()), this);
2085 if ((prop = node.property ("solo-safe")) != 0) {
2086 set_solo_safe (string_is_affirmative (prop->value()), this);
2089 if ((prop = node.property (X_("phase-invert"))) != 0) {
2090 set_phase_invert (boost::dynamic_bitset<> (prop->value ()));
2093 if ((prop = node.property (X_("denormal-protection"))) != 0) {
2094 set_denormal_protection (string_is_affirmative (prop->value()));
2097 if ((prop = node.property (X_("active"))) != 0) {
2098 bool yn = string_is_affirmative (prop->value());
2099 _active = !yn; // force switch
2100 set_active (yn, this);
2103 if ((prop = node.property (X_("order-keys"))) != 0) {
2107 string::size_type colon, equal;
2108 string remaining = prop->value();
2110 while (remaining.length()) {
2112 if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2113 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2116 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2117 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2120 string keyname = remaining.substr (0, equal);
2121 RouteSortOrderKey sk;
2123 if (keyname == "signal") {
2125 } else if (keyname == "editor") {
2128 sk = (RouteSortOrderKey) string_2_enum (remaining.substr (0, equal), sk);
2131 set_order_key (sk, n);
2135 colon = remaining.find_first_of (':');
2137 if (colon != string::npos) {
2138 remaining = remaining.substr (colon+1);
2145 if ((prop = node.property (X_("processor-after-last-custom-meter"))) != 0) {
2146 PBD::ID id (prop->value ());
2147 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2148 ProcessorList::const_iterator i = _processors.begin ();
2149 while (i != _processors.end() && (*i)->id() != id) {
2153 if (i != _processors.end ()) {
2154 _processor_after_last_custom_meter = *i;
2155 _custom_meter_position_noted = true;
2159 if ((prop = node.property (X_("last-custom-meter-was-at-end"))) != 0) {
2160 _last_custom_meter_was_at_end = string_is_affirmative (prop->value ());
2163 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2166 if (child->name() == X_("Comment")) {
2168 /* XXX this is a terrible API design in libxml++ */
2170 XMLNode *cmt = *(child->children().begin());
2171 _comment = cmt->content();
2173 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2174 if (prop->value() == "solo") {
2175 _solo_control->set_state (*child, version);
2176 } else if (prop->value() == "mute") {
2177 _mute_control->set_state (*child, version);
2180 } else if (child->name() == X_("RemoteControl")) {
2181 if ((prop = child->property (X_("id"))) != 0) {
2183 sscanf (prop->value().c_str(), "%d", &x);
2184 set_remote_control_id_internal (x);
2187 } else if (child->name() == X_("MuteMaster")) {
2188 _mute_master->set_state (*child, version);
2196 Route::set_state_2X (const XMLNode& node, int version)
2199 XMLNodeConstIterator niter;
2201 const XMLProperty *prop;
2203 /* 2X things which still remain to be handled:
2209 if (node.name() != "Route") {
2210 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2214 if ((prop = node.property (X_("flags"))) != 0) {
2215 string f = prop->value ();
2216 boost::replace_all (f, "ControlOut", "MonitorOut");
2217 _flags = Flag (string_2_enum (f, _flags));
2222 if (is_master() || is_monitor() || is_auditioner()) {
2223 _mute_master->set_solo_ignore (true);
2226 if ((prop = node.property (X_("phase-invert"))) != 0) {
2227 boost::dynamic_bitset<> p (_input->n_ports().n_audio ());
2228 if (string_is_affirmative (prop->value ())) {
2231 set_phase_invert (p);
2234 if ((prop = node.property (X_("denormal-protection"))) != 0) {
2235 set_denormal_protection (string_is_affirmative (prop->value()));
2238 if ((prop = node.property (X_("soloed"))) != 0) {
2239 bool yn = string_is_affirmative (prop->value());
2241 /* XXX force reset of solo status */
2243 set_solo (yn, this);
2246 if ((prop = node.property (X_("muted"))) != 0) {
2249 bool muted = string_is_affirmative (prop->value());
2255 if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
2257 if (string_is_affirmative (prop->value())){
2258 mute_point = mute_point + "PreFader";
2263 if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
2265 if (string_is_affirmative (prop->value())){
2268 mute_point = mute_point + ",";
2271 mute_point = mute_point + "PostFader";
2276 if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
2278 if (string_is_affirmative (prop->value())){
2281 mute_point = mute_point + ",";
2284 mute_point = mute_point + "Listen";
2289 if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
2291 if (string_is_affirmative (prop->value())){
2294 mute_point = mute_point + ",";
2297 mute_point = mute_point + "Main";
2301 _mute_master->set_mute_points (mute_point);
2302 _mute_master->set_muted_by_self (true);
2306 if ((prop = node.property (X_("meter-point"))) != 0) {
2307 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2310 /* do not carry over edit/mix groups from 2.X because (a) its hard (b) they
2311 don't mean the same thing.
2314 if ((prop = node.property (X_("order-keys"))) != 0) {
2318 string::size_type colon, equal;
2319 string remaining = prop->value();
2321 while (remaining.length()) {
2323 if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2324 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2327 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2328 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2331 string keyname = remaining.substr (0, equal);
2332 RouteSortOrderKey sk;
2334 if (keyname == "signal") {
2336 } else if (keyname == "editor") {
2339 sk = (RouteSortOrderKey) string_2_enum (remaining.substr (0, equal), sk);
2342 set_order_key (sk, n);
2346 colon = remaining.find_first_of (':');
2348 if (colon != string::npos) {
2349 remaining = remaining.substr (colon+1);
2358 nlist = node.children ();
2359 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2363 if (child->name() == IO::state_node_name) {
2365 /* there is a note in IO::set_state_2X() about why we have to call
2369 _input->set_state_2X (*child, version, true);
2370 _output->set_state_2X (*child, version, false);
2372 if ((prop = child->property (X_("name"))) != 0) {
2373 Route::set_name (prop->value ());
2378 if ((prop = child->property (X_("active"))) != 0) {
2379 bool yn = string_is_affirmative (prop->value());
2380 _active = !yn; // force switch
2381 set_active (yn, this);
2384 if ((prop = child->property (X_("gain"))) != 0) {
2387 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2388 _amp->gain_control()->set_value (val);
2392 /* Set up Panners in the IO */
2393 XMLNodeList io_nlist = child->children ();
2395 XMLNodeConstIterator io_niter;
2398 for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2400 io_child = *io_niter;
2402 if (io_child->name() == X_("Panner")) {
2403 _main_outs->panner_shell()->set_state(*io_child, version);
2404 } else if (io_child->name() == X_("Automation")) {
2405 /* IO's automation is for the fader */
2406 _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
2412 XMLNodeList redirect_nodes;
2414 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2418 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2419 redirect_nodes.push_back(child);
2424 set_processor_state_2X (redirect_nodes, version);
2426 Stateful::save_extra_xml (node);
2428 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2431 if (child->name() == X_("Comment")) {
2433 /* XXX this is a terrible API design in libxml++ */
2435 XMLNode *cmt = *(child->children().begin());
2436 _comment = cmt->content();
2438 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2439 if (prop->value() == X_("solo")) {
2440 _solo_control->set_state (*child, version);
2441 } else if (prop->value() == X_("mute")) {
2442 _mute_control->set_state (*child, version);
2445 } else if (child->name() == X_("RemoteControl")) {
2446 if ((prop = child->property (X_("id"))) != 0) {
2448 sscanf (prop->value().c_str(), "%d", &x);
2449 set_remote_control_id_internal (x);
2459 Route::get_processor_state ()
2461 XMLNode* root = new XMLNode (X_("redirects"));
2462 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2463 root->add_child_nocopy ((*i)->state (true));
2470 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2472 /* We don't bother removing existing processors not in nList, as this
2473 method will only be called when creating a Route from scratch, not
2474 for undo purposes. Just put processors in at the appropriate place
2478 for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2479 add_processor_from_xml_2X (**i, version);
2484 Route::set_processor_state (const XMLNode& node)
2486 const XMLNodeList &nlist = node.children();
2487 XMLNodeConstIterator niter;
2488 ProcessorList new_order;
2489 bool must_configure = false;
2491 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2493 XMLProperty* prop = (*niter)->property ("type");
2495 if (prop->value() == "amp") {
2496 _amp->set_state (**niter, Stateful::current_state_version);
2497 new_order.push_back (_amp);
2498 } else if (prop->value() == "meter") {
2499 _meter->set_state (**niter, Stateful::current_state_version);
2500 new_order.push_back (_meter);
2501 } else if (prop->value() == "main-outs") {
2502 _main_outs->set_state (**niter, Stateful::current_state_version);
2503 } else if (prop->value() == "intreturn") {
2505 _intreturn.reset (new InternalReturn (_session));
2506 must_configure = true;
2508 _intreturn->set_state (**niter, Stateful::current_state_version);
2509 } else if (is_monitor() && prop->value() == "monitor") {
2510 if (!_monitor_control) {
2511 _monitor_control.reset (new MonitorProcessor (_session));
2512 must_configure = true;
2514 _monitor_control->set_state (**niter, Stateful::current_state_version);
2515 } else if (prop->value() == "capture") {
2516 /* CapturingProcessor should never be restored, it's always
2517 added explicitly when needed */
2519 ProcessorList::iterator o;
2521 for (o = _processors.begin(); o != _processors.end(); ++o) {
2522 XMLProperty* id_prop = (*niter)->property(X_("id"));
2523 if (id_prop && (*o)->id() == id_prop->value()) {
2524 (*o)->set_state (**niter, Stateful::current_state_version);
2525 new_order.push_back (*o);
2530 // If the processor (*niter) is not on the route then create it
2532 if (o == _processors.end()) {
2534 boost::shared_ptr<Processor> processor;
2536 if (prop->value() == "intsend") {
2538 processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::shared_ptr<Route>(), Delivery::Role (0)));
2540 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2541 prop->value() == "lv2" ||
2542 prop->value() == "windows-vst" ||
2543 prop->value() == "lxvst" ||
2544 prop->value() == "audiounit") {
2546 processor.reset (new PluginInsert(_session));
2548 } else if (prop->value() == "port") {
2550 processor.reset (new PortInsert (_session, _pannable, _mute_master));
2552 } else if (prop->value() == "send") {
2554 processor.reset (new Send (_session, _pannable, _mute_master));
2557 error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2561 if (boost::dynamic_pointer_cast<PluginInsert>(processor)) {
2562 #ifndef NO_PLUGIN_STATE
2563 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2564 /* This processor could not be configured. Turn it into a UnknownProcessor */
2565 processor.reset (new UnknownProcessor (_session, **niter));
2568 /* plugin, with NO_PLUGIN_STATE defined
2569 * =>::set_state() not allowed. Do not
2570 * display a message here - things will
2575 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2576 /* This processor could not be configured. Turn it into a UnknownProcessor */
2577 processor.reset (new UnknownProcessor (_session, **niter));
2581 /* we have to note the monitor send here, otherwise a new one will be created
2582 and the state of this one will be lost.
2584 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
2585 if (isend && isend->role() == Delivery::Listen) {
2586 _monitor_send = isend;
2589 /* it doesn't matter if invisible processors are added here, as they
2590 will be sorted out by setup_invisible_processors () shortly.
2593 new_order.push_back (processor);
2594 must_configure = true;
2600 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2601 _processors = new_order;
2603 if (must_configure) {
2604 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2605 configure_processors_unlocked (0);
2608 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2610 (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
2612 boost::shared_ptr<PluginInsert> pi;
2614 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
2615 if (pi->has_no_inputs ()) {
2616 _have_internal_generator = true;
2623 reset_instrument_info ();
2624 processors_changed (RouteProcessorChange ());
2625 set_processor_positions ();
2629 Route::curve_reallocate ()
2631 // _gain_automation_curve.finish_resize ();
2632 // _pan_automation_curve.finish_resize ();
2636 Route::silence (framecnt_t nframes)
2638 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
2643 silence_unlocked (nframes);
2647 Route::silence_unlocked (framecnt_t nframes)
2649 /* Must be called with the processor lock held */
2653 _output->silence (nframes);
2655 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2656 boost::shared_ptr<PluginInsert> pi;
2658 if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2659 // skip plugins, they don't need anything when we're not active
2663 (*i)->silence (nframes);
2666 if (nframes == _session.get_block_size()) {
2673 Route::add_internal_return ()
2676 _intreturn.reset (new InternalReturn (_session));
2677 add_processor (_intreturn, PreFader);
2682 Route::add_send_to_internal_return (InternalSend* send)
2684 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
2686 for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2687 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2690 return d->add_send (send);
2696 Route::remove_send_from_internal_return (InternalSend* send)
2698 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
2700 for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2701 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2704 return d->remove_send (send);
2710 Route::enable_monitor_send ()
2712 /* Caller must hold process lock */
2713 assert (!AudioEngine::instance()->process_lock().trylock());
2715 /* master never sends to monitor section via the normal mechanism */
2716 assert (!is_master ());
2718 /* make sure we have one */
2719 if (!_monitor_send) {
2720 _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, _session.monitor_out(), Delivery::Listen));
2721 _monitor_send->set_display_to_user (false);
2725 configure_processors (0);
2728 /** Add an aux send to a route.
2729 * @param route route to send to.
2730 * @param before Processor to insert before, or 0 to insert at the end.
2733 Route::add_aux_send (boost::shared_ptr<Route> route, boost::shared_ptr<Processor> before)
2735 assert (route != _session.monitor_out ());
2738 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
2740 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2742 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
2744 if (d && d->target_route() == route) {
2745 /* already listening via the specified IO: do nothing */
2753 boost::shared_ptr<InternalSend> listener;
2756 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2757 listener.reset (new InternalSend (_session, _pannable, _mute_master, route, Delivery::Aux));
2760 add_processor (listener, before);
2762 } catch (failed_constructor& err) {
2770 Route::remove_aux_or_listen (boost::shared_ptr<Route> route)
2772 ProcessorStreams err;
2773 ProcessorList::iterator tmp;
2776 Glib::Threads::RWLock::ReaderLock rl(_processor_lock);
2778 /* have to do this early because otherwise processor reconfig
2779 * will put _monitor_send back in the list
2782 if (route == _session.monitor_out()) {
2783 _monitor_send.reset ();
2787 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2789 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2791 if (d && d->target_route() == route) {
2793 remove_processor (*x, &err, false);
2796 /* list could have been demolished while we dropped the lock
2807 Route::set_comment (string cmt, void *src)
2810 comment_changed (src);
2811 _session.set_dirty ();
2815 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
2817 FeedRecord fr (other, via_sends_only);
2819 pair<FedBy::iterator,bool> result = _fed_by.insert (fr);
2821 if (!result.second) {
2823 /* already a record for "other" - make sure sends-only information is correct */
2824 if (!via_sends_only && result.first->sends_only) {
2825 FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
2826 frp->sends_only = false;
2830 return result.second;
2834 Route::clear_fed_by ()
2840 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
2842 const FedBy& fed_by (other->fed_by());
2844 for (FedBy::iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
2845 boost::shared_ptr<Route> sr = f->r.lock();
2847 if (sr && (sr.get() == this)) {
2849 if (via_sends_only) {
2850 *via_sends_only = f->sends_only;
2861 Route::direct_feeds_according_to_reality (boost::shared_ptr<Route> other, bool* via_send_only)
2863 DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
2865 if (_output->connected_to (other->input())) {
2866 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
2867 if (via_send_only) {
2868 *via_send_only = false;
2875 for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
2877 boost::shared_ptr<IOProcessor> iop;
2879 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
2880 if (iop->feeds (other)) {
2881 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
2882 if (via_send_only) {
2883 *via_send_only = true;
2887 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
2890 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
2895 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdoes NOT feed %1\n", other->name()));
2900 Route::direct_feeds_according_to_graph (boost::shared_ptr<Route> other, bool* via_send_only)
2902 return _session._current_route_graph.has (shared_from_this (), other, via_send_only);
2905 /** Called from the (non-realtime) butler thread when the transport is stopped */
2907 Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool /*did_locate*/, bool can_flush_processors)
2909 framepos_t now = _session.transport_frame();
2912 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2914 Automatable::transport_stopped (now);
2916 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2918 if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && can_flush_processors)) {
2922 (*i)->transport_stopped (now);
2926 _roll_delay = _initial_delay;
2930 Route::input_change_handler (IOChange change, void * /*src*/)
2932 bool need_to_queue_solo_change = true;
2934 if ((change.type & IOChange::ConfigurationChanged)) {
2935 /* This is called with the process lock held if change
2936 contains ConfigurationChanged
2938 need_to_queue_solo_change = false;
2939 configure_processors (0);
2940 _phase_invert.resize (_input->n_ports().n_audio ());
2941 io_changed (); /* EMIT SIGNAL */
2944 if (!_input->connected() && _soloed_by_others_upstream) {
2945 if (need_to_queue_solo_change) {
2946 _session.cancel_solo_after_disconnect (shared_from_this(), true);
2948 cancel_solo_after_disconnect (true);
2954 Route::output_change_handler (IOChange change, void * /*src*/)
2956 bool need_to_queue_solo_change = true;
2958 if ((change.type & IOChange::ConfigurationChanged)) {
2959 /* This is called with the process lock held if change
2960 contains ConfigurationChanged
2962 need_to_queue_solo_change = false;
2963 configure_processors (0);
2964 io_changed (); /* EMIT SIGNAL */
2967 if (!_output->connected() && _soloed_by_others_downstream) {
2968 if (need_to_queue_solo_change) {
2969 _session.cancel_solo_after_disconnect (shared_from_this(), false);
2971 cancel_solo_after_disconnect (false);
2977 Route::cancel_solo_after_disconnect (bool upstream)
2980 _soloed_by_others_upstream = 0;
2982 _soloed_by_others_downstream = 0;
2984 set_mute_master_solo ();
2985 solo_changed (false, this);
2989 Route::pans_required () const
2991 if (n_outputs().n_audio() < 2) {
2995 return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
2999 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
3001 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3007 if (n_outputs().n_total() == 0) {
3011 if (!_active || n_inputs() == ChanCount::ZERO) {
3012 silence_unlocked (nframes);
3016 if (session_state_changing) {
3017 if (_session.transport_speed() != 0.0f) {
3018 /* we're rolling but some state is changing (e.g. our diskstream contents)
3019 so we cannot use them. Be silent till this is over.
3021 XXX note the absurdity of ::no_roll() being called when we ARE rolling!
3023 silence_unlocked (nframes);
3026 /* we're really not rolling, so we're either delivery silence or actually
3027 monitoring, both of which are safe to do while session_state_changing is true.
3031 BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers());
3033 fill_buffers_with_input (bufs, _input, nframes);
3035 if (_meter_point == MeterInput) {
3036 _meter->run (bufs, start_frame, end_frame, nframes, true);
3039 _amp->apply_gain_automation (false);
3040 passthru (bufs, start_frame, end_frame, nframes, 0);
3046 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& /* need_butler */)
3048 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3053 if (n_outputs().n_total() == 0) {
3057 if (!_active || n_inputs().n_total() == 0) {
3058 silence_unlocked (nframes);
3062 framepos_t unused = 0;
3064 if ((nframes = check_initial_delay (nframes, unused)) == 0) {
3070 BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers());
3072 fill_buffers_with_input (bufs, _input, nframes);
3074 if (_meter_point == MeterInput) {
3075 _meter->run (bufs, start_frame, end_frame, nframes, true);
3078 passthru (bufs, start_frame, end_frame, nframes, declick);
3084 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& /* need_butler */)
3091 Route::flush_processors ()
3093 /* XXX shouldn't really try to take this lock, since
3094 this is called from the RT audio thread.
3097 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3099 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3105 Route::set_meter_point (MeterPoint p, bool force)
3107 if (_meter_point == p && !force) {
3111 bool meter_was_visible_to_user = _meter->display_to_user ();
3114 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3116 maybe_note_meter_position ();
3120 if (_meter_point != MeterCustom) {
3122 _meter->set_display_to_user (false);
3124 setup_invisible_processors ();
3128 _meter->set_display_to_user (true);
3130 /* If we have a previous position for the custom meter, try to put it there */
3131 if (_custom_meter_position_noted) {
3132 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
3135 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), after);
3136 if (i != _processors.end ()) {
3137 _processors.remove (_meter);
3138 _processors.insert (i, _meter);
3140 } else if (_last_custom_meter_was_at_end) {
3141 _processors.remove (_meter);
3142 _processors.push_back (_meter);
3147 /* Set up the meter for its new position */
3149 ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
3153 if (loc == _processors.begin()) {
3154 m_in = _input->n_ports();
3156 ProcessorList::iterator before = loc;
3158 m_in = (*before)->output_streams ();
3161 _meter->reflect_inputs (m_in);
3163 /* we do not need to reconfigure the processors, because the meter
3164 (a) is always ready to handle processor_max_streams
3165 (b) is always an N-in/N-out processor, and thus moving
3166 it doesn't require any changes to the other processors.
3170 meter_change (); /* EMIT SIGNAL */
3172 bool const meter_visibly_changed = (_meter->display_to_user() != meter_was_visible_to_user);
3174 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
3178 Route::listen_position_changed ()
3181 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3182 ProcessorState pstate (this);
3185 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3187 if (configure_processors_unlocked (0)) {
3189 configure_processors_unlocked (0); // it worked before we tried to add it ...
3195 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
3196 _session.set_dirty ();
3199 boost::shared_ptr<CapturingProcessor>
3200 Route::add_export_point()
3202 if (!_capturing_processor) {
3204 _capturing_processor.reset (new CapturingProcessor (_session));
3205 _capturing_processor->activate ();
3208 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3209 configure_processors (0);
3214 return _capturing_processor;
3218 Route::update_signal_latency ()
3220 framecnt_t l = _output->user_latency();
3222 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3223 if ((*i)->active ()) {
3224 l += (*i)->signal_latency ();
3228 DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l));
3230 if (_signal_latency != l) {
3231 _signal_latency = l;
3232 signal_latency_changed (); /* EMIT SIGNAL */
3235 return _signal_latency;
3239 Route::set_user_latency (framecnt_t nframes)
3241 _output->set_user_latency (nframes);
3242 _session.update_latency_compensation ();
3246 Route::set_latency_compensation (framecnt_t longest_session_latency)
3248 framecnt_t old = _initial_delay;
3250 if (_signal_latency < longest_session_latency) {
3251 _initial_delay = longest_session_latency - _signal_latency;
3256 DEBUG_TRACE (DEBUG::Latency, string_compose (
3257 "%1: compensate for maximum latency of %2,"
3258 "given own latency of %3, using initial delay of %4\n",
3259 name(), longest_session_latency, _signal_latency, _initial_delay));
3261 if (_initial_delay != old) {
3262 initial_delay_changed (); /* EMIT SIGNAL */
3265 if (_session.transport_stopped()) {
3266 _roll_delay = _initial_delay;
3270 Route::SoloControllable::SoloControllable (std::string name, boost::shared_ptr<Route> r)
3271 : AutomationControl (r->session(), Evoral::Parameter (SoloAutomation),
3272 boost::shared_ptr<AutomationList>(), name)
3275 boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
3280 Route::SoloControllable::set_value (double val)
3282 bool bval = ((val >= 0.5f) ? true: false);
3284 boost::shared_ptr<RouteList> rl (new RouteList);
3286 boost::shared_ptr<Route> r = _route.lock ();
3293 if (Config->get_solo_control_is_listen_control()) {
3294 _session.set_listen (rl, bval);
3296 _session.set_solo (rl, bval);
3301 Route::SoloControllable::get_value () const
3303 boost::shared_ptr<Route> r = _route.lock ();
3308 if (Config->get_solo_control_is_listen_control()) {
3309 return r->listening_via_monitor() ? 1.0f : 0.0f;
3311 return r->self_soloed() ? 1.0f : 0.0f;
3315 Route::MuteControllable::MuteControllable (std::string name, boost::shared_ptr<Route> r)
3316 : AutomationControl (r->session(), Evoral::Parameter (MuteAutomation),
3317 boost::shared_ptr<AutomationList>(), name)
3320 boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MuteAutomation)));
3325 Route::MuteControllable::set_value (double val)
3327 bool bval = ((val >= 0.5f) ? true: false);
3329 boost::shared_ptr<RouteList> rl (new RouteList);
3331 boost::shared_ptr<Route> r = _route.lock ();
3337 _session.set_mute (rl, bval);
3341 Route::MuteControllable::get_value () const
3343 boost::shared_ptr<Route> r = _route.lock ();
3348 return r->muted() ? 1.0f : 0.0f;
3352 Route::set_block_size (pframes_t nframes)
3354 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3355 (*i)->set_block_size (nframes);
3358 _session.ensure_buffers (n_process_buffers ());
3362 Route::protect_automation ()
3364 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3365 (*i)->protect_automation();
3368 /** @param declick 1 to set a pending declick fade-in,
3369 * -1 to set a pending declick fade-out
3372 Route::set_pending_declick (int declick)
3375 /* this call is not allowed to turn off a pending declick */
3377 _pending_declick = declick;
3380 _pending_declick = 0;
3384 /** Shift automation forwards from a particular place, thereby inserting time.
3385 * Adds undo commands for any shifts that are performed.
3387 * @param pos Position to start shifting from.
3388 * @param frames Amount to shift forwards by.
3392 Route::shift (framepos_t pos, framecnt_t frames)
3394 /* gain automation */
3396 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
3398 XMLNode &before = gc->alist()->get_state ();
3399 gc->alist()->shift (pos, frames);
3400 XMLNode &after = gc->alist()->get_state ();
3401 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3404 /* pan automation */
3406 ControlSet::Controls& c (_pannable->controls());
3408 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
3409 boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
3411 boost::shared_ptr<AutomationList> al = pc->alist();
3412 XMLNode& before = al->get_state ();
3413 al->shift (pos, frames);
3414 XMLNode& after = al->get_state ();
3415 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3420 /* redirect automation */
3422 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3423 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
3425 set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
3427 for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
3428 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
3430 boost::shared_ptr<AutomationList> al = ac->alist();
3431 XMLNode &before = al->get_state ();
3432 al->shift (pos, frames);
3433 XMLNode &after = al->get_state ();
3434 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3443 Route::save_as_template (const string& path, const string& name)
3445 XMLNode& node (state (false));
3448 IO::set_name_in_state (*node.children().front(), name);
3450 tree.set_root (&node);
3451 return tree.write (path.c_str());
3456 Route::set_name (const string& str)
3462 name = Route::ensure_track_or_route_name (str, _session);
3463 SessionObject::set_name (name);
3465 ret = (_input->set_name(name) && _output->set_name(name));
3468 /* rename the main outs. Leave other IO processors
3469 * with whatever name they already have, because its
3470 * just fine as it is (it will not contain the route
3471 * name if its a port insert, port send or port return).
3475 if (_main_outs->set_name (name)) {
3476 /* XXX returning false here is stupid because
3477 we already changed the route name.
3487 /** Set the name of a route in an XML description.
3488 * @param node XML <Route> node to set the name in.
3489 * @param name New name.
3492 Route::set_name_in_state (XMLNode& node, string const & name)
3494 node.add_property (X_("name"), name);
3496 XMLNodeList children = node.children();
3497 for (XMLNodeIterator i = children.begin(); i != children.end(); ++i) {
3499 if ((*i)->name() == X_("IO")) {
3501 IO::set_name_in_state (**i, name);
3503 } else if ((*i)->name() == X_("Processor")) {
3505 XMLProperty* role = (*i)->property (X_("role"));
3506 if (role && role->value() == X_("Main")) {
3507 (*i)->add_property (X_("name"), name);
3510 } else if ((*i)->name() == X_("Diskstream")) {
3512 (*i)->add_property (X_("playlist"), string_compose ("%1.1", name).c_str());
3513 (*i)->add_property (X_("name"), name);
3519 boost::shared_ptr<Send>
3520 Route::internal_send_for (boost::shared_ptr<const Route> target) const
3522 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3524 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3525 boost::shared_ptr<InternalSend> send;
3527 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
3528 if (send->target_route() == target) {
3534 return boost::shared_ptr<Send>();
3537 /** @param c Audio channel index.
3538 * @param yn true to invert phase, otherwise false.
3541 Route::set_phase_invert (uint32_t c, bool yn)
3543 if (_phase_invert[c] != yn) {
3544 _phase_invert[c] = yn;
3545 phase_invert_changed (); /* EMIT SIGNAL */
3546 _session.set_dirty ();
3551 Route::set_phase_invert (boost::dynamic_bitset<> p)
3553 if (_phase_invert != p) {
3555 phase_invert_changed (); /* EMIT SIGNAL */
3556 _session.set_dirty ();
3561 Route::phase_invert (uint32_t c) const
3563 return _phase_invert[c];
3566 boost::dynamic_bitset<>
3567 Route::phase_invert () const
3569 return _phase_invert;
3573 Route::set_denormal_protection (bool yn)
3575 if (_denormal_protection != yn) {
3576 _denormal_protection = yn;
3577 denormal_protection_changed (); /* EMIT SIGNAL */
3582 Route::denormal_protection () const
3584 return _denormal_protection;
3588 Route::set_active (bool yn, void* src)
3590 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
3591 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
3595 if (_active != yn) {
3597 _input->set_active (yn);
3598 _output->set_active (yn);
3599 active_changed (); // EMIT SIGNAL
3600 _session.set_dirty ();
3607 Glib::Threads::RWLock::ReaderLock rm (_processor_lock, Glib::Threads::TRY_LOCK);
3613 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3615 boost::shared_ptr<Send> s;
3616 boost::shared_ptr<Return> r;
3618 if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
3619 s->meter()->meter();
3620 } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
3621 r->meter()->meter ();
3626 boost::shared_ptr<Pannable>
3627 Route::pannable() const
3632 boost::shared_ptr<Panner>
3633 Route::panner() const
3636 return _main_outs->panner_shell()->panner();
3639 boost::shared_ptr<PannerShell>
3640 Route::panner_shell() const
3642 return _main_outs->panner_shell();
3645 boost::shared_ptr<AutomationControl>
3646 Route::gain_control() const
3648 return _amp->gain_control();
3651 boost::shared_ptr<AutomationControl>
3652 Route::get_control (const Evoral::Parameter& param)
3654 /* either we own the control or .... */
3656 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
3660 /* maybe one of our processors does or ... */
3662 Glib::Threads::RWLock::ReaderLock rm (_processor_lock, Glib::Threads::TRY_LOCK);
3663 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3664 if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
3672 /* nobody does so we'll make a new one */
3674 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
3681 boost::shared_ptr<Processor>
3682 Route::nth_plugin (uint32_t n)
3684 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3685 ProcessorList::iterator i;
3687 for (i = _processors.begin(); i != _processors.end(); ++i) {
3688 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
3695 return boost::shared_ptr<Processor> ();
3698 boost::shared_ptr<Processor>
3699 Route::nth_send (uint32_t n)
3701 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3702 ProcessorList::iterator i;
3704 for (i = _processors.begin(); i != _processors.end(); ++i) {
3705 if (boost::dynamic_pointer_cast<Send> (*i)) {
3712 return boost::shared_ptr<Processor> ();
3716 Route::has_io_processor_named (const string& name)
3718 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3719 ProcessorList::iterator i;
3721 for (i = _processors.begin(); i != _processors.end(); ++i) {
3722 if (boost::dynamic_pointer_cast<Send> (*i) ||
3723 boost::dynamic_pointer_cast<PortInsert> (*i)) {
3724 if ((*i)->name() == name) {
3733 MuteMaster::MutePoint
3734 Route::mute_points () const
3736 return _mute_master->mute_points ();
3740 Route::set_processor_positions ()
3742 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3744 bool had_amp = false;
3745 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3746 (*i)->set_pre_fader (!had_amp);
3747 if (boost::dynamic_pointer_cast<Amp> (*i)) {
3753 /** Called when there is a proposed change to the input port count */
3755 Route::input_port_count_changing (ChanCount to)
3757 list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
3759 /* The processors cannot be configured with the new input arrangement, so
3765 /* The change is ok */
3770 Route::unknown_processors () const
3774 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3775 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3776 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
3777 p.push_back ((*i)->name ());
3786 Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecnt_t our_latency) const
3788 /* we assume that all our input ports feed all our output ports. its not
3789 universally true, but the alternative is way too corner-case to worry about.
3792 jack_latency_range_t all_connections;
3795 all_connections.min = 0;
3796 all_connections.max = 0;
3798 all_connections.min = ~((jack_nframes_t) 0);
3799 all_connections.max = 0;
3801 /* iterate over all "from" ports and determine the latency range for all of their
3802 connections to the "outside" (outside of this Route).
3805 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
3807 jack_latency_range_t range;
3809 p->get_connected_latency_range (range, playback);
3811 all_connections.min = min (all_connections.min, range.min);
3812 all_connections.max = max (all_connections.max, range.max);
3816 /* set the "from" port latencies to the max/min range of all their connections */
3818 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
3819 p->set_private_latency_range (all_connections, playback);
3822 /* set the ports "in the direction of the flow" to the same value as above plus our own signal latency */
3824 all_connections.min += our_latency;
3825 all_connections.max += our_latency;
3827 for (PortSet::iterator p = to.begin(); p != to.end(); ++p) {
3828 p->set_private_latency_range (all_connections, playback);
3831 return all_connections.max;
3835 Route::set_private_port_latencies (bool playback) const
3837 framecnt_t own_latency = 0;
3839 /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD
3840 OR LATENCY CALLBACK.
3842 This is called (early) from the latency callback. It computes the REAL
3843 latency associated with each port and stores the result as the "private"
3844 latency of the port. A later call to Route::set_public_port_latencies()
3845 sets all ports to the same value to reflect the fact that we do latency
3846 compensation and so all signals are delayed by the same amount as they
3847 flow through ardour.
3850 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3851 if ((*i)->active ()) {
3852 own_latency += (*i)->signal_latency ();
3857 /* playback: propagate latency from "outside the route" to outputs to inputs */
3858 return update_port_latencies (_output->ports (), _input->ports (), true, own_latency);
3860 /* capture: propagate latency from "outside the route" to inputs to outputs */
3861 return update_port_latencies (_input->ports (), _output->ports (), false, own_latency);
3866 Route::set_public_port_latencies (framecnt_t value, bool playback) const
3868 /* this is called to set the JACK-visible port latencies, which take
3869 latency compensation into account.
3872 jack_latency_range_t range;
3878 const PortSet& ports (_input->ports());
3879 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
3880 p->set_public_latency_range (range, playback);
3885 const PortSet& ports (_output->ports());
3886 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
3887 p->set_public_latency_range (range, playback);
3892 /** Put the invisible processors in the right place in _processors.
3893 * Must be called with a writer lock on _processor_lock held.
3896 Route::setup_invisible_processors ()
3899 Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3900 assert (!lm.locked ());
3904 /* too early to be doing this stuff */
3908 /* we'll build this new list here and then use it */
3910 ProcessorList new_processors;
3912 /* find visible processors */
3914 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3915 if ((*i)->display_to_user ()) {
3916 new_processors.push_back (*i);
3922 ProcessorList::iterator amp = new_processors.begin ();
3923 while (amp != new_processors.end() && boost::dynamic_pointer_cast<Amp> (*amp) == 0) {
3927 assert (amp != _processors.end ());
3929 /* and the processor after the amp */
3931 ProcessorList::iterator after_amp = amp;
3937 switch (_meter_point) {
3939 assert (!_meter->display_to_user ());
3940 new_processors.push_front (_meter);
3943 assert (!_meter->display_to_user ());
3944 new_processors.insert (amp, _meter);
3946 case MeterPostFader:
3947 /* do nothing here */
3950 /* do nothing here */
3953 /* the meter is visible, so we don't touch it here */
3960 assert (_main_outs);
3961 assert (!_main_outs->display_to_user ());
3962 new_processors.push_back (_main_outs);
3964 /* iterator for the main outs */
3966 ProcessorList::iterator main = new_processors.end();
3969 /* OUTPUT METERING */
3971 if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
3972 assert (!_meter->display_to_user ());
3974 /* add the processor just before or just after the main outs */
3976 ProcessorList::iterator meter_point = main;
3978 if (_meter_point == MeterOutput) {
3981 new_processors.insert (meter_point, _meter);
3986 if (_monitor_send && !is_monitor ()) {
3987 assert (!_monitor_send->display_to_user ());
3988 if (Config->get_solo_control_is_listen_control()) {
3989 switch (Config->get_listen_position ()) {
3990 case PreFaderListen:
3991 switch (Config->get_pfl_position ()) {
3992 case PFLFromBeforeProcessors:
3993 new_processors.push_front (_monitor_send);
3995 case PFLFromAfterProcessors:
3996 new_processors.insert (amp, _monitor_send);
3999 _monitor_send->set_can_pan (false);
4001 case AfterFaderListen:
4002 switch (Config->get_afl_position ()) {
4003 case AFLFromBeforeProcessors:
4004 new_processors.insert (after_amp, _monitor_send);
4006 case AFLFromAfterProcessors:
4007 new_processors.insert (new_processors.end(), _monitor_send);
4010 _monitor_send->set_can_pan (true);
4014 new_processors.insert (new_processors.end(), _monitor_send);
4015 _monitor_send->set_can_pan (false);
4019 /* MONITOR CONTROL */
4021 if (_monitor_control && is_monitor ()) {
4022 assert (!_monitor_control->display_to_user ());
4023 new_processors.push_front (_monitor_control);
4026 /* INTERNAL RETURN */
4028 /* doing this here means that any monitor control will come just after
4033 assert (!_intreturn->display_to_user ());
4034 new_processors.push_front (_intreturn);
4037 /* EXPORT PROCESSOR */
4039 if (_capturing_processor) {
4040 assert (!_capturing_processor->display_to_user ());
4041 new_processors.push_front (_capturing_processor);
4044 _processors = new_processors;
4046 DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
4047 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4048 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
4055 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
4056 Glib::Threads::RWLock::ReaderLock lp (_processor_lock);
4060 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4061 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery>(*i);
4068 /** If the meter point is `Custom', make a note of where the meter is.
4069 * This is so that if the meter point is subsequently set to something else,
4070 * and then back to custom, we can put the meter back where it was last time
4071 * custom was enabled.
4073 * Must be called with the _processor_lock held.
4076 Route::maybe_note_meter_position ()
4078 if (_meter_point != MeterCustom) {
4082 _custom_meter_position_noted = true;
4083 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4084 if (boost::dynamic_pointer_cast<PeakMeter> (*i)) {
4085 ProcessorList::iterator j = i;
4087 if (j != _processors.end ()) {
4088 _processor_after_last_custom_meter = *j;
4089 _last_custom_meter_was_at_end = false;
4091 _last_custom_meter_was_at_end = true;
4097 boost::shared_ptr<Processor>
4098 Route::processor_by_id (PBD::ID id) const
4100 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4101 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4102 if ((*i)->id() == id) {
4107 return boost::shared_ptr<Processor> ();
4110 /** @return the monitoring state, or in other words what data we are pushing
4111 * into the route (data from the inputs, data from disk or silence)
4114 Route::monitoring_state () const
4116 return MonitoringInput;
4119 /** @return what we should be metering; either the data coming from the input
4120 * IO or the data that is flowing through the route.
4123 Route::metering_state () const
4125 return MeteringRoute;
4129 Route::has_external_redirects () const
4131 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4133 /* ignore inactive processors and obviously ignore the main
4134 * outs since everything has them and we don't care.
4137 if ((*i)->active() && (*i) != _main_outs && (*i)->does_routing()) {
4145 boost::shared_ptr<Processor>
4146 Route::the_instrument () const
4148 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
4149 return the_instrument_unlocked ();
4152 boost::shared_ptr<Processor>
4153 Route::the_instrument_unlocked () const
4155 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4156 if (boost::dynamic_pointer_cast<PluginInsert>(*i)) {
4157 if ((*i)->input_streams().n_midi() > 0 &&
4158 (*i)->output_streams().n_audio() > 0) {
4163 return boost::shared_ptr<Processor>();
4169 Route::non_realtime_locate (framepos_t pos)
4172 _pannable->transport_located (pos);
4176 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
4178 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4179 (*i)->transport_located (pos);
4185 Route::fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes)
4192 * We don't currently mix MIDI input together, so we don't need the
4193 * complex logic of the audio case.
4196 n_buffers = bufs.count().n_midi ();
4198 for (i = 0; i < n_buffers; ++i) {
4200 boost::shared_ptr<MidiPort> source_port = io->midi (i);
4201 MidiBuffer& buf (bufs.get_midi (i));
4204 buf.copy (source_port->get_midi_buffer(nframes));
4206 buf.silence (nframes);
4212 n_buffers = bufs.count().n_audio();
4214 size_t n_ports = io->n_ports().n_audio();
4215 float scaling = 1.0f;
4217 if (n_ports > n_buffers) {
4218 scaling = ((float) n_buffers) / n_ports;
4221 for (i = 0; i < n_ports; ++i) {
4223 /* if there are more ports than buffers, map them onto buffers
4224 * in a round-robin fashion
4227 boost::shared_ptr<AudioPort> source_port = io->audio (i);
4228 AudioBuffer& buf (bufs.get_audio (i%n_buffers));
4231 if (i < n_buffers) {
4233 /* first time through just copy a channel into
4237 buf.read_from (source_port->get_audio_buffer (nframes), nframes);
4239 if (scaling != 1.0f) {
4240 buf.apply_gain (scaling, nframes);
4245 /* on subsequent times around, merge data from
4246 * the port with what is already there
4249 if (scaling != 1.0f) {
4250 buf.accumulate_with_gain_from (source_port->get_audio_buffer (nframes), nframes, 0, scaling);
4252 buf.accumulate_from (source_port->get_audio_buffer (nframes), nframes);
4257 /* silence any remaining buffers */
4259 for (; i < n_buffers; ++i) {
4260 AudioBuffer& buf (bufs.get_audio (i));
4261 buf.silence (nframes);
4264 /* establish the initial setup of the buffer set, reflecting what was
4265 copied into it. unless, of course, we are the auditioner, in which
4266 case nothing was fed into it from the inputs at all.
4269 if (!is_auditioner()) {
4270 bufs.set_count (io->n_ports());