#include <ardour/audioengine.h>
#include <ardour/route.h>
#include <ardour/buffer.h>
-#include <ardour/insert.h>
+#include <ardour/processor.h>
#include <ardour/plugin_insert.h>
#include <ardour/port_insert.h>
#include <ardour/send.h>
using namespace PBD;
uint32_t Route::order_key_cnt = 0;
-
+sigc::signal<void> Route::SyncOrderKeys;
Route::Route (Session& sess, string name, int input_min, int input_max, int output_min, int output_max, Flag flg, DataType default_type)
: IO (sess, name, input_min, input_max, output_min, output_max, default_type),
_flags (flg),
- _solo_control (X_("solo"), *this, ToggleControllable::SoloControl),
- _mute_control (X_("mute"), *this, ToggleControllable::MuteControl)
+ _solo_control (new ToggleControllable (X_("solo"), *this, ToggleControllable::SoloControl)),
+ _mute_control (new ToggleControllable (X_("mute"), *this, ToggleControllable::MuteControl))
{
init ();
}
Route::Route (Session& sess, const XMLNode& node, DataType default_type)
: IO (sess, *node.child ("IO"), default_type),
- _solo_control (X_("solo"), *this, ToggleControllable::SoloControl),
- _mute_control (X_("mute"), *this, ToggleControllable::MuteControl)
+ _solo_control (new ToggleControllable (X_("solo"), *this, ToggleControllable::SoloControl)),
+ _mute_control (new ToggleControllable (X_("mute"), *this, ToggleControllable::MuteControl))
{
init ();
_set_state (node, false);
void
Route::init ()
{
- insert_max_outs.reset();
+ processor_max_outs.reset();
_muted = false;
_soloed = false;
_solo_safe = false;
_initial_delay = 0;
_roll_delay = 0;
_own_latency = 0;
+ _user_latency = 0;
_have_internal_generator = false;
_declickable = false;
_pending_declick = true;
Route::~Route ()
{
- clear_inserts (PreFader);
- clear_inserts (PostFader);
+ clear_processors (PreFader);
+ clear_processors (PostFader);
for (OrderKeys::iterator i = order_keys.begin(); i != order_keys.end(); ++i) {
free ((void*)(i->first));
Route::set_order_key (const char* name, long n)
{
order_keys[strdup(name)] = n;
+
+ if (Config->get_sync_all_route_ordering()) {
+ for (OrderKeys::iterator x = order_keys.begin(); x != order_keys.end(); ++x) {
+ x->second = n;
+ }
+ }
+
_session.set_dirty ();
}
+void
+Route::sync_order_keys ()
+{
+ uint32_t key;
+
+ if (order_keys.empty()) {
+ return;
+ }
+
+ OrderKeys::iterator x = order_keys.begin();
+ key = x->second;
+ ++x;
+
+ for (; x != order_keys.end(); ++x) {
+ x->second = key;
+ }
+}
+
void
Route::inc_gain (gain_t fraction, void *src)
{
if (_mix_group->is_relative()) {
-
- gain_t usable_gain = gain();
+ gain_t usable_gain = gain();
if (usable_gain < 0.000001f) {
- usable_gain=0.000001f;
+ usable_gain = 0.000001f;
}
gain_t delta = val;
if (delta < 0.000001f) {
- delta=0.000001f;
+ delta = 0.000001f;
}
delta -= usable_gain;
- if (delta == 0.0f) return;
+ if (delta == 0.0f)
+ return;
gain_t factor = delta / usable_gain;
if (factor > 0.0f) {
factor = _mix_group->get_max_factor(factor);
if (factor == 0.0f) {
- gain_changed (src);
+ _gain_control->Changed(); /* EMIT SIGNAL */
return;
}
} else {
factor = _mix_group->get_min_factor(factor);
if (factor == 0.0f) {
- gain_changed (src);
+ _gain_control->Changed(); /* EMIT SIGNAL */
return;
}
}
void
Route::process_output_buffers (BufferSet& bufs,
nframes_t start_frame, nframes_t end_frame,
- nframes_t nframes, nframes_t offset, bool with_inserts, int declick,
+ nframes_t nframes, nframes_t offset, bool with_processors, int declick,
bool meter)
{
// This is definitely very audio-only for now
assert(_default_type == DataType::AUDIO);
- InsertList::iterator i;
+ ProcessorList::iterator i;
bool post_fader_work = false;
bool mute_declick_applied = false;
gain_t dmg, dsg, dg;
declick = _pending_declick;
{
- Glib::Mutex::Lock cm (control_outs_lock, Glib::TRY_LOCK);
+ Glib::Mutex::Lock cm (_control_outs_lock, Glib::TRY_LOCK);
if (cm.locked()) {
co = _control_outs;
-------------------------------------------------------------------------------------------------- */
if (declick > 0) {
- Amp::run (bufs, nframes, 0.0, 1.0, false);
+ Amp::run_in_place (bufs, nframes, 0.0, 1.0, false);
_pending_declick = 0;
} else if (declick < 0) {
- Amp::run (bufs, nframes, 1.0, 0.0, false);
+ Amp::run_in_place (bufs, nframes, 1.0, 0.0, false);
_pending_declick = 0;
} else {
/* no global declick */
if (solo_gain != dsg) {
- Amp::run (bufs, nframes, solo_gain, dsg, false);
+ Amp::run_in_place (bufs, nframes, solo_gain, dsg, false);
solo_gain = dsg;
}
}
-------------------------------------------------------------------------------------------------- */
if (meter && (_meter_point == MeterInput)) {
- _meter->run(bufs, start_frame, end_frame, nframes, offset);
+ _meter->run_in_place(bufs, start_frame, end_frame, nframes, offset);
}
if (!_soloed && _mute_affects_pre_fader && (mute_gain != dmg)) {
- Amp::run (bufs, nframes, mute_gain, dmg, false);
+ Amp::run_in_place (bufs, nframes, mute_gain, dmg, false);
mute_gain = dmg;
mute_declick_applied = true;
}
PRE-FADER REDIRECTS
-------------------------------------------------------------------------------------------------- */
- if (with_inserts) {
- Glib::RWLock::ReaderLock rm (insert_lock, Glib::TRY_LOCK);
+ if (with_processors) {
+ Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
if (rm.locked()) {
if (mute_gain > 0 || !_mute_affects_pre_fader) {
- for (i = _inserts.begin(); i != _inserts.end(); ++i) {
+ for (i = _processors.begin(); i != _processors.end(); ++i) {
switch ((*i)->placement()) {
case PreFader:
- (*i)->run (bufs, start_frame, end_frame, nframes, offset);
+ (*i)->run_in_place (bufs, start_frame, end_frame, nframes, offset);
break;
case PostFader:
post_fader_work = true;
}
}
} else {
- for (i = _inserts.begin(); i != _inserts.end(); ++i) {
+ for (i = _processors.begin(); i != _processors.end(); ++i) {
switch ((*i)->placement()) {
case PreFader:
(*i)->silence (nframes, offset);
bufs.set_count(pre_fader_streams());
if (!_soloed && (mute_gain != dmg) && !mute_declick_applied && _mute_affects_post_fader) {
- Amp::run (bufs, nframes, mute_gain, dmg, false);
+ Amp::run_in_place (bufs, nframes, mute_gain, dmg, false);
mute_gain = dmg;
mute_declick_applied = true;
}
-------------------------------------------------------------------------------------------------- */
if (meter && (_meter_point == MeterPreFader)) {
- _meter->run(bufs, start_frame, end_frame, nframes, offset);
+ _meter->run_in_place(bufs, start_frame, end_frame, nframes, offset);
}
// OR recording
- // h/w monitoring not in use
-
- (!Config->get_monitoring_model() == HardwareMonitoring &&
-
// AND software monitoring required
- Config->get_monitoring_model() == SoftwareMonitoring)) {
+ Config->get_monitoring_model() == SoftwareMonitoring) {
if (apply_gain_automation) {
if (_gain != dg) {
- Amp::run (bufs, nframes, _gain, dg, _phase_invert);
+ Amp::run_in_place (bufs, nframes, _gain, dg, _phase_invert);
_gain = dg;
} else if (_gain != 0 && (_phase_invert || _gain != 1.0)) {
POST-FADER REDIRECTS
-------------------------------------------------------------------------------------------------- */
- /* note that post_fader_work cannot be true unless with_inserts was also true, so don't test both */
+ /* note that post_fader_work cannot be true unless with_processors was also true, so don't test both */
if (post_fader_work) {
- Glib::RWLock::ReaderLock rm (insert_lock, Glib::TRY_LOCK);
+ Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
if (rm.locked()) {
if (mute_gain > 0 || !_mute_affects_post_fader) {
- for (i = _inserts.begin(); i != _inserts.end(); ++i) {
+ for (i = _processors.begin(); i != _processors.end(); ++i) {
switch ((*i)->placement()) {
case PreFader:
break;
case PostFader:
- (*i)->run (bufs, start_frame, end_frame, nframes, offset);
+ (*i)->run_in_place (bufs, start_frame, end_frame, nframes, offset);
break;
}
}
} else {
- for (i = _inserts.begin(); i != _inserts.end(); ++i) {
+ for (i = _processors.begin(); i != _processors.end(); ++i) {
switch ((*i)->placement()) {
case PreFader:
break;
}
if (!_soloed && (mute_gain != dmg) && !mute_declick_applied && _mute_affects_control_outs) {
- Amp::run (bufs, nframes, mute_gain, dmg, false);
+ Amp::run_in_place (bufs, nframes, mute_gain, dmg, false);
mute_gain = dmg;
mute_declick_applied = true;
}
----------------------------------------------------------------------*/
if (!_soloed && (mute_gain != dmg) && !mute_declick_applied && _mute_affects_main_outs) {
- Amp::run (bufs, nframes, mute_gain, dmg, false);
+ Amp::run_in_place (bufs, nframes, mute_gain, dmg, false);
mute_gain = dmg;
mute_declick_applied = true;
}
) {
/* don't use Route::silence() here, because that causes
- all outputs (sends, port inserts, etc. to be silent).
+ all outputs (sends, port processors, etc. to be silent).
*/
if (_meter_point == MeterPostFader) {
if ((_gain == 0 && !apply_gain_automation) || dmg == 0) {
_meter->reset();
} else {
- _meter->run(output_buffers(), start_frame, end_frame, nframes, offset);
+ _meter->run_in_place(output_buffers(), start_frame, end_frame, nframes, offset);
}
}
}
ChanCount
Route::n_process_buffers ()
{
- return max (n_inputs(), insert_max_outs);
+ return max (n_inputs(), processor_max_outs);
}
void
collect_input (bufs, nframes, offset);
if (meter_first) {
- _meter->run(bufs, start_frame, end_frame, nframes, offset);
+ _meter->run_in_place(bufs, start_frame, end_frame, nframes, offset);
meter_first = false;
}
if (_soloed != yn) {
_soloed = yn;
solo_changed (src); /* EMIT SIGNAL */
- _solo_control.Changed (); /* EMIT SIGNAL */
+ _solo_control->Changed (); /* EMIT SIGNAL */
}
}
_muted = yn;
mute_changed (src); /* EMIT SIGNAL */
- _mute_control.Changed (); /* EMIT SIGNAL */
+ _mute_control->Changed (); /* EMIT SIGNAL */
Glib::Mutex::Lock lm (declick_lock);
desired_mute_gain = (yn?0.0f:1.0f);
}
int
-Route::add_insert (boost::shared_ptr<Insert> insert, InsertStreams* err)
+Route::add_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err)
{
- ChanCount old_rmo = insert_max_outs;
+ ChanCount old_rmo = processor_max_outs;
if (!_session.engine().connected()) {
return 1;
}
{
- Glib::RWLock::WriterLock lm (insert_lock);
+ Glib::RWLock::WriterLock lm (_processor_lock);
boost::shared_ptr<PluginInsert> pi;
boost::shared_ptr<PortInsert> porti;
- //insert->set_default_type(_default_type);
+ //processor->set_default_type(_default_type);
- if ((pi = boost::dynamic_pointer_cast<PluginInsert>(insert)) != 0) {
+ if ((pi = boost::dynamic_pointer_cast<PluginInsert>(processor)) != 0) {
pi->set_count (1);
if (pi->natural_input_streams() == ChanCount::ZERO) {
}
- _inserts.push_back (insert);
+ _processors.push_back (processor);
- // Set up insert list channels. This will set insert->[input|output]_streams(),
+ // Set up processor list channels. This will set processor->[input|output]_streams(),
// configure redirect ports properly, etc.
if (_reset_plugin_counts (err)) {
- _inserts.pop_back ();
+ _processors.pop_back ();
_reset_plugin_counts (0); // it worked before we tried to add it ...
return -1;
}
// Ensure peak vector sizes before the plugin is activated
- ChanCount potential_max_streams = max(insert->input_streams(), insert->output_streams());
+ ChanCount potential_max_streams = max(processor->input_streams(), processor->output_streams());
_meter->configure_io(potential_max_streams, potential_max_streams);
- insert->activate ();
- insert->ActiveChanged.connect (bind (mem_fun (_session, &Session::update_latency_compensation), false, false));
+ processor->activate ();
+ processor->ActiveChanged.connect (bind (mem_fun (_session, &Session::update_latency_compensation), false, false));
+
+ _user_latency = 0;
}
- if (insert_max_outs != old_rmo || old_rmo == ChanCount::ZERO) {
+ if (processor_max_outs != old_rmo || old_rmo == ChanCount::ZERO) {
reset_panner ();
}
- inserts_changed (); /* EMIT SIGNAL */
+ processors_changed (); /* EMIT SIGNAL */
return 0;
}
int
-Route::add_inserts (const InsertList& others, InsertStreams* err)
+Route::add_processors (const ProcessorList& others, ProcessorStreams* err)
{
- ChanCount old_rmo = insert_max_outs;
+ ChanCount old_rmo = processor_max_outs;
if (!_session.engine().connected()) {
return 1;
}
{
- Glib::RWLock::WriterLock lm (insert_lock);
+ Glib::RWLock::WriterLock lm (_processor_lock);
- InsertList::iterator existing_end = _inserts.end();
+ ProcessorList::iterator existing_end = _processors.end();
--existing_end;
ChanCount potential_max_streams;
- for (InsertList::const_iterator i = others.begin(); i != others.end(); ++i) {
+ for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
boost::shared_ptr<PluginInsert> pi;
// Ensure peak vector sizes before the plugin is activated
_meter->configure_io(potential_max_streams, potential_max_streams);
- _inserts.push_back (*i);
+ _processors.push_back (*i);
if (_reset_plugin_counts (err)) {
++existing_end;
- _inserts.erase (existing_end, _inserts.end());
+ _processors.erase (existing_end, _processors.end());
_reset_plugin_counts (0); // it worked before we tried to add it ...
return -1;
}
(*i)->activate ();
(*i)->ActiveChanged.connect (bind (mem_fun (_session, &Session::update_latency_compensation), false, false));
}
+
+ _user_latency = 0;
}
- if (insert_max_outs != old_rmo || old_rmo == ChanCount::ZERO) {
+ if (processor_max_outs != old_rmo || old_rmo == ChanCount::ZERO) {
reset_panner ();
}
- inserts_changed (); /* EMIT SIGNAL */
+ processors_changed (); /* EMIT SIGNAL */
return 0;
}
-/** Turn off all inserts with a given placement
- * @param p Placement of inserts to disable
+/** Turn off all processors with a given placement
+ * @param p Placement of processors to disable
*/
void
-Route::disable_inserts (Placement p)
+Route::disable_processors (Placement p)
{
- Glib::RWLock::ReaderLock lm (insert_lock);
+ Glib::RWLock::ReaderLock lm (_processor_lock);
- for (InsertList::iterator i = _inserts.begin(); i != _inserts.end(); ++i) {
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
if ((*i)->placement() == p) {
(*i)->set_active (false);
}
*/
void
-Route::disable_inserts ()
+Route::disable_processors ()
{
- Glib::RWLock::ReaderLock lm (insert_lock);
+ Glib::RWLock::ReaderLock lm (_processor_lock);
- for (InsertList::iterator i = _inserts.begin(); i != _inserts.end(); ++i) {
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
(*i)->set_active (false);
}
void
Route::disable_plugins (Placement p)
{
- Glib::RWLock::ReaderLock lm (insert_lock);
+ Glib::RWLock::ReaderLock lm (_processor_lock);
- for (InsertList::iterator i = _inserts.begin(); i != _inserts.end(); ++i) {
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
if (boost::dynamic_pointer_cast<PluginInsert> (*i) && (*i)->placement() == p) {
(*i)->set_active (false);
}
void
Route::disable_plugins ()
{
- Glib::RWLock::ReaderLock lm (insert_lock);
+ Glib::RWLock::ReaderLock lm (_processor_lock);
- for (InsertList::iterator i = _inserts.begin(); i != _inserts.end(); ++i) {
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
(*i)->set_active (false);
}
void
Route::ab_plugins (bool forward)
{
- Glib::RWLock::ReaderLock lm (insert_lock);
+ Glib::RWLock::ReaderLock lm (_processor_lock);
if (forward) {
we go the other way, we will revert them
*/
- for (InsertList::iterator i = _inserts.begin(); i != _inserts.end(); ++i) {
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
continue;
}
/* backward = if the redirect was marked to go active on the next ab, do so */
- for (InsertList::iterator i = _inserts.begin(); i != _inserts.end(); ++i) {
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
continue;
ChanCount
Route::pre_fader_streams() const
{
- boost::shared_ptr<Insert> insert;
+ boost::shared_ptr<Processor> processor;
// Find the last pre-fader redirect
- for (InsertList::const_iterator i = _inserts.begin(); i != _inserts.end(); ++i) {
+ for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
if ((*i)->placement() == PreFader) {
- insert = *i;
+ processor = *i;
}
}
- if (insert) {
- return insert->output_streams();
+ if (processor) {
+ return processor->output_streams();
} else {
return n_inputs ();
}
}
-/** Remove inserts with a given placement.
- * @param p Placement of inserts to remove.
+/** Remove processors with a given placement.
+ * @param p Placement of processors to remove.
*/
void
-Route::clear_inserts (Placement p)
+Route::clear_processors (Placement p)
{
- const ChanCount old_rmo = insert_max_outs;
+ const ChanCount old_rmo = processor_max_outs;
if (!_session.engine().connected()) {
return;
}
{
- Glib::RWLock::WriterLock lm (insert_lock);
- InsertList new_list;
+ Glib::RWLock::WriterLock lm (_processor_lock);
+ ProcessorList new_list;
- for (InsertList::iterator i = _inserts.begin(); i != _inserts.end(); ++i) {
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
if ((*i)->placement() == p) {
/* it's the placement we want to get rid of */
(*i)->drop_references ();
}
}
- _inserts = new_list;
+ _processors = new_list;
}
/* FIXME: can't see how this test can ever fire */
- if (insert_max_outs != old_rmo) {
+ if (processor_max_outs != old_rmo) {
reset_panner ();
}
- insert_max_outs.reset();
+ processor_max_outs.reset();
_have_internal_generator = false;
- inserts_changed (); /* EMIT SIGNAL */
+ processors_changed (); /* EMIT SIGNAL */
}
int
-Route::remove_insert (boost::shared_ptr<Insert> insert, InsertStreams* err)
+Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err)
{
- ChanCount old_rmo = insert_max_outs;
+ ChanCount old_rmo = processor_max_outs;
if (!_session.engine().connected()) {
return 1;
}
- insert_max_outs.reset();
+ processor_max_outs.reset();
{
- Glib::RWLock::WriterLock lm (insert_lock);
- InsertList::iterator i;
+ Glib::RWLock::WriterLock lm (_processor_lock);
+ ProcessorList::iterator i;
bool removed = false;
- for (i = _inserts.begin(); i != _inserts.end(); ++i) {
- if (*i == insert) {
+ for (i = _processors.begin(); i != _processors.end(); ++i) {
+ if (*i == processor) {
- InsertList::iterator tmp;
+ ProcessorList::iterator tmp;
/* move along, see failure case for reset_plugin_counts()
- where we may need to reinsert the insert.
+ where we may need to reprocessor the processor.
*/
tmp = i;
run.
*/
- boost::shared_ptr<Redirect> redirect;
+ boost::shared_ptr<IOProcessor> redirect;
- if ((redirect = boost::dynamic_pointer_cast<Redirect> (*i)) != 0) {
+ if ((redirect = boost::dynamic_pointer_cast<IOProcessor> (*i)) != 0) {
redirect->io()->disconnect_inputs (this);
redirect->io()->disconnect_outputs (this);
}
- _inserts.erase (i);
+ _processors.erase (i);
i = tmp;
removed = true;
break;
}
+
+ _user_latency = 0;
}
if (!removed) {
if (_reset_plugin_counts (err)) {
/* get back to where we where */
- _inserts.insert (i, insert);
+ _processors.insert (i, processor);
/* we know this will work, because it worked before :) */
_reset_plugin_counts (0);
return -1;
bool foo = false;
- for (i = _inserts.begin(); i != _inserts.end(); ++i) {
+ for (i = _processors.begin(); i != _processors.end(); ++i) {
boost::shared_ptr<PluginInsert> pi;
if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
_have_internal_generator = foo;
}
- if (old_rmo != insert_max_outs) {
+ if (old_rmo != processor_max_outs) {
reset_panner ();
}
- insert->drop_references ();
+ processor->drop_references ();
- inserts_changed (); /* EMIT SIGNAL */
+ processors_changed (); /* EMIT SIGNAL */
return 0;
}
int
-Route::reset_plugin_counts (InsertStreams* err)
+Route::reset_plugin_counts (ProcessorStreams* err)
{
- Glib::RWLock::WriterLock lm (insert_lock);
+ Glib::RWLock::WriterLock lm (_processor_lock);
return _reset_plugin_counts (err);
}
int
-Route::_reset_plugin_counts (InsertStreams* err)
+Route::_reset_plugin_counts (ProcessorStreams* err)
{
- InsertList::iterator r;
- map<Placement,list<InsertCount> > insert_map;
+ ProcessorList::iterator r;
+ map<Placement,list<ProcessorCount> > processor_map;
ChanCount initial_streams;
/* Process each placement in order, checking to see if we
can really do what has been requested.
*/
- /* divide inserts up by placement so we get the signal flow
- properly modelled. we need to do this because the _inserts
+ /* divide processors up by placement so we get the signal flow
+ properly modelled. we need to do this because the _processors
list is not sorted by placement
*/
/* ... but it should/will be... */
- for (r = _inserts.begin(); r != _inserts.end(); ++r) {
+ for (r = _processors.begin(); r != _processors.end(); ++r) {
- boost::shared_ptr<Insert> insert;
+ boost::shared_ptr<Processor> processor;
- if ((insert = boost::dynamic_pointer_cast<Insert>(*r)) != 0) {
- insert_map[insert->placement()].push_back (InsertCount (insert));
+ if ((processor = boost::dynamic_pointer_cast<Processor>(*r)) != 0) {
+ processor_map[processor->placement()].push_back (ProcessorCount (processor));
}
}
/* A: PreFader */
- if ( ! check_some_plugin_counts (insert_map[PreFader], n_inputs (), err)) {
+ if ( ! check_some_plugin_counts (processor_map[PreFader], n_inputs (), err)) {
return -1;
}
/* B: PostFader */
- if ( ! check_some_plugin_counts (insert_map[PostFader], post_fader_input, err)) {
+ if ( ! check_some_plugin_counts (processor_map[PostFader], post_fader_input, err)) {
return -1;
}
/* OK, everything can be set up correctly, so lets do it */
- apply_some_plugin_counts (insert_map[PreFader]);
- apply_some_plugin_counts (insert_map[PostFader]);
+ apply_some_plugin_counts (processor_map[PreFader]);
+ apply_some_plugin_counts (processor_map[PostFader]);
- /* recompute max outs of any insert */
+ /* recompute max outs of any processor */
- insert_max_outs.reset();
- InsertList::iterator prev = _inserts.end();
+ processor_max_outs.reset();
+ ProcessorList::iterator prev = _processors.end();
- for (r = _inserts.begin(); r != _inserts.end(); prev = r, ++r) {
- insert_max_outs = max ((*r)->output_streams (), insert_max_outs);
+ for (r = _processors.begin(); r != _processors.end(); prev = r, ++r) {
+ processor_max_outs = max ((*r)->output_streams (), processor_max_outs);
}
/* we're done */
}
int32_t
-Route::apply_some_plugin_counts (list<InsertCount>& iclist)
+Route::apply_some_plugin_counts (list<ProcessorCount>& iclist)
{
- list<InsertCount>::iterator i;
+ list<ProcessorCount>::iterator i;
for (i = iclist.begin(); i != iclist.end(); ++i) {
- if ((*i).insert->configure_io ((*i).in, (*i).out)) {
+ cerr << "now applying for " << (*i).processor->name() << " in = " << (*i).in.n_audio() << " out = " << (*i).out.n_audio() << endl;
+
+ if ((*i).processor->configure_io ((*i).in, (*i).out)) {
return -1;
}
/* make sure that however many we have, they are all active */
- (*i).insert->activate ();
+ (*i).processor->activate ();
}
return 0;
}
/** Returns whether \a iclist can be configured and run starting with
- * \a required_inputs at the first insert's inputs.
+ * \a required_inputs at the first processor's inputs.
* If false is returned, \a iclist can not be run with \a required_inputs, and \a err is set.
* Otherwise, \a err is set to the output of the list.
*/
bool
-Route::check_some_plugin_counts (list<InsertCount>& iclist, ChanCount required_inputs, InsertStreams* err)
+Route::check_some_plugin_counts (list<ProcessorCount>& iclist, ChanCount required_inputs, ProcessorStreams* err)
{
- list<InsertCount>::iterator i;
+ list<ProcessorCount>::iterator i;
size_t index = 0;
if (err) {
for (i = iclist.begin(); i != iclist.end(); ++i) {
- if ((*i).insert->can_support_input_configuration (required_inputs) < 0) {
+
+ cerr << "Checking whether " << (*i).processor->name() << " can support " << required_inputs.n_audio() << " inputs\n";
+
+ if ((*i).processor->can_support_input_configuration (required_inputs) < 0) {
if (err) {
err->index = index;
err->count = required_inputs;
}
(*i).in = required_inputs;
- (*i).out = (*i).insert->output_for_input_configuration (required_inputs);
+ (*i).out = (*i).processor->output_for_input_configuration (required_inputs);
+
+ cerr << "config looks like " << (*i).processor->name() << " in = " << (*i).in.n_audio() << " out = " << (*i).out.n_audio() << endl;
required_inputs = (*i).out;
if (err) {
if (!iclist.empty()) {
err->index = index;
- err->count = iclist.back().insert->output_for_input_configuration(required_inputs);
+ err->count = iclist.back().processor->output_for_input_configuration(required_inputs);
}
}
}
int
-Route::copy_inserts (const Route& other, Placement placement, InsertStreams* err)
+Route::copy_processors (const Route& other, Placement placement, ProcessorStreams* err)
{
- ChanCount old_rmo = insert_max_outs;
+ ChanCount old_rmo = processor_max_outs;
- InsertList to_be_deleted;
+ ProcessorList to_be_deleted;
{
- Glib::RWLock::WriterLock lm (insert_lock);
- InsertList::iterator tmp;
- InsertList the_copy;
+ Glib::RWLock::WriterLock lm (_processor_lock);
+ ProcessorList::iterator tmp;
+ ProcessorList the_copy;
- the_copy = _inserts;
+ the_copy = _processors;
- /* remove all relevant inserts */
+ /* remove all relevant processors */
- for (InsertList::iterator i = _inserts.begin(); i != _inserts.end(); ) {
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ) {
tmp = i;
++tmp;
if ((*i)->placement() == placement) {
to_be_deleted.push_back (*i);
- _inserts.erase (i);
+ _processors.erase (i);
}
i = tmp;
/* now copy the relevant ones from "other" */
- for (InsertList::const_iterator i = other._inserts.begin(); i != other._inserts.end(); ++i) {
+ for (ProcessorList::const_iterator i = other._processors.begin(); i != other._processors.end(); ++i) {
if ((*i)->placement() == placement) {
- _inserts.push_back (Redirect::clone (*i));
+ _processors.push_back (IOProcessor::clone (*i));
}
}
/* FAILED COPY ATTEMPT: we have to restore order */
- /* delete all cloned inserts */
+ /* delete all cloned processors */
- for (InsertList::iterator i = _inserts.begin(); i != _inserts.end(); ) {
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ) {
tmp = i;
++tmp;
if ((*i)->placement() == placement) {
- _inserts.erase (i);
+ _processors.erase (i);
}
i = tmp;
/* restore the natural order */
- _inserts = the_copy;
- insert_max_outs = old_rmo;
+ _processors = the_copy;
+ processor_max_outs = old_rmo;
/* we failed, even though things are OK again */
} else {
- /* SUCCESSFUL COPY ATTEMPT: delete the inserts we removed pre-copy */
+ /* SUCCESSFUL COPY ATTEMPT: delete the processors we removed pre-copy */
to_be_deleted.clear ();
+ _user_latency = 0;
}
}
- if (insert_max_outs != old_rmo || old_rmo == ChanCount::ZERO) {
+ if (processor_max_outs != old_rmo || old_rmo == ChanCount::ZERO) {
reset_panner ();
}
- inserts_changed (); /* EMIT SIGNAL */
+ processors_changed (); /* EMIT SIGNAL */
return 0;
}
void
-Route::all_inserts_flip ()
+Route::all_processors_flip ()
{
- Glib::RWLock::ReaderLock lm (insert_lock);
+ Glib::RWLock::ReaderLock lm (_processor_lock);
- if (_inserts.empty()) {
+ if (_processors.empty()) {
return;
}
- bool first_is_on = _inserts.front()->active();
+ bool first_is_on = _processors.front()->active();
- for (InsertList::iterator i = _inserts.begin(); i != _inserts.end(); ++i) {
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
(*i)->set_active (!first_is_on);
}
_session.set_dirty ();
}
-/** Set all inserts with a given placement to a given active state.
- * @param p Placement of inserts to change.
- * @param state New active state for those inserts.
+/** 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.
*/
void
-Route::all_inserts_active (Placement p, bool state)
+Route::all_processors_active (Placement p, bool state)
{
- Glib::RWLock::ReaderLock lm (insert_lock);
+ Glib::RWLock::ReaderLock lm (_processor_lock);
- if (_inserts.empty()) {
+ if (_processors.empty()) {
return;
}
- for (InsertList::iterator i = _inserts.begin(); i != _inserts.end(); ++i) {
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
if ((*i)->placement() == p) {
(*i)->set_active (state);
}
_session.set_dirty ();
}
-struct InsertSorter {
- bool operator() (boost::shared_ptr<const Insert> a, boost::shared_ptr<const Insert> b) {
+struct ProcessorSorter {
+ bool operator() (boost::shared_ptr<const Processor> a, boost::shared_ptr<const Processor> b) {
return a->sort_key() < b->sort_key();
}
};
int
-Route::sort_inserts (InsertStreams* err)
+Route::sort_processors (ProcessorStreams* err)
{
{
- InsertSorter comparator;
- Glib::RWLock::WriterLock lm (insert_lock);
- ChanCount old_rmo = insert_max_outs;
+ ProcessorSorter comparator;
+ Glib::RWLock::WriterLock lm (_processor_lock);
+ ChanCount old_rmo = processor_max_outs;
/* the sweet power of C++ ... */
- InsertList as_it_was_before = _inserts;
+ ProcessorList as_it_was_before = _processors;
- _inserts.sort (comparator);
+ _processors.sort (comparator);
if (_reset_plugin_counts (err)) {
- _inserts = as_it_was_before;
- insert_max_outs = old_rmo;
+ _processors = as_it_was_before;
+ processor_max_outs = old_rmo;
return -1;
}
}
reset_panner ();
- inserts_changed (); /* EMIT SIGNAL */
+ processors_changed (); /* EMIT SIGNAL */
return 0;
}
Route::state(bool full_state)
{
XMLNode *node = new XMLNode("Route");
- InsertList:: iterator i;
+ ProcessorList::iterator i;
char buf[32];
if (_flags) {
node->add_property ("order-keys", order_string);
node->add_child_nocopy (IO::state (full_state));
- node->add_child_nocopy (_solo_control.get_state ());
- node->add_child_nocopy (_mute_control.get_state ());
+ node->add_child_nocopy (_solo_control->get_state ());
+ node->add_child_nocopy (_mute_control->get_state ());
XMLNode* remote_control_node = new XMLNode (X_("remote_control"));
snprintf (buf, sizeof (buf), "%d", _remote_control_id);
cmt->add_content (_comment);
}
- for (i = _inserts.begin(); i != _inserts.end(); ++i) {
+ for (i = _processors.begin(); i != _processors.end(); ++i) {
node->add_child_nocopy((*i)->state (full_state));
}
}
XMLNode&
-Route::get_insert_state ()
+Route::get_processor_state ()
{
XMLNode* root = new XMLNode (X_("redirects"));
- for (InsertList::iterator i = _inserts.begin(); i != _inserts.end(); ++i) {
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
root->add_child_nocopy ((*i)->state (true));
}
}
int
-Route::set_insert_state (const XMLNode& root)
+Route::set_processor_state (const XMLNode& root)
{
if (root.name() != X_("redirects")) {
return -1;
XMLNodeList nnlist;
XMLNodeConstIterator iter;
XMLNodeConstIterator niter;
- Glib::RWLock::ReaderLock lm (insert_lock);
+ Glib::RWLock::ReaderLock lm (_processor_lock);
nlist = root.children();
for (iter = nlist.begin(); iter != nlist.end(); ++iter){
- /* iter now points to a Redirect state node */
+ /* iter now points to a IOProcessor state node */
nnlist = (*iter)->children ();
XMLProperty* prop = (*niter)->property (X_("id"));
if (!prop) {
- warning << _("Redirect node has no ID, ignored") << endmsg;
+ warning << _("IOProcessor node has no ID, ignored") << endmsg;
break;
}
ID id = prop->value ();
- /* now look for a insert with that ID */
+ /* now look for a processor with that ID */
- for (InsertList::iterator i = _inserts.begin(); i != _inserts.end(); ++i) {
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
if ((*i)->id() == id) {
(*i)->set_state (**iter);
break;
nlist = deferred_state->children();
for (niter = nlist.begin(); niter != nlist.end(); ++niter){
- add_insert_from_xml (**niter);
+ add_processor_from_xml (**niter);
}
delete deferred_state;
}
void
-Route::add_insert_from_xml (const XMLNode& node)
+Route::add_processor_from_xml (const XMLNode& node)
{
const XMLProperty *prop;
try {
boost::shared_ptr<Send> send (new Send (_session, node));
- add_insert (send);
+ add_processor (send);
}
catch (failed_constructor &err) {
return;
}
- } else if (node.name() == "Insert") {
+ // use "Processor" in XML?
+ } else if (node.name() == "Processor") {
try {
if ((prop = node.property ("type")) != 0) {
- boost::shared_ptr<Insert> insert;
+ boost::shared_ptr<Processor> processor;
if (prop->value() == "ladspa" || prop->value() == "Ladspa" || prop->value() == "vst") {
- insert.reset (new PluginInsert(_session, node));
+ processor.reset (new PluginInsert(_session, node));
} else if (prop->value() == "port") {
- insert.reset (new PortInsert (_session, node));
+ processor.reset (new PortInsert (_session, node));
} else if (prop->value() == "send") {
- insert.reset (new Send (_session, node));
+ processor.reset (new Send (_session, node));
} else {
- error << string_compose(_("unknown Insert type \"%1\"; ignored"), prop->value()) << endmsg;
+ error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
}
- add_insert (insert);
+ add_processor (processor);
} else {
- error << _("Insert XML node has no type property") << endmsg;
+ error << _("Processor XML node has no type property") << endmsg;
}
}
catch (failed_constructor &err) {
- warning << _("insert could not be created. Ignored.") << endmsg;
+ warning << _("processor could not be created. Ignored.") << endmsg;
return;
}
}
}
}
- XMLNodeList insert_nodes;
+ XMLNodeList processor_nodes;
for (niter = nlist.begin(); niter != nlist.end(); ++niter){
child = *niter;
- if (child->name() == X_("Send") || child->name() == X_("Insert")) {
- insert_nodes.push_back(child);
+ if (child->name() == X_("Send") || child->name() == X_("Processor")) {
+ processor_nodes.push_back(child);
}
}
- _set_insert_states(insert_nodes);
+ _set_processor_states(processor_nodes);
for (niter = nlist.begin(); niter != nlist.end(); ++niter){
child = *niter;
- // All inserts have been applied already
+ // All processors have been applied already
if (child->name() == X_("Automation")) {
} else if (child->name() == X_("controllable") && (prop = child->property("name")) != 0) {
if (prop->value() == "solo") {
- _solo_control.set_state (*child);
- _session.add_controllable (&_solo_control);
+ _solo_control->set_state (*child);
+ _session.add_controllable (_solo_control);
}
else if (prop->value() == "mute") {
- _mute_control.set_state (*child);
- _session.add_controllable (&_mute_control);
+ _mute_control->set_state (*child);
+ _session.add_controllable (_mute_control);
}
}
else if (child->name() == X_("remote_control")) {
}
void
-Route::_set_insert_states(const XMLNodeList &nlist)
+Route::_set_processor_states(const XMLNodeList &nlist)
{
XMLNodeConstIterator niter;
char buf[64];
- InsertList::iterator i, o;
+ ProcessorList::iterator i, o;
- // Iterate through existing inserts, remove those which are not in the state list
- for (i = _inserts.begin(); i != _inserts.end(); ) {
- InsertList::iterator tmp = i;
+ // Iterate through existing processors, remove those which are not in the state list
+ for (i = _processors.begin(); i != _processors.end(); ) {
+ ProcessorList::iterator tmp = i;
++tmp;
- bool insertInStateList = false;
+ bool processorInStateList = false;
(*i)->id().print (buf, sizeof (buf));
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
- // legacy sessions (Redirect as a child of Insert, both is-a IO)
- if (strncmp(buf,(*niter)->child(X_("Redirect"))->child(X_("IO"))->property(X_("id"))->value().c_str(), sizeof(buf)) == 0) {
- insertInStateList = true;
+ // legacy sessions (IOProcessor as a child of Processor, both is-a IO)
+ if (strncmp(buf,(*niter)->child(X_("IOProcessor"))->child(X_("IO"))->property(X_("id"))->value().c_str(), sizeof(buf)) == 0) {
+ processorInStateList = true;
break;
} else if (strncmp(buf,(*niter)->property(X_("id"))->value().c_str(), sizeof(buf)) == 0) {
- insertInStateList = true;
+ processorInStateList = true;
break;
}
}
- if (!insertInStateList) {
- remove_insert (*i);
+ if (!processorInStateList) {
+ remove_processor (*i);
}
}
- // Iterate through state list and make sure all inserts are on the track and in the correct order,
- // set the state of existing inserts according to the new state on the same go
- i = _inserts.begin();
+ // Iterate through state list and make sure all processors are on the track and in the correct order,
+ // set the state of existing processors according to the new state on the same go
+ i = _processors.begin();
for (niter = nlist.begin(); niter != nlist.end(); ++niter, ++i) {
- // Check whether the next insert in the list
+ // Check whether the next processor in the list
o = i;
- while (o != _inserts.end()) {
+ while (o != _processors.end()) {
(*o)->id().print (buf, sizeof (buf));
- if ( strncmp(buf, (*niter)->child(X_("Redirect"))->child(X_("IO"))->property(X_("id"))->value().c_str(), sizeof(buf)) == 0)
+ if ( strncmp(buf, (*niter)->child(X_("IOProcessor"))->child(X_("IO"))->property(X_("id"))->value().c_str(), sizeof(buf)) == 0)
break;
else if (strncmp(buf,(*niter)->property(X_("id"))->value().c_str(), sizeof(buf)) == 0)
break;
++o;
}
- if (o == _inserts.end()) {
- // If the insert (*niter) is not on the route, we need to create it
+ if (o == _processors.end()) {
+ // If the processor (*niter) is not on the route, we need to create it
// and move it to the correct location
- InsertList::iterator prev_last = _inserts.end();
+ ProcessorList::iterator prev_last = _processors.end();
--prev_last; // We need this to check whether adding succeeded
- add_insert_from_xml (**niter);
+ add_processor_from_xml (**niter);
- InsertList::iterator last = _inserts.end();
+ ProcessorList::iterator last = _processors.end();
--last;
if (prev_last == last) {
- cerr << "Could not fully restore state as some inserts were not possible to create" << endl;
+ cerr << "Could not fully restore state as some processors were not possible to create" << endl;
continue;
}
- boost::shared_ptr<Insert> tmp = (*last);
- // remove the insert from the wrong location
- _inserts.erase(last);
- // insert the new insert at the current location
- _inserts.insert(i, tmp);
+ boost::shared_ptr<Processor> tmp = (*last);
+ // remove the processor from the wrong location
+ _processors.erase(last);
+ // processor the new processor at the current location
+ _processors.insert(i, tmp);
- --i; // move pointer to the newly inserted insert
+ --i; // move pointer to the newly processored processor
continue;
}
- // We found the insert (*niter) on the route, first we must make sure the insert
+ // We found the processor (*niter) on the route, first we must make sure the processor
// is at the location provided in the XML state
if (i != o) {
- boost::shared_ptr<Insert> tmp = (*o);
+ boost::shared_ptr<Processor> tmp = (*o);
// remove the old copy
- _inserts.erase(o);
- // insert the insert at the correct location
- _inserts.insert(i, tmp);
+ _processors.erase(o);
+ // processor the processor at the correct location
+ _processors.insert(i, tmp);
- --i; // move pointer so it points to the right insert
+ --i; // move pointer so it points to the right processor
}
(*i)->set_state( (**niter) );
}
- inserts_changed ();
+ processors_changed ();
}
void
}
{
- Glib::RWLock::ReaderLock lm (insert_lock, Glib::TRY_LOCK);
+ Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
if (lm.locked()) {
- for (InsertList::iterator i = _inserts.begin(); i != _inserts.end(); ++i) {
+ 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
int
Route::set_control_outs (const vector<string>& ports)
{
- Glib::Mutex::Lock lm (control_outs_lock);
+ Glib::Mutex::Lock lm (_control_outs_lock);
vector<string>::const_iterator i;
size_t limit;
_control_outs = 0;
}
- if (control() || master()) {
+ if (is_control() || is_master()) {
/* no control outs for these two special busses */
return 0;
}
/* now connect to the named ports */
for (size_t n = 0; n < limit; ++n) {
- if (_control_outs->connect_output (_control_outs->output (n), ports[n], this)) {
+ if (_control_outs->connect_output (_control_outs->output (n), ports[n % ports.size()], this)) {
error << string_compose (_("could not connect %1 to %2"), _control_outs->output(n)->name(), ports[n]) << endmsg;
return -1;
}
}
}
- /* check Redirects which may also interconnect Routes */
+ /* check IOProcessors which may also interconnect Routes */
- for (InsertList::iterator r = _inserts.begin(); r != _inserts.end(); r++) {
+ for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); r++) {
- boost::shared_ptr<Redirect> redirect = boost::dynamic_pointer_cast<Redirect>(*r);
+ boost::shared_ptr<IOProcessor> redirect = boost::dynamic_pointer_cast<IOProcessor>(*r);
if ( ! redirect)
continue;
}
void
-Route::handle_transport_stopped (bool abort_ignored, bool did_locate, bool can_flush_inserts)
+Route::handle_transport_stopped (bool abort_ignored, bool did_locate, bool can_flush_processors)
{
nframes_t now = _session.transport_frame();
{
- Glib::RWLock::ReaderLock lm (insert_lock);
+ Glib::RWLock::ReaderLock lm (_processor_lock);
if (!did_locate) {
automation_snapshot (now);
}
- for (InsertList::iterator i = _inserts.begin(); i != _inserts.end(); ++i) {
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- if (Config->get_plugins_stop_with_transport() && can_flush_inserts) {
+ if (Config->get_plugins_stop_with_transport() && can_flush_processors) {
(*i)->deactivate ();
(*i)->activate ();
}
return 0;
}
- return max (n_inputs ().n_audio(), static_cast<size_t>(insert_max_outs.n_audio()));
+ return max (n_inputs ().n_audio(), processor_max_outs.n_audio());
}
int
bool can_record, bool rec_monitors_input)
{
{
- Glib::RWLock::ReaderLock lm (insert_lock, Glib::TRY_LOCK);
+ Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
if (lm.locked()) {
// automation snapshot can also be called from the non-rt context
- // and it uses the insert list, so we take the lock out here
+ // and it uses the processor list, so we take the lock out here
automation_snapshot (_session.transport_frame());
}
}
- if ((n_outputs().n_total() == 0 && _inserts.empty()) || n_inputs().n_total() == 0 || !_active) {
+ if ((n_outputs().n_total() == 0 && _processors.empty()) || n_inputs().n_total() == 0 || !_active) {
silence (nframes, offset);
return 0;
}
if (am.locked() && _session.transport_rolling()) {
- ARDOUR::AutomationList& gain_auto = gain_automation();
-
- if (gain_auto.automation_playback()) {
- apply_gain_automation = gain_auto.curve().rt_safe_get_vector (start_frame, end_frame, _session.gain_automation_buffer(), nframes);
+ if (_gain_control->list()->automation_playback()) {
+ apply_gain_automation = _gain_control->list()->curve().rt_safe_get_vector (
+ start_frame, end_frame, _session.gain_automation_buffer(), nframes);
}
}
}
boost::shared_ptr<const PortInsert> pi;
- for (InsertList::const_iterator i = _inserts.begin(); i != _inserts.end(); ++i) {
+ 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->io()->outputs().begin();
}
void
-Route::flush_inserts ()
+Route::flush_processors ()
{
/* XXX shouldn't really try to take this lock, since
this is called from the RT audio thread.
*/
- Glib::RWLock::ReaderLock lm (insert_lock);
+ Glib::RWLock::ReaderLock lm (_processor_lock);
- for (InsertList::iterator i = _inserts.begin(); i != _inserts.end(); ++i) {
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
(*i)->deactivate ();
(*i)->activate ();
}
nframes_t
Route::update_total_latency ()
{
- _own_latency = 0;
+ nframes_t old = _own_latency;
+
+ if (_user_latency) {
+ _own_latency = _user_latency;
+ } else {
+ _own_latency = 0;
- for (InsertList::iterator i = _inserts.begin(); i != _inserts.end(); ++i) {
- if ((*i)->active ()) {
- _own_latency += (*i)->latency ();
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ if ((*i)->active ()) {
+ _own_latency += (*i)->signal_latency ();
+ }
}
}
set_port_latency (_own_latency);
+
+ if (!_user_latency) {
+ /* 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.
+ */
- /* 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_latency ();
+ _own_latency += input_latency ();
+ }
+ if (old != _own_latency) {
+ signal_latency_changed (); /* EMIT SIGNAL */
+ }
+
return _own_latency;
}
+void
+Route::set_user_latency (nframes_t nframes)
+{
+ Latent::set_user_latency (nframes);
+ _session.update_latency_compensation (false, false);
+}
+
void
Route::set_latency_delay (nframes_t longest_session_latency)
{
- _initial_delay = longest_session_latency - _own_latency;
+ nframes_t old = _initial_delay;
+
+ if (_own_latency < longest_session_latency) {
+ _initial_delay = longest_session_latency - _own_latency;
+ } else {
+ _initial_delay = 0;
+ }
+
+ if (_initial_delay != old) {
+ initial_delay_changed (); /* EMIT SIGNAL */
+ }
if (_session.transport_stopped()) {
_roll_delay = _initial_delay;
{
IO::automation_snapshot (now);
- for (InsertList::iterator i = _inserts.begin(); i != _inserts.end(); ++i) {
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
(*i)->automation_snapshot (now);
}
}
void
Route::set_block_size (nframes_t nframes)
{
- for (InsertList::iterator i = _inserts.begin(); i != _inserts.end(); ++i) {
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
(*i)->set_block_size (nframes);
}
}
{
Automatable::protect_automation();
- for (InsertList::iterator i = _inserts.begin(); i != _inserts.end(); ++i)
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
(*i)->protect_automation();
}
projects / ardour.git / blobdiff