#include <sigc++/bind.h>
#include <pbd/xml++.h>
#include <pbd/enumwriter.h>
+#include <pbd/stacktrace.h>
+#include <pbd/memento_command.h>
#include <ardour/timestamps.h>
#include <ardour/audioengine.h>
using namespace PBD;
uint32_t Route::order_key_cnt = 0;
-sigc::signal<void> Route::SyncOrderKeys;
+sigc::signal<void,const char*> 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),
free ((void*)(i->first));
}
- if (_control_outs) {
- delete _control_outs;
- }
+ delete _control_outs;
}
void
}
void
-Route::sync_order_keys ()
+Route::sync_order_keys (const char* base)
{
- 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;
+ OrderKeys::iterator i;
+ uint32_t key;
+
+ if ((i = order_keys.find (base)) == order_keys.end()) {
+ /* key doesn't exist, use the first existing
+ key (this is done during session initialization)
+ */
+ i = order_keys.begin();
+ key = i->second;
+ ++i;
+ } else {
+ /* key exists - use it and reset all others
+ (actually, itself included)
+ */
+ i = order_keys.begin();
+ key = i->second;
+ }
+
+ for (; i != order_keys.end(); ++i) {
+ i->second = key;
}
}
}
}
+#ifdef NEW_POB
+/** Process this route for one (sub) cycle (process thread)
+ *
+ * @param bufs Scratch buffers to use for the signal path
+ * @param start_frame Initial transport frame
+ * @param end_frame Final transport frame
+ * @param nframes Number of frames to output (to ports)
+ * @param offset Output offset (of port buffers, for split cycles)
+ *
+ * Note that (end_frame - start_frame) may not be equal to nframes when the
+ * transport speed isn't 1.0 (eg varispeed).
+ */
+void
+Route::process_output_buffers (BufferSet& bufs,
+ nframes_t start_frame, nframes_t end_frame,
+ 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);
+
+ ProcessorList::iterator i;
+ bool post_fader_work = false;
+ bool mute_declick_applied = false;
+ gain_t dmg, dsg, dg;
+ IO *co;
+ bool mute_audible;
+ bool solo_audible;
+ bool no_monitor;
+ gain_t* gab = _session.gain_automation_buffer();
+
+ switch (Config->get_monitoring_model()) {
+ case HardwareMonitoring:
+ case ExternalMonitoring:
+ no_monitor = true;
+ break;
+ default:
+ no_monitor = false;
+ }
+
+ declick = _pending_declick;
+
+ {
+ Glib::Mutex::Lock cm (_control_outs_lock, Glib::TRY_LOCK);
+
+ if (cm.locked()) {
+ co = _control_outs;
+ } else {
+ co = 0;
+ }
+ }
+
+ {
+ Glib::Mutex::Lock dm (declick_lock, Glib::TRY_LOCK);
+
+ if (dm.locked()) {
+ dmg = desired_mute_gain;
+ dsg = desired_solo_gain;
+ dg = _desired_gain;
+ } else {
+ dmg = mute_gain;
+ dsg = solo_gain;
+ dg = _gain;
+ }
+ }
+
+ /* ----------------------------------------------------------------------------------------------------
+ GLOBAL DECLICK (for transport changes etc.)
+ input metering & monitoring (control outs)
+ denormal control
+ pre-fader redirects
+ pre-fader metering & monitoring (control outs)
+ gain stage
+ post-fader redirects
+ global mute
+ main output
+ post-fader metering & monitoring (control outs)
+ */
+
+ {
+ Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
+ for (i = processors.begin(); i != processors.end(); ++i) {
+ (*i)->run_in_place (bufs, start_frame, end_frame, nframes, offset);
+ }
+ }
+
+ /* ----------------------------------------------------------------------------------------------------
+ INPUT METERING & MONITORING
+ -------------------------------------------------------------------------------------------------- */
+
+ if (meter && (_meter_point == MeterInput)) {
+ _meter->run_in_place(bufs, start_frame, end_frame, nframes, offset);
+ }
+
+ if (!_soloed && _mute_affects_pre_fader && (mute_gain != dmg)) {
+ Amp::run_in_place (bufs, nframes, mute_gain, dmg, false);
+ mute_gain = dmg;
+ mute_declick_applied = true;
+ }
+
+ /* ----------------------------------------------------------------------------------------------------
+ PRE-FADER REDIRECTS
+ -------------------------------------------------------------------------------------------------- */
+
+ // This really should already be true...
+ bufs.set_count(pre_fader_streams());
+
+
+ if ((_meter_point == MeterPreFader) && co) {
+
+ solo_audible = dsg > 0;
+ mute_audible = dmg > 0 || !_mute_affects_pre_fader;
+
+ if ( // muted by solo of another track
+
+ !solo_audible ||
+
+ // muted by mute of this track
+
+ !mute_audible ||
+
+ // rec-enabled but not s/w monitoring
+
+ (no_monitor && record_enabled() && (!Config->get_auto_input() || _session.actively_recording()))
+
+ ) {
+
+ co->silence (nframes, offset);
+
+ } else {
+
+ co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
+ }
+ }
+
+ /* ----------------------------------------------------------------------------------------------------
+ GAIN STAGE
+ -------------------------------------------------------------------------------------------------- */
+
+ /* if not recording or recording and requiring any monitor signal, then apply gain */
+
+ if ( // not recording
+
+ !(record_enabled() && _session.actively_recording()) ||
+
+ // OR recording
+
+ // AND software monitoring required
+
+ Config->get_monitoring_model() == SoftwareMonitoring) {
+
+ if (apply_gain_automation) {
+
+ if (_phase_invert) {
+ for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
+ Sample* const sp = i->data();
+
+ for (nframes_t nx = 0; nx < nframes; ++nx) {
+ sp[nx] *= -gab[nx];
+ }
+ }
+ } else {
+ for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
+ Sample* const sp = i->data();
+
+ for (nframes_t nx = 0; nx < nframes; ++nx) {
+ sp[nx] *= gab[nx];
+ }
+ }
+ }
+
+ if (apply_gain_automation && _session.transport_rolling() && nframes > 0) {
+ _effective_gain = gab[nframes-1];
+ }
+
+ } else {
+
+ /* manual (scalar) gain */
+
+ if (_gain != dg) {
+
+ Amp::run_in_place (bufs, nframes, _gain, dg, _phase_invert);
+ _gain = dg;
+
+ } else if (_gain != 0 && (_phase_invert || _gain != 1.0)) {
+
+ /* no need to interpolate current gain value,
+ but its non-unity, so apply it. if the gain
+ is zero, do nothing because we'll ship silence
+ below.
+ */
+
+ gain_t this_gain;
+
+ if (_phase_invert) {
+ this_gain = -_gain;
+ } else {
+ this_gain = _gain;
+ }
+
+ for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
+ Sample* const sp = i->data();
+ apply_gain_to_buffer(sp,nframes,this_gain);
+ }
+
+ } else if (_gain == 0) {
+ for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
+ i->clear();
+ }
+ }
+ }
+
+ } else {
+
+ /* actively recording, no monitoring required; leave buffers as-is to save CPU cycles */
+
+ }
+
+
+ /* ----------------------------------------------------------------------------------------------------
+ CONTROL OUTPUT STAGE
+ -------------------------------------------------------------------------------------------------- */
+
+ if ((_meter_point == MeterPostFader) && co) {
+
+ solo_audible = solo_gain > 0;
+ mute_audible = dmg > 0 || !_mute_affects_control_outs;
+
+ if ( // silent anyway
+
+ (_gain == 0 && !apply_gain_automation) ||
+
+ // muted by solo of another track
+
+ !solo_audible ||
+
+ // muted by mute of this track
+
+ !mute_audible ||
+
+ // recording but not s/w monitoring
+
+ (no_monitor && record_enabled() && (!Config->get_auto_input() || _session.actively_recording()))
+
+ ) {
+
+ co->silence (nframes, offset);
+
+ } else {
+
+ co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
+ }
+ }
+
+ /* ----------------------------------------------------------------------------------------------------
+ MAIN OUTPUT STAGE
+ -------------------------------------------------------------------------------------------------- */
+
+ solo_audible = dsg > 0;
+ mute_audible = dmg > 0 || !_mute_affects_main_outs;
+
+ if (n_outputs().get(_default_type) == 0) {
+
+ /* relax */
+
+ } else if (no_monitor && record_enabled() && (!Config->get_auto_input() || _session.actively_recording())) {
+
+ IO::silence (nframes, offset);
+
+ } else {
+
+ if ( // silent anyway
+
+ (_gain == 0 && !apply_gain_automation) ||
+
+ // muted by solo of another track, but not using control outs for solo
+
+ (!solo_audible && (Config->get_solo_model() != SoloBus)) ||
+
+ // muted by mute of this track
+
+ !mute_audible
+
+ ) {
+
+ /* don't use Route::silence() here, because that causes
+ all outputs (sends, port processors, etc. to be silent).
+ */
+
+ if (_meter_point == MeterPostFader) {
+ peak_meter().reset();
+ }
+
+ IO::silence (nframes, offset);
+
+ } else {
+
+ deliver_output(bufs, start_frame, end_frame, nframes, offset);
+
+ }
+
+ }
+}
+
+#endif /* NEW_POB */
+
ChanCount
Route::n_process_buffers ()
{
if (meter_first) {
_meter->run_in_place(bufs, start_frame, end_frame, nframes, offset);
meter_first = false;
- }
+ } else {
+ meter_first = true;
+ }
process_output_buffers (bufs, start_frame, end_frame, nframes, offset, true, declick, meter_first);
}
_soloed = yn;
solo_changed (src); /* EMIT SIGNAL */
_solo_control->Changed (); /* EMIT SIGNAL */
+ }
+
+ catch_up_on_solo_mute_override ();
+}
+
+void
+Route::catch_up_on_solo_mute_override ()
+{
+ if (Config->get_solo_model() != InverseMute) {
+ return;
+ }
+
+ {
+
+ Glib::Mutex::Lock lm (declick_lock);
+
+ if (_muted) {
+ if (Config->get_solo_mute_override()) {
+ desired_mute_gain = (_soloed?1.0:0.0);
+ } else {
+ desired_mute_gain = 0.0;
+ }
+ } else {
+ desired_mute_gain = 1.0;
+ }
}
}
_mute_control->Changed (); /* EMIT SIGNAL */
Glib::Mutex::Lock lm (declick_lock);
- desired_mute_gain = (yn?0.0f:1.0f);
+
+ if (_soloed && Config->get_solo_mute_override()){
+ desired_mute_gain = 1.0f;
+ } else {
+ desired_mute_gain = (yn?0.0f:1.0f);
+ }
}
}
int
Route::add_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err)
{
- ChanCount old_rmo = processor_max_outs;
+ ChanCount old_pmo = processor_max_outs;
if (!_session.engine().connected()) {
return 1;
//processor->set_default_type(_default_type);
+ _processors.push_back (processor);
+
+ // Set up processor list channels. This will set processor->[input|output]_streams(),
+ // configure redirect ports properly, etc.
+ if (_reset_processor_counts (err)) {
+ _processors.pop_back ();
+ _reset_processor_counts (0); // it worked before we tried to add it ...
+ return -1;
+ }
+
if ((pi = boost::dynamic_pointer_cast<PluginInsert>(processor)) != 0) {
- pi->set_count (1);
if (pi->natural_input_streams() == ChanCount::ZERO) {
/* generator plugin */
}
- _processors.push_back (processor);
+ // Ensure peak vector sizes before the plugin is activated
- // Set up processor list channels. This will set processor->[input|output]_streams(),
- // configure redirect ports properly, etc.
- if (_reset_plugin_counts (err)) {
- _processors.pop_back ();
- _reset_plugin_counts (0); // it worked before we tried to add it ...
- return -1;
- }
+ ChanCount potential_max_streams;
- // Ensure peak vector sizes before the plugin is activated
- ChanCount potential_max_streams = max(processor->input_streams(), processor->output_streams());
- _meter->configure_io(potential_max_streams, potential_max_streams);
+ potential_max_streams.set (DataType::AUDIO, max (processor->input_streams().n_audio(),
+ processor->output_streams().n_audio()));
+ potential_max_streams.set (DataType::MIDI, max (processor->input_streams().n_midi(),
+ processor->output_streams().n_midi()));
+ _meter->configure_io (potential_max_streams, potential_max_streams);
+
+ // XXX: do we want to emit the signal here ? change call order.
processor->activate ();
processor->ActiveChanged.connect (bind (mem_fun (_session, &Session::update_latency_compensation), false, false));
_user_latency = 0;
}
- if (processor_max_outs != old_rmo || old_rmo == ChanCount::ZERO) {
+ if (processor_max_outs != old_pmo || old_pmo == ChanCount::ZERO) {
reset_panner ();
}
int
Route::add_processors (const ProcessorList& others, ProcessorStreams* err)
{
- ChanCount old_rmo = processor_max_outs;
+ ChanCount old_pmo = processor_max_outs;
if (!_session.engine().connected()) {
return 1;
}
// Ensure peak vector sizes before the plugin is activated
- _meter->configure_io(potential_max_streams, potential_max_streams);
+ _meter->configure_io (potential_max_streams, potential_max_streams);
_processors.push_back (*i);
- if (_reset_plugin_counts (err)) {
+ if (_reset_processor_counts (err)) {
++existing_end;
_processors.erase (existing_end, _processors.end());
- _reset_plugin_counts (0); // it worked before we tried to add it ...
+ _reset_processor_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 (processor_max_outs != old_rmo || old_rmo == ChanCount::ZERO) {
+ if (processor_max_outs != old_pmo || old_pmo == ChanCount::ZERO) {
reset_panner ();
}
void
Route::clear_processors (Placement p)
{
- const ChanCount old_rmo = processor_max_outs;
+ const ChanCount old_pmo = processor_max_outs;
if (!_session.engine().connected()) {
return;
}
/* FIXME: can't see how this test can ever fire */
- if (processor_max_outs != old_rmo) {
+ if (processor_max_outs != old_pmo) {
reset_panner ();
}
int
Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err)
{
- ChanCount old_rmo = processor_max_outs;
+ ChanCount old_pmo = processor_max_outs;
if (!_session.engine().connected()) {
return 1;
ProcessorList::iterator tmp;
- /* move along, see failure case for reset_plugin_counts()
+ /* move along, see failure case for reset_processor_counts()
where we may need to reprocessor the processor.
*/
return 1;
}
- if (_reset_plugin_counts (err)) {
+ if (_reset_processor_counts (err)) {
/* get back to where we where */
_processors.insert (i, processor);
/* we know this will work, because it worked before :) */
- _reset_plugin_counts (0);
+ _reset_processor_counts (0);
return -1;
}
- bool foo = false;
+ _have_internal_generator = false;
for (i = _processors.begin(); i != _processors.end(); ++i) {
boost::shared_ptr<PluginInsert> pi;
if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
if (pi->is_generator()) {
- foo = true;
+ _have_internal_generator = true;
+ break;
}
}
}
-
- _have_internal_generator = foo;
}
- if (old_rmo != processor_max_outs) {
+ if (old_pmo != processor_max_outs) {
reset_panner ();
}
}
int
-Route::reset_plugin_counts (ProcessorStreams* err)
+Route::reset_processor_counts (ProcessorStreams* err)
{
Glib::RWLock::WriterLock lm (_processor_lock);
- return _reset_plugin_counts (err);
+ return _reset_processor_counts (err);
}
int
-Route::_reset_plugin_counts (ProcessorStreams* err)
+Route::_reset_processor_counts (ProcessorStreams* err)
{
ProcessorList::iterator r;
- map<Placement,list<ProcessorCount> > processor_map;
- ChanCount initial_streams;
- ChanCount post_fader_input;
+ uint32_t insert_cnt = 0;
+ uint32_t send_cnt = 0;
+ map<Placement,list<ProcessorCount> > proc_map;
+ ProcessorList::iterator prev;
+ ChanCount initial_streams = n_inputs ();
+ ChanCount previous_initial_streams = n_inputs ();
int ret = -1;
+ uint32_t max_audio = 0;
+ uint32_t max_midi = 0;
- /* Process each placement in order, checking to see if we
- can really do what has been requested.
- */
+ processor_max_outs.reset ();
- /* divide processors up by placement so we get the signal flow
+ /* Step 1: build a map that links each insert to an in/out channel count
+
+ Divide inserts 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, and because other reasons may
exist now or in the future for this separate treatment.
for (r = _processors.begin(); r != _processors.end(); ++r) {
- boost::shared_ptr<Processor> processor;
+ boost::shared_ptr<PluginInsert> plugin_insert;
+ boost::shared_ptr<PortInsert> port_insert;
+
+ if ((plugin_insert = boost::dynamic_pointer_cast<PluginInsert>(*r)) != 0) {
+
+ ++insert_cnt;
+ proc_map[(*r)->placement()].push_back (ProcessorCount (*r));
+
+ /* reset plugin counts back to one for now so
+ that we have a predictable, controlled
+ state to try to configure.
+ */
+
+ plugin_insert->set_count (1);
+
+ } else if ((port_insert = boost::dynamic_pointer_cast<PortInsert>(*r)) != 0) {
+
+ ++insert_cnt;
+ proc_map[(*r)->placement()].push_back (ProcessorCount (*r));
- if ((processor = boost::dynamic_pointer_cast<Processor>(*r)) != 0) {
- processor_map[processor->placement()].push_back (ProcessorCount (processor));
+ } else if (boost::dynamic_pointer_cast<Send> (*r) != 0) {
+ ++send_cnt;
}
}
+ if (insert_cnt == 0) {
+ if (send_cnt) {
+ goto recompute;
+ } else {
+ ret = 0;
+ goto streamcount;
+ }
+ }
+
+ /* Now process each placement in order, checking to see if we
+ can really do what has been requested.
+ */
+
/* A: PreFader */
- if ( ! check_some_plugin_counts (processor_map[PreFader], n_inputs (), err)) {
+ if (check_some_processor_counts (proc_map[PreFader], n_inputs (), err)) {
goto streamcount;
}
- post_fader_input = (err ? err->count : n_inputs());
+ if (!proc_map[PreFader].empty()) {
+ previous_initial_streams = n_inputs ();
+ for (list<ProcessorCount>::iterator i = proc_map[PreFader].begin(); i != proc_map[PreFader].end(); i++) {
+ if (i->processor->can_support_io_configuration (previous_initial_streams, initial_streams) < 0) {
+ goto streamcount;
+ }
+ previous_initial_streams = initial_streams;
+ }
+ }
/* B: PostFader */
- if ( ! check_some_plugin_counts (processor_map[PostFader], post_fader_input, err)) {
+ if (check_some_processor_counts (proc_map[PostFader], initial_streams, err)) {
goto streamcount;
}
+ if (!proc_map[PostFader].empty()) {
+ for (list<ProcessorCount>::iterator i = proc_map[PostFader].begin(); i != proc_map[PostFader].end(); i++) {
+ if (i->processor->can_support_io_configuration (previous_initial_streams, initial_streams) < 0) {
+ goto streamcount;
+ }
+ previous_initial_streams = initial_streams;
+ }
+ }
+
/* OK, everything can be set up correctly, so lets do it */
- apply_some_plugin_counts (processor_map[PreFader]);
- apply_some_plugin_counts (processor_map[PostFader]);
+ apply_some_processor_counts (proc_map[PreFader]);
+ apply_some_processor_counts (proc_map[PostFader]);
/* recompute max outs of any processor */
ret = 0;
- streamcount:
- processor_max_outs.reset();
+ recompute:
- for (r = _processors.begin(); r != _processors.end(); ++r) {
- processor_max_outs = max ((*r)->output_streams (), processor_max_outs);
+ processor_max_outs.reset ();
+ prev = _processors.end();
+
+ for (r = _processors.begin(); r != _processors.end(); prev = r, ++r) {
+ boost::shared_ptr<Send> s;
+
+ if ((s = boost::dynamic_pointer_cast<Send> (*r)) != 0) {
+ if (r == _processors.begin()) {
+ s->expect_inputs (n_inputs());
+ } else {
+ s->expect_inputs ((*prev)->output_streams());
+ }
+
+ } else {
+
+ /* don't pay any attention to send output configuration, since it doesn't
+ affect the route.
+ */
+
+ max_audio = max ((*r)->output_streams ().n_audio(), max_audio);
+ max_midi = max ((*r)->output_streams ().n_midi(), max_midi);
+ }
}
+ processor_max_outs.set (DataType::AUDIO, max_audio);
+ processor_max_outs.set (DataType::MIDI, max_midi);
+
+ /* we're done */
return 0;
+
+ streamcount:
+ for (r = _processors.begin(); r != _processors.end(); ++r) {
+ max_audio = max ((*r)->output_streams ().n_audio(), max_audio);
+ max_midi = max ((*r)->output_streams ().n_midi(), max_midi);
+ }
+
+ processor_max_outs.set (DataType::AUDIO, max_audio);
+ processor_max_outs.set (DataType::MIDI, max_midi);
+
+ return ret;
}
int32_t
-Route::apply_some_p
lugin_counts (list<ProcessorCount>& iclist)
+Route::apply_some_p
rocessor_counts (list<ProcessorCount>& iclist)
{
list<ProcessorCount>::iterator i;
-
+
for (i = iclist.begin(); i != iclist.end(); ++i) {
-
- 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)) {
+ ProcessorCount& pc (*i);
+
+ cerr << "now applying for " << (*i).processor->name() << " in = " << pc.in.n_audio() << " out = " << pc.out.n_audio() << endl;
+
+ if (pc.processor->configure_io (pc.in, pc.out)) {
return -1;
}
+
/* make sure that however many we have, they are all active */
- (*i).processor->activate ();
+
+ pc.processor->activate ();
}
return 0;
* Otherwise, \a err is set to the output of the list.
*/
bool
-Route::check_some_p
lugin_counts (list<ProcessorCount>& iclist, ChanCount required_inputs, ProcessorStreams* err)
+Route::check_some_p
rocessor_counts (list<ProcessorCount>& iclist, ChanCount required_inputs, ProcessorStreams* err)
{
list<ProcessorCount>::iterator i;
size_t index = 0;
err->count = required_inputs;
}
- for (i = iclist.begin(); i != iclist.end(); ++i) {
-
+ for (i = iclist.begin(); i != iclist.end(); ++i, ++index) {
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 (!(*i).processor->can_support_io_configuration (required_inputs, (*i).out)) {
if (err) {
err->index = index;
err->count = required_inputs;
}
- return false;
+ return true;
}
(*i).in = 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;
-
- ++index;
- }
-
- if (err) {
- if (!iclist.empty()) {
- err->index = index;
- err->count = iclist.back().processor->output_for_input_configuration(required_inputs);
- }
}
- return true;
+ return false;
}
int
Route::copy_processors (const Route& other, Placement placement, ProcessorStreams* err)
{
- ChanCount old_rmo = processor_max_outs;
+ ChanCount old_pmo = processor_max_outs;
ProcessorList to_be_deleted;
/* reset plugin stream handling */
- if (_reset_plugin_counts (err)) {
+ if (_reset_processor_counts (err)) {
/* FAILED COPY ATTEMPT: we have to restore order */
/* restore the natural order */
_processors = the_copy;
- processor_max_outs = old_rmo;
+ processor_max_outs = old_pmo;
/* we failed, even though things are OK again */
}
}
- if (processor_max_outs != old_rmo || old_rmo == ChanCount::ZERO) {
+ if (processor_max_outs != old_pmo || old_pmo == ChanCount::ZERO) {
reset_panner ();
}
{
ProcessorSorter comparator;
Glib::RWLock::WriterLock lm (_processor_lock);
- ChanCount old_rmo = processor_max_outs;
+ ChanCount old_pmo = processor_max_outs;
/* the sweet power of C++ ... */
_processors.sort (comparator);
- if (_reset_plugin_counts (err)) {
+ if (_reset_processor_counts (err)) {
_processors = as_it_was_before;
- processor_max_outs = old_rmo;
+ processor_max_outs = old_pmo;
return -1;
}
}
nlist = node.children();
- if (deferred_state) {
- delete deferred_state;
- }
-
+ delete deferred_state;
deferred_state = new XMLNode(X_("deferred state"));
/* set parent class properties before anything else */
string coutname = _name;
coutname += _("[control]");
+ delete _control_outs;
_control_outs = new IO (_session, coutname);
_control_outs->set_state (**(child->children().begin()));
vector<string>::const_iterator i;
size_t limit;
- if (_control_outs) {
- delete _control_outs;
- _control_outs = 0;
- }
+ delete _control_outs;
+ _control_outs = 0;
if (is_control() || is_master()) {
/* no control outs for these two special busses */
Route::input_change_handler (IOChange change, void *ignored)
{
if (change & ConfigurationChanged) {
- reset_plugin_counts (0);
+ reset_processor_counts (0);
}
}
_control_outs->ensure_io (ChanCount::ZERO, ChanCount(DataType::AUDIO, n_outputs().n_audio()), true, this);
}
- reset_plugin_counts (0);
+ reset_processor_counts (0);
}
}
apply_gain_automation = false;
{
- Glib::Mutex::Lock am (_automation_lock, Glib::TRY_LOCK);
+ Glib::Mutex::Lock am (data().control_lock(), Glib::TRY_LOCK);
if (am.locked() && _session.transport_rolling()) {
- if (_gain_control->list()->automation_playback()) {
+ if (_gain_control->automation_playback()) {
apply_gain_automation = _gain_control->list()->curve().rt_safe_get_vector (
start_frame, end_frame, _session.gain_automation_buffer(), nframes);
}
}
}
+#undef DEBUG_LATENCY
+#ifdef DEBUG_LATENCY
+ cerr << _name << ": internal redirect latency = " << _own_latency << endl;
+#endif
+
set_port_latency (_own_latency);
if (!_user_latency) {
signal_latency_changed (); /* EMIT SIGNAL */
}
+#ifdef DEBUG_LATENCY
+ cerr << _name << ": input latency = " << input_latency() << " total = "
+ << _own_latency << endl;
+#endif
+
return _own_latency;
}
return;
}
+ IO::automation_snapshot (now, force);
+
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- // IO::automation_snapshot (now, force); ?
(*i)->automation_snapshot (now, force);
}
}
}
}
+
+/** Shift automation forwards from a particular place, thereby inserting time.
+ * Adds undo commands for any shifts that are performed.
+ *
+ * @param pos Position to start shifting from.
+ * @param frames Amount to shift forwards by.
+ */
+
+void
+Route::shift (nframes64_t pos, nframes64_t frames)
+{
+#ifdef THIS_NEEDS_FIXING_FOR_V3
+
+ /* gain automation */
+ XMLNode &before = _gain_control->get_state ();
+ _gain_control->shift (pos, frames);
+ XMLNode &after = _gain_control->get_state ();
+ _session.add_command (new MementoCommand<AutomationList> (_gain_automation_curve, &before, &after));
+
+ /* pan automation */
+ for (std::vector<StreamPanner*>::iterator i = _panner->begin (); i != _panner->end (); ++i) {
+ Curve & c = (*i)->automation ();
+ XMLNode &before = c.get_state ();
+ c.shift (pos, frames);
+ XMLNode &after = c.get_state ();
+ _session.add_command (new MementoCommand<AutomationList> (c, &before, &after));
+ }
+
+ /* redirect automation */
+ {
+ Glib::RWLock::ReaderLock lm (redirect_lock);
+ for (RedirectList::iterator i = _redirects.begin (); i != _redirects.end (); ++i) {
+
+ set<uint32_t> a;
+ (*i)->what_has_automation (a);
+
+ for (set<uint32_t>::const_iterator j = a.begin (); j != a.end (); ++j) {
+ AutomationList & al = (*i)->automation_list (*j);
+ XMLNode &before = al.get_state ();
+ al.shift (pos, frames);
+ XMLNode &after = al.get_state ();
+ _session.add_command (new MementoCommand<AutomationList> (al, &before, &after));
+ }
+ }
+ }
+#endif
+
+}
projects / ardour.git / blobdiff