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 (!AudioEngine::instance()->port_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().port_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().port_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().port_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().port_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 (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2562 /* This processor could not be configured. Turn it into a UnknownProcessor */
2563 processor.reset (new UnknownProcessor (_session, **niter));
2566 /* we have to note the monitor send here, otherwise a new one will be created
2567 and the state of this one will be lost.
2569 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
2570 if (isend && isend->role() == Delivery::Listen) {
2571 _monitor_send = isend;
2574 /* it doesn't matter if invisible processors are added here, as they
2575 will be sorted out by setup_invisible_processors () shortly.
2578 new_order.push_back (processor);
2579 must_configure = true;
2585 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2586 _processors = new_order;
2588 if (must_configure) {
2589 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2590 configure_processors_unlocked (0);
2593 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2595 (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
2597 boost::shared_ptr<PluginInsert> pi;
2599 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
2600 if (pi->has_no_inputs ()) {
2601 _have_internal_generator = true;
2608 reset_instrument_info ();
2609 processors_changed (RouteProcessorChange ());
2610 set_processor_positions ();
2614 Route::curve_reallocate ()
2616 // _gain_automation_curve.finish_resize ();
2617 // _pan_automation_curve.finish_resize ();
2621 Route::silence (framecnt_t nframes)
2623 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
2628 silence_unlocked (nframes);
2632 Route::silence_unlocked (framecnt_t nframes)
2634 /* Must be called with the processor lock held */
2638 _output->silence (nframes);
2640 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2641 boost::shared_ptr<PluginInsert> pi;
2643 if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2644 // skip plugins, they don't need anything when we're not active
2648 (*i)->silence (nframes);
2651 if (nframes == _session.get_block_size()) {
2658 Route::add_internal_return ()
2661 _intreturn.reset (new InternalReturn (_session));
2662 add_processor (_intreturn, PreFader);
2667 Route::add_send_to_internal_return (InternalSend* send)
2669 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
2671 for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2672 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2675 return d->add_send (send);
2681 Route::remove_send_from_internal_return (InternalSend* send)
2683 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
2685 for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2686 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2689 return d->remove_send (send);
2695 Route::enable_monitor_send ()
2697 /* Caller must hold process lock */
2698 assert (!AudioEngine::instance()->process_lock().trylock());
2700 /* master never sends to monitor section via the normal mechanism */
2701 assert (!is_master ());
2703 /* make sure we have one */
2704 if (!_monitor_send) {
2705 _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, _session.monitor_out(), Delivery::Listen));
2706 _monitor_send->set_display_to_user (false);
2710 configure_processors (0);
2713 /** Add an aux send to a route.
2714 * @param route route to send to.
2715 * @param before Processor to insert before, or 0 to insert at the end.
2718 Route::add_aux_send (boost::shared_ptr<Route> route, boost::shared_ptr<Processor> before)
2720 assert (route != _session.monitor_out ());
2723 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
2725 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2727 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
2729 if (d && d->target_route() == route) {
2730 /* already listening via the specified IO: do nothing */
2738 boost::shared_ptr<InternalSend> listener;
2741 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2742 listener.reset (new InternalSend (_session, _pannable, _mute_master, route, Delivery::Aux));
2745 add_processor (listener, before);
2747 } catch (failed_constructor& err) {
2755 Route::remove_aux_or_listen (boost::shared_ptr<Route> route)
2757 ProcessorStreams err;
2758 ProcessorList::iterator tmp;
2761 Glib::Threads::RWLock::ReaderLock rl(_processor_lock);
2763 /* have to do this early because otherwise processor reconfig
2764 * will put _monitor_send back in the list
2767 if (route == _session.monitor_out()) {
2768 _monitor_send.reset ();
2772 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2774 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2776 if (d && d->target_route() == route) {
2778 remove_processor (*x, &err, false);
2781 /* list could have been demolished while we dropped the lock
2792 Route::set_comment (string cmt, void *src)
2795 comment_changed (src);
2796 _session.set_dirty ();
2800 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
2802 FeedRecord fr (other, via_sends_only);
2804 pair<FedBy::iterator,bool> result = _fed_by.insert (fr);
2806 if (!result.second) {
2808 /* already a record for "other" - make sure sends-only information is correct */
2809 if (!via_sends_only && result.first->sends_only) {
2810 FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
2811 frp->sends_only = false;
2815 return result.second;
2819 Route::clear_fed_by ()
2825 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
2827 const FedBy& fed_by (other->fed_by());
2829 for (FedBy::iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
2830 boost::shared_ptr<Route> sr = f->r.lock();
2832 if (sr && (sr.get() == this)) {
2834 if (via_sends_only) {
2835 *via_sends_only = f->sends_only;
2846 Route::direct_feeds_according_to_reality (boost::shared_ptr<Route> other, bool* via_send_only)
2848 DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
2850 if (_output->connected_to (other->input())) {
2851 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
2852 if (via_send_only) {
2853 *via_send_only = false;
2860 for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
2862 boost::shared_ptr<IOProcessor> iop;
2864 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
2865 if (iop->feeds (other)) {
2866 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
2867 if (via_send_only) {
2868 *via_send_only = true;
2872 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
2875 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
2880 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdoes NOT feed %1\n", other->name()));
2885 Route::direct_feeds_according_to_graph (boost::shared_ptr<Route> other, bool* via_send_only)
2887 return _session._current_route_graph.has (shared_from_this (), other, via_send_only);
2890 /** Called from the (non-realtime) butler thread when the transport is stopped */
2892 Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool /*did_locate*/, bool can_flush_processors)
2894 framepos_t now = _session.transport_frame();
2897 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2899 Automatable::transport_stopped (now);
2901 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2903 if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && can_flush_processors)) {
2907 (*i)->transport_stopped (now);
2911 _roll_delay = _initial_delay;
2915 Route::input_change_handler (IOChange change, void * /*src*/)
2917 bool need_to_queue_solo_change = true;
2919 if ((change.type & IOChange::ConfigurationChanged)) {
2920 /* This is called with the process lock held if change
2921 contains ConfigurationChanged
2923 need_to_queue_solo_change = false;
2924 configure_processors (0);
2925 _phase_invert.resize (_input->n_ports().n_audio ());
2926 io_changed (); /* EMIT SIGNAL */
2929 if (!_input->connected() && _soloed_by_others_upstream) {
2930 if (need_to_queue_solo_change) {
2931 _session.cancel_solo_after_disconnect (shared_from_this(), true);
2933 cancel_solo_after_disconnect (true);
2939 Route::output_change_handler (IOChange change, void * /*src*/)
2941 bool need_to_queue_solo_change = true;
2943 if ((change.type & IOChange::ConfigurationChanged)) {
2944 /* This is called with the process lock held if change
2945 contains ConfigurationChanged
2947 need_to_queue_solo_change = false;
2948 configure_processors (0);
2949 io_changed (); /* EMIT SIGNAL */
2952 if (!_output->connected() && _soloed_by_others_downstream) {
2953 if (need_to_queue_solo_change) {
2954 _session.cancel_solo_after_disconnect (shared_from_this(), false);
2956 cancel_solo_after_disconnect (false);
2962 Route::cancel_solo_after_disconnect (bool upstream)
2965 _soloed_by_others_upstream = 0;
2967 _soloed_by_others_downstream = 0;
2969 set_mute_master_solo ();
2970 solo_changed (false, this);
2974 Route::pans_required () const
2976 if (n_outputs().n_audio() < 2) {
2980 return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
2984 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
2986 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
2992 if (n_outputs().n_total() == 0) {
2996 if (!_active || n_inputs() == ChanCount::ZERO) {
2997 silence_unlocked (nframes);
3001 if (session_state_changing) {
3002 if (_session.transport_speed() != 0.0f) {
3003 /* we're rolling but some state is changing (e.g. our diskstream contents)
3004 so we cannot use them. Be silent till this is over.
3006 XXX note the absurdity of ::no_roll() being called when we ARE rolling!
3008 silence_unlocked (nframes);
3011 /* we're really not rolling, so we're either delivery silence or actually
3012 monitoring, both of which are safe to do while session_state_changing is true.
3016 BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers());
3018 fill_buffers_with_input (bufs, _input, nframes);
3020 if (_meter_point == MeterInput) {
3021 _meter->run (bufs, start_frame, end_frame, nframes, true);
3024 _amp->apply_gain_automation (false);
3025 passthru (bufs, start_frame, end_frame, nframes, 0);
3031 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& /* need_butler */)
3033 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3038 if (n_outputs().n_total() == 0) {
3042 if (!_active || n_inputs().n_total() == 0) {
3043 silence_unlocked (nframes);
3047 framepos_t unused = 0;
3049 if ((nframes = check_initial_delay (nframes, unused)) == 0) {
3055 BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers());
3057 fill_buffers_with_input (bufs, _input, nframes);
3059 if (_meter_point == MeterInput) {
3060 _meter->run (bufs, start_frame, end_frame, nframes, true);
3063 passthru (bufs, start_frame, end_frame, nframes, declick);
3069 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& /* need_butler */)
3076 Route::flush_processors ()
3078 /* XXX shouldn't really try to take this lock, since
3079 this is called from the RT audio thread.
3082 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3084 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3090 Route::set_meter_point (MeterPoint p, bool force)
3092 if (_meter_point == p && !force) {
3096 bool meter_was_visible_to_user = _meter->display_to_user ();
3099 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3101 maybe_note_meter_position ();
3105 if (_meter_point != MeterCustom) {
3107 _meter->set_display_to_user (false);
3109 setup_invisible_processors ();
3113 _meter->set_display_to_user (true);
3115 /* If we have a previous position for the custom meter, try to put it there */
3116 if (_custom_meter_position_noted) {
3117 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
3120 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), after);
3121 if (i != _processors.end ()) {
3122 _processors.remove (_meter);
3123 _processors.insert (i, _meter);
3125 } else if (_last_custom_meter_was_at_end) {
3126 _processors.remove (_meter);
3127 _processors.push_back (_meter);
3132 /* Set up the meter for its new position */
3134 ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
3138 if (loc == _processors.begin()) {
3139 m_in = _input->n_ports();
3141 ProcessorList::iterator before = loc;
3143 m_in = (*before)->output_streams ();
3146 _meter->reflect_inputs (m_in);
3148 /* we do not need to reconfigure the processors, because the meter
3149 (a) is always ready to handle processor_max_streams
3150 (b) is always an N-in/N-out processor, and thus moving
3151 it doesn't require any changes to the other processors.
3156 _meter->reset_max();
3158 meter_change (); /* EMIT SIGNAL */
3160 bool const meter_visibly_changed = (_meter->display_to_user() != meter_was_visible_to_user);
3162 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
3166 Route::listen_position_changed ()
3169 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3170 ProcessorState pstate (this);
3173 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3175 if (configure_processors_unlocked (0)) {
3177 configure_processors_unlocked (0); // it worked before we tried to add it ...
3183 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
3184 _session.set_dirty ();
3187 boost::shared_ptr<CapturingProcessor>
3188 Route::add_export_point()
3190 if (!_capturing_processor) {
3192 _capturing_processor.reset (new CapturingProcessor (_session));
3193 _capturing_processor->activate ();
3196 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3197 configure_processors (0);
3202 return _capturing_processor;
3206 Route::update_signal_latency ()
3208 framecnt_t l = _output->user_latency();
3210 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3211 if ((*i)->active ()) {
3212 l += (*i)->signal_latency ();
3216 DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l));
3218 if (_signal_latency != l) {
3219 _signal_latency = l;
3220 signal_latency_changed (); /* EMIT SIGNAL */
3223 return _signal_latency;
3227 Route::set_user_latency (framecnt_t nframes)
3229 _output->set_user_latency (nframes);
3230 _session.update_latency_compensation ();
3234 Route::set_latency_compensation (framecnt_t longest_session_latency)
3236 framecnt_t old = _initial_delay;
3238 if (_signal_latency < longest_session_latency) {
3239 _initial_delay = longest_session_latency - _signal_latency;
3244 DEBUG_TRACE (DEBUG::Latency, string_compose (
3245 "%1: compensate for maximum latency of %2,"
3246 "given own latency of %3, using initial delay of %4\n",
3247 name(), longest_session_latency, _signal_latency, _initial_delay));
3249 if (_initial_delay != old) {
3250 initial_delay_changed (); /* EMIT SIGNAL */
3253 if (_session.transport_stopped()) {
3254 _roll_delay = _initial_delay;
3258 Route::SoloControllable::SoloControllable (std::string name, boost::shared_ptr<Route> r)
3259 : AutomationControl (r->session(), Evoral::Parameter (SoloAutomation),
3260 boost::shared_ptr<AutomationList>(), name)
3263 boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
3268 Route::SoloControllable::set_value (double val)
3270 bool bval = ((val >= 0.5f) ? true: false);
3272 boost::shared_ptr<RouteList> rl (new RouteList);
3274 boost::shared_ptr<Route> r = _route.lock ();
3281 if (Config->get_solo_control_is_listen_control()) {
3282 _session.set_listen (rl, bval);
3284 _session.set_solo (rl, bval);
3289 Route::SoloControllable::get_value () const
3291 boost::shared_ptr<Route> r = _route.lock ();
3296 if (Config->get_solo_control_is_listen_control()) {
3297 return r->listening_via_monitor() ? 1.0f : 0.0f;
3299 return r->self_soloed() ? 1.0f : 0.0f;
3303 Route::MuteControllable::MuteControllable (std::string name, boost::shared_ptr<Route> r)
3304 : AutomationControl (r->session(), Evoral::Parameter (MuteAutomation),
3305 boost::shared_ptr<AutomationList>(), name)
3308 boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MuteAutomation)));
3313 Route::MuteControllable::set_value (double val)
3315 bool bval = ((val >= 0.5f) ? true: false);
3317 boost::shared_ptr<RouteList> rl (new RouteList);
3319 boost::shared_ptr<Route> r = _route.lock ();
3325 _session.set_mute (rl, bval);
3329 Route::MuteControllable::get_value () const
3331 boost::shared_ptr<Route> r = _route.lock ();
3336 return r->muted() ? 1.0f : 0.0f;
3340 Route::set_block_size (pframes_t nframes)
3342 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3343 (*i)->set_block_size (nframes);
3346 _session.ensure_buffers (n_process_buffers ());
3350 Route::protect_automation ()
3352 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3353 (*i)->protect_automation();
3356 /** @param declick 1 to set a pending declick fade-in,
3357 * -1 to set a pending declick fade-out
3360 Route::set_pending_declick (int declick)
3363 /* this call is not allowed to turn off a pending declick */
3365 _pending_declick = declick;
3368 _pending_declick = 0;
3372 /** Shift automation forwards from a particular place, thereby inserting time.
3373 * Adds undo commands for any shifts that are performed.
3375 * @param pos Position to start shifting from.
3376 * @param frames Amount to shift forwards by.
3380 Route::shift (framepos_t pos, framecnt_t frames)
3382 /* gain automation */
3384 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
3386 XMLNode &before = gc->alist()->get_state ();
3387 gc->alist()->shift (pos, frames);
3388 XMLNode &after = gc->alist()->get_state ();
3389 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3392 /* pan automation */
3394 ControlSet::Controls& c (_pannable->controls());
3396 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
3397 boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
3399 boost::shared_ptr<AutomationList> al = pc->alist();
3400 XMLNode& before = al->get_state ();
3401 al->shift (pos, frames);
3402 XMLNode& after = al->get_state ();
3403 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3408 /* redirect automation */
3410 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3411 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
3413 set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
3415 for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
3416 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
3418 boost::shared_ptr<AutomationList> al = ac->alist();
3419 XMLNode &before = al->get_state ();
3420 al->shift (pos, frames);
3421 XMLNode &after = al->get_state ();
3422 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3431 Route::save_as_template (const string& path, const string& name)
3433 XMLNode& node (state (false));
3436 IO::set_name_in_state (*node.children().front(), name);
3438 tree.set_root (&node);
3439 return tree.write (path.c_str());
3444 Route::set_name (const string& str)
3450 name = Route::ensure_track_or_route_name (str, _session);
3451 SessionObject::set_name (name);
3453 ret = (_input->set_name(name) && _output->set_name(name));
3456 /* rename the main outs. Leave other IO processors
3457 * with whatever name they already have, because its
3458 * just fine as it is (it will not contain the route
3459 * name if its a port insert, port send or port return).
3463 if (_main_outs->set_name (name)) {
3464 /* XXX returning false here is stupid because
3465 we already changed the route name.
3475 /** Set the name of a route in an XML description.
3476 * @param node XML <Route> node to set the name in.
3477 * @param name New name.
3480 Route::set_name_in_state (XMLNode& node, string const & name)
3482 node.add_property (X_("name"), name);
3484 XMLNodeList children = node.children();
3485 for (XMLNodeIterator i = children.begin(); i != children.end(); ++i) {
3487 if ((*i)->name() == X_("IO")) {
3489 IO::set_name_in_state (**i, name);
3491 } else if ((*i)->name() == X_("Processor")) {
3493 XMLProperty* role = (*i)->property (X_("role"));
3494 if (role && role->value() == X_("Main")) {
3495 (*i)->add_property (X_("name"), name);
3498 } else if ((*i)->name() == X_("Diskstream")) {
3500 (*i)->add_property (X_("playlist"), string_compose ("%1.1", name).c_str());
3501 (*i)->add_property (X_("name"), name);
3507 boost::shared_ptr<Send>
3508 Route::internal_send_for (boost::shared_ptr<const Route> target) const
3510 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3512 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3513 boost::shared_ptr<InternalSend> send;
3515 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
3516 if (send->target_route() == target) {
3522 return boost::shared_ptr<Send>();
3525 /** @param c Audio channel index.
3526 * @param yn true to invert phase, otherwise false.
3529 Route::set_phase_invert (uint32_t c, bool yn)
3531 if (_phase_invert[c] != yn) {
3532 _phase_invert[c] = yn;
3533 phase_invert_changed (); /* EMIT SIGNAL */
3534 _session.set_dirty ();
3539 Route::set_phase_invert (boost::dynamic_bitset<> p)
3541 if (_phase_invert != p) {
3543 phase_invert_changed (); /* EMIT SIGNAL */
3544 _session.set_dirty ();
3549 Route::phase_invert (uint32_t c) const
3551 return _phase_invert[c];
3554 boost::dynamic_bitset<>
3555 Route::phase_invert () const
3557 return _phase_invert;
3561 Route::set_denormal_protection (bool yn)
3563 if (_denormal_protection != yn) {
3564 _denormal_protection = yn;
3565 denormal_protection_changed (); /* EMIT SIGNAL */
3570 Route::denormal_protection () const
3572 return _denormal_protection;
3576 Route::set_active (bool yn, void* src)
3578 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
3579 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
3583 if (_active != yn) {
3585 _input->set_active (yn);
3586 _output->set_active (yn);
3587 active_changed (); // EMIT SIGNAL
3588 _session.set_dirty ();
3595 Glib::Threads::RWLock::ReaderLock rm (_processor_lock, Glib::Threads::TRY_LOCK);
3601 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3603 boost::shared_ptr<Send> s;
3604 boost::shared_ptr<Return> r;
3606 if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
3607 s->meter()->meter();
3608 } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
3609 r->meter()->meter ();
3614 boost::shared_ptr<Pannable>
3615 Route::pannable() const
3620 boost::shared_ptr<Panner>
3621 Route::panner() const
3624 return _main_outs->panner_shell()->panner();
3627 boost::shared_ptr<PannerShell>
3628 Route::panner_shell() const
3630 return _main_outs->panner_shell();
3633 boost::shared_ptr<AutomationControl>
3634 Route::gain_control() const
3636 return _amp->gain_control();
3639 boost::shared_ptr<AutomationControl>
3640 Route::get_control (const Evoral::Parameter& param)
3642 /* either we own the control or .... */
3644 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
3648 /* maybe one of our processors does or ... */
3650 Glib::Threads::RWLock::ReaderLock rm (_processor_lock, Glib::Threads::TRY_LOCK);
3651 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3652 if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
3660 /* nobody does so we'll make a new one */
3662 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
3669 boost::shared_ptr<Processor>
3670 Route::nth_plugin (uint32_t n)
3672 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3673 ProcessorList::iterator i;
3675 for (i = _processors.begin(); i != _processors.end(); ++i) {
3676 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
3683 return boost::shared_ptr<Processor> ();
3686 boost::shared_ptr<Processor>
3687 Route::nth_send (uint32_t n)
3689 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3690 ProcessorList::iterator i;
3692 for (i = _processors.begin(); i != _processors.end(); ++i) {
3693 if (boost::dynamic_pointer_cast<Send> (*i)) {
3700 return boost::shared_ptr<Processor> ();
3704 Route::has_io_processor_named (const string& name)
3706 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3707 ProcessorList::iterator i;
3709 for (i = _processors.begin(); i != _processors.end(); ++i) {
3710 if (boost::dynamic_pointer_cast<Send> (*i) ||
3711 boost::dynamic_pointer_cast<PortInsert> (*i)) {
3712 if ((*i)->name() == name) {
3721 MuteMaster::MutePoint
3722 Route::mute_points () const
3724 return _mute_master->mute_points ();
3728 Route::set_processor_positions ()
3730 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3732 bool had_amp = false;
3733 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3734 (*i)->set_pre_fader (!had_amp);
3735 if (boost::dynamic_pointer_cast<Amp> (*i)) {
3741 /** Called when there is a proposed change to the input port count */
3743 Route::input_port_count_changing (ChanCount to)
3745 list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
3747 /* The processors cannot be configured with the new input arrangement, so
3753 /* The change is ok */
3758 Route::unknown_processors () const
3762 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3763 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3764 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
3765 p.push_back ((*i)->name ());
3774 Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecnt_t our_latency) const
3776 /* we assume that all our input ports feed all our output ports. its not
3777 universally true, but the alternative is way too corner-case to worry about.
3780 LatencyRange all_connections;
3783 all_connections.min = 0;
3784 all_connections.max = 0;
3786 all_connections.min = ~((jack_nframes_t) 0);
3787 all_connections.max = 0;
3789 /* iterate over all "from" ports and determine the latency range for all of their
3790 connections to the "outside" (outside of this Route).
3793 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
3797 p->get_connected_latency_range (range, playback);
3799 all_connections.min = min (all_connections.min, range.min);
3800 all_connections.max = max (all_connections.max, range.max);
3804 /* set the "from" port latencies to the max/min range of all their connections */
3806 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
3807 p->set_private_latency_range (all_connections, playback);
3810 /* set the ports "in the direction of the flow" to the same value as above plus our own signal latency */
3812 all_connections.min += our_latency;
3813 all_connections.max += our_latency;
3815 for (PortSet::iterator p = to.begin(); p != to.end(); ++p) {
3816 p->set_private_latency_range (all_connections, playback);
3819 return all_connections.max;
3823 Route::set_private_port_latencies (bool playback) const
3825 framecnt_t own_latency = 0;
3827 /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD
3828 OR LATENCY CALLBACK.
3830 This is called (early) from the latency callback. It computes the REAL
3831 latency associated with each port and stores the result as the "private"
3832 latency of the port. A later call to Route::set_public_port_latencies()
3833 sets all ports to the same value to reflect the fact that we do latency
3834 compensation and so all signals are delayed by the same amount as they
3835 flow through ardour.
3838 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3839 if ((*i)->active ()) {
3840 own_latency += (*i)->signal_latency ();
3845 /* playback: propagate latency from "outside the route" to outputs to inputs */
3846 return update_port_latencies (_output->ports (), _input->ports (), true, own_latency);
3848 /* capture: propagate latency from "outside the route" to inputs to outputs */
3849 return update_port_latencies (_input->ports (), _output->ports (), false, own_latency);
3854 Route::set_public_port_latencies (framecnt_t value, bool playback) const
3856 /* this is called to set the JACK-visible port latencies, which take
3857 latency compensation into account.
3866 const PortSet& ports (_input->ports());
3867 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
3868 p->set_public_latency_range (range, playback);
3873 const PortSet& ports (_output->ports());
3874 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
3875 p->set_public_latency_range (range, playback);
3880 /** Put the invisible processors in the right place in _processors.
3881 * Must be called with a writer lock on _processor_lock held.
3884 Route::setup_invisible_processors ()
3887 Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3888 assert (!lm.locked ());
3892 /* too early to be doing this stuff */
3896 /* we'll build this new list here and then use it */
3898 ProcessorList new_processors;
3900 /* find visible processors */
3902 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3903 if ((*i)->display_to_user ()) {
3904 new_processors.push_back (*i);
3910 ProcessorList::iterator amp = new_processors.begin ();
3911 while (amp != new_processors.end() && boost::dynamic_pointer_cast<Amp> (*amp) == 0) {
3915 assert (amp != _processors.end ());
3917 /* and the processor after the amp */
3919 ProcessorList::iterator after_amp = amp;
3925 switch (_meter_point) {
3927 assert (!_meter->display_to_user ());
3928 new_processors.push_front (_meter);
3931 assert (!_meter->display_to_user ());
3932 new_processors.insert (amp, _meter);
3934 case MeterPostFader:
3935 /* do nothing here */
3938 /* do nothing here */
3941 /* the meter is visible, so we don't touch it here */
3948 assert (_main_outs);
3949 assert (!_main_outs->display_to_user ());
3950 new_processors.push_back (_main_outs);
3952 /* iterator for the main outs */
3954 ProcessorList::iterator main = new_processors.end();
3957 /* OUTPUT METERING */
3959 if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
3960 assert (!_meter->display_to_user ());
3962 /* add the processor just before or just after the main outs */
3964 ProcessorList::iterator meter_point = main;
3966 if (_meter_point == MeterOutput) {
3969 new_processors.insert (meter_point, _meter);
3974 if (_monitor_send && !is_monitor ()) {
3975 assert (!_monitor_send->display_to_user ());
3976 if (Config->get_solo_control_is_listen_control()) {
3977 switch (Config->get_listen_position ()) {
3978 case PreFaderListen:
3979 switch (Config->get_pfl_position ()) {
3980 case PFLFromBeforeProcessors:
3981 new_processors.push_front (_monitor_send);
3983 case PFLFromAfterProcessors:
3984 new_processors.insert (amp, _monitor_send);
3987 _monitor_send->set_can_pan (false);
3989 case AfterFaderListen:
3990 switch (Config->get_afl_position ()) {
3991 case AFLFromBeforeProcessors:
3992 new_processors.insert (after_amp, _monitor_send);
3994 case AFLFromAfterProcessors:
3995 new_processors.insert (new_processors.end(), _monitor_send);
3998 _monitor_send->set_can_pan (true);
4002 new_processors.insert (new_processors.end(), _monitor_send);
4003 _monitor_send->set_can_pan (false);
4007 /* MONITOR CONTROL */
4009 if (_monitor_control && is_monitor ()) {
4010 assert (!_monitor_control->display_to_user ());
4011 new_processors.push_front (_monitor_control);
4014 /* INTERNAL RETURN */
4016 /* doing this here means that any monitor control will come just after
4021 assert (!_intreturn->display_to_user ());
4022 new_processors.push_front (_intreturn);
4025 /* EXPORT PROCESSOR */
4027 if (_capturing_processor) {
4028 assert (!_capturing_processor->display_to_user ());
4029 new_processors.push_front (_capturing_processor);
4032 _processors = new_processors;
4034 DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
4035 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4036 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
4043 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
4044 Glib::Threads::RWLock::ReaderLock lp (_processor_lock);
4048 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4049 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery>(*i);
4056 /** If the meter point is `Custom', make a note of where the meter is.
4057 * This is so that if the meter point is subsequently set to something else,
4058 * and then back to custom, we can put the meter back where it was last time
4059 * custom was enabled.
4061 * Must be called with the _processor_lock held.
4064 Route::maybe_note_meter_position ()
4066 if (_meter_point != MeterCustom) {
4070 _custom_meter_position_noted = true;
4071 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4072 if (boost::dynamic_pointer_cast<PeakMeter> (*i)) {
4073 ProcessorList::iterator j = i;
4075 if (j != _processors.end ()) {
4076 _processor_after_last_custom_meter = *j;
4077 _last_custom_meter_was_at_end = false;
4079 _last_custom_meter_was_at_end = true;
4085 boost::shared_ptr<Processor>
4086 Route::processor_by_id (PBD::ID id) const
4088 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4089 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4090 if ((*i)->id() == id) {
4095 return boost::shared_ptr<Processor> ();
4098 /** @return the monitoring state, or in other words what data we are pushing
4099 * into the route (data from the inputs, data from disk or silence)
4102 Route::monitoring_state () const
4104 return MonitoringInput;
4107 /** @return what we should be metering; either the data coming from the input
4108 * IO or the data that is flowing through the route.
4111 Route::metering_state () const
4113 return MeteringRoute;
4117 Route::has_external_redirects () const
4119 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4121 /* ignore inactive processors and obviously ignore the main
4122 * outs since everything has them and we don't care.
4125 if ((*i)->active() && (*i) != _main_outs && (*i)->does_routing()) {
4133 boost::shared_ptr<Processor>
4134 Route::the_instrument () const
4136 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
4137 return the_instrument_unlocked ();
4140 boost::shared_ptr<Processor>
4141 Route::the_instrument_unlocked () const
4143 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4144 if (boost::dynamic_pointer_cast<PluginInsert>(*i)) {
4145 if ((*i)->input_streams().n_midi() > 0 &&
4146 (*i)->output_streams().n_audio() > 0) {
4151 return boost::shared_ptr<Processor>();
4157 Route::non_realtime_locate (framepos_t pos)
4160 _pannable->transport_located (pos);
4164 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
4166 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4167 (*i)->transport_located (pos);
4173 Route::fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes)
4180 * We don't currently mix MIDI input together, so we don't need the
4181 * complex logic of the audio case.
4184 n_buffers = bufs.count().n_midi ();
4186 for (i = 0; i < n_buffers; ++i) {
4188 boost::shared_ptr<MidiPort> source_port = io->midi (i);
4189 MidiBuffer& buf (bufs.get_midi (i));
4192 buf.copy (source_port->get_midi_buffer(nframes));
4194 buf.silence (nframes);
4200 n_buffers = bufs.count().n_audio();
4202 size_t n_ports = io->n_ports().n_audio();
4203 float scaling = 1.0f;
4205 if (n_ports > n_buffers) {
4206 scaling = ((float) n_buffers) / n_ports;
4209 for (i = 0; i < n_ports; ++i) {
4211 /* if there are more ports than buffers, map them onto buffers
4212 * in a round-robin fashion
4215 boost::shared_ptr<AudioPort> source_port = io->audio (i);
4216 AudioBuffer& buf (bufs.get_audio (i%n_buffers));
4219 if (i < n_buffers) {
4221 /* first time through just copy a channel into
4225 buf.read_from (source_port->get_audio_buffer (nframes), nframes);
4227 if (scaling != 1.0f) {
4228 buf.apply_gain (scaling, nframes);
4233 /* on subsequent times around, merge data from
4234 * the port with what is already there
4237 if (scaling != 1.0f) {
4238 buf.accumulate_with_gain_from (source_port->get_audio_buffer (nframes), nframes, 0, scaling);
4240 buf.accumulate_from (source_port->get_audio_buffer (nframes), nframes);
4245 /* silence any remaining buffers */
4247 for (; i < n_buffers; ++i) {
4248 AudioBuffer& buf (bufs.get_audio (i));
4249 buf.silence (nframes);
4252 /* establish the initial setup of the buffer set, reflecting what was
4253 copied into it. unless, of course, we are the auditioner, in which
4254 case nothing was fed into it from the inputs at all.
4257 if (!is_auditioner()) {
4258 bufs.set_count (io->n_ports());