#include "pbd/convert.h"
#include "pbd/boost_debug.h"
-#include "evoral/Curve.hpp"
-
#include "ardour/amp.h"
-#include "ardour/audio_port.h"
+#include "ardour/audio_buffer.h"
#include "ardour/audioengine.h"
#include "ardour/buffer.h"
#include "ardour/buffer_set.h"
-#include "ardour/configuration.h"
-#include "ardour/cycle_timer.h"
+#include "ardour/capturing_processor.h"
#include "ardour/debug.h"
#include "ardour/delivery.h"
-#include "ardour/dB.h"
-#include "ardour/internal_send.h"
#include "ardour/internal_return.h"
-#include "ardour/ladspa_plugin.h"
+#include "ardour/internal_send.h"
#include "ardour/meter.h"
-#include "ardour/mix.h"
#include "ardour/monitor_processor.h"
#include "ardour/pannable.h"
-#include "ardour/panner.h"
#include "ardour/panner_shell.h"
#include "ardour/plugin_insert.h"
#include "ardour/port.h"
#include "ardour/port_insert.h"
#include "ardour/processor.h"
-#include "ardour/profile.h"
#include "ardour/route.h"
#include "ardour/route_group.h"
#include "ardour/send.h"
#include "ardour/session.h"
-#include "ardour/timestamps.h"
-#include "ardour/utils.h"
-#include "ardour/graph.h"
#include "ardour/unknown_processor.h"
-#include "ardour/capturing_processor.h"
+#include "ardour/utils.h"
#include "i18n.h"
Route::Route (Session& sess, string name, Flag flg, DataType default_type)
: SessionObject (sess, name)
, Automatable (sess)
- , GraphNode( sess.route_graph )
- , _active (true)
- , _initial_delay (0)
- , _roll_delay (0)
+ , GraphNode (sess._process_graph)
+ , _active (true)
+ , _signal_latency (0)
+ , _initial_delay (0)
+ , _roll_delay (0)
, _flags (flg)
- , _pending_declick (true)
- , _meter_point (MeterPostFader)
- , _self_solo (false)
- , _soloed_by_others_upstream (0)
- , _soloed_by_others_downstream (0)
- , _solo_isolated (0)
- , _denormal_protection (false)
- , _recordable (true)
- , _silent (false)
- , _declickable (false)
- , _solo_control (new SoloControllable (X_("solo"), *this))
- , _mute_control (new MuteControllable (X_("mute"), *this))
+ , _pending_declick (true)
+ , _meter_point (MeterPostFader)
+ , _self_solo (false)
+ , _soloed_by_others_upstream (0)
+ , _soloed_by_others_downstream (0)
+ , _solo_isolated (0)
+ , _denormal_protection (false)
+ , _recordable (true)
+ , _silent (false)
+ , _declickable (false)
, _mute_master (new MuteMaster (sess, name))
- , _have_internal_generator (false)
- , _solo_safe (false)
+ , _have_internal_generator (false)
+ , _solo_safe (false)
, _default_type (default_type)
- , _remote_control_id (0)
- , _in_configure_processors (false)
+ , _remote_control_id (0)
+ , _in_configure_processors (false)
+ , _custom_meter_position_noted (false)
+ , _last_custom_meter_was_at_end (false)
{
processor_max_streams.reset();
order_keys[N_("signal")] = order_key_cnt++;
+
+ if (is_master()) {
+ set_remote_control_id (MasterBusRemoteControlID);
+ } else if (is_monitor()) {
+ set_remote_control_id (MonitorBusRemoteControlID);
+ }
+
}
int
Route::init ()
{
- /* add standard controls */
+ /* add standard controls */
+
+ _solo_control.reset (new SoloControllable (X_("solo"), shared_from_this ()));
+ _mute_control.reset (new MuteControllable (X_("mute"), shared_from_this ()));
_solo_control->set_flags (Controllable::Flag (_solo_control->flags() | Controllable::Toggle));
_mute_control->set_flags (Controllable::Flag (_mute_control->flags() | Controllable::Toggle));
add_control (_solo_control);
add_control (_mute_control);
- /* panning */
-
- Pannable* p = new Pannable (_session);
-#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
- boost_debug_shared_ptr_mark_interesting (p, "Pannable");
-#endif
- _pannable.reset (p);
+ /* panning */
+
+ if (!(_flags & Route::MonitorOut)) {
+ _pannable.reset (new Pannable (_session));
+ }
/* input and output objects */
_output.reset (new IO (_session, _name, IO::Output, _default_type));
_input->changed.connect_same_thread (*this, boost::bind (&Route::input_change_handler, this, _1, _2));
- _output->changed.connect_same_thread (*this, boost::bind (&Route::output_change_handler, this, _1, _2));
-
_input->PortCountChanging.connect_same_thread (*this, boost::bind (&Route::input_port_count_changing, this, _1));
+ _output->changed.connect_same_thread (*this, boost::bind (&Route::output_change_handler, this, _1, _2));
+
/* add amp processor */
_amp.reset (new Amp (_session));
add_processor (_amp, PostFader);
- /* add standard processors: meter, main outs, monitor out */
+ /* create standard processors: meter, main outs, monitor out;
+ they will be added to _processors by setup_invisible_processors ()
+ */
_meter.reset (new PeakMeter (_session));
_meter->set_display_to_user (false);
-
- add_processor (_meter, PostFader);
+ _meter->activate ();
_main_outs.reset (new Delivery (_session, _output, _pannable, _mute_master, _name, Delivery::Main));
-
- add_processor (_main_outs, PostFader);
+ _main_outs->activate ();
if (is_monitor()) {
/* where we listen to tracks */
_intreturn.reset (new InternalReturn (_session));
- add_processor (_intreturn, PreFader);
-
- ProcessorList::iterator i;
-
- for (i = _processors.begin(); i != _processors.end(); ++i) {
- if (*i == _intreturn) {
- ++i;
- break;
- }
- }
+ _intreturn->activate ();
- /* the thing that provides proper control over a control/monitor/listen bus
- (such as per-channel cut, dim, solo, invert, etc).
- It always goes right after the internal return;
- */
- _monitor_control.reset (new MonitorProcessor (_session));
- add_processor (_monitor_control, i);
-
- /* no panning on the monitor main outs */
-
-#ifdef PANNER_HACKS
- _main_outs->panner()->set_bypassed (true);
-#endif
+ /* the thing that provides proper control over a control/monitor/listen bus
+ (such as per-channel cut, dim, solo, invert, etc).
+ */
+ _monitor_control.reset (new MonitorProcessor (_session));
+ _monitor_control->activate ();
}
- if (is_master() || is_monitor() || is_hidden()) {
- _mute_master->set_solo_ignore (true);
- }
+ if (is_master() || is_monitor() || is_hidden()) {
+ _mute_master->set_solo_ignore (true);
+ }
/* now that we have _meter, its safe to connect to this */
Metering::Meter.connect_same_thread (*this, (boost::bind (&Route::meter, this)));
- return 0;
+ {
+ /* run a configure so that the invisible processors get set up */
+ Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+ configure_processors (0);
+ }
+
+ return 0;
}
Route::~Route ()
{
DEBUG_TRACE (DEBUG::Destruction, string_compose ("route %1 destructor\n", _name));
- /* do this early so that we don't get incoming signals as we are going through destruction
+ /* do this early so that we don't get incoming signals as we are going through destruction
*/
drop_connections ();
/* don't use clear_processors here, as it depends on the session which may
- be half-destroyed by now
+ be half-destroyed by now
*/
Glib::RWLock::WriterLock lm (_processor_lock);
void
Route::set_remote_control_id (uint32_t id, bool notify_class_listeners)
{
+ /* force IDs for master/monitor busses and prevent
+ any other route from accidentally getting these IDs
+ (i.e. legacy sessions)
+ */
+
+ if (is_master() && id != MasterBusRemoteControlID) {
+ id = MasterBusRemoteControlID;
+ }
+
+ if (is_monitor() && id != MonitorBusRemoteControlID) {
+ id = MonitorBusRemoteControlID;
+ }
+
+ /* don't allow it to collide */
+
+ if (!is_master () && !is_monitor() &&
+ (id == MasterBusRemoteControlID || id == MonitorBusRemoteControlID)) {
+ id += MonitorBusRemoteControlID;
+ }
+
if (id != _remote_control_id) {
_remote_control_id = id;
RemoteControlIDChanged ();
}
bool changed = false;
-
+
for (; i != order_keys.end(); ++i) {
if (i->second != key) {
i->second = key;
_amp->set_gain (val, src);
}
+void
+Route::maybe_declick (BufferSet&, framecnt_t, int)
+{
+ /* this is the "bus" implementation and they never declick.
+ */
+ return;
+}
+
/** Process this route for one (sub) cycle (process thread)
*
* @param bufs Scratch buffers to use for the signal path
void
Route::process_output_buffers (BufferSet& bufs,
framepos_t start_frame, framepos_t end_frame, pframes_t nframes,
- bool /*with_processors*/, int declick,
- bool gain_automation_ok)
+ int declick, bool gain_automation_ok)
{
- bool monitor;
-
- bufs.is_silent (false);
+ bufs.set_is_silent (false);
- switch (Config->get_monitoring_model()) {
- case HardwareMonitoring:
- case ExternalMonitoring:
- monitor = !record_enabled() || (_session.config.get_auto_input() && !_session.actively_recording());
- break;
- default:
- monitor = true;
- }
-
- if (!declick) {
- declick = _pending_declick;
+ /* figure out if we're going to use gain automation */
+ if (gain_automation_ok) {
+ _amp->setup_gain_automation (start_frame, end_frame, nframes);
+ } else {
+ _amp->apply_gain_automation (false);
}
- /* figure out if we're going to use gain automation */
- if (gain_automation_ok) {
- _amp->setup_gain_automation (start_frame, end_frame, nframes);
- } else {
- _amp->apply_gain_automation (false);
- }
-
- /* tell main outs what to do about monitoring */
- _main_outs->no_outs_cuz_we_no_monitor (!monitor);
+ /* Tell main outs what to do about monitoring. We do this so that
+ on a transition between monitoring states we get a de-clicking gain
+ change in the _main_outs delivery.
+ */
+ _main_outs->no_outs_cuz_we_no_monitor (monitoring_state () == MonitoringSilence);
/* -------------------------------------------------------------------------------------------
GLOBAL DECLICK (for transport changes etc.)
----------------------------------------------------------------------------------------- */
- if (declick > 0) {
- Amp::declick (bufs, nframes, 1);
- } else if (declick < 0) {
- Amp::declick (bufs, nframes, -1);
- }
-
+ maybe_declick (bufs, nframes, declick);
_pending_declick = 0;
/* -------------------------------------------------------------------------------------------
and go ....
----------------------------------------------------------------------------------------- */
+ /* set this to be true if the meter will already have been ::run() earlier */
+ bool const meter_already_run = metering_state() == MeteringInput;
+
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- if (boost::dynamic_pointer_cast<UnknownProcessor> (*i)) {
- break;
+ if (meter_already_run && boost::dynamic_pointer_cast<PeakMeter> (*i)) {
+ /* don't ::run() the meter, otherwise it will have its previous peak corrupted */
+ continue;
}
-
- if (bufs.count() != (*i)->input_streams()) {
- cerr << _name << " bufs = " << bufs.count()
- << " input for " << (*i)->name() << " = " << (*i)->input_streams()
- << endl;
+
+#ifndef NDEBUG
+ /* if it has any inputs, make sure they match */
+ if (boost::dynamic_pointer_cast<UnknownProcessor> (*i) == 0 && (*i)->input_streams() != ChanCount::ZERO) {
+ if (bufs.count() != (*i)->input_streams()) {
+ DEBUG_TRACE (
+ DEBUG::Processors, string_compose (
+ "%1 bufs = %2 input for %3 = %4\n",
+ _name, bufs.count(), (*i)->name(), (*i)->input_streams()
+ )
+ );
+ continue;
+ }
}
- assert (bufs.count() == (*i)->input_streams());
-
- /* should we NOT run plugins here if the route is inactive?
- do we catch route != active somewhere higher?
- */
+#endif
+
+ /* should we NOT run plugins here if the route is inactive?
+ do we catch route != active somewhere higher?
+ */
(*i)->run (bufs, start_frame, end_frame, nframes, *i != _processors.back());
bufs.set_count ((*i)->output_streams());
}
write_out_of_band_data (bufs, start_frame, end_frame, nframes);
- process_output_buffers (bufs, start_frame, end_frame, nframes, true, declick, true);
+ process_output_buffers (bufs, start_frame, end_frame, nframes, declick, true);
}
void
Route::passthru_silence (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
{
BufferSet& bufs (_session.get_silent_buffers (n_process_buffers()));
+
bufs.set_count (_input->n_ports());
write_out_of_band_data (bufs, start_frame, end_frame, nframes);
- process_output_buffers (bufs, start_frame, end_frame, nframes, true, declick, false);
+ process_output_buffers (bufs, start_frame, end_frame, nframes, declick, false);
}
void
Route::set_listen (bool yn, void* src)
{
- if (_solo_safe) {
- return;
- }
+ if (_solo_safe) {
+ return;
+ }
+
+ if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
+ _route_group->foreach_route (boost::bind (&Route::set_listen, _1, yn, _route_group));
+ return;
+ }
if (_monitor_send) {
if (yn != _monitor_send->active()) {
if (yn) {
_monitor_send->activate ();
- _mute_master->set_soloed (true);
- } else {
+ _mute_master->set_soloed (true);
+ } else {
_monitor_send->deactivate ();
- _mute_master->set_soloed (false);
+ _mute_master->set_soloed (false);
}
listen_changed (src); /* EMIT SIGNAL */
}
bool
-Route::listening () const
+Route::listening_via_monitor () const
{
if (_monitor_send) {
return _monitor_send->active ();
if (_solo_safe != yn) {
_solo_safe = yn;
solo_safe_changed (src);
- }
+ }
}
bool
if (self_soloed() != yn) {
set_self_solo (yn);
- set_mute_master_solo ();
+ set_mute_master_solo ();
solo_changed (true, src); /* EMIT SIGNAL */
_solo_control->Changed (); /* EMIT SIGNAL */
}
void
Route::set_self_solo (bool yn)
{
- _self_solo = yn;
+ _self_solo = yn;
}
void
Route::mod_solo_by_others_upstream (int32_t delta)
{
- if (_solo_safe) {
- return;
- }
+ if (_solo_safe) {
+ return;
+ }
- uint32_t old_sbu = _soloed_by_others_upstream;
+ uint32_t old_sbu = _soloed_by_others_upstream;
if (delta < 0) {
if (_soloed_by_others_upstream >= (uint32_t) abs (delta)) {
_soloed_by_others_upstream += delta;
}
- DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 SbU delta %2 = %3 old = %4 sbd %5 ss %6 exclusive %7\n",
- name(), delta, _soloed_by_others_upstream, old_sbu,
- _soloed_by_others_downstream, _self_solo, Config->get_exclusive_solo()));
-
- /* push the inverse solo change to everything that feeds us.
-
- This is important for solo-within-group. When we solo 1 track out of N that
- feed a bus, that track will cause mod_solo_by_upstream (+1) to be called
- on the bus. The bus then needs to call mod_solo_by_downstream (-1) on all
- tracks that feed it. This will silence them if they were audible because
- of a bus solo, but the newly soloed track will still be audible (because
- it is self-soloed).
-
- but .. do this only when we are being told to solo-by-upstream (i.e delta = +1),
- not in reverse.
- */
-
- if ((_self_solo || _soloed_by_others_downstream) &&
- ((old_sbu == 0 && _soloed_by_others_upstream > 0) ||
- (old_sbu > 0 && _soloed_by_others_upstream == 0))) {
-
- if (delta > 0 || !Config->get_exclusive_solo()) {
- DEBUG_TRACE (DEBUG::Solo, "\t ... INVERT push\n");
- for (FedBy::iterator i = _fed_by.begin(); i != _fed_by.end(); ++i) {
- boost::shared_ptr<Route> sr = i->r.lock();
- if (sr) {
- sr->mod_solo_by_others_downstream (-delta);
- }
- }
- }
- }
-
- set_mute_master_solo ();
- solo_changed (false, this);
+ DEBUG_TRACE (DEBUG::Solo, string_compose (
+ "%1 SbU delta %2 = %3 old = %4 sbd %5 ss %6 exclusive %7\n",
+ name(), delta, _soloed_by_others_upstream, old_sbu,
+ _soloed_by_others_downstream, _self_solo, Config->get_exclusive_solo()));
+
+ /* push the inverse solo change to everything that feeds us.
+
+ This is important for solo-within-group. When we solo 1 track out of N that
+ feed a bus, that track will cause mod_solo_by_upstream (+1) to be called
+ on the bus. The bus then needs to call mod_solo_by_downstream (-1) on all
+ tracks that feed it. This will silence them if they were audible because
+ of a bus solo, but the newly soloed track will still be audible (because
+ it is self-soloed).
+
+ but .. do this only when we are being told to solo-by-upstream (i.e delta = +1),
+ not in reverse.
+ */
+
+ if ((_self_solo || _soloed_by_others_downstream) &&
+ ((old_sbu == 0 && _soloed_by_others_upstream > 0) ||
+ (old_sbu > 0 && _soloed_by_others_upstream == 0))) {
+
+ if (delta > 0 || !Config->get_exclusive_solo()) {
+ DEBUG_TRACE (DEBUG::Solo, "\t ... INVERT push\n");
+ for (FedBy::iterator i = _fed_by.begin(); i != _fed_by.end(); ++i) {
+ boost::shared_ptr<Route> sr = i->r.lock();
+ if (sr) {
+ sr->mod_solo_by_others_downstream (-delta);
+ }
+ }
+ }
+ }
+
+ set_mute_master_solo ();
+ solo_changed (false, this);
}
void
Route::mod_solo_by_others_downstream (int32_t delta)
{
- if (_solo_safe) {
- return;
- }
+ if (_solo_safe) {
+ return;
+ }
- if (delta < 0) {
+ if (delta < 0) {
if (_soloed_by_others_downstream >= (uint32_t) abs (delta)) {
_soloed_by_others_downstream += delta;
} else {
_soloed_by_others_downstream += delta;
}
- DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 SbD delta %2 = %3\n", name(), delta, _soloed_by_others_downstream));
+ DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 SbD delta %2 = %3\n", name(), delta, _soloed_by_others_downstream));
- set_mute_master_solo ();
- solo_changed (false, this);
+ set_mute_master_solo ();
+ solo_changed (false, this);
}
void
Route::set_mute_master_solo ()
{
- _mute_master->set_soloed (self_soloed() || soloed_by_others_downstream() || soloed_by_others_upstream());
+ _mute_master->set_soloed (self_soloed() || soloed_by_others_downstream() || soloed_by_others_upstream());
}
void
_route_group->foreach_route (boost::bind (&Route::set_solo_isolated, _1, yn, _route_group));
return;
}
-
+
/* forward propagate solo-isolate status to everything fed by this route, but not those via sends only */
boost::shared_ptr<RouteList> routes = _session.get_routes ();
for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) {
- continue;
- }
+ continue;
+ }
bool sends_only;
- bool does_feed = direct_feeds (*i, &sends_only); // we will recurse anyway, so don't use ::feeds()
-
+ bool does_feed = direct_feeds_according_to_graph (*i, &sends_only); // we will recurse anyway, so don't use ::feeds()
+
if (does_feed && !sends_only) {
(*i)->set_solo_isolated (yn, (*i)->route_group());
}
}
- /* XXX should we back-propagate as well? (April 2010: myself and chris goddard think not) */
+ /* XXX should we back-propagate as well? (April 2010: myself and chris goddard think not) */
- bool changed = false;
+ bool changed = false;
if (yn) {
- if (_solo_isolated == 0) {
- _mute_master->set_solo_ignore (true);
- changed = true;
- }
+ if (_solo_isolated == 0) {
+ _mute_master->set_solo_ignore (true);
+ changed = true;
+ }
_solo_isolated++;
} else {
if (_solo_isolated > 0) {
_solo_isolated--;
- if (_solo_isolated == 0) {
- _mute_master->set_solo_ignore (false);
- changed = true;
- }
+ if (_solo_isolated == 0) {
+ _mute_master->set_solo_ignore (false);
+ changed = true;
+ }
}
}
- if (changed) {
- solo_isolated_changed (src);
- }
+ if (changed) {
+ solo_isolated_changed (src);
+ }
}
bool
void
Route::set_mute_points (MuteMaster::MutePoint mp)
{
- _mute_master->set_mute_points (mp);
- mute_points_changed (); /* EMIT SIGNAL */
-
- if (_mute_master->muted_by_self()) {
- mute_changed (this); /* EMIT SIGNAL */
+ _mute_master->set_mute_points (mp);
+ mute_points_changed (); /* EMIT SIGNAL */
+
+ if (_mute_master->muted_by_self()) {
+ mute_changed (this); /* EMIT SIGNAL */
_mute_control->Changed (); /* EMIT SIGNAL */
- }
+ }
}
void
}
if (muted() != yn) {
- _mute_master->set_muted_by_self (yn);
+ _mute_master->set_muted_by_self (yn);
+ /* allow any derived classes to respond to the mute change
+ before anybody else knows about it.
+ */
+ act_on_mute ();
+ /* tell everyone else */
mute_changed (src); /* EMIT SIGNAL */
_mute_control->Changed (); /* EMIT SIGNAL */
}
bool
Route::muted () const
{
- return _mute_master->muted_by_self();
+ return _mute_master->muted_by_self();
}
#if 0
cerr << name << " {" << endl;
for (list<boost::shared_ptr<Processor> >::const_iterator p = procs.begin();
p != procs.end(); ++p) {
- cerr << "\t" << (*p)->name() << " ID = " << (*p)->id() << endl;
+ cerr << "\t" << (*p)->name() << " ID = " << (*p)->id() << " @ " << (*p) << endl;
}
cerr << "}" << endl;
}
#endif
-int
-Route::add_processor (boost::shared_ptr<Processor> processor, Placement placement, ProcessorStreams* err)
+/** Supposing that we want to insert a Processor at a given Placement, return
+ * the processor to add the new one before (or 0 to add at the end).
+ */
+boost::shared_ptr<Processor>
+Route::before_processor_for_placement (Placement p)
{
- ProcessorList::iterator loc;
-
- /* XXX this is not thread safe - we don't hold the lock across determining the iter
- to add before and actually doing the insertion. dammit.
- */
+ Glib::RWLock::ReaderLock lm (_processor_lock);
- if (placement == PreFader) {
+ ProcessorList::iterator loc;
+
+ if (p == PreFader) {
/* generic pre-fader: insert immediately before the amp */
loc = find (_processors.begin(), _processors.end(), _amp);
} else {
loc = find (_processors.begin(), _processors.end(), _main_outs);
}
- return add_processor (processor, loc, err);
+ return loc != _processors.end() ? *loc : boost::shared_ptr<Processor> ();
+}
+
+/** Supposing that we want to insert a Processor at a given index, return
+ * the processor to add the new one before (or 0 to add at the end).
+ */
+boost::shared_ptr<Processor>
+Route::before_processor_for_index (int index)
+{
+ if (index == -1) {
+ return boost::shared_ptr<Processor> ();
+ }
+
+ Glib::RWLock::ReaderLock lm (_processor_lock);
+
+ ProcessorList::iterator i = _processors.begin ();
+ int j = 0;
+ while (i != _processors.end() && j < index) {
+ if ((*i)->display_to_user()) {
+ ++j;
+ }
+
+ ++i;
+ }
+
+ return (i != _processors.end() ? *i : boost::shared_ptr<Processor> ());
+}
+
+/** Add a processor either pre- or post-fader
+ * @return 0 on success, non-0 on failure.
+ */
+int
+Route::add_processor (boost::shared_ptr<Processor> processor, Placement placement, ProcessorStreams* err, bool activation_allowed)
+{
+ return add_processor (processor, before_processor_for_placement (placement), err, activation_allowed);
}
+/** Add a processor to a route such that it ends up with a given index into the visible processors.
+ * @param index Index to add the processor at, or -1 to add at the end of the list.
+ * @return 0 on success, non-0 on failure.
+ */
+int
+Route::add_processor_by_index (boost::shared_ptr<Processor> processor, int index, ProcessorStreams* err, bool activation_allowed)
+{
+ return add_processor (processor, before_processor_for_index (index), err, activation_allowed);
+}
+
/** Add a processor to the route.
- * @a iter must point to an iterator in _processors and the new
- * processor will be inserted immediately before this location. Otherwise,
- * @a position is used.
+ * @param before An existing processor in the list, or 0; the new processor will be inserted immediately before it (or at the end).
+ * @return 0 on success, non-0 on failure.
*/
int
-Route::add_processor (boost::shared_ptr<Processor> processor, ProcessorList::iterator iter, ProcessorStreams* err, bool activation_allowed)
+Route::add_processor (boost::shared_ptr<Processor> processor, boost::shared_ptr<Processor> before, ProcessorStreams* err, bool activation_allowed)
{
- ChanCount old_pms = processor_max_streams;
+ assert (processor != _meter);
+ assert (processor != _main_outs);
+
+ DEBUG_TRACE (DEBUG::Processors, string_compose (
+ "%1 adding processor %2\n", name(), processor->name()));
if (!_session.engine().connected() || !processor) {
return 1;
{
Glib::RWLock::WriterLock lm (_processor_lock);
+ ProcessorState pstate (this);
boost::shared_ptr<PluginInsert> pi;
boost::shared_ptr<PortInsert> porti;
- ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), processor);
-
- if (processor == _amp || processor == _meter || processor == _main_outs) {
- // Ensure only one of these are in the list at any time
- if (loc != _processors.end()) {
- if (iter == loc) { // Already in place, do nothing
+ if (processor == _amp) {
+ /* Ensure that only one amp is in the list at any time */
+ ProcessorList::iterator check = find (_processors.begin(), _processors.end(), processor);
+ if (check != _processors.end()) {
+ if (before == _amp) {
+ /* Already in position; all is well */
return 0;
- } else { // New position given, relocate
- _processors.erase (loc);
+ } else {
+ _processors.erase (check);
}
}
+ }
- } else {
- if (loc != _processors.end()) {
- cerr << "ERROR: Processor added to route twice!" << endl;
+ assert (find (_processors.begin(), _processors.end(), processor) == _processors.end ());
+
+ ProcessorList::iterator loc;
+ if (before) {
+ /* inserting before a processor; find it */
+ loc = find (_processors.begin(), _processors.end(), before);
+ if (loc == _processors.end ()) {
+ /* Not found */
return 1;
}
-
- loc = iter;
+ } else {
+ /* inserting at end */
+ loc = _processors.end ();
}
_processors.insert (loc, processor);
Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
if (configure_processors_unlocked (err)) {
- ProcessorList::iterator ploc = loc;
- --ploc;
- _processors.erase(ploc);
+ pstate.restore ();
configure_processors_unlocked (0); // it worked before we tried to add it ...
- cerr << "configure failed\n";
return -1;
}
}
if ((pi = boost::dynamic_pointer_cast<PluginInsert>(processor)) != 0) {
- if (pi->natural_input_streams() == ChanCount::ZERO) {
+ if (pi->has_no_inputs ()) {
/* generator plugin */
_have_internal_generator = true;
}
}
- /* is this the monitor send ? if so, make sure we keep track of it */
-
- boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
-
- if (isend && _session.monitor_out() && (isend->target_id() == _session.monitor_out()->id())) {
- _monitor_send = isend;
- }
-
- if (activation_allowed && (processor != _monitor_send)) {
+ if (activation_allowed) {
processor->activate ();
}
- processor->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false, false));
+ processor->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
_output->set_user_latency (0);
}
XMLNodeList const & children = node.children ();
XMLNodeList::const_iterator i = children.begin ();
-
+
while (i != children.end() && (*i)->name() != X_("Redirect")) {
++i;
}
if ((prop = node.property ("type")) != 0) {
- if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
+ if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
prop->value() == "lv2" ||
prop->value() == "vst" ||
+ prop->value() == "lxvst" ||
prop->value() == "audiounit") {
processor.reset (new PluginInsert (_session));
return false;
}
- if (processor->set_state (node, version)) {
- return false;
- }
+ if (processor->set_state (node, version)) {
+ return false;
+ }
return (add_processor (processor, placement) == 0);
}
if (before) {
loc = find(_processors.begin(), _processors.end(), before);
} else {
- /* nothing specified - at end but before main outs */
- loc = find (_processors.begin(), _processors.end(), _main_outs);
+ /* nothing specified - at end */
+ loc = _processors.end ();
}
- ChanCount old_pms = processor_max_streams;
-
if (!_session.engine().connected()) {
return 1;
}
{
Glib::RWLock::WriterLock lm (_processor_lock);
-
- ChanCount potential_max_streams = ChanCount::max (_input->n_ports(), _output->n_ports());
+ ProcessorState pstate (this);
for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
- // Ensure meter only appears in the list once
if (*i == _meter) {
- ProcessorList::iterator m = find(_processors.begin(), _processors.end(), *i);
- if (m != _processors.end()) {
- _processors.erase(m);
- }
+ continue;
}
boost::shared_ptr<PluginInsert> pi;
if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
pi->set_count (1);
-
- ChanCount m = max (pi->input_streams(), pi->output_streams());
-
- if (m > potential_max_streams) {
- potential_max_streams = m;
- }
}
- ProcessorList::iterator inserted = _processors.insert (loc, *i);
+ _processors.insert (loc, *i);
if ((*i)->active()) {
(*i)->activate ();
{
Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
if (configure_processors_unlocked (err)) {
- _processors.erase (inserted);
+ pstate.restore ();
configure_processors_unlocked (0); // it worked before we tried to add it ...
return -1;
}
}
- (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false, false));
+ (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
+ }
+
+ for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ boost::shared_ptr<PluginInsert> pi;
+
+ if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
+ if (pi->has_no_inputs ()) {
+ _have_internal_generator = true;
+ break;
+ }
+ }
}
_output->set_user_latency (0);
void
Route::clear_processors (Placement p)
{
- const ChanCount old_pms = processor_max_streams;
-
if (!_session.engine().connected()) {
return;
}
}
int
-Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err)
+Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err, bool need_process_lock)
{
/* these can never be removed */
return 0;
}
- ChanCount old_pms = processor_max_streams;
-
if (!_session.engine().connected()) {
return 1;
}
{
Glib::RWLock::WriterLock lm (_processor_lock);
+ ProcessorState pstate (this);
+
ProcessorList::iterator i;
bool removed = false;
if (!removed) {
/* what? */
return 1;
- }
+ }
- {
+ if (need_process_lock) {
Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
-
+
+ if (configure_processors_unlocked (err)) {
+ pstate.restore ();
+ /* we know this will work, because it worked before :) */
+ configure_processors_unlocked (0);
+ return -1;
+ }
+ } else {
if (configure_processors_unlocked (err)) {
- /* get back to where we where */
- _processors.insert (i, processor);
+ pstate.restore ();
/* we know this will work, because it worked before :) */
configure_processors_unlocked (0);
return -1;
boost::shared_ptr<PluginInsert> pi;
if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
- if (pi->is_generator()) {
+ if (pi->has_no_inputs ()) {
_have_internal_generator = true;
break;
}
{
Glib::RWLock::WriterLock lm (_processor_lock);
+ ProcessorState pstate (this);
+
ProcessorList::iterator i;
boost::shared_ptr<Processor> processor;
- ProcessorList as_we_were = _processors;
-
for (i = _processors.begin(); i != _processors.end(); ) {
processor = *i;
{
Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
-
+
if (configure_processors_unlocked (err)) {
- /* get back to where we where */
- _processors = as_we_were;
+ pstate.restore ();
/* we know this will work, because it worked before :) */
configure_processors_unlocked (0);
return -1;
boost::shared_ptr<PluginInsert> pi;
if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
- if (pi->is_generator()) {
+ if (pi->has_no_inputs ()) {
_have_internal_generator = true;
break;
}
Route::configure_processors (ProcessorStreams* err)
{
assert (!AudioEngine::instance()->process_lock().trylock());
-
+
if (!_in_configure_processors) {
Glib::RWLock::WriterLock lm (_processor_lock);
return configure_processors_unlocked (err);
}
+
return 0;
}
ChanCount
Route::input_streams () const
{
- return _input->n_ports ();
+ return _input->n_ports ();
}
list<pair<ChanCount, ChanCount> >
DEBUG_TRACE (DEBUG::Processors, "--- CONFIGURE ABORTED due to unknown processor.\n");
break;
}
-
+
if ((*p)->can_support_io_configuration(in, out)) {
DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID=%2 in=%3 out=%4\n",(*p)->name(), (*p)->id(), in, out));
configuration.push_back(make_pair(in, out));
}
DEBUG_TRACE (DEBUG::Processors, "}\n");
-
+
return configuration;
}
return 0;
}
+ /* put invisible processors where they should be */
+ setup_invisible_processors ();
+
_in_configure_processors = true;
list<pair<ChanCount, ChanCount> > configuration = try_configure_processors_unlocked (input_streams (), err);
if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
break;
}
-
+
(*p)->configure_io(c->first, c->second);
processor_max_streams = ChanCount::max(processor_max_streams, c->first);
processor_max_streams = ChanCount::max(processor_max_streams, c->second);
}
/* make sure we have sufficient scratch buffers to cope with the new processor
- configuration */
+ configuration
+ */
_session.ensure_buffers (n_process_buffers ());
DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
return 0;
}
-void
-Route::all_processors_flip ()
-{
- Glib::RWLock::ReaderLock lm (_processor_lock);
-
- if (_processors.empty()) {
- return;
- }
-
- bool first_is_on = _processors.front()->active();
-
- for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- if (first_is_on) {
- (*i)->deactivate ();
- } else {
- (*i)->activate ();
- }
- }
-
- _session.set_dirty ();
-}
-
-/** Set all processors with a given placement to a given active state.
- * @param p Placement of processors to change.
- * @param state New active state for those processors.
+/** Set all visible processors to a given active state (except Fader, whose state is not changed)
+ * @param state New active state for those processors.
*/
void
-Route::all_processors_active (Placement p, bool state)
+Route::all_visible_processors_active (bool state)
{
Glib::RWLock::ReaderLock lm (_processor_lock);
if (_processors.empty()) {
return;
}
- ProcessorList::iterator start, end;
- placement_range(p, start, end);
-
- bool before_amp = true;
+
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- if ((*i) == _amp) {
- before_amp = false;
+ if (!(*i)->display_to_user() || boost::dynamic_pointer_cast<Amp> (*i)) {
continue;
}
- if (p == PreFader && before_amp) {
- if (state) {
- (*i)->activate ();
- } else {
- (*i)->deactivate ();
- }
+
+ if (state) {
+ (*i)->activate ();
+ } else {
+ (*i)->deactivate ();
}
}
_session.set_dirty ();
}
-bool
-Route::processor_is_prefader (boost::shared_ptr<Processor> p)
+int
+Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
{
- bool pre_fader = true;
- Glib::RWLock::ReaderLock lm (_processor_lock);
+ /* "new_order" is an ordered list of processors to be positioned according to "placement".
+ NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
+ processors in the current actual processor list that are hidden. Any visible processors
+ in the current list but not in "new_order" will be assumed to be deleted.
+ */
- for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ {
+ Glib::RWLock::WriterLock lm (_processor_lock);
+ ProcessorState pstate (this);
- /* semantic note: if p == amp, we want to return true, so test
- for equality before checking if this is the amp
- */
-
- if ((*i) == p) {
- break;
- }
-
- if ((*i) == _amp) {
- pre_fader = false;
- break;
- }
- }
-
- return pre_fader;
-}
-
-int
-Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
-{
- /* "new_order" is an ordered list of processors to be positioned according to "placement".
- NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
- processors in the current actual processor list that are hidden. Any visible processors
- in the current list but not in "new_order" will be assumed to be deleted.
- */
-
- {
- Glib::RWLock::WriterLock lm (_processor_lock);
- ChanCount old_pms = processor_max_streams;
- ProcessorList::iterator oiter;
- ProcessorList::const_iterator niter;
- ProcessorList as_it_was_before = _processors;
- ProcessorList as_it_will_be;
+ ProcessorList::iterator oiter;
+ ProcessorList::const_iterator niter;
+ ProcessorList as_it_will_be;
oiter = _processors.begin();
niter = new_order.begin();
}
}
- /* now remove from old order - its taken care of no matter what */
+ /* now remove from old order - its taken care of no matter what */
oiter = _processors.erase (oiter);
}
_processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
+ /* If the meter is in a custom position, find it and make a rough note of its position */
+ maybe_note_meter_position ();
+
{
Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
-
+
if (configure_processors_unlocked (err)) {
- _processors = as_it_was_before;
- processor_max_streams = old_pms;
+ pstate.restore ();
return -1;
}
}
cmt->add_content (_comment);
}
- node->add_child_nocopy (_pannable->state (full_state));
+ if (_pannable) {
+ node->add_child_nocopy (_pannable->state (full_state));
+ }
for (i = _processors.begin(); i != _processors.end(); ++i) {
+ if (!full_state) {
+ /* template save: do not include internal sends functioning as
+ aux sends because the chance of the target ID
+ in the session where this template is used
+ is not very likely.
+
+ similarly, do not save listen sends which connect to
+ the monitor section, because these will always be
+ added if necessary.
+ */
+ boost::shared_ptr<InternalSend> is;
+
+ if ((is = boost::dynamic_pointer_cast<InternalSend> (*i)) != 0) {
+ if (is->role() == Delivery::Aux || is->role() == Delivery::Listen) {
+ continue;
+ }
+ }
+ }
node->add_child_nocopy((*i)->state (full_state));
}
- if (_extra_xml){
+ if (_extra_xml) {
node->add_child_copy (*_extra_xml);
}
+ if (_custom_meter_position_noted) {
+ boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
+ if (after) {
+ after->id().print (buf, sizeof (buf));
+ node->add_property (X_("processor-after-last-custom-meter"), buf);
+ }
+
+ node->add_property (X_("last-custom-meter-was-at-end"), _last_custom_meter_was_at_end ? "yes" : "no");
+ }
+
return *node;
}
int
Route::set_state (const XMLNode& node, int version)
-{
- return _set_state (node, version, true);
-}
-
-int
-Route::_set_state (const XMLNode& node, int version, bool /*call_base*/)
{
if (version < 3000) {
- return _set_state_2X (node, version);
+ return set_state_2X (node, version);
}
XMLNodeList nlist;
Route::set_name (prop->value());
}
- if ((prop = node.property ("id")) != 0) {
- _id = prop->value ();
- }
+ set_id (node);
if ((prop = node.property (X_("flags"))) != 0) {
_flags = Flag (string_2_enum (prop->value(), _flags));
_flags = Flag (0);
}
- if (is_master() || is_monitor() || is_hidden()) {
- _mute_master->set_solo_ignore (true);
- }
+ if (is_master() || is_monitor() || is_hidden()) {
+ _mute_master->set_solo_ignore (true);
+ }
+
+ if (is_monitor()) {
+ /* monitor bus does not get a panner, but if (re)created
+ via XML, it will already have one by the time we
+ call ::set_state(). so ... remove it.
+ */
+ unpan ();
+ }
/* add all processors (except amp, which is always present) */
nlist = node.children();
XMLNode processor_state (X_("processor_state"));
+ Stateful::save_extra_xml (node);
+
for (niter = nlist.begin(); niter != nlist.end(); ++niter){
child = *niter;
}
- if (child->name() == X_("Pannable")) {
- _pannable->set_state (*child, version);
- }
+ if (child->name() == X_("Pannable")) {
+ if (_pannable) {
+ _pannable->set_state (*child, version);
+ } else {
+ warning << string_compose (_("Pannable state found for route (%1) without a panner!"), name()) << endmsg;
+ }
+ }
+ }
+
+ if ((prop = node.property (X_("meter-point"))) != 0) {
+ MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
+ set_meter_point (mp, true);
+ if (_meter) {
+ _meter->set_display_to_user (_meter_point == MeterCustom);
+ }
}
set_processor_state (processor_state);
set_active (yn, this);
}
- if ((prop = node.property (X_("meter-point"))) != 0) {
- MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
- set_meter_point (mp, true);
- if (_meter) {
- _meter->set_display_to_user (_meter_point == MeterCustom);
- }
- }
-
if ((prop = node.property (X_("order-keys"))) != 0) {
int32_t n;
}
}
+ if ((prop = node.property (X_("processor-after-last-custom-meter"))) != 0) {
+ PBD::ID id (prop->value ());
+ Glib::RWLock::ReaderLock lm (_processor_lock);
+ ProcessorList::const_iterator i = _processors.begin ();
+ while (i != _processors.end() && (*i)->id() != id) {
+ ++i;
+ }
+
+ if (i != _processors.end ()) {
+ _processor_after_last_custom_meter = *i;
+ _custom_meter_position_noted = true;
+ }
+ }
+
+ if ((prop = node.property (X_("last-custom-meter-was-at-end"))) != 0) {
+ _last_custom_meter_was_at_end = string_is_affirmative (prop->value ());
+ }
+
for (niter = nlist.begin(); niter != nlist.end(); ++niter){
child = *niter;
XMLNode *cmt = *(child->children().begin());
_comment = cmt->content();
- } else if (child->name() == X_("Extra")) {
-
- _extra_xml = new XMLNode (*child);
-
} else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
if (prop->value() == "solo") {
_solo_control->set_state (*child, version);
}
int
-Route::_set_state_2X (const XMLNode& node, int version)
+Route::set_state_2X (const XMLNode& node, int version)
{
XMLNodeList nlist;
XMLNodeConstIterator niter;
} else {
_flags = Flag (0);
}
-
+
if ((prop = node.property (X_("phase-invert"))) != 0) {
boost::dynamic_bitset<> p (_input->n_ports().n_audio ());
if (string_is_affirmative (prop->value ())) {
p.set ();
- }
+ }
set_phase_invert (p);
}
}
if ((prop = node.property (X_("muted"))) != 0) {
-
+
bool first = true;
bool muted = string_is_affirmative (prop->value());
-
- if (muted){
-
+
+ if (muted) {
+
string mute_point;
-
+
if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
-
+
if (string_is_affirmative (prop->value())){
mute_point = mute_point + "PreFader";
first = false;
}
}
-
+
if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
-
+
if (string_is_affirmative (prop->value())){
-
+
if (!first) {
mute_point = mute_point + ",";
}
-
+
mute_point = mute_point + "PostFader";
first = false;
}
}
if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
-
+
if (string_is_affirmative (prop->value())){
-
+
if (!first) {
mute_point = mute_point + ",";
}
-
+
mute_point = mute_point + "Listen";
first = false;
}
}
if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
-
+
if (string_is_affirmative (prop->value())){
-
+
if (!first) {
mute_point = mute_point + ",";
}
-
+
mute_point = mute_point + "Main";
}
}
-
+
_mute_master->set_mute_points (mute_point);
+ _mute_master->set_muted_by_self (true);
}
}
Route::set_name (prop->value ());
}
- if ((prop = child->property (X_("id"))) != 0) {
- _id = prop->value ();
- }
+ set_id (*child);
if ((prop = child->property (X_("active"))) != 0) {
bool yn = string_is_affirmative (prop->value());
_active = !yn; // force switch
set_active (yn, this);
}
-
+
if ((prop = child->property (X_("gain"))) != 0) {
gain_t val;
_amp->gain_control()->set_value (val);
}
}
-
+
/* Set up Panners in the IO */
XMLNodeList io_nlist = child->children ();
-
+
XMLNodeConstIterator io_niter;
XMLNode *io_child;
-
+
for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
io_child = *io_niter;
-
+
if (io_child->name() == X_("Panner")) {
_main_outs->panner_shell()->set_state(*io_child, version);
} else if (io_child->name() == X_("Automation")) {
set_processor_state_2X (redirect_nodes, version);
+ Stateful::save_extra_xml (node);
+
for (niter = nlist.begin(); niter != nlist.end(); ++niter){
child = *niter;
XMLNode *cmt = *(child->children().begin());
_comment = cmt->content();
- } else if (child->name() == X_("extra")) {
-
- _extra_xml = new XMLNode (*child);
-
} else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
if (prop->value() == X_("solo")) {
_solo_control->set_state (*child, version);
} else if (prop->value() == X_("mute")) {
_mute_control->set_state (*child, version);
- }
-
+ }
+
} else if (child->name() == X_("RemoteControl")) {
if ((prop = child->property (X_("id"))) != 0) {
int32_t x;
set_remote_control_id (x);
}
- }
+ }
}
return 0;
{
const XMLNodeList &nlist = node.children();
XMLNodeConstIterator niter;
- ProcessorList new_order;
- bool must_configure = false;
+ ProcessorList new_order;
+ bool must_configure = false;
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
XMLProperty* prop = (*niter)->property ("type");
if (prop->value() == "amp") {
- _amp->set_state (**niter, Stateful::current_state_version);
- new_order.push_back (_amp);
- } else if (prop->value() == "meter") {
- _meter->set_state (**niter, Stateful::current_state_version);
- new_order.push_back (_meter);
- } else if (prop->value() == "main-outs") {
- _main_outs->set_state (**niter, Stateful::current_state_version);
- new_order.push_back (_main_outs);
- } else if (prop->value() == "intreturn") {
- if (!_intreturn) {
- _intreturn.reset (new InternalReturn (_session));
- must_configure = true;
- }
- _intreturn->set_state (**niter, Stateful::current_state_version);
- new_order.push_back (_intreturn);
- } else if (is_monitor() && prop->value() == "monitor") {
- if (!_monitor_control) {
- _monitor_control.reset (new MonitorProcessor (_session));
- must_configure = true;
- }
- _monitor_control->set_state (**niter, Stateful::current_state_version);
- new_order.push_back (_monitor_control);
- } else {
- ProcessorList::iterator o;
+ _amp->set_state (**niter, Stateful::current_state_version);
+ new_order.push_back (_amp);
+ } else if (prop->value() == "meter") {
+ _meter->set_state (**niter, Stateful::current_state_version);
+ new_order.push_back (_meter);
+ } else if (prop->value() == "main-outs") {
+ _main_outs->set_state (**niter, Stateful::current_state_version);
+ } else if (prop->value() == "intreturn") {
+ if (!_intreturn) {
+ _intreturn.reset (new InternalReturn (_session));
+ must_configure = true;
+ }
+ _intreturn->set_state (**niter, Stateful::current_state_version);
+ } else if (is_monitor() && prop->value() == "monitor") {
+ if (!_monitor_control) {
+ _monitor_control.reset (new MonitorProcessor (_session));
+ must_configure = true;
+ }
+ _monitor_control->set_state (**niter, Stateful::current_state_version);
+ } else if (prop->value() == "capture") {
+ _capturing_processor.reset (new CapturingProcessor (_session));
+ } else {
+ ProcessorList::iterator o;
for (o = _processors.begin(); o != _processors.end(); ++o) {
XMLProperty* id_prop = (*niter)->property(X_("id"));
if (id_prop && (*o)->id() == id_prop->value()) {
- (*o)->set_state (**niter, Stateful::current_state_version);
- new_order.push_back (*o);
+ (*o)->set_state (**niter, Stateful::current_state_version);
+ new_order.push_back (*o);
break;
}
}
- // If the processor (*niter) is not on the route then create it
-
- if (o == _processors.end()) {
-
- boost::shared_ptr<Processor> processor;
-
- if (prop->value() == "intsend") {
-
- processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::shared_ptr<Route>(), Delivery::Role (0)));
-
- } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
- prop->value() == "lv2" ||
- prop->value() == "vst" ||
- prop->value() == "audiounit") {
-
- processor.reset (new PluginInsert(_session));
-
- } else if (prop->value() == "port") {
-
- processor.reset (new PortInsert (_session, _pannable, _mute_master));
-
- } else if (prop->value() == "send") {
-
- processor.reset (new Send (_session, _pannable, _mute_master));
-
- } else {
- error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
- continue;
- }
+ // If the processor (*niter) is not on the route then create it
+
+ if (o == _processors.end()) {
+
+ boost::shared_ptr<Processor> processor;
+
+ if (prop->value() == "intsend") {
+
+ processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::shared_ptr<Route>(), Delivery::Role (0)));
+
+ } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
+ prop->value() == "lv2" ||
+ prop->value() == "vst" ||
+ prop->value() == "lxvst" ||
+ prop->value() == "audiounit") {
+
+ processor.reset (new PluginInsert(_session));
+
+ } else if (prop->value() == "port") {
+
+ processor.reset (new PortInsert (_session, _pannable, _mute_master));
+
+ } else if (prop->value() == "send") {
+
+ processor.reset (new Send (_session, _pannable, _mute_master));
+
+ } else {
+ error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
+ continue;
+ }
if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
/* This processor could not be configured. Turn it into a UnknownProcessor */
processor.reset (new UnknownProcessor (_session, **niter));
}
-
+
+ /* we have to note the monitor send here, otherwise a new one will be created
+ and the state of this one will be lost.
+ */
+ boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
+ if (isend && isend->role() == Delivery::Listen) {
+ _monitor_send = isend;
+ }
+
+ /* it doesn't matter if invisible processors are added here, as they
+ will be sorted out by setup_invisible_processors () shortly.
+ */
+
new_order.push_back (processor);
must_configure = true;
- }
- }
- }
+ }
+ }
+ }
{
Glib::RWLock::WriterLock lm (_processor_lock);
- _processors = new_order;
- if (must_configure) {
+ _processors = new_order;
+
+ if (must_configure) {
Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
- configure_processors_unlocked (0);
- }
- }
+ configure_processors_unlocked (0);
+ }
+
+ for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
+
+ (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
+
+ boost::shared_ptr<PluginInsert> pi;
+
+ if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
+ if (pi->has_no_inputs ()) {
+ _have_internal_generator = true;
+ break;
+ }
+ }
+ }
+ }
- processors_changed (RouteProcessorChange ());
+ processors_changed (RouteProcessorChange ());
set_processor_positions ();
}
Route::silence_unlocked (framecnt_t nframes)
{
/* Must be called with the processor lock held */
-
+
if (!_silent) {
_output->silence (nframes);
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
boost::shared_ptr<PluginInsert> pi;
-
+
if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
// skip plugins, they don't need anything when we're not active
continue;
}
-
+
(*i)->silence (nframes);
}
-
+
if (nframes == _session.get_block_size()) {
// _silent = true;
}
}
}
-BufferSet*
-Route::get_return_buffer () const
+void
+Route::add_send_to_internal_return (InternalSend* send)
{
Glib::RWLock::ReaderLock rm (_processor_lock);
boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
if (d) {
- BufferSet* bs = d->get_buffers ();
- return bs;
+ return d->add_send (send);
}
}
-
- return 0;
}
void
-Route::release_return_buffer () const
+Route::remove_send_from_internal_return (InternalSend* send)
{
Glib::RWLock::ReaderLock rm (_processor_lock);
boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
if (d) {
- return d->release_buffers ();
+ return d->remove_send (send);
}
}
}
+void
+Route::enable_monitor_send ()
+{
+ /* Caller must hold process lock */
+ assert (!AudioEngine::instance()->process_lock().trylock());
+
+ /* master never sends to monitor section via the normal mechanism */
+ assert (!is_master ());
+
+ /* make sure we have one */
+ if (!_monitor_send) {
+ _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, _session.monitor_out(), Delivery::Listen));
+ _monitor_send->set_display_to_user (false);
+ }
+
+ /* set it up */
+ configure_processors (0);
+}
+
+/** Add an aux send to a route.
+ * @param route route to send to.
+ * @param before Processor to insert before, or 0 to insert at the end.
+ */
int
-Route::listen_via (boost::shared_ptr<Route> route, Placement placement, bool /*active*/, bool aux)
+Route::add_aux_send (boost::shared_ptr<Route> route, boost::shared_ptr<Processor> before)
{
- vector<string> ports;
- vector<string>::const_iterator i;
+ assert (route != _session.monitor_out ());
{
Glib::RWLock::ReaderLock rm (_processor_lock);
for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
- boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
+ boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
if (d && d->target_route() == route) {
-
- /* if the target is the control outs, then make sure
- we take note of which i-send is doing that.
- */
-
- if (route == _session.monitor_out()) {
- _monitor_send = boost::dynamic_pointer_cast<Delivery>(d);
- }
-
/* already listening via the specified IO: do nothing */
-
return 0;
}
}
}
- boost::shared_ptr<InternalSend> listener;
-
try {
- if (is_master()) {
-
- if (route == _session.monitor_out()) {
- /* master never sends to control outs */
- return 0;
- } else {
- listener.reset (new InternalSend (_session, _pannable, _mute_master, route, (aux ? Delivery::Aux : Delivery::Listen)));
- }
+ boost::shared_ptr<InternalSend> listener;
- } else {
- listener.reset (new InternalSend (_session, _pannable, _mute_master, route, (aux ? Delivery::Aux : Delivery::Listen)));
- }
+ {
+ Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+ listener.reset (new InternalSend (_session, _pannable, _mute_master, route, Delivery::Aux));
+ }
+
+ add_processor (listener, before);
} catch (failed_constructor& err) {
return -1;
}
- if (route == _session.monitor_out()) {
- _monitor_send = listener;
- }
-
-
- if (aux) {
-
- add_processor (listener, placement);
-
- } else {
-
- if (placement == PostFader) {
- /* put it *really* at the end, not just after the panner (main outs)
- */
- add_processor (listener, _processors.end());
- } else {
- add_processor (listener, PreFader);
- }
-
- }
-
return 0;
}
void
-Route::drop_listen (boost::shared_ptr<Route> route)
+Route::remove_aux_or_listen (boost::shared_ptr<Route> route)
{
ProcessorStreams err;
ProcessorList::iterator tmp;
- Glib::RWLock::ReaderLock rl(_processor_lock);
- rl.acquire ();
-
- again:
- for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ) {
-
- boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
-
- if (d && d->target_route() == route) {
- rl.release ();
- remove_processor (*x, &err);
- rl.acquire ();
+ {
+ Glib::RWLock::ReaderLock rl(_processor_lock);
- /* list could have been demolished while we dropped the lock
- so start over.
- */
+ /* have to do this early because otherwise processor reconfig
+ * will put _monitor_send back in the list
+ */
- goto again;
+ if (route == _session.monitor_out()) {
+ _monitor_send.reset ();
}
- }
- rl.release ();
+ again:
+ for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
+
+ boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
+
+ if (d && d->target_route() == route) {
+ rl.release ();
+ remove_processor (*x, &err, false);
+ rl.acquire ();
- if (route == _session.monitor_out()) {
- _monitor_send.reset ();
+ /* list could have been demolished while we dropped the lock
+ so start over.
+ */
+
+ goto again;
+ }
+ }
}
}
bool
Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
{
- FeedRecord fr (other, via_sends_only);
+ FeedRecord fr (other, via_sends_only);
+
+ pair<FedBy::iterator,bool> result = _fed_by.insert (fr);
- pair<FedBy::iterator,bool> result = _fed_by.insert (fr);
+ if (!result.second) {
- if (!result.second) {
+ /* already a record for "other" - make sure sends-only information is correct */
+ if (!via_sends_only && result.first->sends_only) {
+ FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
+ frp->sends_only = false;
+ }
+ }
- /* already a record for "other" - make sure sends-only information is correct */
- if (!via_sends_only && result.first->sends_only) {
- FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
- frp->sends_only = false;
- }
- }
-
- return result.second;
+ return result.second;
}
void
Route::clear_fed_by ()
{
- _fed_by.clear ();
+ _fed_by.clear ();
}
bool
Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
{
- const FedBy& fed_by (other->fed_by());
+ const FedBy& fed_by (other->fed_by());
- for (FedBy::iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
- boost::shared_ptr<Route> sr = f->r.lock();
+ for (FedBy::iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
+ boost::shared_ptr<Route> sr = f->r.lock();
- if (sr && (sr.get() == this)) {
+ if (sr && (sr.get() == this)) {
- if (via_sends_only) {
- *via_sends_only = f->sends_only;
- }
+ if (via_sends_only) {
+ *via_sends_only = f->sends_only;
+ }
- return true;
- }
- }
+ return true;
+ }
+ }
- return false;
+ return false;
}
bool
-Route::direct_feeds (boost::shared_ptr<Route> other, bool* only_send)
+Route::direct_feeds_according_to_reality (boost::shared_ptr<Route> other, bool* via_send_only)
{
DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
if (_output->connected_to (other->input())) {
DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
- if (only_send) {
- *only_send = false;
+ if (via_send_only) {
+ *via_send_only = false;
}
return true;
}
-
+
for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
boost::shared_ptr<IOProcessor> iop;
if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
if (iop->feeds (other)) {
DEBUG_TRACE (DEBUG::Graph, string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
- if (only_send) {
- *only_send = true;
+ if (via_send_only) {
+ *via_send_only = true;
}
return true;
} else {
} else {
DEBUG_TRACE (DEBUG::Graph, string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
}
-
+
}
DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdoes NOT feed %1\n", other->name()));
return false;
}
+bool
+Route::direct_feeds_according_to_graph (boost::shared_ptr<Route> other, bool* via_send_only)
+{
+ return _session._current_route_graph.has (shared_from_this (), other, via_send_only);
+}
+
/** Called from the (non-realtime) butler thread when the transport is stopped */
void
Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool did_locate, bool can_flush_processors)
automation_snapshot (now, true);
}
- Automatable::transport_stopped (now);
+ Automatable::transport_stopped (now);
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- if (Config->get_plugins_stop_with_transport() && can_flush_processors) {
- (*i)->flush ();
+ if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && can_flush_processors)) {
+ (*i)->flush ();
}
(*i)->transport_stopped (now);
_roll_delay = _initial_delay;
}
-/** Called with the process lock held if change contains ConfigurationChanged */
void
Route::input_change_handler (IOChange change, void * /*src*/)
{
+ bool need_to_queue_solo_change = true;
+
if ((change.type & IOChange::ConfigurationChanged)) {
+ /* This is called with the process lock held if change
+ contains ConfigurationChanged
+ */
+ need_to_queue_solo_change = false;
configure_processors (0);
_phase_invert.resize (_input->n_ports().n_audio ());
io_changed (); /* EMIT SIGNAL */
}
+
+ if (!_input->connected() && _soloed_by_others_upstream) {
+ if (need_to_queue_solo_change) {
+ _session.cancel_solo_after_disconnect (shared_from_this(), true);
+ } else {
+ cancel_solo_after_disconnect (true);
+ }
+ }
}
-/** Called with the process lock held if change contains ConfigurationChanged */
void
Route::output_change_handler (IOChange change, void * /*src*/)
{
- if ((change.type & IOChange::ConfigurationChanged)) {
-
- /* XXX resize all listeners to match _main_outs? */
+ bool need_to_queue_solo_change = true;
- /* Auto-connect newly-created outputs, unless we're auto-connecting to master
- and we are master (as an auto-connect in this situation would cause a
- feedback loop)
+ if ((change.type & IOChange::ConfigurationChanged)) {
+ /* This is called with the process lock held if change
+ contains ConfigurationChanged
*/
- AutoConnectOption ac = Config->get_output_auto_connect ();
- if (ac == AutoConnectPhysical || (ac == AutoConnectMaster && !is_master ())) {
+ need_to_queue_solo_change = false;
+ }
- ChanCount start = change.before;
-
- for (DataType::iterator i = DataType::begin(); i != DataType::end(); ++i) {
- if (change.before.get(*i) < change.after.get(*i)) {
- /* the existing ChanCounts don't matter for this call as they are only
- to do with matching input and output indices, and we are only changing
- outputs here.
- */
- ChanCount dummy;
-
- /* only auto-connect the newly-created outputs, not the ones that were
- already there
- */
- start.set (*i, start.get (*i) + 1);
-
- _session.auto_connect_route (this, dummy, dummy, false, ChanCount(), change.before);
- }
- }
+ if (!_output->connected() && _soloed_by_others_downstream) {
+ if (need_to_queue_solo_change) {
+ _session.cancel_solo_after_disconnect (shared_from_this(), false);
+ } else {
+ cancel_solo_after_disconnect (false);
}
-
- // configure_processors (0);
}
}
-uint32_t
-Route::pans_required () const
+void
+Route::cancel_solo_after_disconnect (bool upstream)
+{
+ if (upstream) {
+ _soloed_by_others_upstream = 0;
+ } else {
+ _soloed_by_others_downstream = 0;
+ }
+ set_mute_master_solo ();
+ solo_changed (false, this);
+}
+
+uint32_t
+Route::pans_required () const
{
if (n_outputs().n_audio() < 2) {
return 0;
}
int
-Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
- bool session_state_changing, bool /*can_record*/, bool /*rec_monitors_input*/)
+Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
{
Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
if (!lm.locked()) {
if (_session.transport_speed() != 0.0f) {
/* we're rolling but some state is changing (e.g. our diskstream contents)
so we cannot use them. Be silent till this is over.
-
+
XXX note the absurdity of ::no_roll() being called when we ARE rolling!
*/
silence_unlocked (nframes);
return 0;
}
-framecnt_t
-Route::check_initial_delay (framecnt_t nframes, framecnt_t& transport_frame)
-{
- if (_roll_delay > nframes) {
-
- _roll_delay -= nframes;
- silence_unlocked (nframes);
- /* transport frame is not legal for caller to use */
- return 0;
-
- } else if (_roll_delay > 0) {
-
- nframes -= _roll_delay;
- silence_unlocked (_roll_delay);
- /* we've written _roll_delay of samples into the
- output ports, so make a note of that for
- future reference.
- */
- _main_outs->increment_output_offset (_roll_delay);
- transport_frame += _roll_delay;
-
- _roll_delay = 0;
- }
-
- return nframes;
-}
-
int
-Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick,
- bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
+Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& /* need_butler */)
{
Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
if (!lm.locked()) {
return 0;
}
-
+
automation_snapshot (_session.transport_frame(), false);
if (n_outputs().n_total() == 0) {
return 0;
}
- framecnt_t unused = 0;
+ framepos_t unused = 0;
if ((nframes = check_initial_delay (nframes, unused)) == 0) {
return 0;
}
int
-Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/,
- bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
+Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& /* need_butler */)
{
silence (nframes);
return 0;
}
-void
-Route::toggle_monitor_input ()
-{
- for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
- i->ensure_monitor_input( ! i->monitoring_input());
- }
-}
-
-bool
-Route::has_external_redirects () const
-{
- // FIXME: what about sends? - they don't return a signal back to ardour?
-
- boost::shared_ptr<const PortInsert> pi;
-
- for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
-
- if ((pi = boost::dynamic_pointer_cast<const PortInsert>(*i)) != 0) {
-
- for (PortSet::const_iterator port = pi->output()->ports().begin(); port != pi->output()->ports().end(); ++port) {
-
- string port_name = port->name();
- string client_name = port_name.substr (0, port_name.find(':'));
-
- /* only say "yes" if the redirect is actually in use */
-
- if (client_name != "ardour" && pi->active()) {
- return true;
- }
- }
- }
- }
-
- return false;
-}
-
void
Route::flush_processors ()
{
Glib::RWLock::ReaderLock lm (_processor_lock);
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- (*i)->flush ();
+ (*i)->flush ();
}
}
{
Glib::RWLock::WriterLock lm (_processor_lock);
-
- if (p != MeterCustom) {
- // Move meter in the processors list to reflect the new position
- ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
- _processors.erase(loc);
- switch (p) {
- case MeterInput:
- loc = _processors.begin();
- break;
- case MeterPreFader:
- loc = find (_processors.begin(), _processors.end(), _amp);
- break;
- case MeterPostFader:
- loc = _processors.end();
- break;
- default:
- break;
- }
-
- ChanCount m_in;
-
- if (loc == _processors.begin()) {
- m_in = _input->n_ports();
- } else {
- ProcessorList::iterator before = loc;
- --before;
- m_in = (*before)->output_streams ();
- }
-
- _meter->reflect_inputs (m_in);
-
- _processors.insert (loc, _meter);
- /* we do not need to reconfigure the processors, because the meter
- (a) is always ready to handle processor_max_streams
- (b) is always an N-in/N-out processor, and thus moving
- it doesn't require any changes to the other processors.
- */
-
+ maybe_note_meter_position ();
+
+ _meter_point = p;
+
+ if (_meter_point != MeterCustom) {
+
_meter->set_display_to_user (false);
-
+
+ setup_invisible_processors ();
+
} else {
-
- // just make it visible and let the user move it
-
+
_meter->set_display_to_user (true);
+
+ /* If we have a previous position for the custom meter, try to put it there */
+ if (_custom_meter_position_noted) {
+ boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
+
+ if (after) {
+ ProcessorList::iterator i = find (_processors.begin(), _processors.end(), after);
+ if (i != _processors.end ()) {
+ _processors.remove (_meter);
+ _processors.insert (i, _meter);
+ }
+ } else if (_last_custom_meter_was_at_end) {
+ _processors.remove (_meter);
+ _processors.push_back (_meter);
+ }
+ }
+ }
+
+ /* Set up the meter for its new position */
+
+ ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
+
+ ChanCount m_in;
+
+ if (loc == _processors.begin()) {
+ m_in = _input->n_ports();
+ } else {
+ ProcessorList::iterator before = loc;
+ --before;
+ m_in = (*before)->output_streams ();
}
+
+ _meter->reflect_inputs (m_in);
+
+ /* we do not need to reconfigure the processors, because the meter
+ (a) is always ready to handle processor_max_streams
+ (b) is always an N-in/N-out processor, and thus moving
+ it doesn't require any changes to the other processors.
+ */
}
- _meter_point = p;
meter_change (); /* EMIT SIGNAL */
bool const meter_visibly_changed = (_meter->display_to_user() != meter_was_visible_to_user);
-
+
processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
}
void
-Route::put_monitor_send_at (Placement p)
+Route::listen_position_changed ()
{
- if (!_monitor_send) {
- return;
- }
-
{
Glib::RWLock::WriterLock lm (_processor_lock);
- ProcessorList as_it_was (_processors);
- ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), _monitor_send);
- _processors.erase(loc);
-
- switch (p) {
- case PreFader:
- loc = find(_processors.begin(), _processors.end(), _amp);
- if (loc != _processors.begin()) {
- --loc;
- }
- break;
- case PostFader:
- loc = _processors.end();
- break;
- }
-
- _processors.insert (loc, _monitor_send);
+ ProcessorState pstate (this);
{
Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
-
+
if (configure_processors_unlocked (0)) {
- _processors = as_it_was;
+ pstate.restore ();
configure_processors_unlocked (0); // it worked before we tried to add it ...
return;
}
boost::shared_ptr<CapturingProcessor>
Route::add_export_point()
{
- // Check if it exists already
- boost::shared_ptr<CapturingProcessor> processor;
- if ((processor = boost::dynamic_pointer_cast<CapturingProcessor> (*_processors.begin()))) {
- return processor;
+ if (!_capturing_processor) {
+
+ _capturing_processor.reset (new CapturingProcessor (_session));
+ _capturing_processor->activate ();
+
+ {
+ Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+ configure_processors (0);
+ }
+
}
- // ...else add it
- processor.reset (new CapturingProcessor (_session));
- add_processor (processor, _processors.begin());
- return processor;
+ return _capturing_processor;
}
framecnt_t
-Route::update_total_latency ()
+Route::update_signal_latency ()
{
- framecnt_t old = _output->effective_latency();
- framecnt_t own_latency = _output->user_latency();
+ framecnt_t l = _output->user_latency();
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
if ((*i)->active ()) {
- own_latency += (*i)->signal_latency ();
+ l += (*i)->signal_latency ();
}
}
- DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal redirect latency = %2\n", _name, own_latency));
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l));
- _output->set_port_latency (own_latency);
-
- if (_output->user_latency() == 0) {
-
- /* this (virtual) function is used for pure Routes,
- not derived classes like AudioTrack. this means
- that the data processed here comes from an input
- port, not prerecorded material, and therefore we
- have to take into account any input latency.
- */
-
- own_latency += _input->signal_latency ();
- }
-
- if (old != own_latency) {
- _output->set_latency_delay (own_latency);
+ if (_signal_latency != l) {
+ _signal_latency = l;
signal_latency_changed (); /* EMIT SIGNAL */
}
- DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: input latency = %2 total = %3\n", _name, _input->signal_latency(), own_latency));
-
- return _output->effective_latency ();
+ return _signal_latency;
}
void
Route::set_user_latency (framecnt_t nframes)
{
_output->set_user_latency (nframes);
- _session.update_latency_compensation (false, false);
+ _session.update_latency_compensation ();
}
void
-Route::set_latency_delay (framecnt_t longest_session_latency)
+Route::set_latency_compensation (framecnt_t longest_session_latency)
{
framecnt_t old = _initial_delay;
- if (_output->effective_latency() < longest_session_latency) {
- _initial_delay = longest_session_latency - _output->effective_latency();
+ if (_signal_latency < longest_session_latency) {
+ _initial_delay = longest_session_latency - _signal_latency;
} else {
_initial_delay = 0;
}
+ DEBUG_TRACE (DEBUG::Latency, string_compose (
+ "%1: compensate for maximum latency of %2,"
+ "given own latency of %3, using initial delay of %4\n",
+ name(), longest_session_latency, _signal_latency, _initial_delay));
+
if (_initial_delay != old) {
initial_delay_changed (); /* EMIT SIGNAL */
}
void
Route::automation_snapshot (framepos_t now, bool force)
{
- _pannable->automation_snapshot (now, force);
+ if (_pannable) {
+ _pannable->automation_snapshot (now, force);
+ }
+
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
(*i)->automation_snapshot (now, force);
}
}
-Route::SoloControllable::SoloControllable (std::string name, Route& r)
- : AutomationControl (r.session(), Evoral::Parameter (SoloAutomation),
+Route::SoloControllable::SoloControllable (std::string name, boost::shared_ptr<Route> r)
+ : AutomationControl (r->session(), Evoral::Parameter (SoloAutomation),
boost::shared_ptr<AutomationList>(), name)
- , route (r)
+ , _route (r)
{
boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
set_list (gl);
Route::SoloControllable::set_value (double val)
{
bool bval = ((val >= 0.5f) ? true: false);
-# if 0
- this is how it should be done
boost::shared_ptr<RouteList> rl (new RouteList);
- rl->push_back (route);
+
+ boost::shared_ptr<Route> r = _route.lock ();
+ if (!r) {
+ return;
+ }
+
+ rl->push_back (r);
if (Config->get_solo_control_is_listen_control()) {
_session.set_listen (rl, bval);
} else {
_session.set_solo (rl, bval);
}
-#else
- route.set_solo (bval, this);
-#endif
}
double
-Route::SoloControllable::get_value (void) const
+Route::SoloControllable::get_value () const
{
+ boost::shared_ptr<Route> r = _route.lock ();
+ if (!r) {
+ return 0;
+ }
+
if (Config->get_solo_control_is_listen_control()) {
- return route.listening() ? 1.0f : 0.0f;
+ return r->listening_via_monitor() ? 1.0f : 0.0f;
} else {
- return route.self_soloed() ? 1.0f : 0.0f;
+ return r->self_soloed() ? 1.0f : 0.0f;
}
}
-Route::MuteControllable::MuteControllable (std::string name, Route& r)
- : AutomationControl (r.session(), Evoral::Parameter (MuteAutomation),
+Route::MuteControllable::MuteControllable (std::string name, boost::shared_ptr<Route> r)
+ : AutomationControl (r->session(), Evoral::Parameter (MuteAutomation),
boost::shared_ptr<AutomationList>(), name)
- , route (r)
+ , _route (r)
{
boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MuteAutomation)));
set_list (gl);
Route::MuteControllable::set_value (double val)
{
bool bval = ((val >= 0.5f) ? true: false);
-# if 0
- this is how it should be done
boost::shared_ptr<RouteList> rl (new RouteList);
- rl->push_back (route);
+
+ boost::shared_ptr<Route> r = _route.lock ();
+ if (!r) {
+ return;
+ }
+
+ rl->push_back (r);
_session.set_mute (rl, bval);
-#else
- route.set_mute (bval, this);
-#endif
}
double
-Route::MuteControllable::get_value (void) const
+Route::MuteControllable::get_value () const
{
- return route.muted() ? 1.0f : 0.0f;
+ boost::shared_ptr<Route> r = _route.lock ();
+ if (!r) {
+ return 0;
+ }
+
+ return r->muted() ? 1.0f : 0.0f;
}
void
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
(*i)->set_block_size (nframes);
}
-
+
_session.ensure_buffers (n_process_buffers ());
}
Route::shift (framepos_t pos, framecnt_t frames)
{
/* gain automation */
- {
-
boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
-
- XMLNode &before = gc->alist()->get_state ();
- gc->alist()->shift (pos, frames);
- XMLNode &after = gc->alist()->get_state ();
-
_session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
- }
+ {
+ boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
+
+ XMLNode &before = gc->alist()->get_state ();
+ gc->alist()->shift (pos, frames);
+ XMLNode &after = gc->alist()->get_state ();
+ _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
+ }
/* pan automation */
- {
- ControlSet::Controls& c (_pannable->controls());
-
- for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
-
boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
- if (pc) {
-
boost::shared_ptr<AutomationList> al = pc->alist();
- XMLNode& before = al->get_state ();
- al->shift (pos, frames);
- XMLNode& after = al->get_state ();
-
_session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
- }
- }
- }
+ if (_pannable) {
+ ControlSet::Controls& c (_pannable->controls());
+
+ for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
+ boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
+ if (pc) {
+ boost::shared_ptr<AutomationList> al = pc->alist();
+ XMLNode& before = al->get_state ();
+ al->shift (pos, frames);
+ XMLNode& after = al->get_state ();
+ _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
+ }
+ }
+ }
/* redirect automation */
{
set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
-
boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
- if (ac) {
-
boost::shared_ptr<AutomationList> al = ac->alist();
- XMLNode &before = al->get_state ();
- al->shift (pos, frames);
- XMLNode &after = al->get_state ();
-
_session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
- }
- }
- }
+ boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
+ if (ac) {
+ boost::shared_ptr<AutomationList> al = ac->alist();
+ XMLNode &before = al->get_state ();
+ al->shift (pos, frames);
+ XMLNode &after = al->get_state ();
+ _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
+ }
+ }
+ }
}
}
ret = (_input->set_name(name) && _output->set_name(name));
if (ret) {
+ /* rename the main outs. Leave other IO processors
+ * with whatever name they already have, because its
+ * just fine as it is (it will not contain the route
+ * name if its a port insert, port send or port return).
+ */
+
+ if (_main_outs) {
+ if (_main_outs->set_name (name)) {
+ /* XXX returning false here is stupid because
+ we already changed the route name.
+ */
+ return false;
+ }
+ }
+ }
- Glib::RWLock::ReaderLock lm (_processor_lock);
+ return ret;
+}
- for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+/** Set the name of a route in an XML description.
+ * @param node XML <Route> node to set the name in.
+ * @param name New name.
+ */
+void
+Route::set_name_in_state (XMLNode& node, string const & name)
+{
+ node.add_property (X_("name"), name);
- /* rename all I/O processors that have inputs or outputs */
+ XMLNodeList children = node.children();
+ for (XMLNodeIterator i = children.begin(); i != children.end(); ++i) {
+
+ if ((*i)->name() == X_("IO")) {
- boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
+ IO::set_name_in_state (**i, name);
- if (iop && (iop->output() || iop->input())) {
- if (!iop->set_name (name)) {
- ret = false;
- }
+ } else if ((*i)->name() == X_("Processor")) {
+
+ XMLProperty* role = (*i)->property (X_("role"));
+ if (role && role->value() == X_("Main")) {
+ (*i)->add_property (X_("name"), name);
}
- }
+
+ } else if ((*i)->name() == X_("Diskstream")) {
+ (*i)->add_property (X_("playlist"), string_compose ("%1.1", name).c_str());
+ (*i)->add_property (X_("name"), name);
+
+ }
}
-
- return ret;
}
boost::shared_ptr<Send>
if (_phase_invert[c] != yn) {
_phase_invert[c] = yn;
phase_invert_changed (); /* EMIT SIGNAL */
- _session.set_dirty ();
+ _session.set_dirty ();
}
}
if (_phase_invert != p) {
_phase_invert = p;
phase_invert_changed (); /* EMIT SIGNAL */
- _session.set_dirty ();
+ _session.set_dirty ();
}
}
_route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
return;
}
-
+
if (_active != yn) {
_active = yn;
_input->set_active (yn);
boost::shared_ptr<Panner>
Route::panner() const
{
- /* may be null ! */
+ /* may be null ! */
return _main_outs->panner_shell()->panner();
}
if (n-- == 0) {
return *i;
}
- }
+ }
}
return boost::shared_ptr<Processor> ();
bool
Route::has_io_processor_named (const string& name)
{
- Glib::RWLock::ReaderLock lm (_processor_lock);
- ProcessorList::iterator i;
-
- for (i = _processors.begin(); i != _processors.end(); ++i) {
- if (boost::dynamic_pointer_cast<Send> (*i) ||
-
boost::dynamic_pointer_cast<PortInsert> (*i)) {
- if ((*i)->name() == name) {
- return true;
- }
- }
- }
-
- return false;
+ Glib::RWLock::ReaderLock lm (_processor_lock);
+ ProcessorList::iterator i;
+
+ for (i = _processors.begin(); i != _processors.end(); ++i) {
+ if (boost::dynamic_pointer_cast<Send> (*i) ||
+ boost::dynamic_pointer_cast<PortInsert> (*i)) {
+ if ((*i)->name() == name) {
+ return true;
+ }
+ }
+ }
+
+ return false;
}
MuteMaster::MutePoint
Route::unknown_processors () const
{
list<string> p;
-
+
Glib::RWLock::ReaderLock lm (_processor_lock);
for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
return p;
}
-void
-Route::set_latency_ranges (bool playback) const
+
+framecnt_t
+Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecnt_t our_latency) const
+{
+ /* we assume that all our input ports feed all our output ports. its not
+ universally true, but the alternative is way too corner-case to worry about.
+ */
+
+ jack_latency_range_t all_connections;
+
+ if (from.empty()) {
+ all_connections.min = 0;
+ all_connections.max = 0;
+ } else {
+ all_connections.min = ~((jack_nframes_t) 0);
+ all_connections.max = 0;
+
+ /* iterate over all "from" ports and determine the latency range for all of their
+ connections to the "outside" (outside of this Route).
+ */
+
+ for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
+
+ jack_latency_range_t range;
+
+ p->get_connected_latency_range (range, playback);
+
+ all_connections.min = min (all_connections.min, range.min);
+ all_connections.max = max (all_connections.max, range.max);
+ }
+ }
+
+ /* set the "from" port latencies to the max/min range of all their connections */
+
+ for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
+ p->set_private_latency_range (all_connections, playback);
+ }
+
+ /* set the ports "in the direction of the flow" to the same value as above plus our own signal latency */
+
+ all_connections.min += our_latency;
+ all_connections.max += our_latency;
+
+ for (PortSet::iterator p = to.begin(); p != to.end(); ++p) {
+ p->set_private_latency_range (all_connections, playback);
+ }
+
+ return all_connections.max;
+}
+
+framecnt_t
+Route::set_private_port_latencies (bool playback) const
{
framecnt_t own_latency = 0;
- /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD OR
- LATENCY CALLBACK
- */
+ /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD
+ OR LATENCY CALLBACK.
+
+ This is called (early) from the latency callback. It computes the REAL
+ latency associated with each port and stores the result as the "private"
+ latency of the port. A later call to Route::set_public_port_latencies()
+ sets all ports to the same value to reflect the fact that we do latency
+ compensation and so all signals are delayed by the same amount as they
+ flow through ardour.
+ */
for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
if ((*i)->active ()) {
}
}
- if (playback) {
- update_port_latencies (_input->ports (), _output->ports (), true, own_latency);
- } else {
- update_port_latencies (_output->ports (), _input->ports (), false, own_latency);
- }
-}
-
-void
-Route::update_port_latencies (const PortSet& operands, const PortSet& feeders, bool playback, framecnt_t our_latency) const
-{
-#ifdef HAVE_JACK_NEW_LATENCY
-
- /* we assume that all our input ports feed all our output ports. its not
- universally true, but the alternative is way too corner-case to worry about.
- */
-
- jack_latency_range_t all_connections;
-
- all_connections.min = ~((jack_nframes_t) 0);
- all_connections.max = 0;
-
- /* iterate over all feeder ports and determine their relevant latency, taking
- the maximum and minimum across all of them.
- */
-
- for (PortSet::const_iterator p = feeders.begin(); p != feeders.end(); ++p) {
-
- jack_latency_range_t range;
-
- p->get_connected_latency_range (range, playback);
-
- all_connections.min = min (all_connections.min, range.min);
- all_connections.max = max (all_connections.max, range.max);
- }
-
- all_connections.min += our_latency;
- all_connections.max += our_latency;
-
- for (PortSet::const_iterator p = operands.begin(); p != operands.end(); ++p) {
-
- p->set_latency_range (all_connections, playback);
-
- DEBUG_TRACE (DEBUG::Latency, string_compose ("Port %1 %5 latency range %2 .. %3 + %4\n",
- p->name(),
- all_connections.min,
- all_connections.max,
- our_latency,
- (playback ? "PLAYBACK" : "CAPTURE")));
- }
+ if (playback) {
+ /* playback: propagate latency from "outside the route" to outputs to inputs */
+ return update_port_latencies (_output->ports (), _input->ports (), true, own_latency);
+ } else {
+ /* capture: propagate latency from "outside the route" to inputs to outputs */
+ return update_port_latencies (_input->ports (), _output->ports (), false, own_latency);
+ }
+}
+
+void
+Route::set_public_port_latencies (framecnt_t value, bool playback) const
+{
+ /* this is called to set the JACK-visible port latencies, which take
+ latency compensation into account.
+ */
+
+ jack_latency_range_t range;
+
+ range.min = value;
+ range.max = value;
+
+ {
+ const PortSet& ports (_input->ports());
+ for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
+ p->set_public_latency_range (range, playback);
+ }
+ }
+
+ {
+ const PortSet& ports (_output->ports());
+ for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
+ p->set_public_latency_range (range, playback);
+ }
+ }
+}
+
+/** Put the invisible processors in the right place in _processors.
+ * Must be called with a writer lock on _processor_lock held.
+ */
+void
+Route::setup_invisible_processors ()
+{
+#ifndef NDEBUG
+ Glib::RWLock::WriterLock lm (_processor_lock, Glib::TRY_LOCK);
+ assert (!lm.locked ());
#endif
+
+ if (!_main_outs) {
+ /* too early to be doing this stuff */
+ return;
+ }
+
+ /* we'll build this new list here and then use it */
+
+ ProcessorList new_processors;
+
+ /* find visible processors */
+
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ if ((*i)->display_to_user ()) {
+ new_processors.push_back (*i);
+ }
+ }
+
+ /* find the amp */
+
+ ProcessorList::iterator amp = new_processors.begin ();
+ while (amp != new_processors.end() && boost::dynamic_pointer_cast<Amp> (*amp) == 0) {
+ ++amp;
+ }
+
+ assert (amp != _processors.end ());
+
+ /* and the processor after the amp */
+
+ ProcessorList::iterator after_amp = amp;
+ ++after_amp;
+
+ /* METER */
+
+ if (_meter) {
+ switch (_meter_point) {
+ case MeterInput:
+ assert (!_meter->display_to_user ());
+ new_processors.push_front (_meter);
+ break;
+ case MeterPreFader:
+ assert (!_meter->display_to_user ());
+ new_processors.insert (amp, _meter);
+ break;
+ case MeterPostFader:
+ /* do nothing here */
+ break;
+ case MeterOutput:
+ /* do nothing here */
+ break;
+ case MeterCustom:
+ /* the meter is visible, so we don't touch it here */
+ break;
+ }
+ }
+
+ /* MAIN OUTS */
+
+ assert (_main_outs);
+ assert (!_main_outs->display_to_user ());
+ new_processors.push_back (_main_outs);
+
+ /* iterator for the main outs */
+
+ ProcessorList::iterator main = new_processors.end();
+ --main;
+
+ /* OUTPUT METERING */
+
+ if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
+ assert (!_meter->display_to_user ());
+
+ /* add the processor just before or just after the main outs */
+
+ ProcessorList::iterator meter_point = main;
+
+ if (_meter_point == MeterOutput) {
+ ++meter_point;
+ }
+ new_processors.insert (meter_point, _meter);
+ }
+
+ /* MONITOR SEND */
+
+ if (_monitor_send && !is_monitor ()) {
+ assert (!_monitor_send->display_to_user ());
+ if (Config->get_solo_control_is_listen_control()) {
+ switch (Config->get_listen_position ()) {
+ case PreFaderListen:
+ switch (Config->get_pfl_position ()) {
+ case PFLFromBeforeProcessors:
+ new_processors.push_front (_monitor_send);
+ break;
+ case PFLFromAfterProcessors:
+ new_processors.insert (amp, _monitor_send);
+ break;
+ }
+ _monitor_send->set_can_pan (false);
+ break;
+ case AfterFaderListen:
+ switch (Config->get_afl_position ()) {
+ case AFLFromBeforeProcessors:
+ new_processors.insert (after_amp, _monitor_send);
+ break;
+ case AFLFromAfterProcessors:
+ new_processors.insert (new_processors.end(), _monitor_send);
+ break;
+ }
+ _monitor_send->set_can_pan (true);
+ break;
+ }
+ } else {
+ new_processors.insert (new_processors.end(), _monitor_send);
+ _monitor_send->set_can_pan (false);
+ }
+ }
+
+ /* MONITOR CONTROL */
+
+ if (_monitor_control && is_monitor ()) {
+ assert (!_monitor_control->display_to_user ());
+ new_processors.push_front (_monitor_control);
+ }
+
+ /* INTERNAL RETURN */
+
+ /* doing this here means that any monitor control will come just after
+ the return.
+ */
+
+ if (_intreturn) {
+ assert (!_intreturn->display_to_user ());
+ new_processors.push_front (_intreturn);
+ }
+
+ /* EXPORT PROCESSOR */
+
+ if (_capturing_processor) {
+ assert (!_capturing_processor->display_to_user ());
+ new_processors.push_front (_capturing_processor);
+ }
+
+ _processors = new_processors;
+
+ DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
+ }
+}
+
+void
+Route::unpan ()
+{
+ Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+ Glib::RWLock::ReaderLock lp (_processor_lock);
+
+ _pannable.reset ();
+
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery>(*i);
+ if (d) {
+ d->unpan ();
+ }
+ }
+}
+
+/** If the meter point is `Custom', make a note of where the meter is.
+ * This is so that if the meter point is subsequently set to something else,
+ * and then back to custom, we can put the meter back where it was last time
+ * custom was enabled.
+ *
+ * Must be called with the _processor_lock held.
+ */
+void
+Route::maybe_note_meter_position ()
+{
+ if (_meter_point != MeterCustom) {
+ return;
+ }
+
+ _custom_meter_position_noted = true;
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ if (boost::dynamic_pointer_cast<PeakMeter> (*i)) {
+ ProcessorList::iterator j = i;
+ ++j;
+ if (j != _processors.end ()) {
+ _processor_after_last_custom_meter = *j;
+ _last_custom_meter_was_at_end = false;
+ } else {
+ _last_custom_meter_was_at_end = true;
+ }
+ }
+ }
+}
+
+boost::shared_ptr<Processor>
+Route::processor_by_id (PBD::ID id) const
+{
+ Glib::RWLock::ReaderLock lm (_processor_lock);
+ for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ if ((*i)->id() == id) {
+ return *i;
+ }
+ }
+
+ return boost::shared_ptr<Processor> ();
+}
+
+/** @return the monitoring state, or in other words what data we are pushing
+ * into the route (data from the inputs, data from disk or silence)
+ */
+MonitorState
+Route::monitoring_state () const
+{
+ return MonitoringInput;
+}
+
+/** @return what we should be metering; either the data coming from the input
+ * IO or the data that is flowing through the route.
+ */
+MeterState
+Route::metering_state () const
+{
+ return MeteringRoute;
+}
+
+bool
+Route::has_external_redirects () const
+{
+ for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
+
+ /* ignore inactive processors and obviously ignore the main
+ * outs since everything has them and we don't care.
+ */
+
+ if ((*i)->active() && (*i) != _main_outs && (*i)->does_routing()) {
+ return true;;
+ }
+ }
+
+ return false;
+}
+
+boost::shared_ptr<Processor>
+Route::the_instrument () const
+{
+ Glib::RWLock::WriterLock lm (_processor_lock);
+ for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ if ((*i)->input_streams().n_midi() > 0 &&
+ (*i)->output_streams().n_audio() > 0) {
+ return (*i);
+ }
+ }
+ return boost::shared_ptr<Processor>();
}
projects / ardour.git / blobdiff