2 Copyright (C) 2000 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 #include "libardour-config.h"
29 #include <boost/algorithm/string.hpp>
31 #include "pbd/xml++.h"
32 #include "pbd/enumwriter.h"
33 #include "pbd/memento_command.h"
34 #include "pbd/stacktrace.h"
35 #include "pbd/convert.h"
36 #include "pbd/boost_debug.h"
38 #include "ardour/amp.h"
39 #include "ardour/audio_buffer.h"
40 #include "ardour/audio_port.h"
41 #include "ardour/audioengine.h"
42 #include "ardour/buffer.h"
43 #include "ardour/buffer_set.h"
44 #include "ardour/capturing_processor.h"
45 #include "ardour/debug.h"
46 #include "ardour/delivery.h"
47 #include "ardour/internal_return.h"
48 #include "ardour/internal_send.h"
49 #include "ardour/meter.h"
50 #include "ardour/midi_buffer.h"
51 #include "ardour/midi_port.h"
52 #include "ardour/monitor_processor.h"
53 #include "ardour/pannable.h"
54 #include "ardour/panner_shell.h"
55 #include "ardour/plugin_insert.h"
56 #include "ardour/port.h"
57 #include "ardour/port_insert.h"
58 #include "ardour/processor.h"
59 #include "ardour/route.h"
60 #include "ardour/route_group.h"
61 #include "ardour/send.h"
62 #include "ardour/session.h"
63 #include "ardour/unknown_processor.h"
64 #include "ardour/utils.h"
69 using namespace ARDOUR;
72 PBD::Signal1<void,RouteSortOrderKey> Route::SyncOrderKeys;
73 PBD::Signal0<void> Route::RemoteControlIDChange;
75 Route::Route (Session& sess, string name, Flag flg, DataType default_type)
76 : SessionObject (sess, name)
78 , GraphNode (sess._process_graph)
84 , _pending_declick (true)
85 , _meter_point (MeterPostFader)
86 , _meter_type (MeterPeak)
88 , _soloed_by_others_upstream (0)
89 , _soloed_by_others_downstream (0)
91 , _denormal_protection (false)
94 , _declickable (false)
95 , _mute_master (new MuteMaster (sess, name))
96 , _have_internal_generator (false)
98 , _default_type (default_type)
99 , _remote_control_id (0)
100 , _in_configure_processors (false)
101 , _custom_meter_position_noted (false)
102 , _last_custom_meter_was_at_end (false)
104 processor_max_streams.reset();
110 /* add standard controls */
112 _solo_control.reset (new SoloControllable (X_("solo"), shared_from_this ()));
113 _mute_control.reset (new MuteControllable (X_("mute"), shared_from_this ()));
115 _solo_control->set_flags (Controllable::Flag (_solo_control->flags() | Controllable::Toggle));
116 _mute_control->set_flags (Controllable::Flag (_mute_control->flags() | Controllable::Toggle));
118 add_control (_solo_control);
119 add_control (_mute_control);
123 if (!(_flags & Route::MonitorOut)) {
124 _pannable.reset (new Pannable (_session));
127 /* input and output objects */
129 _input.reset (new IO (_session, _name, IO::Input, _default_type));
130 _output.reset (new IO (_session, _name, IO::Output, _default_type));
132 _input->changed.connect_same_thread (*this, boost::bind (&Route::input_change_handler, this, _1, _2));
133 _input->PortCountChanging.connect_same_thread (*this, boost::bind (&Route::input_port_count_changing, this, _1));
135 _output->changed.connect_same_thread (*this, boost::bind (&Route::output_change_handler, this, _1, _2));
137 /* add amp processor */
139 _amp.reset (new Amp (_session));
140 add_processor (_amp, PostFader);
142 /* create standard processors: meter, main outs, monitor out;
143 they will be added to _processors by setup_invisible_processors ()
146 _meter.reset (new PeakMeter (_session, _name));
147 _meter->set_display_to_user (false);
150 _main_outs.reset (new Delivery (_session, _output, _pannable, _mute_master, _name, Delivery::Main));
151 _main_outs->activate ();
154 /* where we listen to tracks */
155 _intreturn.reset (new InternalReturn (_session));
156 _intreturn->activate ();
158 /* the thing that provides proper control over a control/monitor/listen bus
159 (such as per-channel cut, dim, solo, invert, etc).
161 _monitor_control.reset (new MonitorProcessor (_session));
162 _monitor_control->activate ();
165 if (is_master() || is_monitor() || is_auditioner()) {
166 _mute_master->set_solo_ignore (true);
169 /* now that we have _meter, its safe to connect to this */
171 Metering::Meter.connect_same_thread (*this, (boost::bind (&Route::meter, this)));
174 /* run a configure so that the invisible processors get set up */
175 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
176 configure_processors (0);
184 DEBUG_TRACE (DEBUG::Destruction, string_compose ("route %1 destructor\n", _name));
186 /* do this early so that we don't get incoming signals as we are going through destruction
191 /* don't use clear_processors here, as it depends on the session which may
192 be half-destroyed by now
195 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
196 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
197 (*i)->drop_references ();
200 _processors.clear ();
204 Route::set_remote_control_id (uint32_t id, bool notify_class_listeners)
206 if (Config->get_remote_model() != UserOrdered) {
210 set_remote_control_id_internal (id, notify_class_listeners);
214 Route::set_remote_control_id_internal (uint32_t id, bool notify_class_listeners)
216 /* force IDs for master/monitor busses and prevent
217 any other route from accidentally getting these IDs
218 (i.e. legacy sessions)
221 if (is_master() && id != MasterBusRemoteControlID) {
222 id = MasterBusRemoteControlID;
225 if (is_monitor() && id != MonitorBusRemoteControlID) {
226 id = MonitorBusRemoteControlID;
233 /* don't allow it to collide */
235 if (!is_master () && !is_monitor() &&
236 (id == MasterBusRemoteControlID || id == MonitorBusRemoteControlID)) {
237 id += MonitorBusRemoteControlID;
240 if (id != remote_control_id()) {
241 _remote_control_id = id;
242 RemoteControlIDChanged ();
244 if (notify_class_listeners) {
245 RemoteControlIDChange ();
251 Route::remote_control_id() const
254 return MasterBusRemoteControlID;
258 return MonitorBusRemoteControlID;
261 return _remote_control_id;
265 Route::has_order_key (RouteSortOrderKey key) const
267 return (order_keys.find (key) != order_keys.end());
271 Route::order_key (RouteSortOrderKey key) const
273 OrderKeys::const_iterator i = order_keys.find (key);
275 if (i == order_keys.end()) {
283 Route::sync_order_keys (RouteSortOrderKey base)
285 /* this is called after changes to 1 or more route order keys have been
286 * made, and we want to sync up.
289 OrderKeys::iterator i = order_keys.find (base);
291 if (i == order_keys.end()) {
295 for (OrderKeys::iterator k = order_keys.begin(); k != order_keys.end(); ++k) {
297 if (k->first != base) {
298 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("%1 set key for %2 to %3 from %4\n",
300 enum_2_string (k->first),
302 enum_2_string (base)));
304 k->second = i->second;
310 Route::set_remote_control_id_from_order_key (RouteSortOrderKey /*key*/, uint32_t rid)
312 if (is_master() || is_monitor() || is_auditioner()) {
313 /* hard-coded remote IDs, or no remote ID */
317 if (_remote_control_id != rid) {
318 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("%1: set edit-based RID to %2\n", name(), rid));
319 _remote_control_id = rid;
320 RemoteControlIDChanged (); /* EMIT SIGNAL (per-route) */
323 /* don't emit the class-level RID signal RemoteControlIDChange here,
324 leave that to the entity that changed the order key, so that we
325 don't get lots of emissions for no good reasons (e.g. when changing
326 all route order keys).
328 See Session::sync_remote_id_from_order_keys() for the (primary|only)
329 spot where that is emitted.
334 Route::set_order_key (RouteSortOrderKey key, uint32_t n)
336 OrderKeys::iterator i = order_keys.find (key);
338 if (i != order_keys.end() && i->second == n) {
344 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("%1 order key %2 set to %3\n",
345 name(), enum_2_string (key), order_key (key)));
347 _session.set_dirty ();
351 Route::ensure_track_or_route_name(string name, Session &session)
353 string newname = name;
355 while (!session.io_name_is_legal (newname)) {
356 newname = bump_name_once (newname, '.');
364 Route::inc_gain (gain_t fraction, void *src)
366 _amp->inc_gain (fraction, src);
370 Route::set_gain (gain_t val, void *src)
372 if (src != 0 && _route_group && src != _route_group && _route_group->is_active() && _route_group->is_gain()) {
374 if (_route_group->is_relative()) {
376 gain_t usable_gain = _amp->gain();
377 if (usable_gain < 0.000001f) {
378 usable_gain = 0.000001f;
382 if (delta < 0.000001f) {
386 delta -= usable_gain;
391 gain_t factor = delta / usable_gain;
394 factor = _route_group->get_max_factor(factor);
395 if (factor == 0.0f) {
396 _amp->gain_control()->Changed(); /* EMIT SIGNAL */
400 factor = _route_group->get_min_factor(factor);
401 if (factor == 0.0f) {
402 _amp->gain_control()->Changed(); /* EMIT SIGNAL */
407 _route_group->foreach_route (boost::bind (&Route::inc_gain, _1, factor, _route_group));
411 _route_group->foreach_route (boost::bind (&Route::set_gain, _1, val, _route_group));
417 if (val == _amp->gain()) {
421 _amp->set_gain (val, src);
425 Route::maybe_declick (BufferSet&, framecnt_t, int)
427 /* this is the "bus" implementation and they never declick.
432 /** Process this route for one (sub) cycle (process thread)
434 * @param bufs Scratch buffers to use for the signal path
435 * @param start_frame Initial transport frame
436 * @param end_frame Final transport frame
437 * @param nframes Number of frames to output (to ports)
439 * Note that (end_frame - start_frame) may not be equal to nframes when the
440 * transport speed isn't 1.0 (eg varispeed).
443 Route::process_output_buffers (BufferSet& bufs,
444 framepos_t start_frame, framepos_t end_frame, pframes_t nframes,
445 int declick, bool gain_automation_ok)
447 bufs.set_is_silent (false);
449 /* figure out if we're going to use gain automation */
450 if (gain_automation_ok) {
451 _amp->set_gain_automation_buffer (_session.gain_automation_buffer ());
452 _amp->setup_gain_automation (start_frame, end_frame, nframes);
454 _amp->apply_gain_automation (false);
457 /* Tell main outs what to do about monitoring. We do this so that
458 on a transition between monitoring states we get a de-clicking gain
459 change in the _main_outs delivery.
462 _main_outs->no_outs_cuz_we_no_monitor (monitoring_state () == MonitoringSilence);
464 /* -------------------------------------------------------------------------------------------
465 GLOBAL DECLICK (for transport changes etc.)
466 ----------------------------------------------------------------------------------------- */
468 maybe_declick (bufs, nframes, declick);
469 _pending_declick = 0;
471 /* -------------------------------------------------------------------------------------------
472 DENORMAL CONTROL/PHASE INVERT
473 ----------------------------------------------------------------------------------------- */
475 if (_phase_invert.any ()) {
479 if (_denormal_protection || Config->get_denormal_protection()) {
481 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
482 Sample* const sp = i->data();
484 if (_phase_invert[chn]) {
485 for (pframes_t nx = 0; nx < nframes; ++nx) {
490 for (pframes_t nx = 0; nx < nframes; ++nx) {
498 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
499 Sample* const sp = i->data();
501 if (_phase_invert[chn]) {
502 for (pframes_t nx = 0; nx < nframes; ++nx) {
511 if (_denormal_protection || Config->get_denormal_protection()) {
513 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
514 Sample* const sp = i->data();
515 for (pframes_t nx = 0; nx < nframes; ++nx) {
523 /* -------------------------------------------------------------------------------------------
525 ----------------------------------------------------------------------------------------- */
527 /* set this to be true if the meter will already have been ::run() earlier */
528 bool const meter_already_run = metering_state() == MeteringInput;
530 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
532 if (meter_already_run && boost::dynamic_pointer_cast<PeakMeter> (*i)) {
533 /* don't ::run() the meter, otherwise it will have its previous peak corrupted */
538 /* if it has any inputs, make sure they match */
539 if (boost::dynamic_pointer_cast<UnknownProcessor> (*i) == 0 && (*i)->input_streams() != ChanCount::ZERO) {
540 if (bufs.count() != (*i)->input_streams()) {
542 DEBUG::Processors, string_compose (
543 "%1 bufs = %2 input for %3 = %4\n",
544 _name, bufs.count(), (*i)->name(), (*i)->input_streams()
552 /* should we NOT run plugins here if the route is inactive?
553 do we catch route != active somewhere higher?
556 (*i)->run (bufs, start_frame, end_frame, nframes, *i != _processors.back());
557 bufs.set_count ((*i)->output_streams());
562 Route::n_process_buffers ()
564 return max (_input->n_ports(), processor_max_streams);
568 Route::monitor_run (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
570 assert (is_monitor());
571 BufferSet& bufs (_session.get_scratch_buffers (n_process_buffers()));
572 passthru (bufs, start_frame, end_frame, nframes, declick);
576 Route::passthru (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
580 if (is_monitor() && _session.listening() && !_session.is_auditioning()) {
582 /* control/monitor bus ignores input ports when something is
583 feeding the listen "stream". data will "arrive" into the
584 route from the intreturn processor element.
587 bufs.silence (nframes, 0);
590 write_out_of_band_data (bufs, start_frame, end_frame, nframes);
591 process_output_buffers (bufs, start_frame, end_frame, nframes, declick, true);
595 Route::passthru_silence (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
597 BufferSet& bufs (_session.get_silent_buffers (n_process_buffers()));
599 bufs.set_count (_input->n_ports());
600 write_out_of_band_data (bufs, start_frame, end_frame, nframes);
601 process_output_buffers (bufs, start_frame, end_frame, nframes, declick, false);
605 Route::set_listen (bool yn, void* src)
611 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
612 _route_group->foreach_route (boost::bind (&Route::set_listen, _1, yn, _route_group));
617 if (yn != _monitor_send->active()) {
619 _monitor_send->activate ();
620 _mute_master->set_soloed (true);
622 _monitor_send->deactivate ();
623 _mute_master->set_soloed (false);
626 listen_changed (src); /* EMIT SIGNAL */
632 Route::listening_via_monitor () const
635 return _monitor_send->active ();
642 Route::set_solo_safe (bool yn, void *src)
644 if (_solo_safe != yn) {
646 solo_safe_changed (src);
651 Route::solo_safe() const
657 Route::set_solo (bool yn, void *src)
660 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 ignore solo change due to solo-safe\n", name()));
664 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
665 _route_group->foreach_route (boost::bind (&Route::set_solo, _1, yn, _route_group));
669 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1: set solo => %2, src: %3 grp ? %4 currently self-soloed ? %5\n",
670 name(), yn, src, (src == _route_group), self_soloed()));
672 if (self_soloed() != yn) {
674 set_mute_master_solo ();
675 solo_changed (true, src); /* EMIT SIGNAL */
676 _solo_control->Changed (); /* EMIT SIGNAL */
681 Route::set_self_solo (bool yn)
683 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1: set SELF solo => %2\n", name(), yn));
688 Route::mod_solo_by_others_upstream (int32_t delta)
691 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 ignore solo-by-upstream due to solo-safe\n", name()));
695 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 mod solo-by-upstream by %2, current up = %3 down = %4\n",
696 name(), delta, _soloed_by_others_upstream, _soloed_by_others_downstream));
698 uint32_t old_sbu = _soloed_by_others_upstream;
701 if (_soloed_by_others_upstream >= (uint32_t) abs (delta)) {
702 _soloed_by_others_upstream += delta;
704 _soloed_by_others_upstream = 0;
707 _soloed_by_others_upstream += delta;
710 DEBUG_TRACE (DEBUG::Solo, string_compose (
711 "%1 SbU delta %2 = %3 old = %4 sbd %5 ss %6 exclusive %7\n",
712 name(), delta, _soloed_by_others_upstream, old_sbu,
713 _soloed_by_others_downstream, _self_solo, Config->get_exclusive_solo()));
715 /* push the inverse solo change to everything that feeds us.
717 This is important for solo-within-group. When we solo 1 track out of N that
718 feed a bus, that track will cause mod_solo_by_upstream (+1) to be called
719 on the bus. The bus then needs to call mod_solo_by_downstream (-1) on all
720 tracks that feed it. This will silence them if they were audible because
721 of a bus solo, but the newly soloed track will still be audible (because
724 but .. do this only when we are being told to solo-by-upstream (i.e delta = +1),
728 if ((_self_solo || _soloed_by_others_downstream) &&
729 ((old_sbu == 0 && _soloed_by_others_upstream > 0) ||
730 (old_sbu > 0 && _soloed_by_others_upstream == 0))) {
732 if (delta > 0 || !Config->get_exclusive_solo()) {
733 DEBUG_TRACE (DEBUG::Solo, "\t ... INVERT push\n");
734 for (FedBy::iterator i = _fed_by.begin(); i != _fed_by.end(); ++i) {
735 boost::shared_ptr<Route> sr = i->r.lock();
737 sr->mod_solo_by_others_downstream (-delta);
743 set_mute_master_solo ();
744 solo_changed (false, this);
748 Route::mod_solo_by_others_downstream (int32_t delta)
751 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 ignore solo-by-downstream due to solo safe\n", name()));
755 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 mod solo-by-downstream by %2, current up = %3 down = %4\n",
756 name(), delta, _soloed_by_others_upstream, _soloed_by_others_downstream));
759 if (_soloed_by_others_downstream >= (uint32_t) abs (delta)) {
760 _soloed_by_others_downstream += delta;
762 _soloed_by_others_downstream = 0;
765 _soloed_by_others_downstream += delta;
768 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 SbD delta %2 = %3\n", name(), delta, _soloed_by_others_downstream));
770 set_mute_master_solo ();
771 solo_changed (false, this);
775 Route::set_mute_master_solo ()
777 _mute_master->set_soloed (self_soloed() || soloed_by_others_downstream() || soloed_by_others_upstream());
781 Route::set_solo_isolated (bool yn, void *src)
783 if (is_master() || is_monitor() || is_auditioner()) {
787 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
788 _route_group->foreach_route (boost::bind (&Route::set_solo_isolated, _1, yn, _route_group));
792 /* forward propagate solo-isolate status to everything fed by this route, but not those via sends only */
794 boost::shared_ptr<RouteList> routes = _session.get_routes ();
795 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
797 if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
802 bool does_feed = direct_feeds_according_to_graph (*i, &sends_only); // we will recurse anyway, so don't use ::feeds()
804 if (does_feed && !sends_only) {
805 (*i)->set_solo_isolated (yn, (*i)->route_group());
809 /* XXX should we back-propagate as well? (April 2010: myself and chris goddard think not) */
811 bool changed = false;
814 if (_solo_isolated == 0) {
815 _mute_master->set_solo_ignore (true);
820 if (_solo_isolated > 0) {
822 if (_solo_isolated == 0) {
823 _mute_master->set_solo_ignore (false);
830 solo_isolated_changed (src);
835 Route::solo_isolated () const
837 return _solo_isolated > 0;
841 Route::set_mute_points (MuteMaster::MutePoint mp)
843 _mute_master->set_mute_points (mp);
844 mute_points_changed (); /* EMIT SIGNAL */
846 if (_mute_master->muted_by_self()) {
847 mute_changed (this); /* EMIT SIGNAL */
848 _mute_control->Changed (); /* EMIT SIGNAL */
853 Route::set_mute (bool yn, void *src)
855 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_mute()) {
856 _route_group->foreach_route (boost::bind (&Route::set_mute, _1, yn, _route_group));
861 _mute_master->set_muted_by_self (yn);
862 /* allow any derived classes to respond to the mute change
863 before anybody else knows about it.
866 /* tell everyone else */
867 mute_changed (src); /* EMIT SIGNAL */
868 _mute_control->Changed (); /* EMIT SIGNAL */
873 Route::muted () const
875 return _mute_master->muted_by_self();
880 dump_processors(const string& name, const list<boost::shared_ptr<Processor> >& procs)
882 cerr << name << " {" << endl;
883 for (list<boost::shared_ptr<Processor> >::const_iterator p = procs.begin();
884 p != procs.end(); ++p) {
885 cerr << "\t" << (*p)->name() << " ID = " << (*p)->id() << " @ " << (*p) << endl;
891 /** Supposing that we want to insert a Processor at a given Placement, return
892 * the processor to add the new one before (or 0 to add at the end).
894 boost::shared_ptr<Processor>
895 Route::before_processor_for_placement (Placement p)
897 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
899 ProcessorList::iterator loc;
902 /* generic pre-fader: insert immediately before the amp */
903 loc = find (_processors.begin(), _processors.end(), _amp);
905 /* generic post-fader: insert right before the main outs */
906 loc = find (_processors.begin(), _processors.end(), _main_outs);
909 return loc != _processors.end() ? *loc : boost::shared_ptr<Processor> ();
912 /** Supposing that we want to insert a Processor at a given index, return
913 * the processor to add the new one before (or 0 to add at the end).
915 boost::shared_ptr<Processor>
916 Route::before_processor_for_index (int index)
919 return boost::shared_ptr<Processor> ();
922 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
924 ProcessorList::iterator i = _processors.begin ();
926 while (i != _processors.end() && j < index) {
927 if ((*i)->display_to_user()) {
934 return (i != _processors.end() ? *i : boost::shared_ptr<Processor> ());
937 /** Add a processor either pre- or post-fader
938 * @return 0 on success, non-0 on failure.
941 Route::add_processor (boost::shared_ptr<Processor> processor, Placement placement, ProcessorStreams* err, bool activation_allowed)
943 return add_processor (processor, before_processor_for_placement (placement), err, activation_allowed);
947 /** Add a processor to a route such that it ends up with a given index into the visible processors.
948 * @param index Index to add the processor at, or -1 to add at the end of the list.
949 * @return 0 on success, non-0 on failure.
952 Route::add_processor_by_index (boost::shared_ptr<Processor> processor, int index, ProcessorStreams* err, bool activation_allowed)
954 return add_processor (processor, before_processor_for_index (index), err, activation_allowed);
957 /** Add a processor to the route.
958 * @param before An existing processor in the list, or 0; the new processor will be inserted immediately before it (or at the end).
959 * @return 0 on success, non-0 on failure.
962 Route::add_processor (boost::shared_ptr<Processor> processor, boost::shared_ptr<Processor> before, ProcessorStreams* err, bool activation_allowed)
964 assert (processor != _meter);
965 assert (processor != _main_outs);
967 DEBUG_TRACE (DEBUG::Processors, string_compose (
968 "%1 adding processor %2\n", name(), processor->name()));
970 if (!_session.engine().connected() || !processor) {
975 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
976 ProcessorState pstate (this);
978 boost::shared_ptr<PluginInsert> pi;
979 boost::shared_ptr<PortInsert> porti;
981 if (processor == _amp) {
982 /* Ensure that only one amp is in the list at any time */
983 ProcessorList::iterator check = find (_processors.begin(), _processors.end(), processor);
984 if (check != _processors.end()) {
985 if (before == _amp) {
986 /* Already in position; all is well */
989 _processors.erase (check);
994 assert (find (_processors.begin(), _processors.end(), processor) == _processors.end ());
996 ProcessorList::iterator loc;
998 /* inserting before a processor; find it */
999 loc = find (_processors.begin(), _processors.end(), before);
1000 if (loc == _processors.end ()) {
1005 /* inserting at end */
1006 loc = _processors.end ();
1009 _processors.insert (loc, processor);
1011 // Set up processor list channels. This will set processor->[input|output]_streams(),
1012 // configure redirect ports properly, etc.
1015 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1017 if (configure_processors_unlocked (err)) {
1019 configure_processors_unlocked (0); // it worked before we tried to add it ...
1024 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(processor)) != 0) {
1026 if (pi->has_no_inputs ()) {
1027 /* generator plugin */
1028 _have_internal_generator = true;
1033 if (activation_allowed && !_session.get_disable_all_loaded_plugins()) {
1034 processor->activate ();
1037 processor->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
1039 _output->set_user_latency (0);
1042 reset_instrument_info ();
1043 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1044 set_processor_positions ();
1050 Route::add_processor_from_xml_2X (const XMLNode& node, int version)
1052 const XMLProperty *prop;
1055 boost::shared_ptr<Processor> processor;
1057 /* bit of a hack: get the `placement' property from the <Redirect> tag here
1058 so that we can add the processor in the right place (pre/post-fader)
1061 XMLNodeList const & children = node.children ();
1062 XMLNodeList::const_iterator i = children.begin ();
1064 while (i != children.end() && (*i)->name() != X_("Redirect")) {
1068 Placement placement = PreFader;
1070 if (i != children.end()) {
1071 if ((prop = (*i)->property (X_("placement"))) != 0) {
1072 placement = Placement (string_2_enum (prop->value(), placement));
1076 if (node.name() == "Insert") {
1078 if ((prop = node.property ("type")) != 0) {
1080 if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
1081 prop->value() == "lv2" ||
1082 prop->value() == "windows-vst" ||
1083 prop->value() == "lxvst" ||
1084 prop->value() == "audiounit") {
1086 processor.reset (new PluginInsert (_session));
1090 processor.reset (new PortInsert (_session, _pannable, _mute_master));
1095 } else if (node.name() == "Send") {
1097 processor.reset (new Send (_session, _pannable, _mute_master));
1101 error << string_compose(_("unknown Processor type \"%1\"; ignored"), node.name()) << endmsg;
1105 if (processor->set_state (node, version)) {
1109 return (add_processor (processor, placement) == 0);
1112 catch (failed_constructor &err) {
1113 warning << _("processor could not be created. Ignored.") << endmsg;
1119 Route::add_processors (const ProcessorList& others, boost::shared_ptr<Processor> before, ProcessorStreams* err)
1121 /* NOTE: this is intended to be used ONLY when copying
1122 processors from another Route. Hence the subtle
1123 differences between this and ::add_processor()
1126 ProcessorList::iterator loc;
1129 loc = find(_processors.begin(), _processors.end(), before);
1131 /* nothing specified - at end */
1132 loc = _processors.end ();
1135 if (!_session.engine().connected()) {
1139 if (others.empty()) {
1144 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1145 ProcessorState pstate (this);
1147 for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
1153 boost::shared_ptr<PluginInsert> pi;
1155 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1159 _processors.insert (loc, *i);
1161 if ((*i)->active()) {
1166 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1167 if (configure_processors_unlocked (err)) {
1169 configure_processors_unlocked (0); // it worked before we tried to add it ...
1174 (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
1177 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
1178 boost::shared_ptr<PluginInsert> pi;
1180 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1181 if (pi->has_no_inputs ()) {
1182 _have_internal_generator = true;
1188 _output->set_user_latency (0);
1191 reset_instrument_info ();
1192 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1193 set_processor_positions ();
1199 Route::placement_range(Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end)
1201 if (p == PreFader) {
1202 start = _processors.begin();
1203 end = find(_processors.begin(), _processors.end(), _amp);
1205 start = find(_processors.begin(), _processors.end(), _amp);
1207 end = _processors.end();
1211 /** Turn off all processors with a given placement
1212 * @param p Placement of processors to disable
1215 Route::disable_processors (Placement p)
1217 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1219 ProcessorList::iterator start, end;
1220 placement_range(p, start, end);
1222 for (ProcessorList::iterator i = start; i != end; ++i) {
1223 (*i)->deactivate ();
1226 _session.set_dirty ();
1229 /** Turn off all redirects
1232 Route::disable_processors ()
1234 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1236 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1237 (*i)->deactivate ();
1240 _session.set_dirty ();
1243 /** Turn off all redirects with a given placement
1244 * @param p Placement of redirects to disable
1247 Route::disable_plugins (Placement p)
1249 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1251 ProcessorList::iterator start, end;
1252 placement_range(p, start, end);
1254 for (ProcessorList::iterator i = start; i != end; ++i) {
1255 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1256 (*i)->deactivate ();
1260 _session.set_dirty ();
1263 /** Turn off all plugins
1266 Route::disable_plugins ()
1268 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1270 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1271 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1272 (*i)->deactivate ();
1276 _session.set_dirty ();
1281 Route::ab_plugins (bool forward)
1283 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1287 /* forward = turn off all active redirects, and mark them so that the next time
1288 we go the other way, we will revert them
1291 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1292 if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1296 if ((*i)->active()) {
1297 (*i)->deactivate ();
1298 (*i)->set_next_ab_is_active (true);
1300 (*i)->set_next_ab_is_active (false);
1306 /* backward = if the redirect was marked to go active on the next ab, do so */
1308 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1310 if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1314 if ((*i)->get_next_ab_is_active()) {
1317 (*i)->deactivate ();
1322 _session.set_dirty ();
1326 /** Remove processors with a given placement.
1327 * @param p Placement of processors to remove.
1330 Route::clear_processors (Placement p)
1332 if (!_session.engine().connected()) {
1336 bool already_deleting = _session.deletion_in_progress();
1337 if (!already_deleting) {
1338 _session.set_deletion_in_progress();
1342 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1343 ProcessorList new_list;
1344 ProcessorStreams err;
1345 bool seen_amp = false;
1347 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1353 if ((*i) == _amp || (*i) == _meter || (*i) == _main_outs) {
1355 /* you can't remove these */
1357 new_list.push_back (*i);
1364 new_list.push_back (*i);
1367 (*i)->drop_references ();
1375 (*i)->drop_references ();
1378 new_list.push_back (*i);
1385 _processors = new_list;
1388 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1389 configure_processors_unlocked (&err); // this can't fail
1393 processor_max_streams.reset();
1394 _have_internal_generator = false;
1395 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1396 set_processor_positions ();
1398 reset_instrument_info ();
1400 if (!already_deleting) {
1401 _session.clear_deletion_in_progress();
1406 Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err, bool need_process_lock)
1408 // TODO once the export point can be configured properly, do something smarter here
1409 if (processor == _capturing_processor) {
1410 _capturing_processor.reset();
1413 /* these can never be removed */
1415 if (processor == _amp || processor == _meter || processor == _main_outs) {
1419 if (!_session.engine().connected()) {
1423 processor_max_streams.reset();
1426 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1427 ProcessorState pstate (this);
1429 ProcessorList::iterator i;
1430 bool removed = false;
1432 for (i = _processors.begin(); i != _processors.end(); ) {
1433 if (*i == processor) {
1435 /* move along, see failure case for configure_processors()
1436 where we may need to reconfigure the processor.
1439 /* stop redirects that send signals to JACK ports
1440 from causing noise as a result of no longer being
1444 boost::shared_ptr<IOProcessor> iop;
1446 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (*i)) != 0) {
1450 i = _processors.erase (i);
1458 _output->set_user_latency (0);
1466 if (need_process_lock) {
1467 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1469 if (configure_processors_unlocked (err)) {
1471 /* we know this will work, because it worked before :) */
1472 configure_processors_unlocked (0);
1476 if (configure_processors_unlocked (err)) {
1478 /* we know this will work, because it worked before :) */
1479 configure_processors_unlocked (0);
1484 _have_internal_generator = false;
1486 for (i = _processors.begin(); i != _processors.end(); ++i) {
1487 boost::shared_ptr<PluginInsert> pi;
1489 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1490 if (pi->has_no_inputs ()) {
1491 _have_internal_generator = true;
1498 reset_instrument_info ();
1499 processor->drop_references ();
1500 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1501 set_processor_positions ();
1507 Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
1509 ProcessorList deleted;
1511 if (!_session.engine().connected()) {
1515 processor_max_streams.reset();
1518 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1519 ProcessorState pstate (this);
1521 ProcessorList::iterator i;
1522 boost::shared_ptr<Processor> processor;
1524 for (i = _processors.begin(); i != _processors.end(); ) {
1528 /* these can never be removed */
1530 if (processor == _amp || processor == _meter || processor == _main_outs) {
1535 /* see if its in the list of processors to delete */
1537 if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
1542 /* stop IOProcessors that send to JACK ports
1543 from causing noise as a result of no longer being
1547 boost::shared_ptr<IOProcessor> iop;
1549 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (processor)) != 0) {
1553 deleted.push_back (processor);
1554 i = _processors.erase (i);
1557 if (deleted.empty()) {
1558 /* none of those in the requested list were found */
1562 _output->set_user_latency (0);
1565 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1567 if (configure_processors_unlocked (err)) {
1569 /* we know this will work, because it worked before :) */
1570 configure_processors_unlocked (0);
1575 _have_internal_generator = false;
1577 for (i = _processors.begin(); i != _processors.end(); ++i) {
1578 boost::shared_ptr<PluginInsert> pi;
1580 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1581 if (pi->has_no_inputs ()) {
1582 _have_internal_generator = true;
1589 /* now try to do what we need to so that those that were removed will be deleted */
1591 for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
1592 (*i)->drop_references ();
1595 reset_instrument_info ();
1596 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1597 set_processor_positions ();
1603 Route::reset_instrument_info ()
1605 boost::shared_ptr<Processor> instr = the_instrument();
1607 _instrument_info.set_internal_instrument (instr);
1611 /** Caller must hold process lock */
1613 Route::configure_processors (ProcessorStreams* err)
1615 assert (!AudioEngine::instance()->process_lock().trylock());
1617 if (!_in_configure_processors) {
1618 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1619 return configure_processors_unlocked (err);
1626 Route::input_streams () const
1628 return _input->n_ports ();
1631 list<pair<ChanCount, ChanCount> >
1632 Route::try_configure_processors (ChanCount in, ProcessorStreams* err)
1634 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1636 return try_configure_processors_unlocked (in, err);
1639 list<pair<ChanCount, ChanCount> >
1640 Route::try_configure_processors_unlocked (ChanCount in, ProcessorStreams* err)
1642 // Check each processor in order to see if we can configure as requested
1644 list<pair<ChanCount, ChanCount> > configuration;
1647 DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
1648 DEBUG_TRACE (DEBUG::Processors, "{\n");
1650 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1652 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1653 DEBUG_TRACE (DEBUG::Processors, "--- CONFIGURE ABORTED due to unknown processor.\n");
1657 if ((*p)->can_support_io_configuration(in, out)) {
1658 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID=%2 in=%3 out=%4\n",(*p)->name(), (*p)->id(), in, out));
1659 configuration.push_back(make_pair(in, out));
1666 DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
1667 DEBUG_TRACE (DEBUG::Processors, string_compose ("---- %1 cannot support in=%2 out=%3\n", (*p)->name(), in, out));
1668 DEBUG_TRACE (DEBUG::Processors, "}\n");
1669 return list<pair<ChanCount, ChanCount> > ();
1673 DEBUG_TRACE (DEBUG::Processors, "}\n");
1675 return configuration;
1678 /** Set the input/output configuration of each processor in the processors list.
1679 * Caller must hold process lock.
1680 * Return 0 on success, otherwise configuration is impossible.
1683 Route::configure_processors_unlocked (ProcessorStreams* err)
1685 assert (!AudioEngine::instance()->process_lock().trylock());
1687 if (_in_configure_processors) {
1691 /* put invisible processors where they should be */
1692 setup_invisible_processors ();
1694 _in_configure_processors = true;
1696 list<pair<ChanCount, ChanCount> > configuration = try_configure_processors_unlocked (input_streams (), err);
1698 if (configuration.empty ()) {
1699 _in_configure_processors = false;
1705 list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1706 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1708 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1712 (*p)->configure_io(c->first, c->second);
1713 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1714 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1719 _meter->reset_max_channels (processor_max_streams);
1722 /* make sure we have sufficient scratch buffers to cope with the new processor
1725 _session.ensure_buffers (n_process_buffers ());
1727 DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
1729 _in_configure_processors = false;
1733 /** Set all visible processors to a given active state (except Fader, whose state is not changed)
1734 * @param state New active state for those processors.
1737 Route::all_visible_processors_active (bool state)
1739 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1741 if (_processors.empty()) {
1745 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1746 if (!(*i)->display_to_user() || boost::dynamic_pointer_cast<Amp> (*i)) {
1753 (*i)->deactivate ();
1757 _session.set_dirty ();
1761 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
1763 /* "new_order" is an ordered list of processors to be positioned according to "placement".
1764 NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
1765 processors in the current actual processor list that are hidden. Any visible processors
1766 in the current list but not in "new_order" will be assumed to be deleted.
1770 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1771 ProcessorState pstate (this);
1773 ProcessorList::iterator oiter;
1774 ProcessorList::const_iterator niter;
1775 ProcessorList as_it_will_be;
1777 oiter = _processors.begin();
1778 niter = new_order.begin();
1780 while (niter != new_order.end()) {
1782 /* if the next processor in the old list is invisible (i.e. should not be in the new order)
1783 then append it to the temp list.
1785 Otherwise, see if the next processor in the old list is in the new list. if not,
1786 its been deleted. If its there, append it to the temp list.
1789 if (oiter == _processors.end()) {
1791 /* no more elements in the old list, so just stick the rest of
1792 the new order onto the temp list.
1795 as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
1796 while (niter != new_order.end()) {
1803 if (!(*oiter)->display_to_user()) {
1805 as_it_will_be.push_back (*oiter);
1809 /* visible processor: check that its in the new order */
1811 if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
1812 /* deleted: do nothing, shared_ptr<> will clean up */
1814 /* ignore this one, and add the next item from the new order instead */
1815 as_it_will_be.push_back (*niter);
1820 /* now remove from old order - its taken care of no matter what */
1821 oiter = _processors.erase (oiter);
1826 _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
1828 /* If the meter is in a custom position, find it and make a rough note of its position */
1829 maybe_note_meter_position ();
1832 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1834 if (configure_processors_unlocked (err)) {
1841 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1842 set_processor_positions ();
1854 Route::get_template()
1856 return state(false);
1860 Route::state(bool full_state)
1862 XMLNode *node = new XMLNode("Route");
1863 ProcessorList::iterator i;
1866 id().print (buf, sizeof (buf));
1867 node->add_property("id", buf);
1868 node->add_property ("name", _name);
1869 node->add_property("default-type", _default_type.to_string());
1872 node->add_property("flags", enum_2_string (_flags));
1875 node->add_property("active", _active?"yes":"no");
1877 boost::to_string (_phase_invert, p);
1878 node->add_property("phase-invert", p);
1879 node->add_property("denormal-protection", _denormal_protection?"yes":"no");
1880 node->add_property("meter-point", enum_2_string (_meter_point));
1882 node->add_property("meter-type", enum_2_string (_meter_type));
1885 node->add_property("route-group", _route_group->name());
1888 string order_string;
1889 OrderKeys::iterator x = order_keys.begin();
1891 while (x != order_keys.end()) {
1892 order_string += enum_2_string ((*x).first);
1893 order_string += '=';
1894 snprintf (buf, sizeof(buf), "%" PRId32, (*x).second);
1895 order_string += buf;
1899 if (x == order_keys.end()) {
1903 order_string += ':';
1905 node->add_property ("order-keys", order_string);
1906 node->add_property ("self-solo", (_self_solo ? "yes" : "no"));
1907 snprintf (buf, sizeof (buf), "%d", _soloed_by_others_upstream);
1908 node->add_property ("soloed-by-upstream", buf);
1909 snprintf (buf, sizeof (buf), "%d", _soloed_by_others_downstream);
1910 node->add_property ("soloed-by-downstream", buf);
1911 node->add_property ("solo-isolated", solo_isolated() ? "yes" : "no");
1912 node->add_property ("solo-safe", _solo_safe ? "yes" : "no");
1914 node->add_child_nocopy (_input->state (full_state));
1915 node->add_child_nocopy (_output->state (full_state));
1916 node->add_child_nocopy (_solo_control->get_state ());
1917 node->add_child_nocopy (_mute_control->get_state ());
1918 node->add_child_nocopy (_mute_master->get_state ());
1920 XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
1921 snprintf (buf, sizeof (buf), "%d", _remote_control_id);
1922 remote_control_node->add_property (X_("id"), buf);
1923 node->add_child_nocopy (*remote_control_node);
1925 if (_comment.length()) {
1926 XMLNode *cmt = node->add_child ("Comment");
1927 cmt->add_content (_comment);
1931 node->add_child_nocopy (_pannable->state (full_state));
1934 for (i = _processors.begin(); i != _processors.end(); ++i) {
1936 /* template save: do not include internal sends functioning as
1937 aux sends because the chance of the target ID
1938 in the session where this template is used
1941 similarly, do not save listen sends which connect to
1942 the monitor section, because these will always be
1945 boost::shared_ptr<InternalSend> is;
1947 if ((is = boost::dynamic_pointer_cast<InternalSend> (*i)) != 0) {
1948 if (is->role() == Delivery::Listen) {
1953 node->add_child_nocopy((*i)->state (full_state));
1957 node->add_child_copy (*_extra_xml);
1960 if (_custom_meter_position_noted) {
1961 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
1963 after->id().print (buf, sizeof (buf));
1964 node->add_property (X_("processor-after-last-custom-meter"), buf);
1967 node->add_property (X_("last-custom-meter-was-at-end"), _last_custom_meter_was_at_end ? "yes" : "no");
1974 Route::set_state (const XMLNode& node, int version)
1976 if (version < 3000) {
1977 return set_state_2X (node, version);
1981 XMLNodeConstIterator niter;
1983 const XMLProperty *prop;
1985 if (node.name() != "Route"){
1986 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1990 if ((prop = node.property (X_("name"))) != 0) {
1991 Route::set_name (prop->value());
1996 if ((prop = node.property (X_("flags"))) != 0) {
1997 _flags = Flag (string_2_enum (prop->value(), _flags));
2002 if (is_master() || is_monitor() || is_auditioner()) {
2003 _mute_master->set_solo_ignore (true);
2007 /* monitor bus does not get a panner, but if (re)created
2008 via XML, it will already have one by the time we
2009 call ::set_state(). so ... remove it.
2014 /* add all processors (except amp, which is always present) */
2016 nlist = node.children();
2017 XMLNode processor_state (X_("processor_state"));
2019 Stateful::save_extra_xml (node);
2021 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2025 if (child->name() == IO::state_node_name) {
2026 if ((prop = child->property (X_("direction"))) == 0) {
2030 if (prop->value() == "Input") {
2031 _input->set_state (*child, version);
2032 } else if (prop->value() == "Output") {
2033 _output->set_state (*child, version);
2037 if (child->name() == X_("Processor")) {
2038 processor_state.add_child_copy (*child);
2041 if (child->name() == X_("Pannable")) {
2043 _pannable->set_state (*child, version);
2045 warning << string_compose (_("Pannable state found for route (%1) without a panner!"), name()) << endmsg;
2050 if ((prop = node.property (X_("meter-point"))) != 0) {
2051 MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
2052 set_meter_point (mp, true);
2054 _meter->set_display_to_user (_meter_point == MeterCustom);
2058 if ((prop = node.property (X_("meter-type"))) != 0) {
2059 _meter_type = MeterType (string_2_enum (prop->value (), _meter_type));
2062 set_processor_state (processor_state);
2064 // this looks up the internal instrument in processors
2065 reset_instrument_info();
2067 if ((prop = node.property ("self-solo")) != 0) {
2068 set_self_solo (string_is_affirmative (prop->value()));
2071 if ((prop = node.property ("soloed-by-upstream")) != 0) {
2072 _soloed_by_others_upstream = 0; // needed for mod_.... () to work
2073 mod_solo_by_others_upstream (atoi (prop->value()));
2076 if ((prop = node.property ("soloed-by-downstream")) != 0) {
2077 _soloed_by_others_downstream = 0; // needed for mod_.... () to work
2078 mod_solo_by_others_downstream (atoi (prop->value()));
2081 if ((prop = node.property ("solo-isolated")) != 0) {
2082 set_solo_isolated (string_is_affirmative (prop->value()), this);
2085 if ((prop = node.property ("solo-safe")) != 0) {
2086 set_solo_safe (string_is_affirmative (prop->value()), this);
2089 if ((prop = node.property (X_("phase-invert"))) != 0) {
2090 set_phase_invert (boost::dynamic_bitset<> (prop->value ()));
2093 if ((prop = node.property (X_("denormal-protection"))) != 0) {
2094 set_denormal_protection (string_is_affirmative (prop->value()));
2097 if ((prop = node.property (X_("active"))) != 0) {
2098 bool yn = string_is_affirmative (prop->value());
2099 _active = !yn; // force switch
2100 set_active (yn, this);
2103 if ((prop = node.property (X_("order-keys"))) != 0) {
2107 string::size_type colon, equal;
2108 string remaining = prop->value();
2110 while (remaining.length()) {
2112 if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2113 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2116 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2117 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2120 string keyname = remaining.substr (0, equal);
2121 RouteSortOrderKey sk;
2123 if (keyname == "signal") {
2125 } else if (keyname == "editor") {
2128 sk = (RouteSortOrderKey) string_2_enum (remaining.substr (0, equal), sk);
2131 set_order_key (sk, n);
2135 colon = remaining.find_first_of (':');
2137 if (colon != string::npos) {
2138 remaining = remaining.substr (colon+1);
2145 if ((prop = node.property (X_("processor-after-last-custom-meter"))) != 0) {
2146 PBD::ID id (prop->value ());
2147 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2148 ProcessorList::const_iterator i = _processors.begin ();
2149 while (i != _processors.end() && (*i)->id() != id) {
2153 if (i != _processors.end ()) {
2154 _processor_after_last_custom_meter = *i;
2155 _custom_meter_position_noted = true;
2159 if ((prop = node.property (X_("last-custom-meter-was-at-end"))) != 0) {
2160 _last_custom_meter_was_at_end = string_is_affirmative (prop->value ());
2163 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2166 if (child->name() == X_("Comment")) {
2168 /* XXX this is a terrible API design in libxml++ */
2170 XMLNode *cmt = *(child->children().begin());
2171 _comment = cmt->content();
2173 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2174 if (prop->value() == "solo") {
2175 _solo_control->set_state (*child, version);
2176 } else if (prop->value() == "mute") {
2177 _mute_control->set_state (*child, version);
2180 } else if (child->name() == X_("RemoteControl")) {
2181 if ((prop = child->property (X_("id"))) != 0) {
2183 sscanf (prop->value().c_str(), "%d", &x);
2184 set_remote_control_id_internal (x);
2187 } else if (child->name() == X_("MuteMaster")) {
2188 _mute_master->set_state (*child, version);
2196 Route::set_state_2X (const XMLNode& node, int version)
2199 XMLNodeConstIterator niter;
2201 const XMLProperty *prop;
2203 /* 2X things which still remain to be handled:
2209 if (node.name() != "Route") {
2210 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2214 if ((prop = node.property (X_("flags"))) != 0) {
2215 string f = prop->value ();
2216 boost::replace_all (f, "ControlOut", "MonitorOut");
2217 _flags = Flag (string_2_enum (f, _flags));
2222 if (is_master() || is_monitor() || is_auditioner()) {
2223 _mute_master->set_solo_ignore (true);
2226 if ((prop = node.property (X_("phase-invert"))) != 0) {
2227 boost::dynamic_bitset<> p (_input->n_ports().n_audio ());
2228 if (string_is_affirmative (prop->value ())) {
2231 set_phase_invert (p);
2234 if ((prop = node.property (X_("denormal-protection"))) != 0) {
2235 set_denormal_protection (string_is_affirmative (prop->value()));
2238 if ((prop = node.property (X_("soloed"))) != 0) {
2239 bool yn = string_is_affirmative (prop->value());
2241 /* XXX force reset of solo status */
2243 set_solo (yn, this);
2246 if ((prop = node.property (X_("muted"))) != 0) {
2249 bool muted = string_is_affirmative (prop->value());
2255 if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
2257 if (string_is_affirmative (prop->value())){
2258 mute_point = mute_point + "PreFader";
2263 if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
2265 if (string_is_affirmative (prop->value())){
2268 mute_point = mute_point + ",";
2271 mute_point = mute_point + "PostFader";
2276 if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
2278 if (string_is_affirmative (prop->value())){
2281 mute_point = mute_point + ",";
2284 mute_point = mute_point + "Listen";
2289 if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
2291 if (string_is_affirmative (prop->value())){
2294 mute_point = mute_point + ",";
2297 mute_point = mute_point + "Main";
2301 _mute_master->set_mute_points (mute_point);
2302 _mute_master->set_muted_by_self (true);
2306 if ((prop = node.property (X_("meter-point"))) != 0) {
2307 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2310 /* do not carry over edit/mix groups from 2.X because (a) its hard (b) they
2311 don't mean the same thing.
2314 if ((prop = node.property (X_("order-keys"))) != 0) {
2318 string::size_type colon, equal;
2319 string remaining = prop->value();
2321 while (remaining.length()) {
2323 if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2324 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2327 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2328 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2331 string keyname = remaining.substr (0, equal);
2332 RouteSortOrderKey sk;
2334 if (keyname == "signal") {
2336 } else if (keyname == "editor") {
2339 sk = (RouteSortOrderKey) string_2_enum (remaining.substr (0, equal), sk);
2342 set_order_key (sk, n);
2346 colon = remaining.find_first_of (':');
2348 if (colon != string::npos) {
2349 remaining = remaining.substr (colon+1);
2358 nlist = node.children ();
2359 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2363 if (child->name() == IO::state_node_name) {
2365 /* there is a note in IO::set_state_2X() about why we have to call
2369 _input->set_state_2X (*child, version, true);
2370 _output->set_state_2X (*child, version, false);
2372 if ((prop = child->property (X_("name"))) != 0) {
2373 Route::set_name (prop->value ());
2378 if ((prop = child->property (X_("active"))) != 0) {
2379 bool yn = string_is_affirmative (prop->value());
2380 _active = !yn; // force switch
2381 set_active (yn, this);
2384 if ((prop = child->property (X_("gain"))) != 0) {
2387 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2388 _amp->gain_control()->set_value (val);
2392 /* Set up Panners in the IO */
2393 XMLNodeList io_nlist = child->children ();
2395 XMLNodeConstIterator io_niter;
2398 for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2400 io_child = *io_niter;
2402 if (io_child->name() == X_("Panner")) {
2403 _main_outs->panner_shell()->set_state(*io_child, version);
2404 } else if (io_child->name() == X_("Automation")) {
2405 /* IO's automation is for the fader */
2406 _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
2412 XMLNodeList redirect_nodes;
2414 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2418 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2419 redirect_nodes.push_back(child);
2424 set_processor_state_2X (redirect_nodes, version);
2426 Stateful::save_extra_xml (node);
2428 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2431 if (child->name() == X_("Comment")) {
2433 /* XXX this is a terrible API design in libxml++ */
2435 XMLNode *cmt = *(child->children().begin());
2436 _comment = cmt->content();
2438 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2439 if (prop->value() == X_("solo")) {
2440 _solo_control->set_state (*child, version);
2441 } else if (prop->value() == X_("mute")) {
2442 _mute_control->set_state (*child, version);
2445 } else if (child->name() == X_("RemoteControl")) {
2446 if ((prop = child->property (X_("id"))) != 0) {
2448 sscanf (prop->value().c_str(), "%d", &x);
2449 set_remote_control_id_internal (x);
2459 Route::get_processor_state ()
2461 XMLNode* root = new XMLNode (X_("redirects"));
2462 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2463 root->add_child_nocopy ((*i)->state (true));
2470 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2472 /* We don't bother removing existing processors not in nList, as this
2473 method will only be called when creating a Route from scratch, not
2474 for undo purposes. Just put processors in at the appropriate place
2478 for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2479 add_processor_from_xml_2X (**i, version);
2484 Route::set_processor_state (const XMLNode& node)
2486 const XMLNodeList &nlist = node.children();
2487 XMLNodeConstIterator niter;
2488 ProcessorList new_order;
2489 bool must_configure = false;
2491 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2493 XMLProperty* prop = (*niter)->property ("type");
2495 if (prop->value() == "amp") {
2496 _amp->set_state (**niter, Stateful::current_state_version);
2497 new_order.push_back (_amp);
2498 } else if (prop->value() == "meter") {
2499 _meter->set_state (**niter, Stateful::current_state_version);
2500 new_order.push_back (_meter);
2501 } else if (prop->value() == "main-outs") {
2502 _main_outs->set_state (**niter, Stateful::current_state_version);
2503 } else if (prop->value() == "intreturn") {
2505 _intreturn.reset (new InternalReturn (_session));
2506 must_configure = true;
2508 _intreturn->set_state (**niter, Stateful::current_state_version);
2509 } else if (is_monitor() && prop->value() == "monitor") {
2510 if (!_monitor_control) {
2511 _monitor_control.reset (new MonitorProcessor (_session));
2512 must_configure = true;
2514 _monitor_control->set_state (**niter, Stateful::current_state_version);
2515 } else if (prop->value() == "capture") {
2516 /* CapturingProcessor should never be restored, it's always
2517 added explicitly when needed */
2519 ProcessorList::iterator o;
2521 for (o = _processors.begin(); o != _processors.end(); ++o) {
2522 XMLProperty* id_prop = (*niter)->property(X_("id"));
2523 if (id_prop && (*o)->id() == id_prop->value()) {
2524 (*o)->set_state (**niter, Stateful::current_state_version);
2525 new_order.push_back (*o);
2530 // If the processor (*niter) is not on the route then create it
2532 if (o == _processors.end()) {
2534 boost::shared_ptr<Processor> processor;
2536 if (prop->value() == "intsend") {
2538 processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::shared_ptr<Route>(), Delivery::Role (0)));
2540 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2541 prop->value() == "lv2" ||
2542 prop->value() == "windows-vst" ||
2543 prop->value() == "lxvst" ||
2544 prop->value() == "audiounit") {
2546 processor.reset (new PluginInsert(_session));
2548 } else if (prop->value() == "port") {
2550 processor.reset (new PortInsert (_session, _pannable, _mute_master));
2552 } else if (prop->value() == "send") {
2554 processor.reset (new Send (_session, _pannable, _mute_master));
2557 error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2561 #ifndef NO_PLUGIN_STATE
2562 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2563 /* This processor could not be configured. Turn it into a UnknownProcessor */
2564 processor.reset (new UnknownProcessor (_session, **niter));
2567 if (boost::dynamic_pointer_cast<PluginInsert>(processor)) {
2568 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2569 /* This processor could not be configured. Turn it into a UnknownProcessor */
2570 processor.reset (new UnknownProcessor (_session, **niter));
2573 /* plugin, but ::set_state() not * allowed no message here - things will get too verbose */
2577 /* we have to note the monitor send here, otherwise a new one will be created
2578 and the state of this one will be lost.
2580 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
2581 if (isend && isend->role() == Delivery::Listen) {
2582 _monitor_send = isend;
2585 /* it doesn't matter if invisible processors are added here, as they
2586 will be sorted out by setup_invisible_processors () shortly.
2589 new_order.push_back (processor);
2590 must_configure = true;
2596 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2597 _processors = new_order;
2599 if (must_configure) {
2600 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2601 configure_processors_unlocked (0);
2604 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2606 (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
2608 boost::shared_ptr<PluginInsert> pi;
2610 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
2611 if (pi->has_no_inputs ()) {
2612 _have_internal_generator = true;
2619 reset_instrument_info ();
2620 processors_changed (RouteProcessorChange ());
2621 set_processor_positions ();
2625 Route::curve_reallocate ()
2627 // _gain_automation_curve.finish_resize ();
2628 // _pan_automation_curve.finish_resize ();
2632 Route::silence (framecnt_t nframes)
2634 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
2639 silence_unlocked (nframes);
2643 Route::silence_unlocked (framecnt_t nframes)
2645 /* Must be called with the processor lock held */
2649 _output->silence (nframes);
2651 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2652 boost::shared_ptr<PluginInsert> pi;
2654 if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2655 // skip plugins, they don't need anything when we're not active
2659 (*i)->silence (nframes);
2662 if (nframes == _session.get_block_size()) {
2669 Route::add_internal_return ()
2672 _intreturn.reset (new InternalReturn (_session));
2673 add_processor (_intreturn, PreFader);
2678 Route::add_send_to_internal_return (InternalSend* send)
2680 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
2682 for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2683 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2686 return d->add_send (send);
2692 Route::remove_send_from_internal_return (InternalSend* send)
2694 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
2696 for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2697 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2700 return d->remove_send (send);
2706 Route::enable_monitor_send ()
2708 /* Caller must hold process lock */
2709 assert (!AudioEngine::instance()->process_lock().trylock());
2711 /* master never sends to monitor section via the normal mechanism */
2712 assert (!is_master ());
2714 /* make sure we have one */
2715 if (!_monitor_send) {
2716 _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, _session.monitor_out(), Delivery::Listen));
2717 _monitor_send->set_display_to_user (false);
2721 configure_processors (0);
2724 /** Add an aux send to a route.
2725 * @param route route to send to.
2726 * @param before Processor to insert before, or 0 to insert at the end.
2729 Route::add_aux_send (boost::shared_ptr<Route> route, boost::shared_ptr<Processor> before)
2731 assert (route != _session.monitor_out ());
2734 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
2736 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2738 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
2740 if (d && d->target_route() == route) {
2741 /* already listening via the specified IO: do nothing */
2749 boost::shared_ptr<InternalSend> listener;
2752 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2753 listener.reset (new InternalSend (_session, _pannable, _mute_master, route, Delivery::Aux));
2756 add_processor (listener, before);
2758 } catch (failed_constructor& err) {
2766 Route::remove_aux_or_listen (boost::shared_ptr<Route> route)
2768 ProcessorStreams err;
2769 ProcessorList::iterator tmp;
2772 Glib::Threads::RWLock::ReaderLock rl(_processor_lock);
2774 /* have to do this early because otherwise processor reconfig
2775 * will put _monitor_send back in the list
2778 if (route == _session.monitor_out()) {
2779 _monitor_send.reset ();
2783 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2785 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2787 if (d && d->target_route() == route) {
2789 remove_processor (*x, &err, false);
2792 /* list could have been demolished while we dropped the lock
2803 Route::set_comment (string cmt, void *src)
2806 comment_changed (src);
2807 _session.set_dirty ();
2811 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
2813 FeedRecord fr (other, via_sends_only);
2815 pair<FedBy::iterator,bool> result = _fed_by.insert (fr);
2817 if (!result.second) {
2819 /* already a record for "other" - make sure sends-only information is correct */
2820 if (!via_sends_only && result.first->sends_only) {
2821 FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
2822 frp->sends_only = false;
2826 return result.second;
2830 Route::clear_fed_by ()
2836 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
2838 const FedBy& fed_by (other->fed_by());
2840 for (FedBy::iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
2841 boost::shared_ptr<Route> sr = f->r.lock();
2843 if (sr && (sr.get() == this)) {
2845 if (via_sends_only) {
2846 *via_sends_only = f->sends_only;
2857 Route::direct_feeds_according_to_reality (boost::shared_ptr<Route> other, bool* via_send_only)
2859 DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
2861 if (_output->connected_to (other->input())) {
2862 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
2863 if (via_send_only) {
2864 *via_send_only = false;
2871 for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
2873 boost::shared_ptr<IOProcessor> iop;
2875 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
2876 if (iop->feeds (other)) {
2877 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
2878 if (via_send_only) {
2879 *via_send_only = true;
2883 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
2886 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
2891 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdoes NOT feed %1\n", other->name()));
2896 Route::direct_feeds_according_to_graph (boost::shared_ptr<Route> other, bool* via_send_only)
2898 return _session._current_route_graph.has (shared_from_this (), other, via_send_only);
2901 /** Called from the (non-realtime) butler thread when the transport is stopped */
2903 Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool /*did_locate*/, bool can_flush_processors)
2905 framepos_t now = _session.transport_frame();
2908 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2910 Automatable::transport_stopped (now);
2912 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2914 if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && can_flush_processors)) {
2918 (*i)->transport_stopped (now);
2922 _roll_delay = _initial_delay;
2926 Route::input_change_handler (IOChange change, void * /*src*/)
2928 bool need_to_queue_solo_change = true;
2930 if ((change.type & IOChange::ConfigurationChanged)) {
2931 /* This is called with the process lock held if change
2932 contains ConfigurationChanged
2934 need_to_queue_solo_change = false;
2935 configure_processors (0);
2936 _phase_invert.resize (_input->n_ports().n_audio ());
2937 io_changed (); /* EMIT SIGNAL */
2940 if (!_input->connected() && _soloed_by_others_upstream) {
2941 if (need_to_queue_solo_change) {
2942 _session.cancel_solo_after_disconnect (shared_from_this(), true);
2944 cancel_solo_after_disconnect (true);
2950 Route::output_change_handler (IOChange change, void * /*src*/)
2952 bool need_to_queue_solo_change = true;
2954 if ((change.type & IOChange::ConfigurationChanged)) {
2955 /* This is called with the process lock held if change
2956 contains ConfigurationChanged
2958 need_to_queue_solo_change = false;
2959 configure_processors (0);
2960 io_changed (); /* EMIT SIGNAL */
2963 if (!_output->connected() && _soloed_by_others_downstream) {
2964 if (need_to_queue_solo_change) {
2965 _session.cancel_solo_after_disconnect (shared_from_this(), false);
2967 cancel_solo_after_disconnect (false);
2973 Route::cancel_solo_after_disconnect (bool upstream)
2976 _soloed_by_others_upstream = 0;
2978 _soloed_by_others_downstream = 0;
2980 set_mute_master_solo ();
2981 solo_changed (false, this);
2985 Route::pans_required () const
2987 if (n_outputs().n_audio() < 2) {
2991 return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
2995 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
2997 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3003 if (n_outputs().n_total() == 0) {
3007 if (!_active || n_inputs() == ChanCount::ZERO) {
3008 silence_unlocked (nframes);
3012 if (session_state_changing) {
3013 if (_session.transport_speed() != 0.0f) {
3014 /* we're rolling but some state is changing (e.g. our diskstream contents)
3015 so we cannot use them. Be silent till this is over.
3017 XXX note the absurdity of ::no_roll() being called when we ARE rolling!
3019 silence_unlocked (nframes);
3022 /* we're really not rolling, so we're either delivery silence or actually
3023 monitoring, both of which are safe to do while session_state_changing is true.
3027 BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers());
3029 fill_buffers_with_input (bufs, _input, nframes);
3031 if (_meter_point == MeterInput) {
3032 _meter->run (bufs, start_frame, end_frame, nframes, true);
3035 _amp->apply_gain_automation (false);
3036 passthru (bufs, start_frame, end_frame, nframes, 0);
3042 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& /* need_butler */)
3044 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3049 if (n_outputs().n_total() == 0) {
3053 if (!_active || n_inputs().n_total() == 0) {
3054 silence_unlocked (nframes);
3058 framepos_t unused = 0;
3060 if ((nframes = check_initial_delay (nframes, unused)) == 0) {
3066 BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers());
3068 fill_buffers_with_input (bufs, _input, nframes);
3070 if (_meter_point == MeterInput) {
3071 _meter->run (bufs, start_frame, end_frame, nframes, true);
3074 passthru (bufs, start_frame, end_frame, nframes, declick);
3080 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& /* need_butler */)
3087 Route::flush_processors ()
3089 /* XXX shouldn't really try to take this lock, since
3090 this is called from the RT audio thread.
3093 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3095 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3101 Route::set_meter_point (MeterPoint p, bool force)
3103 if (_meter_point == p && !force) {
3107 bool meter_was_visible_to_user = _meter->display_to_user ();
3110 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3112 maybe_note_meter_position ();
3116 if (_meter_point != MeterCustom) {
3118 _meter->set_display_to_user (false);
3120 setup_invisible_processors ();
3124 _meter->set_display_to_user (true);
3126 /* If we have a previous position for the custom meter, try to put it there */
3127 if (_custom_meter_position_noted) {
3128 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
3131 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), after);
3132 if (i != _processors.end ()) {
3133 _processors.remove (_meter);
3134 _processors.insert (i, _meter);
3136 } else if (_last_custom_meter_was_at_end) {
3137 _processors.remove (_meter);
3138 _processors.push_back (_meter);
3143 /* Set up the meter for its new position */
3145 ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
3149 if (loc == _processors.begin()) {
3150 m_in = _input->n_ports();
3152 ProcessorList::iterator before = loc;
3154 m_in = (*before)->output_streams ();
3157 _meter->reflect_inputs (m_in);
3159 /* we do not need to reconfigure the processors, because the meter
3160 (a) is always ready to handle processor_max_streams
3161 (b) is always an N-in/N-out processor, and thus moving
3162 it doesn't require any changes to the other processors.
3166 meter_change (); /* EMIT SIGNAL */
3168 bool const meter_visibly_changed = (_meter->display_to_user() != meter_was_visible_to_user);
3170 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
3174 Route::listen_position_changed ()
3177 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3178 ProcessorState pstate (this);
3181 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3183 if (configure_processors_unlocked (0)) {
3185 configure_processors_unlocked (0); // it worked before we tried to add it ...
3191 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
3192 _session.set_dirty ();
3195 boost::shared_ptr<CapturingProcessor>
3196 Route::add_export_point()
3198 if (!_capturing_processor) {
3200 _capturing_processor.reset (new CapturingProcessor (_session));
3201 _capturing_processor->activate ();
3204 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3205 configure_processors (0);
3210 return _capturing_processor;
3214 Route::update_signal_latency ()
3216 framecnt_t l = _output->user_latency();
3218 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3219 if ((*i)->active ()) {
3220 l += (*i)->signal_latency ();
3224 DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l));
3226 if (_signal_latency != l) {
3227 _signal_latency = l;
3228 signal_latency_changed (); /* EMIT SIGNAL */
3231 return _signal_latency;
3235 Route::set_user_latency (framecnt_t nframes)
3237 _output->set_user_latency (nframes);
3238 _session.update_latency_compensation ();
3242 Route::set_latency_compensation (framecnt_t longest_session_latency)
3244 framecnt_t old = _initial_delay;
3246 if (_signal_latency < longest_session_latency) {
3247 _initial_delay = longest_session_latency - _signal_latency;
3252 DEBUG_TRACE (DEBUG::Latency, string_compose (
3253 "%1: compensate for maximum latency of %2,"
3254 "given own latency of %3, using initial delay of %4\n",
3255 name(), longest_session_latency, _signal_latency, _initial_delay));
3257 if (_initial_delay != old) {
3258 initial_delay_changed (); /* EMIT SIGNAL */
3261 if (_session.transport_stopped()) {
3262 _roll_delay = _initial_delay;
3266 Route::SoloControllable::SoloControllable (std::string name, boost::shared_ptr<Route> r)
3267 : AutomationControl (r->session(), Evoral::Parameter (SoloAutomation),
3268 boost::shared_ptr<AutomationList>(), name)
3271 boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
3276 Route::SoloControllable::set_value (double val)
3278 bool bval = ((val >= 0.5f) ? true: false);
3280 boost::shared_ptr<RouteList> rl (new RouteList);
3282 boost::shared_ptr<Route> r = _route.lock ();
3289 if (Config->get_solo_control_is_listen_control()) {
3290 _session.set_listen (rl, bval);
3292 _session.set_solo (rl, bval);
3297 Route::SoloControllable::get_value () const
3299 boost::shared_ptr<Route> r = _route.lock ();
3304 if (Config->get_solo_control_is_listen_control()) {
3305 return r->listening_via_monitor() ? 1.0f : 0.0f;
3307 return r->self_soloed() ? 1.0f : 0.0f;
3311 Route::MuteControllable::MuteControllable (std::string name, boost::shared_ptr<Route> r)
3312 : AutomationControl (r->session(), Evoral::Parameter (MuteAutomation),
3313 boost::shared_ptr<AutomationList>(), name)
3316 boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MuteAutomation)));
3321 Route::MuteControllable::set_value (double val)
3323 bool bval = ((val >= 0.5f) ? true: false);
3325 boost::shared_ptr<RouteList> rl (new RouteList);
3327 boost::shared_ptr<Route> r = _route.lock ();
3333 _session.set_mute (rl, bval);
3337 Route::MuteControllable::get_value () const
3339 boost::shared_ptr<Route> r = _route.lock ();
3344 return r->muted() ? 1.0f : 0.0f;
3348 Route::set_block_size (pframes_t nframes)
3350 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3351 (*i)->set_block_size (nframes);
3354 _session.ensure_buffers (n_process_buffers ());
3358 Route::protect_automation ()
3360 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3361 (*i)->protect_automation();
3364 /** @param declick 1 to set a pending declick fade-in,
3365 * -1 to set a pending declick fade-out
3368 Route::set_pending_declick (int declick)
3371 /* this call is not allowed to turn off a pending declick */
3373 _pending_declick = declick;
3376 _pending_declick = 0;
3380 /** Shift automation forwards from a particular place, thereby inserting time.
3381 * Adds undo commands for any shifts that are performed.
3383 * @param pos Position to start shifting from.
3384 * @param frames Amount to shift forwards by.
3388 Route::shift (framepos_t pos, framecnt_t frames)
3390 /* gain automation */
3392 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
3394 XMLNode &before = gc->alist()->get_state ();
3395 gc->alist()->shift (pos, frames);
3396 XMLNode &after = gc->alist()->get_state ();
3397 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3400 /* pan automation */
3402 ControlSet::Controls& c (_pannable->controls());
3404 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
3405 boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
3407 boost::shared_ptr<AutomationList> al = pc->alist();
3408 XMLNode& before = al->get_state ();
3409 al->shift (pos, frames);
3410 XMLNode& after = al->get_state ();
3411 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3416 /* redirect automation */
3418 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3419 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
3421 set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
3423 for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
3424 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
3426 boost::shared_ptr<AutomationList> al = ac->alist();
3427 XMLNode &before = al->get_state ();
3428 al->shift (pos, frames);
3429 XMLNode &after = al->get_state ();
3430 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3439 Route::save_as_template (const string& path, const string& name)
3441 XMLNode& node (state (false));
3444 IO::set_name_in_state (*node.children().front(), name);
3446 tree.set_root (&node);
3447 return tree.write (path.c_str());
3452 Route::set_name (const string& str)
3458 name = Route::ensure_track_or_route_name (str, _session);
3459 SessionObject::set_name (name);
3461 ret = (_input->set_name(name) && _output->set_name(name));
3464 /* rename the main outs. Leave other IO processors
3465 * with whatever name they already have, because its
3466 * just fine as it is (it will not contain the route
3467 * name if its a port insert, port send or port return).
3471 if (_main_outs->set_name (name)) {
3472 /* XXX returning false here is stupid because
3473 we already changed the route name.
3483 /** Set the name of a route in an XML description.
3484 * @param node XML <Route> node to set the name in.
3485 * @param name New name.
3488 Route::set_name_in_state (XMLNode& node, string const & name)
3490 node.add_property (X_("name"), name);
3492 XMLNodeList children = node.children();
3493 for (XMLNodeIterator i = children.begin(); i != children.end(); ++i) {
3495 if ((*i)->name() == X_("IO")) {
3497 IO::set_name_in_state (**i, name);
3499 } else if ((*i)->name() == X_("Processor")) {
3501 XMLProperty* role = (*i)->property (X_("role"));
3502 if (role && role->value() == X_("Main")) {
3503 (*i)->add_property (X_("name"), name);
3506 } else if ((*i)->name() == X_("Diskstream")) {
3508 (*i)->add_property (X_("playlist"), string_compose ("%1.1", name).c_str());
3509 (*i)->add_property (X_("name"), name);
3515 boost::shared_ptr<Send>
3516 Route::internal_send_for (boost::shared_ptr<const Route> target) const
3518 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3520 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3521 boost::shared_ptr<InternalSend> send;
3523 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
3524 if (send->target_route() == target) {
3530 return boost::shared_ptr<Send>();
3533 /** @param c Audio channel index.
3534 * @param yn true to invert phase, otherwise false.
3537 Route::set_phase_invert (uint32_t c, bool yn)
3539 if (_phase_invert[c] != yn) {
3540 _phase_invert[c] = yn;
3541 phase_invert_changed (); /* EMIT SIGNAL */
3542 _session.set_dirty ();
3547 Route::set_phase_invert (boost::dynamic_bitset<> p)
3549 if (_phase_invert != p) {
3551 phase_invert_changed (); /* EMIT SIGNAL */
3552 _session.set_dirty ();
3557 Route::phase_invert (uint32_t c) const
3559 return _phase_invert[c];
3562 boost::dynamic_bitset<>
3563 Route::phase_invert () const
3565 return _phase_invert;
3569 Route::set_denormal_protection (bool yn)
3571 if (_denormal_protection != yn) {
3572 _denormal_protection = yn;
3573 denormal_protection_changed (); /* EMIT SIGNAL */
3578 Route::denormal_protection () const
3580 return _denormal_protection;
3584 Route::set_active (bool yn, void* src)
3586 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
3587 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
3591 if (_active != yn) {
3593 _input->set_active (yn);
3594 _output->set_active (yn);
3595 active_changed (); // EMIT SIGNAL
3596 _session.set_dirty ();
3603 Glib::Threads::RWLock::ReaderLock rm (_processor_lock, Glib::Threads::TRY_LOCK);
3609 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3611 boost::shared_ptr<Send> s;
3612 boost::shared_ptr<Return> r;
3614 if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
3615 s->meter()->meter();
3616 } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
3617 r->meter()->meter ();
3622 boost::shared_ptr<Pannable>
3623 Route::pannable() const
3628 boost::shared_ptr<Panner>
3629 Route::panner() const
3632 return _main_outs->panner_shell()->panner();
3635 boost::shared_ptr<PannerShell>
3636 Route::panner_shell() const
3638 return _main_outs->panner_shell();
3641 boost::shared_ptr<AutomationControl>
3642 Route::gain_control() const
3644 return _amp->gain_control();
3647 boost::shared_ptr<AutomationControl>
3648 Route::get_control (const Evoral::Parameter& param)
3650 /* either we own the control or .... */
3652 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
3656 /* maybe one of our processors does or ... */
3658 Glib::Threads::RWLock::ReaderLock rm (_processor_lock, Glib::Threads::TRY_LOCK);
3659 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3660 if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
3668 /* nobody does so we'll make a new one */
3670 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
3677 boost::shared_ptr<Processor>
3678 Route::nth_plugin (uint32_t n)
3680 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3681 ProcessorList::iterator i;
3683 for (i = _processors.begin(); i != _processors.end(); ++i) {
3684 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
3691 return boost::shared_ptr<Processor> ();
3694 boost::shared_ptr<Processor>
3695 Route::nth_send (uint32_t n)
3697 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3698 ProcessorList::iterator i;
3700 for (i = _processors.begin(); i != _processors.end(); ++i) {
3701 if (boost::dynamic_pointer_cast<Send> (*i)) {
3708 return boost::shared_ptr<Processor> ();
3712 Route::has_io_processor_named (const string& name)
3714 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3715 ProcessorList::iterator i;
3717 for (i = _processors.begin(); i != _processors.end(); ++i) {
3718 if (boost::dynamic_pointer_cast<Send> (*i) ||
3719 boost::dynamic_pointer_cast<PortInsert> (*i)) {
3720 if ((*i)->name() == name) {
3729 MuteMaster::MutePoint
3730 Route::mute_points () const
3732 return _mute_master->mute_points ();
3736 Route::set_processor_positions ()
3738 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3740 bool had_amp = false;
3741 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3742 (*i)->set_pre_fader (!had_amp);
3743 if (boost::dynamic_pointer_cast<Amp> (*i)) {
3749 /** Called when there is a proposed change to the input port count */
3751 Route::input_port_count_changing (ChanCount to)
3753 list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
3755 /* The processors cannot be configured with the new input arrangement, so
3761 /* The change is ok */
3766 Route::unknown_processors () const
3770 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3771 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3772 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
3773 p.push_back ((*i)->name ());
3782 Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecnt_t our_latency) const
3784 /* we assume that all our input ports feed all our output ports. its not
3785 universally true, but the alternative is way too corner-case to worry about.
3788 jack_latency_range_t all_connections;
3791 all_connections.min = 0;
3792 all_connections.max = 0;
3794 all_connections.min = ~((jack_nframes_t) 0);
3795 all_connections.max = 0;
3797 /* iterate over all "from" ports and determine the latency range for all of their
3798 connections to the "outside" (outside of this Route).
3801 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
3803 jack_latency_range_t range;
3805 p->get_connected_latency_range (range, playback);
3807 all_connections.min = min (all_connections.min, range.min);
3808 all_connections.max = max (all_connections.max, range.max);
3812 /* set the "from" port latencies to the max/min range of all their connections */
3814 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
3815 p->set_private_latency_range (all_connections, playback);
3818 /* set the ports "in the direction of the flow" to the same value as above plus our own signal latency */
3820 all_connections.min += our_latency;
3821 all_connections.max += our_latency;
3823 for (PortSet::iterator p = to.begin(); p != to.end(); ++p) {
3824 p->set_private_latency_range (all_connections, playback);
3827 return all_connections.max;
3831 Route::set_private_port_latencies (bool playback) const
3833 framecnt_t own_latency = 0;
3835 /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD
3836 OR LATENCY CALLBACK.
3838 This is called (early) from the latency callback. It computes the REAL
3839 latency associated with each port and stores the result as the "private"
3840 latency of the port. A later call to Route::set_public_port_latencies()
3841 sets all ports to the same value to reflect the fact that we do latency
3842 compensation and so all signals are delayed by the same amount as they
3843 flow through ardour.
3846 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3847 if ((*i)->active ()) {
3848 own_latency += (*i)->signal_latency ();
3853 /* playback: propagate latency from "outside the route" to outputs to inputs */
3854 return update_port_latencies (_output->ports (), _input->ports (), true, own_latency);
3856 /* capture: propagate latency from "outside the route" to inputs to outputs */
3857 return update_port_latencies (_input->ports (), _output->ports (), false, own_latency);
3862 Route::set_public_port_latencies (framecnt_t value, bool playback) const
3864 /* this is called to set the JACK-visible port latencies, which take
3865 latency compensation into account.
3868 jack_latency_range_t range;
3874 const PortSet& ports (_input->ports());
3875 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
3876 p->set_public_latency_range (range, playback);
3881 const PortSet& ports (_output->ports());
3882 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
3883 p->set_public_latency_range (range, playback);
3888 /** Put the invisible processors in the right place in _processors.
3889 * Must be called with a writer lock on _processor_lock held.
3892 Route::setup_invisible_processors ()
3895 Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3896 assert (!lm.locked ());
3900 /* too early to be doing this stuff */
3904 /* we'll build this new list here and then use it */
3906 ProcessorList new_processors;
3908 /* find visible processors */
3910 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3911 if ((*i)->display_to_user ()) {
3912 new_processors.push_back (*i);
3918 ProcessorList::iterator amp = new_processors.begin ();
3919 while (amp != new_processors.end() && boost::dynamic_pointer_cast<Amp> (*amp) == 0) {
3923 assert (amp != _processors.end ());
3925 /* and the processor after the amp */
3927 ProcessorList::iterator after_amp = amp;
3933 switch (_meter_point) {
3935 assert (!_meter->display_to_user ());
3936 new_processors.push_front (_meter);
3939 assert (!_meter->display_to_user ());
3940 new_processors.insert (amp, _meter);
3942 case MeterPostFader:
3943 /* do nothing here */
3946 /* do nothing here */
3949 /* the meter is visible, so we don't touch it here */
3956 assert (_main_outs);
3957 assert (!_main_outs->display_to_user ());
3958 new_processors.push_back (_main_outs);
3960 /* iterator for the main outs */
3962 ProcessorList::iterator main = new_processors.end();
3965 /* OUTPUT METERING */
3967 if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
3968 assert (!_meter->display_to_user ());
3970 /* add the processor just before or just after the main outs */
3972 ProcessorList::iterator meter_point = main;
3974 if (_meter_point == MeterOutput) {
3977 new_processors.insert (meter_point, _meter);
3982 if (_monitor_send && !is_monitor ()) {
3983 assert (!_monitor_send->display_to_user ());
3984 if (Config->get_solo_control_is_listen_control()) {
3985 switch (Config->get_listen_position ()) {
3986 case PreFaderListen:
3987 switch (Config->get_pfl_position ()) {
3988 case PFLFromBeforeProcessors:
3989 new_processors.push_front (_monitor_send);
3991 case PFLFromAfterProcessors:
3992 new_processors.insert (amp, _monitor_send);
3995 _monitor_send->set_can_pan (false);
3997 case AfterFaderListen:
3998 switch (Config->get_afl_position ()) {
3999 case AFLFromBeforeProcessors:
4000 new_processors.insert (after_amp, _monitor_send);
4002 case AFLFromAfterProcessors:
4003 new_processors.insert (new_processors.end(), _monitor_send);
4006 _monitor_send->set_can_pan (true);
4010 new_processors.insert (new_processors.end(), _monitor_send);
4011 _monitor_send->set_can_pan (false);
4015 /* MONITOR CONTROL */
4017 if (_monitor_control && is_monitor ()) {
4018 assert (!_monitor_control->display_to_user ());
4019 new_processors.push_front (_monitor_control);
4022 /* INTERNAL RETURN */
4024 /* doing this here means that any monitor control will come just after
4029 assert (!_intreturn->display_to_user ());
4030 new_processors.push_front (_intreturn);
4033 /* EXPORT PROCESSOR */
4035 if (_capturing_processor) {
4036 assert (!_capturing_processor->display_to_user ());
4037 new_processors.push_front (_capturing_processor);
4040 _processors = new_processors;
4042 DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
4043 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4044 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
4051 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
4052 Glib::Threads::RWLock::ReaderLock lp (_processor_lock);
4056 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4057 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery>(*i);
4064 /** If the meter point is `Custom', make a note of where the meter is.
4065 * This is so that if the meter point is subsequently set to something else,
4066 * and then back to custom, we can put the meter back where it was last time
4067 * custom was enabled.
4069 * Must be called with the _processor_lock held.
4072 Route::maybe_note_meter_position ()
4074 if (_meter_point != MeterCustom) {
4078 _custom_meter_position_noted = true;
4079 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4080 if (boost::dynamic_pointer_cast<PeakMeter> (*i)) {
4081 ProcessorList::iterator j = i;
4083 if (j != _processors.end ()) {
4084 _processor_after_last_custom_meter = *j;
4085 _last_custom_meter_was_at_end = false;
4087 _last_custom_meter_was_at_end = true;
4093 boost::shared_ptr<Processor>
4094 Route::processor_by_id (PBD::ID id) const
4096 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4097 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4098 if ((*i)->id() == id) {
4103 return boost::shared_ptr<Processor> ();
4106 /** @return the monitoring state, or in other words what data we are pushing
4107 * into the route (data from the inputs, data from disk or silence)
4110 Route::monitoring_state () const
4112 return MonitoringInput;
4115 /** @return what we should be metering; either the data coming from the input
4116 * IO or the data that is flowing through the route.
4119 Route::metering_state () const
4121 return MeteringRoute;
4125 Route::has_external_redirects () const
4127 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4129 /* ignore inactive processors and obviously ignore the main
4130 * outs since everything has them and we don't care.
4133 if ((*i)->active() && (*i) != _main_outs && (*i)->does_routing()) {
4141 boost::shared_ptr<Processor>
4142 Route::the_instrument () const
4144 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
4145 return the_instrument_unlocked ();
4148 boost::shared_ptr<Processor>
4149 Route::the_instrument_unlocked () const
4151 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4152 if (boost::dynamic_pointer_cast<PluginInsert>(*i)) {
4153 if ((*i)->input_streams().n_midi() > 0 &&
4154 (*i)->output_streams().n_audio() > 0) {
4159 return boost::shared_ptr<Processor>();
4165 Route::non_realtime_locate (framepos_t pos)
4168 _pannable->transport_located (pos);
4172 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
4174 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4175 (*i)->transport_located (pos);
4181 Route::fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes)
4188 * We don't currently mix MIDI input together, so we don't need the
4189 * complex logic of the audio case.
4192 n_buffers = bufs.count().n_midi ();
4194 for (i = 0; i < n_buffers; ++i) {
4196 boost::shared_ptr<MidiPort> source_port = io->midi (i);
4197 MidiBuffer& buf (bufs.get_midi (i));
4200 buf.copy (source_port->get_midi_buffer(nframes));
4202 buf.silence (nframes);
4208 n_buffers = bufs.count().n_audio();
4210 size_t n_ports = io->n_ports().n_audio();
4211 float scaling = 1.0f;
4213 if (n_ports > n_buffers) {
4214 scaling = ((float) n_buffers) / n_ports;
4217 for (i = 0; i < n_ports; ++i) {
4219 /* if there are more ports than buffers, map them onto buffers
4220 * in a round-robin fashion
4223 boost::shared_ptr<AudioPort> source_port = io->audio (i);
4224 AudioBuffer& buf (bufs.get_audio (i%n_buffers));
4227 if (i < n_buffers) {
4229 /* first time through just copy a channel into
4233 buf.read_from (source_port->get_audio_buffer (nframes), nframes);
4235 if (scaling != 1.0f) {
4236 buf.apply_gain (scaling, nframes);
4241 /* on subsequent times around, merge data from
4242 * the port with what is already there
4245 if (scaling != 1.0f) {
4246 buf.accumulate_with_gain_from (source_port->get_audio_buffer (nframes), nframes, 0, scaling);
4248 buf.accumulate_from (source_port->get_audio_buffer (nframes), nframes);
4253 /* silence any remaining buffers */
4255 for (; i < n_buffers; ++i) {
4256 AudioBuffer& buf (bufs.get_audio (i));
4257 buf.silence (nframes);
4260 /* establish the initial setup of the buffer set, reflecting what was
4261 copied into it. unless, of course, we are the auditioner, in which
4262 case nothing was fed into it from the inputs at all.
4265 if (!is_auditioner()) {
4266 bufs.set_count (io->n_ports());