/*
- Copyright (C) 2000 Paul Davis
+ Copyright (C) 2000 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include <cmath>
#include <fstream>
#include <cassert>
+#include <algorithm>
#include <sigc++/bind.h>
#include "pbd/xml++.h"
#include "pbd/enumwriter.h"
-#include "pbd/stacktrace.h"
#include "pbd/memento_command.h"
#include "evoral/Curve.hpp"
-#include "ardour/timestamps.h"
+#include "ardour/amp.h"
+#include "ardour/audio_port.h"
#include "ardour/audioengine.h"
-#include "ardour/route.h"
#include "ardour/buffer.h"
-#include "ardour/processor.h"
-#include "ardour/plugin_insert.h"
-#include "ardour/port_insert.h"
-#include "ardour/send.h"
-#include "ardour/session.h"
-#include "ardour/utils.h"
+#include "ardour/buffer_set.h"
#include "ardour/configuration.h"
#include "ardour/cycle_timer.h"
-#include "ardour/route_group.h"
-#include "ardour/port.h"
-#include "ardour/audio_port.h"
-#include "ardour/ladspa_plugin.h"
-#include "ardour/panner.h"
+#include "ardour/debug.h"
+#include "ardour/delivery.h"
#include "ardour/dB.h"
-#include "ardour/amp.h"
+#include "ardour/internal_send.h"
+#include "ardour/internal_return.h"
+#include "ardour/ladspa_plugin.h"
#include "ardour/meter.h"
-#include "ardour/buffer_set.h"
#include "ardour/mix.h"
+#include "ardour/panner.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 "i18n.h"
using namespace PBD;
uint32_t Route::order_key_cnt = 0;
-sigc::signal<void,const char*> Route::SyncOrderKeys;
+sigc::signal<void, string const &> Route::SyncOrderKeys;
-Route::Route (Session& sess, string name,
- int in_min, int in_max, int out_min, int out_max,
- Flag flg, DataType default_type)
- : IO (sess, name, in_min, in_max, out_min, out_max, default_type)
+Route::Route (Session& sess, string name, Flag flg, DataType default_type)
+ : SessionObject (sess, name)
+ , AutomatableControls (sess)
, _flags (flg)
- , _solo_control (new ToggleControllable (X_("solo"), *this, ToggleControllable::SoloControl))
- , _mute_control (new ToggleControllable (X_("mute"), *this, ToggleControllable::MuteControl))
+ , _solo_control (new SoloControllable (X_("solo"), *this))
+ , _mute_master (new MuteMaster (sess, name))
+ , _default_type (default_type)
+
{
init ();
+
+ /* add standard processors other than amp (added by ::init()) */
+
+ _meter.reset (new PeakMeter (_session));
+ _meter->set_display_to_user (_meter_point == MeterCustom);
+ add_processor (_meter, PreFader);
+
+ if (_flags & ControlOut) {
+ /* where we listen to tracks */
+ _intreturn.reset (new InternalReturn (_session));
+ add_processor (_intreturn, PreFader);
+ }
+
+ _main_outs.reset (new Delivery (_session, _output, _mute_master, _name, Delivery::Main));
+ add_processor (_main_outs, PostFader);
+
+ /* now that we have _meter, its safe to connect to this */
+
+ _meter_connection = Metering::connect (mem_fun (*this, &Route::meter));
}
Route::Route (Session& sess, const XMLNode& node, DataType default_type)
- : IO (sess, *node.child ("IO"), default_type)
- , _solo_control (new ToggleControllable (X_("solo"), *this, ToggleControllable::SoloControl))
- , _mute_control (new ToggleControllable (X_("mute"), *this, ToggleControllable::MuteControl))
+ : SessionObject (sess, "toBeReset")
+ , AutomatableControls (sess)
+ , _solo_control (new SoloControllable (X_("solo"), *this))
+ , _mute_master (new MuteMaster (sess, "toBeReset"))
+ , _default_type (default_type)
{
init ();
- _set_state (node, false);
+
+ _set_state (node, Stateful::loading_state_version, false);
+
+ /* now that we have _meter, its safe to connect to this */
+
+ _meter_connection = Metering::connect (mem_fun (*this, &Route::meter));
}
void
Route::init ()
{
- processor_max_outs.reset();
- _muted = false;
- _soloed = false;
+ _self_solo = false;
+ _soloed_by_others = 0;
+ _solo_isolated = false;
_solo_safe = false;
- _recordable = true;
_active = true;
- _phase_invert = false;
- _denormal_protection = false;
- order_keys[strdup (N_("signal"))] = order_key_cnt++;
+ processor_max_streams.reset();
+ _recordable = true;
+ order_keys[N_("signal")] = order_key_cnt++;
_silent = false;
_meter_point = MeterPostFader;
_initial_delay = 0;
_roll_delay = 0;
- _own_latency = 0;
- _user_latency = 0;
_have_internal_generator = false;
_declickable = false;
_pending_declick = true;
_remote_control_id = 0;
-
- _edit_group = 0;
- _mix_group = 0;
+ _in_configure_processors = false;
+ _mute_points = MuteMaster::AllPoints;
- _mute_affects_pre_fader = Config->get_mute_affects_pre_fader();
- _mute_affects_post_fader = Config->get_mute_affects_post_fader();
- _mute_affects_control_outs = Config->get_mute_affects_control_outs();
- _mute_affects_main_outs = Config->get_mute_affects_main_outs();
-
- solo_gain = 1.0;
- desired_solo_gain = 1.0;
- mute_gain = 1.0;
- desired_mute_gain = 1.0;
+ _route_group = 0;
+
+ _phase_invert = 0;
+ _denormal_protection = false;
- _control_outs = 0;
+ /* add standard controls */
- input_changed.connect (mem_fun (this, &Route::input_change_handler));
- output_changed.connect (mem_fun (this, &Route::output_change_handler));
+ add_control (_solo_control);
+ add_control (_mute_master);
+
+ /* input and output objects */
+
+ _input.reset (new IO (_session, _name, IO::Input, _default_type));
+ _output.reset (new IO (_session, _name, IO::Output, _default_type));
+
+ _input->changed.connect (mem_fun (this, &Route::input_change_handler));
+ _output->changed.connect (mem_fun (this, &Route::output_change_handler));
+
+ /* add amp processor */
+
+ _amp.reset (new Amp (_session, _mute_master));
+ add_processor (_amp, PostFader);
}
Route::~Route ()
{
+ Metering::disconnect (_meter_connection);
+
clear_processors (PreFader);
clear_processors (PostFader);
-
- for (OrderKeys::iterator i = order_keys.begin(); i != order_keys.end(); ++i) {
- free ((void*)(i->first));
- }
-
- delete _control_outs;
}
void
}
long
-Route::order_key (const char* name) const
+Route::order_key (std::string const & name) const
{
- OrderKeys::const_iterator i;
-
- for (i = order_keys.begin(); i != order_keys.end(); ++i) {
- if (!strcmp (name, i->first)) {
- return i->second;
- }
+ OrderKeys::const_iterator i = order_keys.find (name);
+ if (i == order_keys.end()) {
+ return -1;
}
- return -1;
+ return i->second;
}
void
-Route::set_order_key (const char* name, long n)
+Route::set_order_key (std::string const & name, long n)
{
- order_keys[strdup(name)] = n;
+ order_keys[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 ();
}
+/** Set all order keys to be the same as that for `base', if such a key
+ * exists in this route.
+ * @param base Base key.
+ */
void
-Route::sync_order_keys (const char* base)
+Route::sync_order_keys (std::string const & base)
{
if (order_keys.empty()) {
return;
++i;
} else {
/* key exists - use it and reset all others (actually, itself included) */
- i = order_keys.begin();
key = i->second;
+ i = order_keys.begin();
}
for (; i != order_keys.end(); ++i) {
void
Route::inc_gain (gain_t fraction, void *src)
{
- IO::inc_gain (fraction, src);
+ _amp->inc_gain (fraction, src);
}
void
Route::set_gain (gain_t val, void *src)
{
- if (src != 0 && _mix_group && src != _mix_group && _mix_group->is_active()) {
-
- if (_mix_group->is_relative()) {
-
- gain_t usable_gain = gain();
+ if (src != 0 && _route_group && src != _route_group && _route_group->active_property (RouteGroup::Gain)) {
+
+ if (_route_group->is_relative()) {
+
+ gain_t usable_gain = _amp->gain();
if (usable_gain < 0.000001f) {
usable_gain = 0.000001f;
}
-
+
gain_t delta = val;
if (delta < 0.000001f) {
delta = 0.000001f;
gain_t factor = delta / usable_gain;
if (factor > 0.0f) {
- factor = _mix_group->get_max_factor(factor);
+ factor = _route_group->get_max_factor(factor);
if (factor == 0.0f) {
- _gain_control->Changed(); /* EMIT SIGNAL */
+ _amp->gain_control()->Changed(); /* EMIT SIGNAL */
return;
}
} else {
- factor = _mix_group->get_min_factor(factor);
+ factor = _route_group->get_min_factor(factor);
if (factor == 0.0f) {
- _gain_control->Changed(); /* EMIT SIGNAL */
+ _amp->gain_control()->Changed(); /* EMIT SIGNAL */
return;
}
}
-
- _mix_group->apply (&Route::inc_gain, factor, _mix_group);
+
+ _route_group->apply (&Route::inc_gain, factor, _route_group);
} else {
-
- _mix_group->apply (&Route::set_gain, val, _mix_group);
+
+ _route_group->apply (&Route::set_gain, val, _route_group);
}
return;
- }
+ }
- if (val == gain()) {
+ if (val == _amp->gain()) {
return;
}
- IO::set_gain (val, src);
+ _amp->set_gain (val, src);
}
/** 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 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)
+ sframes_t start_frame, sframes_t end_frame, nframes_t nframes,
+ bool /*with_processors*/, int declick)
{
- // 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();
+ bool monitor;
+
+ bufs.is_silent (false);
switch (Config->get_monitoring_model()) {
case HardwareMonitoring:
case ExternalMonitoring:
- no_monitor = true;
+ monitor = !record_enabled() || (_session.config.get_auto_input() && !_session.actively_recording());
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.)
- ----------------------------------------------------------------------------------------- */
-
- if (declick > 0) {
- Amp::run_in_place (bufs, nframes, 0.0, 1.0, false);
- _pending_declick = 0;
- } else if (declick < 0) {
- Amp::run_in_place (bufs, nframes, 1.0, 0.0, false);
- _pending_declick = 0;
- } else {
-
- /* no global declick */
-
- if (solo_gain != dsg) {
- Amp::run_in_place (bufs, nframes, solo_gain, dsg, false);
- solo_gain = dsg;
- }
+ monitor = true;
}
-
- /* -------------------------------------------------------------------------------------------
- INPUT METERING & MONITORING
- ----------------------------------------------------------------------------------------- */
-
- if (meter && (_meter_point == MeterInput)) {
- _meter->run_in_place(bufs, start_frame, end_frame, nframes, offset);
+ if (!declick) {
+ declick = _pending_declick;
}
- 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;
- }
-
- if ((_meter_point == MeterInput) && 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
-
- // TODO: this is probably wrong
-
- ( 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);
-
- }
- }
+ /* figure out if we're going to use gain automation */
+ _amp->setup_gain_automation (start_frame, end_frame, nframes);
- /* -------------------------------------------------------------------------------------------
- DENORMAL CONTROL
- ----------------------------------------------------------------------------------------- */
- if (_denormal_protection || Config->get_denormal_protection()) {
+ /* tell main outs what to do about monitoring */
+ _main_outs->no_outs_cuz_we_no_monitor (!monitor);
- for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
- Sample* const sp = i->data();
-
- for (nframes_t nx = offset; nx < nframes + offset; ++nx) {
- sp[nx] += 1.0e-27f;
- }
- }
- }
/* -------------------------------------------------------------------------------------------
- PRE-FADER REDIRECTS
+ GLOBAL DECLICK (for transport changes etc.)
----------------------------------------------------------------------------------------- */
- 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 = _processors.begin(); i != _processors.end(); ++i) {
- switch ((*i)->placement()) {
- case PreFader:
- (*i)->run_in_place (bufs, start_frame, end_frame, nframes, offset);
- break;
- case PostFader:
- post_fader_work = true;
- break;
- }
- }
- } else {
- for (i = _processors.begin(); i != _processors.end(); ++i) {
- switch ((*i)->placement()) {
- case PreFader:
- (*i)->silence (nframes, offset);
- break;
- case PostFader:
- post_fader_work = true;
- break;
- }
- }
- }
- }
+ if (declick > 0) {
+ Amp::apply_gain (bufs, nframes, 0.0, 1.0);
+ } else if (declick < 0) {
+ Amp::apply_gain (bufs, nframes, 1.0, 0.0);
}
- /* When we entered this method, the number of bufs was set by n_process_buffers(), so
- * it may be larger than required. Consider e.g a mono track with two redirects A and B.
- * If A has one input and three outputs, and B three inputs and one output, n_process_buffers()
- * will be 3. In this case, now we've done pre-fader redirects, we can reset the number of bufs.
- */
- bufs.set_count (pre_fader_streams());
-
- if (!_soloed && (mute_gain != dmg) && !mute_declick_applied && _mute_affects_post_fader) {
- Amp::run_in_place (bufs, nframes, mute_gain, dmg, false);
- mute_gain = dmg;
- mute_declick_applied = true;
- }
+ _pending_declick = 0;
/* -------------------------------------------------------------------------------------------
- PRE-FADER METERING & MONITORING
+ DENORMAL CONTROL/PHASE INVERT
----------------------------------------------------------------------------------------- */
- if (meter && (_meter_point == MeterPreFader)) {
- _meter->run_in_place(bufs, start_frame, end_frame, nframes, offset);
- }
-
-
- 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 (_phase_invert) {
- /* if not recording or recording and requiring any monitor signal, then apply gain */
+ int chn = 0;
- if ( // not recording
+ if (_denormal_protection || Config->get_denormal_protection()) {
- !(record_enabled() && _session.actively_recording()) ||
-
- // OR recording
-
- // AND software monitoring required
+ for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
+ Sample* const sp = i->data();
- 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();
-
+ if (_phase_invert & chn) {
for (nframes_t nx = 0; nx < nframes; ++nx) {
- sp[nx] *= -gab[nx];
+ sp[nx] = -sp[nx];
+ sp[nx] += 1.0e-27f;
}
- }
- } else {
- for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
- Sample* const sp = i->data();
-
+ } else {
for (nframes_t nx = 0; nx < nframes; ++nx) {
- sp[nx] *= gab[nx];
+ sp[nx] += 1.0e-27f;
}
}
}
-
- 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);
- }
+ for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
+ Sample* const sp = i->data();
- } else if (_gain == 0) {
- for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
- i->clear();
+ if (_phase_invert & chn) {
+ for (nframes_t nx = 0; nx < nframes; ++nx) {
+ sp[nx] = -sp[nx];
+ }
}
}
}
} else {
- /* actively recording, no monitoring required; leave buffers as-is to save CPU cycles */
-
- }
-
- /* -------------------------------------------------------------------------------------------
- POST-FADER REDIRECTS
- ----------------------------------------------------------------------------------------- */
-
- /* note that post_fader_work cannot be true unless with_processors was also true,
- so don't test both
- */
-
- if (post_fader_work) {
+ if (_denormal_protection || Config->get_denormal_protection()) {
- Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
- if (rm.locked()) {
- if (mute_gain > 0 || !_mute_affects_post_fader) {
- for (i = _processors.begin(); i != _processors.end(); ++i) {
- switch ((*i)->placement()) {
- case PreFader:
- break;
- case PostFader:
- (*i)->run_in_place (bufs, start_frame, end_frame, nframes, offset);
- break;
- }
- }
- } else {
- for (i = _processors.begin(); i != _processors.end(); ++i) {
- switch ((*i)->placement()) {
- case PreFader:
- break;
- case PostFader:
- (*i)->silence (nframes, offset);
- break;
- }
+ 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] += 1.0e-27f;
}
}
- }
- }
- if (!_soloed && (mute_gain != dmg) && !mute_declick_applied && _mute_affects_control_outs) {
- Amp::run_in_place (bufs, nframes, mute_gain, dmg, false);
- mute_gain = dmg;
- mute_declick_applied = true;
+ }
}
/* -------------------------------------------------------------------------------------------
- CONTROL OUTPUT STAGE
+ and go ....
----------------------------------------------------------------------------------------- */
- if ((_meter_point == MeterPostFader) && co) {
-
- solo_audible = solo_gain > 0;
- mute_audible = dmg > 0 || !_mute_affects_control_outs;
-
- if ( // silent anyway
+ Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
- (_gain == 0 && !apply_gain_automation) ||
+ if (rm.locked()) {
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ if (bufs.count() != (*i)->input_streams()) {
+ cerr << _name << " bufs = " << bufs.count()
+ << " input for " << (*i)->name() << " = " << (*i)->input_streams()
+ << endl;
+ }
+ assert (bufs.count() == (*i)->input_streams());
+ (*i)->run (bufs, start_frame, end_frame, nframes);
+ bufs.set_count (ChanCount::max(bufs.count(), (*i)->output_streams()));
+ }
- // muted by solo of another track
+ if (!_processors.empty()) {
+ bufs.set_count (ChanCount::max (bufs.count(), _processors.back()->output_streams()));
+ }
+ }
+}
- !solo_audible ||
+ChanCount
+Route::n_process_buffers ()
+{
+ return max (_input->n_ports(), processor_max_streams);
+}
- // muted by mute of this track
+void
+Route::passthru (sframes_t start_frame, sframes_t end_frame, nframes_t nframes, int declick)
+{
+ BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers());
- !mute_audible ||
+ _silent = false;
- // recording but not s/w monitoring
-
- ( no_monitor && record_enabled()
- && (!Config->get_auto_input() || _session.actively_recording()) )
+ assert (bufs.available() >= _input->n_ports());
- ) {
-
- co->silence (nframes, offset);
-
- } else {
+ if (_input->n_ports() == ChanCount::ZERO) {
+ silence (nframes);
+ }
- co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
- }
- }
+ bufs.set_count (_input->n_ports());
- /* -------------------------------------------------------------------------------------------
- GLOBAL MUTE
- ----------------------------------------------------------------------------------------- */
+ if (is_control() && _session.listening()) {
- if (!_soloed && (mute_gain != dmg) && !mute_declick_applied && _mute_affects_main_outs) {
- Amp::run_in_place (bufs, nframes, mute_gain, dmg, false);
- mute_gain = dmg;
- mute_declick_applied = true;
- }
-
- /* -------------------------------------------------------------------------------------------
- MAIN OUTPUT STAGE
- ----------------------------------------------------------------------------------------- */
+ /* control/monitor bus ignores input ports when something is
+ feeding the listen "stream". data will "arrive" into the
+ route from the intreturn processor element.
+ */
- solo_audible = dsg > 0;
- mute_audible = dmg > 0 || !_mute_affects_main_outs;
-
- if (n_outputs().get(_default_type) == 0) {
-
- /* relax */
+ bufs.silence (nframes, 0);
- } 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
+ for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
- (!solo_audible && (Config->get_solo_model() != SoloBus)) ||
-
- // muted by mute of this track
+ BufferSet::iterator o = bufs.begin(*t);
+ PortSet& ports (_input->ports());
- !mute_audible
+ for (PortSet::iterator i = ports.begin(*t); i != ports.end(*t); ++i, ++o) {
+ o->read_from (i->get_buffer(nframes), nframes);
+ }
+ }
+ }
- ) {
+ write_out_of_band_data (bufs, start_frame, end_frame, nframes);
+ process_output_buffers (bufs, start_frame, end_frame, nframes, true, declick);
+}
- /* 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();
- }
+void
+Route::passthru_silence (sframes_t start_frame, sframes_t end_frame, nframes_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);
+}
- IO::silence (nframes, offset);
-
- } else {
-
- deliver_output(bufs, start_frame, end_frame, nframes, offset);
+void
+Route::set_listen (bool yn, void* src)
+{
+ if (_control_outs) {
+ if (yn != _control_outs->active()) {
+ if (yn) {
+ _control_outs->activate ();
+ } else {
+ _control_outs->deactivate ();
+ }
+ listen_changed (src); /* EMIT SIGNAL */
}
-
}
+}
- /* -------------------------------------------------------------------------------------------
- POST-FADER METERING
- ----------------------------------------------------------------------------------------- */
-
- if (meter && (_meter_point == MeterPostFader)) {
- if ((_gain == 0 && !apply_gain_automation) || dmg == 0) {
- _meter->reset();
- } else {
- _meter->run_in_place(output_buffers(), start_frame, end_frame, nframes, offset);
- }
+bool
+Route::listening () const
+{
+ if (_control_outs) {
+ return _control_outs->active ();
+ } else {
+ return false;
}
}
-#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)
+Route::set_solo_safe (bool yn, void *src)
{
- // 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();
+ if (_solo_safe != yn) {
+ _solo_safe = yn;
+ solo_safe_changed (src);
+ }
+}
- switch (Config->get_monitoring_model()) {
- case HardwareMonitoring:
- case ExternalMonitoring:
- no_monitor = true;
- break;
- default:
- no_monitor = false;
+bool
+Route::solo_safe() const
+{
+ return _solo_safe;
+}
+
+void
+Route::set_solo (bool yn, void *src)
+{
+ if (_solo_safe) {
+ return;
}
- declick = _pending_declick;
+ if (_route_group && src != _route_group && _route_group->active_property (RouteGroup::Solo)) {
+ _route_group->apply (&Route::set_solo, yn, _route_group);
+ return;
+ }
- {
- Glib::Mutex::Lock cm (_control_outs_lock, Glib::TRY_LOCK);
-
- if (cm.locked()) {
- co = _control_outs;
- } else {
- co = 0;
- }
+ if (self_soloed() != yn) {
+ set_self_solo (yn);
+ set_delivery_solo ();
+ solo_changed (src); /* EMIT SIGNAL */
+ _solo_control->Changed (); /* EMIT SIGNAL */
}
-
- {
- Glib::Mutex::Lock dm (declick_lock, Glib::TRY_LOCK);
-
- if (dm.locked()) {
- dmg = desired_mute_gain;
- dsg = desired_solo_gain;
- dg = _desired_gain;
+}
+
+void
+Route::set_self_solo (bool yn)
+{
+ _self_solo = yn;
+}
+
+void
+Route::mod_solo_by_others (int32_t delta)
+{
+ if (delta < 0) {
+ if (_soloed_by_others >= (uint32_t) delta) {
+ _soloed_by_others += delta;
} else {
- dmg = mute_gain;
- dsg = solo_gain;
- dg = _gain;
+ _soloed_by_others = 0;
}
+ } else {
+ _soloed_by_others += delta;
}
- /* -------------------------------------------------------------------------------------------
- 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)
- ----------------------------------------------------------------------------------------- */
+ set_delivery_solo ();
+}
- {
- 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);
+void
+Route::set_delivery_solo ()
+{
+ /* tell all delivery processors what the solo situation is, so that they keep
+ delivering even though Session::soloing() is true and they were not
+ explicitly soloed.
+ */
+
+ Glib::RWLock::ReaderLock rm (_processor_lock);
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ boost::shared_ptr<Delivery> d;
+
+ if ((d = boost::dynamic_pointer_cast<Delivery> (*i)) != 0) {
+ d->set_solo_level (soloed ());
+ d->set_solo_isolated (solo_isolated());
}
}
+}
-
- /* -------------------------------------------------------------------------------------------
- INPUT METERING & MONITORING
- ----------------------------------------------------------------------------------------- */
-
- if (meter && (_meter_point == MeterInput)) {
- _meter->run_in_place(bufs, start_frame, end_frame, nframes, offset);
+void
+Route::set_solo_isolated (bool yn, void *src)
+{
+ if (_route_group && src != _route_group && _route_group->active_property (RouteGroup::Solo)) {
+ _route_group->apply (&Route::set_solo_isolated, yn, _route_group);
+ return;
}
- 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;
+ if (yn != _solo_isolated) {
+ _solo_isolated = yn;
+ set_delivery_solo ();
+ solo_isolated_changed (src);
}
+}
- /* -------------------------------------------------------------------------------------------
- PRE-FADER REDIRECTS
- ----------------------------------------------------------------------------------------- */
+bool
+Route::solo_isolated () const
+{
+ return _solo_isolated;
+}
- // This really should already be true...
- bufs.set_count(pre_fader_streams());
-
+void
+Route::set_mute_points (MuteMaster::MutePoint mp)
+{
+ _mute_points = mp;
+ mute_points_changed (); /* EMIT SIGNAL */
- 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()) )
+ if (_mute_master->muted()) {
+ _mute_master->mute_at (_mute_points);
+ mute_changed (this); /* EMIT SIGNAL */
+ }
+}
- ) {
-
- co->silence (nframes, offset);
-
+void
+Route::set_mute (bool yn, void *src)
+{
+ if (_route_group && src != _route_group && _route_group->active_property (RouteGroup::Mute)) {
+ _route_group->apply (&Route::set_mute, yn, _route_group);
+ return;
+ }
+
+ if (muted() != yn) {
+ if (yn) {
+ _mute_master->mute_at (_mute_points);
} else {
+ _mute_master->clear_mute ();
+ }
- co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
- }
- }
-
- /* -------------------------------------------------------------------------------------------
- GAIN STAGE
- ----------------------------------------------------------------------------------------- */
+ mute_changed (src); /* EMIT SIGNAL */
+ }
+}
- /* if not recording or recording and requiring any monitor signal, then apply gain */
+bool
+Route::muted() const
+{
+ return _mute_master->muted ();
+}
- if ( // not recording
+#if 0
+static void
+dump_processors(const string& name, const list<boost::shared_ptr<Processor> >& procs)
+{
+ 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 << "}" << endl;
+}
+#endif
- !(record_enabled() && _session.actively_recording()) ||
-
- // OR recording
-
- // AND software monitoring required
+int
+Route::add_processor (boost::shared_ptr<Processor> processor, Placement placement, ProcessorStreams* err)
+{
+ ProcessorList::iterator loc;
- 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.
- */
+ /* 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.
+ */
- 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);
- }
+ if (placement == PreFader) {
+ /* generic pre-fader: insert immediately before the amp */
+ loc = find (_processors.begin(), _processors.end(), _amp);
+ } else {
+ /* generic post-fader: insert right before the main outs */
+ loc = find (_processors.begin(), _processors.end(), _main_outs);
+ }
- } else if (_gain == 0) {
- for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
- i->clear();
- }
- }
- }
+ return add_processor (processor, loc, err);
+}
- } else {
- /* actively recording, no monitoring required; leave buffers as-is to save CPU cycles */
+/** Add a processor to the route.
+ * If @a iter is not NULL, it must point to an iterator in _processors and the new
+ * processor will be inserted immediately before this location. Otherwise,
+ * @a position is used.
+ */
+int
+Route::add_processor (boost::shared_ptr<Processor> processor, ProcessorList::iterator iter, ProcessorStreams* err)
+{
+ ChanCount old_pms = processor_max_streams;
+ if (!_session.engine().connected() || !processor) {
+ return 1;
}
- /* -------------------------------------------------------------------------------------------
- CONTROL OUTPUT STAGE
- ----------------------------------------------------------------------------------------- */
+ {
+ Glib::RWLock::WriterLock lm (_processor_lock);
- if ((_meter_point == MeterPostFader) && co) {
-
- solo_audible = solo_gain > 0;
- mute_audible = dmg > 0 || !_mute_affects_control_outs;
+ boost::shared_ptr<PluginInsert> pi;
+ boost::shared_ptr<PortInsert> porti;
- if ( // silent anyway
+ ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), processor);
- (_gain == 0 && !apply_gain_automation) ||
+ 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
+ return 0;
+ } else { // New position given, relocate
+ _processors.erase (loc);
+ }
+ }
- // muted by solo of another track
+ } else {
+ if (loc != _processors.end()) {
+ cerr << "ERROR: Processor added to route twice!" << endl;
+ return 1;
+ }
- !solo_audible ||
+ loc = iter;
+ }
- // muted by mute of this track
+ _processors.insert (loc, processor);
- !mute_audible ||
+ // Set up processor list channels. This will set processor->[input|output]_streams(),
+ // configure redirect ports properly, etc.
- // recording but not s/w monitoring
+ if (configure_processors_unlocked (err)) {
+ ProcessorList::iterator ploc = loc;
+ --ploc;
+ _processors.erase(ploc);
+ configure_processors_unlocked (0); // it worked before we tried to add it ...
+ cerr << "configure failed\n";
+ return -1;
+ }
- (no_monitor && record_enabled() && (!Config->get_auto_input() || _session.actively_recording()))
+ if ((pi = boost::dynamic_pointer_cast<PluginInsert>(processor)) != 0) {
- ) {
-
- co->silence (nframes, offset);
-
- } else {
+ if (pi->natural_input_streams() == ChanCount::ZERO) {
+ /* generator plugin */
+ _have_internal_generator = true;
+ }
- co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
- }
- }
+ }
- /* -------------------------------------------------------------------------------------------
- MAIN OUTPUT STAGE
- ----------------------------------------------------------------------------------------- */
+ if (_control_outs != processor) {
+ // 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));
- solo_audible = dsg > 0;
- mute_audible = dmg > 0 || !_mute_affects_main_outs;
-
- if (n_outputs().get(_default_type) == 0) {
-
- /* relax */
+ _output->set_user_latency (0);
+ }
- } else if (no_monitor && record_enabled()
- && (!Config->get_auto_input() || _session.actively_recording())) {
-
- IO::silence (nframes, offset);
-
- } else {
+ processors_changed (); /* EMIT SIGNAL */
- if ( // silent anyway
+ return 0;
+}
- (_gain == 0 && !apply_gain_automation) ||
+bool
+Route::add_processor_from_xml (const XMLNode& node, ProcessorList::iterator iter)
+{
+ const XMLProperty *prop;
- // muted by solo of another track, but not using control outs for solo
+ if (node.name() != "Processor") {
+ return false;
+ }
- (!solo_audible && (Config->get_solo_model() != SoloBus)) ||
+ try {
+ if ((prop = node.property ("type")) != 0) {
- // muted by mute of this track
+ boost::shared_ptr<Processor> processor;
- !mute_audible
+ if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
+ prop->value() == "lv2" ||
+ prop->value() == "vst" ||
+ prop->value() == "audiounit") {
- ) {
+ processor.reset (new PluginInsert(_session, node));
- /* don't use Route::silence() here, because that causes
- all outputs (sends, port processors, etc. to be silent).
- */
+ } else if (prop->value() == "port") {
- if (_meter_point == MeterPostFader) {
- peak_meter().reset();
- }
+ processor.reset (new PortInsert (_session, _mute_master, node));
- IO::silence (nframes, offset);
-
- } else {
-
- deliver_output(bufs, start_frame, end_frame, nframes, offset);
+ } else if (prop->value() == "send") {
- }
+ processor.reset (new Send (_session, _mute_master, node));
- }
-}
+ } else if (prop->value() == "meter") {
-#endif /* NEW_POB */
+ if (_meter) {
+ if (_meter->set_state (node, Stateful::loading_state_version)) {
+ return false;
+ } else {
+ return true;
+ }
+ }
-ChanCount
-Route::n_process_buffers ()
-{
- return max (n_inputs(), processor_max_outs);
-}
+ _meter.reset (new PeakMeter (_session, node));
+ _meter->set_display_to_user (_meter_point == MeterCustom);
+ processor = _meter;
-void
-Route::passthru (nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset, int declick, bool meter_first)
-{
- BufferSet& bufs = _session.get_scratch_buffers(n_process_buffers());
+ } else if (prop->value() == "amp") {
- _silent = false;
+ /* amp always exists */
- collect_input (bufs, nframes, offset);
+ processor = _amp;
+ if (processor->set_state (node, Stateful::loading_state_version)) {
+ return false;
+ } else {
+ /* never any reason to add it */
+ return true;
+ }
- 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);
-}
+ } else if (prop->value() == "intsend") {
-void
-Route::passthru_silence (nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset, int declick, bool meter)
-{
- process_output_buffers (_session.get_silent_buffers (n_process_buffers()), start_frame, end_frame, nframes, offset, true, declick, meter);
-}
+ processor.reset (new InternalSend (_session, _mute_master, node));
-void
-Route::set_solo (bool yn, void *src)
-{
- if (_solo_safe) {
- return;
- }
+ } else if (prop->value() == "intreturn") {
- if (_mix_group && src != _mix_group && _mix_group->is_active()) {
- _mix_group->apply (&Route::set_solo, yn, _mix_group);
- return;
- }
+ if (_intreturn) {
+ if (_intreturn->set_state (node, Stateful::loading_state_version)) {
+ return false;
+ } else {
+ return true;
+ }
+ }
+ _intreturn.reset (new InternalReturn (_session, node));
+ processor = _intreturn;
- if (_soloed != yn) {
- _soloed = yn;
- solo_changed (src); /* EMIT SIGNAL */
- _solo_control->Changed (); /* EMIT SIGNAL */
- }
-
- catch_up_on_solo_mute_override ();
-}
+ } else if (prop->value() == "main-outs") {
-void
-Route::catch_up_on_solo_mute_override ()
-{
- if (Config->get_solo_model() != InverseMute) {
- return;
- }
-
- {
+ if (_main_outs) {
+ if (_main_outs->set_state (node, Stateful::loading_state_version)) {
+ return false;
+ } else {
+ return true;
+ }
+ }
+
+ _main_outs.reset (new Delivery (_session, _output, _mute_master, node));
+ processor = _main_outs;
- 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;
+ error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
+ return false;
+ }
+
+ if (iter == _processors.end() && processor->display_to_user() && !_processors.empty()) {
+ /* check for invisible processors stacked at the end and leave them there */
+ ProcessorList::iterator p;
+ p = _processors.end();
+ --p;
+ while (!(*p)->display_to_user() && p != _processors.begin()) {
+ --p;
+ }
+ ++p;
+ iter = p;
}
+
+ return (add_processor (processor, iter) == 0);
+
} else {
- desired_mute_gain = 1.0;
+ error << _("Processor XML node has no type property") << endmsg;
+ return false;
}
}
+
+ catch (failed_constructor &err) {
+ warning << _("processor could not be created. Ignored.") << endmsg;
+ return false;
+ }
}
-void
-Route::set_solo_mute (bool yn)
+
+bool
+Route::add_processor_from_xml_2X (const XMLNode& node, int version, ProcessorList::iterator iter)
{
- Glib::Mutex::Lock lm (declick_lock);
+ const XMLProperty *prop;
- /* Called by Session in response to another Route being soloed.
- */
-
- desired_solo_gain = (yn?0.0:1.0);
-}
+ try {
+ boost::shared_ptr<Processor> processor;
-void
-Route::set_solo_safe (bool yn, void *src)
-{
- if (_solo_safe != yn) {
- _solo_safe = yn;
- solo_safe_changed (src); /* EMIT SIGNAL */
- }
-}
+ if (node.name() == "Insert") {
-void
-Route::set_mute (bool yn, void *src)
+ if ((prop = node.property ("type")) != 0) {
-{
- if (_mix_group && src != _mix_group && _mix_group->is_active()) {
- _mix_group->apply (&Route::set_mute, yn, _mix_group);
- return;
- }
+ if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
+ prop->value() == "lv2" ||
+ prop->value() == "vst" ||
+ prop->value() == "audiounit") {
- if (_muted != yn) {
- _muted = yn;
- mute_changed (src); /* EMIT SIGNAL */
-
- _mute_control->Changed (); /* EMIT SIGNAL */
-
- Glib::Mutex::Lock lm (declick_lock);
-
- if (_soloed && Config->get_solo_mute_override()){
- desired_mute_gain = 1.0f;
- } else {
- desired_mute_gain = (yn?0.0f:1.0f);
- }
- }
-}
+ processor.reset (new PluginInsert (_session, node));
-int
-Route::add_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err)
-{
- ChanCount old_pmo = processor_max_outs;
+ } else {
- if (!_session.engine().connected()) {
- return 1;
- }
+ processor.reset (new PortInsert (_session, _mute_master, node));
+ }
- {
- Glib::RWLock::WriterLock lm (_processor_lock);
+ }
- boost::shared_ptr<PluginInsert> pi;
- boost::shared_ptr<PortInsert> porti;
+ } else if (node.name() == "Send") {
- //processor->set_default_type(_default_type);
+ processor.reset (new Send (_session, _mute_master, node, version));
- _processors.push_back (processor);
+ } else {
- // 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;
+ error << string_compose(_("unknown Processor type \"%1\"; ignored"), node.name()) << endmsg;
+ return false;
}
- if ((pi = boost::dynamic_pointer_cast<PluginInsert>(processor)) != 0) {
-
- if (pi->natural_input_streams() == ChanCount::ZERO) {
- /* generator plugin */
- _have_internal_generator = true;
+ if (iter == _processors.end() && processor->display_to_user() && !_processors.empty()) {
+ /* check for invisible processors stacked at the end and leave them there */
+ ProcessorList::iterator p;
+ p = _processors.end();
+ --p;
+ while (!(*p)->display_to_user() && p != _processors.begin()) {
+ --p;
}
-
+ ++p;
+ iter = p;
}
-
- // Ensure peak vector sizes before the plugin is activated
- ChanCount 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()));
+ return (add_processor (processor, iter) == 0);
+ }
- _meter->configure_io (potential_max_streams, potential_max_streams);
+ catch (failed_constructor &err) {
+ warning << _("processor could not be created. Ignored.") << endmsg;
+ return false;
+ }
+}
- // 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));
+int
+Route::add_processors (const ProcessorList& others, boost::shared_ptr<Processor> before, ProcessorStreams* err)
+{
+ ProcessorList::iterator loc;
- _user_latency = 0;
- }
-
- if (processor_max_outs != old_pmo || old_pmo == ChanCount::ZERO) {
- reset_panner ();
+ 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);
}
- processors_changed (); /* EMIT SIGNAL */
-
- return 0;
+ return add_processors (others, loc, err);
}
int
-Route::add_processors (const ProcessorList& others, ProcessorStreams* err)
+Route::add_processors (const ProcessorList& others, ProcessorList::iterator iter, ProcessorStreams* err)
{
/* NOTE: this is intended to be used ONLY when copying
processors from another Route. Hence the subtle
differences between this and ::add_processor()
*/
- ChanCount old_pmo = processor_max_outs;
+ ChanCount old_pms = processor_max_streams;
if (!_session.engine().connected()) {
return 1;
}
+ if (others.empty()) {
+ return 0;
+ }
+
{
Glib::RWLock::WriterLock lm (_processor_lock);
-
ProcessorList::iterator existing_end = _processors.end();
--existing_end;
- ChanCount potential_max_streams;
+ ChanCount potential_max_streams = ChanCount::max (_input->n_ports(), _output->n_ports());
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);
+ }
+ }
+
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)
+
+ ChanCount m = max (pi->input_streams(), pi->output_streams());
+
+ if (m > potential_max_streams) {
potential_max_streams = m;
+ }
}
- // Ensure peak vector sizes before the plugin is activated
- _meter->configure_io (potential_max_streams, potential_max_streams);
+ _processors.insert (iter, *i);
- _processors.push_back (*i);
-
- if (_reset_processor_counts (err)) {
+ if (configure_processors_unlocked (err)) {
++existing_end;
_processors.erase (existing_end, _processors.end());
- _reset_processor_counts (0); // it worked before we tried to add it ...
+ configure_processors_unlocked (0); // it worked before we tried to add it ...
return -1;
}
-
+
(*i)->ActiveChanged.connect (bind (mem_fun (_session, &Session::update_latency_compensation), false, false));
}
- _user_latency = 0;
- }
-
- if (processor_max_outs != old_pmo || old_pmo == ChanCount::ZERO) {
- reset_panner ();
+ _output->set_user_latency (0);
}
processors_changed (); /* EMIT SIGNAL */
+
return 0;
}
+void
+Route::placement_range(Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end)
+{
+ if (p == PreFader) {
+ start = _processors.begin();
+ end = find(_processors.begin(), _processors.end(), _amp);
+ } else {
+ start = find(_processors.begin(), _processors.end(), _amp);
+ ++start;
+ end = _processors.end();
+ }
+}
+
/** Turn off all processors with a given placement
* @param p Placement of processors to disable
*/
Route::disable_processors (Placement p)
{
Glib::RWLock::ReaderLock lm (_processor_lock);
-
- for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- if ((*i)->placement() == p) {
- (*i)->deactivate ();
- }
+
+ ProcessorList::iterator start, end;
+ placement_range(p, start, end);
+
+ for (ProcessorList::iterator i = start; i != end; ++i) {
+ (*i)->deactivate ();
}
_session.set_dirty ();
}
-/** Turn off all redirects
+/** Turn off all redirects
*/
void
Route::disable_processors ()
{
Glib::RWLock::ReaderLock lm (_processor_lock);
-
+
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
(*i)->deactivate ();
}
-
+
_session.set_dirty ();
}
Route::disable_plugins (Placement p)
{
Glib::RWLock::ReaderLock lm (_processor_lock);
-
- for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- if (boost::dynamic_pointer_cast<PluginInsert> (*i) && (*i)->placement() == p) {
+
+ ProcessorList::iterator start, end;
+ placement_range(p, start, end);
+
+ for (ProcessorList::iterator i = start; i != end; ++i) {
+ if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
(*i)->deactivate ();
}
}
-
+
_session.set_dirty ();
}
Route::disable_plugins ()
{
Glib::RWLock::ReaderLock lm (_processor_lock);
-
+
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
(*i)->deactivate ();
}
}
-
+
_session.set_dirty ();
}
Route::ab_plugins (bool forward)
{
Glib::RWLock::ReaderLock lm (_processor_lock);
-
+
if (forward) {
/* forward = turn off all active redirects, and mark them so that the next time
}
}
}
-
- _session.set_dirty ();
-}
-
-
-/* Figure out the streams that will feed into PreFader */
-ChanCount
-Route::pre_fader_streams() const
-{
- boost::shared_ptr<Processor> processor;
- /* Find the last pre-fader redirect that isn't a send; sends don't affect the number
- * of streams. */
- for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
- if ((*i)->placement() == PreFader && boost::dynamic_pointer_cast<Send> (*i) == 0) {
- processor = *i;
- }
- }
-
- if (processor) {
- return processor->output_streams();
- } else {
- return n_inputs ();
- }
+ _session.set_dirty ();
}
void
Route::clear_processors (Placement p)
{
- const ChanCount old_pmo = processor_max_outs;
+ const ChanCount old_pms = processor_max_streams;
if (!_session.engine().connected()) {
return;
}
+ bool already_deleting = _session.deletion_in_progress();
+ if (!already_deleting) {
+ _session.set_deletion_in_progress();
+ }
+
{
Glib::RWLock::WriterLock lm (_processor_lock);
ProcessorList new_list;
-
+ ProcessorStreams err;
+ bool seen_amp = false;
+
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 ();
- } else {
- /* it's a different placement, so keep it */
+
+ if (*i == _amp) {
+ seen_amp = true;
+ }
+
+ if ((*i) == _amp || (*i) == _meter || (*i) == _main_outs) {
+
+ /* you can't remove these */
+
new_list.push_back (*i);
+
+ } else {
+ if (seen_amp) {
+
+ switch (p) {
+ case PreFader:
+ new_list.push_back (*i);
+ break;
+ case PostFader:
+ (*i)->drop_references ();
+ break;
+ }
+
+ } else {
+
+ switch (p) {
+ case PreFader:
+ (*i)->drop_references ();
+ break;
+ case PostFader:
+ new_list.push_back (*i);
+ break;
+ }
+ }
}
}
-
+
_processors = new_list;
+ configure_processors_unlocked (&err); // this can't fail
}
- /* FIXME: can't see how this test can ever fire */
- if (processor_max_outs != old_pmo) {
- reset_panner ();
- }
-
- processor_max_outs.reset();
+ processor_max_streams.reset();
_have_internal_generator = false;
processors_changed (); /* EMIT SIGNAL */
+
+ if (!already_deleting) {
+ _session.clear_deletion_in_progress();
+ }
}
int
Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err)
{
- ChanCount old_pmo = processor_max_outs;
+ /* these can never be removed */
+
+ if (processor == _amp || processor == _meter || processor == _main_outs) {
+ return 0;
+ }
+
+ ChanCount old_pms = processor_max_streams;
if (!_session.engine().connected()) {
return 1;
}
- processor_max_outs.reset();
+ processor_max_streams.reset();
{
Glib::RWLock::WriterLock lm (_processor_lock);
ProcessorList::iterator i;
bool removed = false;
- for (i = _processors.begin(); i != _processors.end(); ++i) {
+ for (i = _processors.begin(); i != _processors.end(); ) {
if (*i == processor) {
- ProcessorList::iterator tmp;
-
- /* move along, see failure case for reset_processor_counts()
- where we may need to reprocessor the processor.
+ /* move along, see failure case for configure_processors()
+ where we may need to reconfigure the processor.
*/
- tmp = i;
- ++tmp;
-
/* stop redirects that send signals to JACK ports
from causing noise as a result of no longer being
run.
*/
- boost::shared_ptr<IOProcessor> redirect;
-
- if ((redirect = boost::dynamic_pointer_cast<IOProcessor> (*i)) != 0) {
- redirect->io()->disconnect_inputs (this);
- redirect->io()->disconnect_outputs (this);
- }
+ boost::shared_ptr<IOProcessor> iop;
- _processors.erase (i);
+ if ((iop = boost::dynamic_pointer_cast<IOProcessor> (*i)) != 0) {
+ if (iop->input()) {
+ iop->input()->disconnect (this);
+ }
+ if (iop->output()) {
+ iop->output()->disconnect (this);
+ }
+ }
- i = tmp;
+ i = _processors.erase (i);
removed = true;
break;
+
+ } else {
+ ++i;
}
- _user_latency = 0;
+ _output->set_user_latency (0);
}
if (!removed) {
return 1;
}
- if (_reset_processor_counts (err)) {
+ if (configure_processors_unlocked (err)) {
/* get back to where we where */
_processors.insert (i, processor);
/* we know this will work, because it worked before :) */
- _reset_processor_counts (0);
+ configure_processors_unlocked (0);
return -1;
}
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()) {
_have_internal_generator = true;
}
}
- if (old_pmo != processor_max_outs) {
- reset_panner ();
- }
-
processor->drop_references ();
-
processors_changed (); /* EMIT SIGNAL */
+
return 0;
}
int
-Route::reset_processor_counts (ProcessorStreams* err)
+Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
{
- Glib::RWLock::WriterLock lm (_processor_lock);
- return _reset_processor_counts (err);
-}
-
-
-int
-Route::_reset_processor_counts (ProcessorStreams* err)
-{
- ProcessorList::iterator r;
- 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;
-
- processor_max_outs.reset ();
-
- /* 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.
- */
-
- /* ... but it should/will be... */
-
- for (r = _processors.begin(); r != _processors.end(); ++r) {
+ ProcessorList deleted;
+ ProcessorList as_we_were;
- 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) {
+ if (!_session.engine().connected()) {
+ return 1;
+ }
- ++insert_cnt;
- proc_map[(*r)->placement()].push_back (ProcessorCount (*r));
+ processor_max_streams.reset();
- } else if (boost::dynamic_pointer_cast<Send> (*r) != 0) {
- ++send_cnt;
- }
- }
+ {
+ Glib::RWLock::WriterLock lm (_processor_lock);
+ ProcessorList::iterator i;
+ boost::shared_ptr<Processor> processor;
- if (insert_cnt == 0) {
- if (send_cnt) {
- goto recompute;
- } else {
- ret = 0;
- goto streamcount;
- }
- }
+ as_we_were = _processors;
- /* Now process each placement in order, checking to see if we
- can really do what has been requested.
- */
+ for (i = _processors.begin(); i != _processors.end(); ) {
- /* A: PreFader */
-
- if (check_some_processor_counts (proc_map[PreFader], n_inputs (), err)) {
- goto streamcount;
- }
+ processor = *i;
- 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) == false) {
- goto streamcount;
- }
- previous_initial_streams = initial_streams;
- }
- }
+ /* these can never be removed */
- /* B: PostFader */
+ if (processor == _amp || processor == _meter || processor == _main_outs) {
+ ++i;
+ continue;
+ }
- if (check_some_processor_counts (proc_map[PostFader], initial_streams, err)) {
- goto streamcount;
- }
+ /* see if its in the list of processors to delete */
- 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) == false) {
- goto streamcount;
+ if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
+ ++i;
+ continue;
}
- previous_initial_streams = initial_streams;
- }
- }
- /* OK, everything can be set up correctly, so lets do it */
+ /* stop IOProcessors that send to JACK ports
+ from causing noise as a result of no longer being
+ run.
+ */
- apply_some_processor_counts (proc_map[PreFader]);
- apply_some_processor_counts (proc_map[PostFader]);
+ boost::shared_ptr<IOProcessor> iop;
- /* recompute max outs of any processor */
+ if ((iop = boost::dynamic_pointer_cast<IOProcessor> (processor)) != 0) {
+ iop->disconnect ();
+ }
- ret = 0;
+ deleted.push_back (processor);
+ i = _processors.erase (i);
+ }
- recompute:
+ if (deleted.empty()) {
+ /* none of those in the requested list were found */
+ return 0;
+ }
- processor_max_outs.reset ();
- prev = _processors.end();
+ _output->set_user_latency (0);
- for (r = _processors.begin(); r != _processors.end(); prev = r, ++r) {
- boost::shared_ptr<Send> s;
+ if (configure_processors_unlocked (err)) {
+ /* get back to where we where */
+ _processors = as_we_were;
+ /* we know this will work, because it worked before :) */
+ configure_processors_unlocked (0);
+ return -1;
+ }
- if ((s = boost::dynamic_pointer_cast<Send> (*r)) != 0) {
+ _have_internal_generator = false;
- /* don't pay any attention to send output configuration, since it doesn't
- affect the route.
- */
+ for (i = _processors.begin(); i != _processors.end(); ++i) {
+ boost::shared_ptr<PluginInsert> pi;
- if (r == _processors.begin()) {
- s->expect_inputs (n_inputs());
- } else {
- s->expect_inputs ((*prev)->output_streams());
+ if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
+ if (pi->is_generator()) {
+ _have_internal_generator = true;
+ break;
+ }
}
-
- } else {
-
- 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;
+ /* now try to do what we need to so that those that were removed will be deleted */
- 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);
+ for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
+ (*i)->drop_references ();
}
- processor_max_outs.set (DataType::AUDIO, max_audio);
- processor_max_outs.set (DataType::MIDI, max_midi);
-
- return ret;
-}
-
-int32_t
-Route::apply_some_processor_counts (list<ProcessorCount>& iclist)
-{
- list<ProcessorCount>::iterator i;
-
- for (i = iclist.begin(); i != iclist.end(); ++i) {
-
- ProcessorCount& pc (*i);
+ processors_changed (); /* EMIT SIGNAL */
- if (pc.processor->configure_io (pc.in, pc.out)) {
- return -1;
- }
+ return 0;
+}
- /* make sure that however many we have, they are all active */
- pc.processor->activate ();
+int
+Route::configure_processors (ProcessorStreams* err)
+{
+ if (!_in_configure_processors) {
+ Glib::RWLock::WriterLock lm (_processor_lock);
+ return configure_processors_unlocked (err);
}
-
return 0;
}
-/** Returns whether \a iclist can be configured and run starting with
- * \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.
+/** Configure the input/output configuration of each processor in the processors list.
+ * Return 0 on success, otherwise configuration is impossible.
*/
-bool
-Route::check_some_processor_counts (list<ProcessorCount>& iclist, ChanCount required_inputs, ProcessorStreams* err)
+int
+Route::configure_processors_unlocked (ProcessorStreams* err)
{
- list<ProcessorCount>::iterator i;
- size_t index = 0;
-
- if (err) {
- err->index = 0;
- err->count = required_inputs;
+ if (_in_configure_processors) {
+ return 0;
+ }
+
+ _in_configure_processors = true;
+
+ // Check each processor in order to see if we can configure as requested
+ ChanCount in = _input->n_ports ();
+ ChanCount out;
+ list< pair<ChanCount,ChanCount> > configuration;
+ uint32_t index = 0;
+
+ DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
+#ifndef NDEBUG
+ DEBUG_TRACE (DEBUG::Processors, "{\n");
+ for (list<boost::shared_ptr<Processor> >::const_iterator p = _processors.begin(); p != _processors.end(); ++p) {
+ DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID = %2\n", (*p)->name(), (*p)->id()));
}
+ DEBUG_TRACE (DEBUG::Processors, "}\n");
+#endif
- for (i = iclist.begin(); i != iclist.end(); ++i, ++index) {
+ for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
- if (!(*i).processor->can_support_io_configuration (required_inputs, (*i).out)) {
+ if ((*p)->can_support_io_configuration(in, out)) {
+ DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1in = %2 out = %3\n",(*p)->name(), in, out));
+ configuration.push_back(make_pair(in, out));
+ in = out;
+ } else {
if (err) {
err->index = index;
- err->count = required_inputs;
+ err->count = in;
}
- return true;
+ _in_configure_processors = false;
+ return -1;
}
-
- (*i).in = required_inputs;
- required_inputs = (*i).out;
}
- return false;
+ /* Take the process lock so that if we add a processor which increases the required
+ number of scratch buffers, we create those scratch buffers before the process
+ thread has a chance to ask for them.
+ XXX: in an ideal world we'd perhaps use some RCU magic to avoid having to take
+ the lock here.
+ */
+
+ Glib::Mutex::Lock pl (_session.engine().process_lock ());
+
+ // We can, so configure everything
+ list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
+ for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
+ (*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);
+ out = c->second;
+ }
+
+ /* make sure we have sufficient scratch buffers to cope with the new processor
+ configuration */
+ _session.ensure_buffers (n_process_buffers ());
+
+ _in_configure_processors = false;
+ return 0;
}
void
}
bool first_is_on = _processors.front()->active();
-
+
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
if (first_is_on) {
(*i)->deactivate ();
(*i)->activate ();
}
}
-
+
_session.set_dirty ();
}
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)->placement() == p) {
+ if ((*i) == _amp) {
+ before_amp = false;
+ continue;
+ }
+ if (p == PreFader && before_amp) {
if (state) {
(*i)->activate ();
} else {
}
}
}
-
+
_session.set_dirty ();
}
-struct ProcessorSorter {
- bool operator() (boost::shared_ptr<const Processor> a, boost::shared_ptr<const Processor> b) {
- return a->sort_key() < b->sort_key();
- }
-};
+bool
+Route::processor_is_prefader (boost::shared_ptr<Processor> p)
+{
+ bool pre_fader = true;
+ Glib::RWLock::ReaderLock lm (_processor_lock);
+
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+
+ /* 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::sort_processors (ProcessorStreams* err)
+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.
+ */
+
{
- ProcessorSorter comparator;
Glib::RWLock::WriterLock lm (_processor_lock);
- ChanCount old_pmo = processor_max_outs;
+ ChanCount old_pms = processor_max_streams;
+ ProcessorList::iterator oiter;
+ ProcessorList::const_iterator niter;
+ ProcessorList as_it_was_before = _processors;
+ ProcessorList as_it_will_be;
- /* the sweet power of C++ ... */
+ oiter = _processors.begin();
+ niter = new_order.begin();
- ProcessorList as_it_was_before = _processors;
+ while (niter != new_order.end()) {
- _processors.sort (comparator);
-
- if (_reset_processor_counts (err)) {
+ /* if the next processor in the old list is invisible (i.e. should not be in the new order)
+ then append it to the temp list.
+
+ Otherwise, see if the next processor in the old list is in the new list. if not,
+ its been deleted. If its there, append it to the temp list.
+ */
+
+ if (oiter == _processors.end()) {
+
+ /* no more elements in the old list, so just stick the rest of
+ the new order onto the temp list.
+ */
+
+ as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
+ while (niter != new_order.end()) {
+ ++niter;
+ }
+ break;
+
+ } else {
+
+ if (!(*oiter)->display_to_user()) {
+
+ as_it_will_be.push_back (*oiter);
+
+ } else {
+
+ /* visible processor: check that its in the new order */
+
+ if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
+ /* deleted: do nothing, shared_ptr<> will clean up */
+ } else {
+ /* ignore this one, and add the next item from the new order instead */
+ as_it_will_be.push_back (*niter);
+ ++niter;
+ }
+ }
+
+ /* 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 (configure_processors_unlocked (err)) {
_processors = as_it_was_before;
- processor_max_outs = old_pmo;
+ processor_max_streams = old_pms;
return -1;
- }
- }
+ }
+ }
- reset_panner ();
processors_changed (); /* EMIT SIGNAL */
return 0;
ProcessorList::iterator i;
char buf[32];
+ id().print (buf, sizeof (buf));
+ node->add_property("id", buf);
+ node->add_property ("name", _name);
+ node->add_property("default-type", _default_type.to_string());
+
if (_flags) {
node->add_property("flags", enum_2_string (_flags));
}
-
- node->add_property("default-type", _default_type.to_string());
node->add_property("active", _active?"yes":"no");
- node->add_property("muted", _muted?"yes":"no");
- node->add_property("soloed", _soloed?"yes":"no");
node->add_property("phase-invert", _phase_invert?"yes":"no");
node->add_property("denormal-protection", _denormal_protection?"yes":"no");
- node->add_property("mute-affects-pre-fader", _mute_affects_pre_fader?"yes":"no");
- node->add_property("mute-affects-post-fader", _mute_affects_post_fader?"yes":"no");
- node->add_property("mute-affects-control-outs", _mute_affects_control_outs?"yes":"no");
- node->add_property("mute-affects-main-outs", _mute_affects_main_outs?"yes":"no");
node->add_property("meter-point", enum_2_string (_meter_point));
- if (_edit_group) {
- node->add_property("edit-group", _edit_group->name());
- }
- if (_mix_group) {
- node->add_property("mix-group", _mix_group->name());
+ if (_route_group) {
+ node->add_property("route-group", _route_group->name());
}
string order_string;
- OrderKeys::iterator x = order_keys.begin();
+ OrderKeys::iterator x = order_keys.begin();
while (x != order_keys.end()) {
order_string += string ((*x).first);
order_string += '=';
snprintf (buf, sizeof(buf), "%ld", (*x).second);
order_string += buf;
-
+
++x;
if (x == order_keys.end()) {
order_string += ':';
}
node->add_property ("order-keys", order_string);
+ node->add_property ("self-solo", (_self_solo ? "yes" : "no"));
+ snprintf (buf, sizeof (buf), "%d", _soloed_by_others);
+ node->add_property ("soloed-by-others", buf);
- node->add_child_nocopy (IO::state (full_state));
+ node->add_child_nocopy (_input->state (full_state));
+ node->add_child_nocopy (_output->state (full_state));
node->add_child_nocopy (_solo_control->get_state ());
- node->add_child_nocopy (_mute_control->get_state ());
+ node->add_child_nocopy (_mute_master->get_state ());
XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
snprintf (buf, sizeof (buf), "%d", _remote_control_id);
remote_control_node->add_property (X_("id"), buf);
node->add_child_nocopy (*remote_control_node);
- if (_control_outs) {
- XMLNode* cnode = new XMLNode (X_("ControlOuts"));
- cnode->add_child_nocopy (_control_outs->state (full_state));
- node->add_child_nocopy (*cnode);
- }
-
if (_comment.length()) {
XMLNode *cmt = node->add_child ("Comment");
cmt->add_content (_comment);
if (_extra_xml){
node->add_child_copy (*_extra_xml);
}
-
+
return *node;
}
-XMLNode&
-Route::get_processor_state ()
+int
+Route::set_state (const XMLNode& node, int version)
{
- XMLNode* root = new XMLNode (X_("redirects"));
- for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- root->add_child_nocopy ((*i)->state (true));
- }
-
- return *root;
+ return _set_state (node, version, true);
}
int
-Route::set_processor_state (const XMLNode& root)
+Route::_set_state (const XMLNode& node, int version, bool /*call_base*/)
{
- if (root.name() != X_("redirects")) {
- return -1;
+ if (version < 3000) {
+ return _set_state_2X (node, version);
}
XMLNodeList nlist;
- XMLNodeList nnlist;
- XMLNodeConstIterator iter;
XMLNodeConstIterator niter;
- Glib::RWLock::ReaderLock lm (_processor_lock);
+ XMLNode *child;
+ XMLPropertyList plist;
+ const XMLProperty *prop;
- nlist = root.children();
-
- for (iter = nlist.begin(); iter != nlist.end(); ++iter){
+ if (node.name() != "Route"){
+ error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
+ return -1;
+ }
- /* iter now points to a IOProcessor state node */
-
- nnlist = (*iter)->children ();
+ if ((prop = node.property (X_("name"))) != 0) {
+ Route::set_name (prop->value());
+ }
- for (niter = nnlist.begin(); niter != nnlist.end(); ++niter) {
+ if ((prop = node.property ("id")) != 0) {
+ _id = prop->value ();
+ }
- /* find the IO child node, since it contains the ID we need */
+ if ((prop = node.property (X_("flags"))) != 0) {
+ _flags = Flag (string_2_enum (prop->value(), _flags));
+ } else {
+ _flags = Flag (0);
+ }
- /* XXX OOP encapsulation violation, ugh */
+ /* add all processors (except amp, which is always present) */
- if ((*niter)->name() == IO::state_node_name) {
+ nlist = node.children();
+ XMLNode processor_state (X_("processor_state"));
- XMLProperty* prop = (*niter)->property (X_("id"));
-
- if (!prop) {
- warning << _("IOProcessor node has no ID, ignored") << endmsg;
- break;
- }
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter){
- ID id = prop->value ();
+ child = *niter;
- /* now look for a processor with that ID */
-
- for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- if ((*i)->id() == id) {
- (*i)->set_state (**iter);
- break;
- }
- }
-
- break;
-
+ if (child->name() == IO::state_node_name) {
+ if ((prop = child->property (X_("direction"))) == 0) {
+ continue;
+ }
+
+ if (prop->value() == "Input") {
+ _input->set_state (*child, version);
+ } else if (prop->value() == "Output") {
+ _output->set_state (*child, version);
}
}
+ if (child->name() == X_("Processor")) {
+ processor_state.add_child_copy (*child);
+ }
}
- return 0;
-}
+ set_processor_state (processor_state);
-void
-Route::set_deferred_state ()
-{
- XMLNodeList nlist;
- XMLNodeConstIterator niter;
+ if ((prop = node.property ("self-solo")) != 0) {
+ set_self_solo (string_is_affirmative (prop->value()));
+ }
- if (!deferred_state) {
- return;
+ if ((prop = node.property ("soloed-by-others")) != 0) {
+ _soloed_by_others = 0; // needed for mod_solo_by_others () to work
+ mod_solo_by_others (atoi (prop->value()));
}
- nlist = deferred_state->children();
+ if ((prop = node.property ("solo-isolated")) != 0) {
+ set_solo_isolated (string_is_affirmative (prop->value()), this);
+ }
- for (niter = nlist.begin(); niter != nlist.end(); ++niter){
- add_processor_from_xml (**niter);
+ if ((prop = node.property (X_("phase-invert"))) != 0) {
+ set_phase_invert (string_is_affirmative (prop->value()));
}
- delete deferred_state;
- deferred_state = 0;
-}
+ if ((prop = node.property (X_("denormal-protection"))) != 0) {
+ set_denormal_protection (string_is_affirmative (prop->value()));
+ }
-void
-Route::add_processor_from_xml (const XMLNode& node)
-{
- const XMLProperty *prop;
+ if ((prop = node.property (X_("active"))) != 0) {
+ bool yn = string_is_affirmative (prop->value());
+ _active = !yn; // force switch
+ set_active (yn);
+ }
- // legacy sessions use a different node name for sends
- if (node.name() == "Send") {
-
- try {
- boost::shared_ptr<Send> send (new Send (_session, node));
- add_processor (send);
- }
-
- catch (failed_constructor &err) {
- error << _("Send construction failed") << endmsg;
- return;
+ if ((prop = node.property (X_("meter-point"))) != 0) {
+ _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
+ if (_meter) {
+ _meter->set_display_to_user (_meter_point == MeterCustom);
}
-
- // use "Processor" in XML?
- } else if (node.name() == "Processor") {
-
- try {
- if ((prop = node.property ("type")) != 0) {
+ }
+
+ if ((prop = node.property (X_("route-group"))) != 0) {
+ RouteGroup* route_group = _session.route_group_by_name(prop->value());
+ if (route_group == 0) {
+ error << string_compose(_("Route %1: unknown route group \"%2 in saved state (ignored)"), _name, prop->value()) << endmsg;
+ } else {
+ set_route_group (route_group, this);
+ }
+ }
+
+ if ((prop = node.property (X_("order-keys"))) != 0) {
+
+ long n;
+
+ string::size_type colon, equal;
+ string remaining = prop->value();
+
+ while (remaining.length()) {
+
+ if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
+ error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
+ << endmsg;
+ } else {
+ if (sscanf (remaining.substr (equal+1).c_str(), "%ld", &n) != 1) {
+ error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
+ << endmsg;
+ } else {
+ set_order_key (remaining.substr (0, equal), n);
+ }
+ }
+
+ colon = remaining.find_first_of (':');
+
+ if (colon != string::npos) {
+ remaining = remaining.substr (colon+1);
+ } else {
+ break;
+ }
+ }
+ }
+
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter){
+ child = *niter;
+
+ if (child->name() == X_("Comment")) {
+
+ /* XXX this is a terrible API design in libxml++ */
+
+ XMLNode *cmt = *(child->children().begin());
+ _comment = cmt->content();
- boost::shared_ptr<Processor> processor;
- bool have_insert = false;
+ } else if (child->name() == X_("Extra")) {
- if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
- prop->value() == "lv2" ||
- prop->value() == "vst" ||
- prop->value() == "audiounit") {
-
- processor.reset (new PluginInsert(_session, node));
- have_insert = true;
-
- } else if (prop->value() == "port") {
-
- processor.reset (new PortInsert (_session, node));
-
- } else if (prop->value() == "send") {
-
- processor.reset (new Send (_session, node));
- have_insert = true;
+ _extra_xml = new XMLNode (*child);
- } else {
+ } else if (child->name() == X_("Controllable") && (prop = child->property("name")) != 0) {
- error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
- }
-
- add_processor (processor);
-
- } else {
- error << _("Processor XML node has no type property") << endmsg;
+ if (prop->value() == "solo") {
+ _solo_control->set_state (*child, version);
+ _session.add_controllable (_solo_control);
}
- }
- catch (failed_constructor &err) {
- warning << _("processor could not be created. Ignored.") << endmsg;
- return;
+ } else if (child->name() == X_("RemoteControl")) {
+ if ((prop = child->property (X_("id"))) != 0) {
+ int32_t x;
+ sscanf (prop->value().c_str(), "%d", &x);
+ set_remote_control_id (x);
+ }
+
+ } else if (child->name() == X_("MuteMaster")) {
+ _mute_master->set_state (*child, version);
}
}
-}
-int
-Route::set_state (const XMLNode& node)
-{
- return _set_state (node, true);
+ return 0;
}
int
-Route::_set_state (const XMLNode& node, bool call_base)
+Route::_set_state_2X (const XMLNode& node, int version)
{
XMLNodeList nlist;
XMLNodeConstIterator niter;
XMLPropertyList plist;
const XMLProperty *prop;
- if (node.name() != "Route"){
+ /* 2X things which still remain to be handled:
+ * default-type
+ * muted
+ * mute-affects-pre-fader
+ * mute-affects-post-fader
+ * mute-affects-control-outs
+ * mute-affects-main-outs
+ * automation
+ * controlouts
+ */
+
+ if (node.name() != "Route") {
error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
return -1;
}
} else {
_flags = Flag (0);
}
-
- if ((prop = node.property (X_("default-type"))) != 0) {
- _default_type = DataType(prop->value());
- assert(_default_type != DataType::NIL);
- }
- if ((prop = node.property (X_("phase-invert"))) != 0) {
- set_phase_invert (prop->value()=="yes"?true:false, this);
- }
+ /* add standard processors */
- if ((prop = node.property (X_("denormal-protection"))) != 0) {
- set_denormal_protection (prop->value()=="yes"?true:false, this);
- }
-
- _active = true;
- if ((prop = node.property (X_("active"))) != 0) {
- set_active (prop->value() == "yes");
+ _meter.reset (new PeakMeter (_session));
+ add_processor (_meter, PreFader);
+
+ if (_flags & ControlOut) {
+ /* where we listen to tracks */
+ _intreturn.reset (new InternalReturn (_session));
+ add_processor (_intreturn, PreFader);
}
- if ((prop = node.property (X_("muted"))) != 0) {
- bool yn = prop->value()=="yes"?true:false;
+ _main_outs.reset (new Delivery (_session, _output, _mute_master, _name, Delivery::Main));
+ add_processor (_main_outs, PostFader);
- /* force reset of mute status */
+ /* IOs */
- _muted = !yn;
- set_mute(yn, this);
- mute_gain = desired_mute_gain;
- }
+ nlist = node.children ();
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
- if ((prop = node.property (X_("soloed"))) != 0) {
- bool yn = prop->value()=="yes"?true:false;
+ child = *niter;
- /* force reset of solo status */
+ if (child->name() == IO::state_node_name) {
- _soloed = !yn;
- set_solo (yn, this);
- solo_gain = desired_solo_gain;
- }
+ /* there is a note in IO::set_state_2X() about why we have to call
+ this directly.
+ */
+
+ _input->set_state_2X (*child, version, true);
+ _output->set_state_2X (*child, version, false);
+
+ if ((prop = child->property (X_("name"))) != 0) {
+ set_name (prop->value ());
+ }
+
+ if ((prop = child->property (X_("id"))) != 0) {
+ _id = prop->value ();
+ }
+
+ if ((prop = child->property (X_("active"))) != 0) {
+ bool yn = string_is_affirmative (prop->value());
+ _active = !yn; // force switch
+ set_active (yn);
+ }
+ }
- if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
- _mute_affects_pre_fader = (prop->value()=="yes")?true:false;
+ /* XXX: panners? */
}
- if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
- _mute_affects_post_fader = (prop->value()=="yes")?true:false;
+ if ((prop = node.property (X_("phase-invert"))) != 0) {
+ set_phase_invert (string_is_affirmative (prop->value()));
}
- if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
- _mute_affects_control_outs = (prop->value()=="yes")?true:false;
+ if ((prop = node.property (X_("denormal-protection"))) != 0) {
+ set_denormal_protection (string_is_affirmative (prop->value()));
}
- if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
- _mute_affects_main_outs = (prop->value()=="yes")?true:false;
+ if ((prop = node.property (X_("soloed"))) != 0) {
+ bool yn = string_is_affirmative (prop->value());
+
+ /* XXX force reset of solo status */
+
+ set_solo (yn, this);
}
if ((prop = node.property (X_("meter-point"))) != 0) {
_meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
}
-
+
+ /* XXX: if the route was in both a mix group and an edit group, it'll end up
+ just in the edit group. */
+
+ if ((prop = node.property (X_("mix-group"))) != 0) {
+ RouteGroup* route_group = _session.route_group_by_name(prop->value());
+ if (route_group == 0) {
+ error << string_compose(_("Route %1: unknown route group \"%2 in saved state (ignored)"), _name, prop->value()) << endmsg;
+ } else {
+ set_route_group (route_group, this);
+ }
+ }
+
if ((prop = node.property (X_("edit-group"))) != 0) {
- RouteGroup* edit_group = _session.edit_group_by_name(prop->value());
- if(edit_group == 0) {
- error << string_compose(_("Route %1: unknown edit group \"%2 in saved state (ignored)"), _name, prop->value()) << endmsg;
+ RouteGroup* route_group = _session.route_group_by_name(prop->value());
+ if (route_group == 0) {
+ error << string_compose(_("Route %1: unknown route group \"%2 in saved state (ignored)"), _name, prop->value()) << endmsg;
} else {
- set_edit_group(edit_group, this);
+ set_route_group (route_group, this);
}
}
if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
- << endmsg;
+ << endmsg;
} else {
if (sscanf (remaining.substr (equal+1).c_str(), "%ld", &n) != 1) {
error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
- << endmsg;
+ << endmsg;
} else {
- set_order_key (remaining.substr (0, equal).c_str(), n);
+ set_order_key (remaining.substr (0, equal), n);
}
}
}
}
- nlist = node.children();
-
- delete deferred_state;
- deferred_state = new XMLNode(X_("deferred state"));
-
- /* set parent class properties before anything else */
+ XMLNodeList redirect_nodes;
for (niter = nlist.begin(); niter != nlist.end(); ++niter){
child = *niter;
- if (child->name() == IO::state_node_name && call_base) {
- IO::set_state (*child);
- break;
- }
- }
-
- XMLNodeList processor_nodes;
-
- for (niter = nlist.begin(); niter != nlist.end(); ++niter){
-
- child = *niter;
-
- if (child->name() == X_("Send") || child->name() == X_("Processor")) {
- processor_nodes.push_back(child);
+ if (child->name() == X_("Send") || child->name() == X_("Insert")) {
+ redirect_nodes.push_back(child);
}
}
- _set_processor_states(processor_nodes);
-
+ set_processor_state_2X (redirect_nodes, version);
for (niter = nlist.begin(); niter != nlist.end(); ++niter){
child = *niter;
- // All processors have been applied already
-
- if (child->name() == X_("Automation")) {
-
- if ((prop = child->property (X_("path"))) != 0) {
- load_automation (prop->value());
- }
- } else if (child->name() == X_("ControlOuts")) {
-
- string coutname = _name;
- coutname += _("[control]");
-
- delete _control_outs;
- _control_outs = new IO (_session, coutname);
-
- /* fix up the control out name in the XML before setting it.
- Otherwise track templates don't work because the control
- outs end up with the stored template name, rather than
- the new name of the track based on the template.
- */
-
- XMLProperty* prop = (*child->children().begin())->property ("name");
- if (prop) {
- prop->set_value (coutname);
- }
-
- _control_outs->set_state (**(child->children().begin()));
-
- } else if (child->name() == X_("Comment")) {
+ if (child->name() == X_("Comment")) {
/* XXX this is a terrible API design in libxml++ */
_extra_xml = new XMLNode (*child);
} else if (child->name() == X_("Controllable") && (prop = child->property("name")) != 0) {
-
+
if (prop->value() == "solo") {
- _solo_control->set_state (*child);
+ _solo_control->set_state (*child, version);
_session.add_controllable (_solo_control);
- } else if (prop->value() == "mute") {
- _mute_control->set_state (*child);
- _session.add_controllable (_mute_control);
}
- }
- else if (child->name() == X_("RemoteControl")) {
+
+ } else if (child->name() == X_("RemoteControl")) {
if ((prop = child->property (X_("id"))) != 0) {
int32_t x;
sscanf (prop->value().c_str(), "%d", &x);
set_remote_control_id (x);
}
- }
- }
- if ((prop = node.property (X_("mix-group"))) != 0) {
- RouteGroup* mix_group = _session.mix_group_by_name(prop->value());
- if (mix_group == 0) {
- error << string_compose(_("Route %1: unknown mix group \"%2 in saved state (ignored)"), _name, prop->value()) << endmsg;
- } else {
- set_mix_group(mix_group, this);
- }
+ }
}
return 0;
}
+XMLNode&
+Route::get_processor_state ()
+{
+ XMLNode* root = new XMLNode (X_("redirects"));
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ root->add_child_nocopy ((*i)->state (true));
+ }
+
+ return *root;
+}
+
void
-Route::_set_processor_states(const XMLNodeList &nlist)
+Route::set_processor_state_2X (XMLNodeList const & nList, int version)
{
- XMLNodeConstIterator niter;
- char buf[64];
+ /* We don't bother removing existing processors not in nList, as this
+ method will only be called when creating a Route from scratch, not
+ for undo purposes. Just put processors in at the appropriate place
+ in the list.
+ */
+
+ for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
+ add_processor_from_xml_2X (**i, version, _processors.begin ());
+ }
+}
+void
+Route::set_processor_state (const XMLNode& node)
+{
+ const XMLNodeList &nlist = node.children();
+ XMLNodeConstIterator niter;
ProcessorList::iterator i, o;
// Iterate through existing processors, remove those which are not in the state list
+
for (i = _processors.begin(); i != _processors.end(); ) {
+
+ /* leave amp alone, always */
+
+ if ((*i) == _amp) {
+ ++i;
+ continue;
+ }
+
ProcessorList::iterator tmp = i;
++tmp;
bool processorInStateList = false;
-
- (*i)->id().print (buf, sizeof (buf));
-
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
- // 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) {
+ XMLProperty* id_prop = (*niter)->property(X_("id"));
+
+ if (id_prop && (*i)->id() == id_prop->value()) {
processorInStateList = true;
break;
}
}
-
+
if (!processorInStateList) {
remove_processor (*i);
}
-
i = tmp;
}
-
// 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 processor in the list
+ XMLProperty* prop = (*niter)->property ("type");
+
o = i;
- while (o != _processors.end()) {
- (*o)->id().print (buf, sizeof (buf));
- 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;
+ // Check whether the next processor in the list is the right one,
+ // except for "amp" which is always there and may not have the
+ // old ID since it is always created anew in every Route
+
+ if (prop->value() != "amp") {
+ while (o != _processors.end()) {
+ XMLProperty* id_prop = (*niter)->property(X_("id"));
+ if (id_prop && (*o)->id() == id_prop->value()) {
+ break;
+ }
+
+ ++o;
+ }
}
+ // If the processor (*niter) is not on the route,
+ // create it and move it to the correct location
+
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
- ProcessorList::iterator prev_last = _processors.end();
- --prev_last; // We need this to check whether adding succeeded
-
- add_processor_from_xml (**niter);
+ if (add_processor_from_xml (**niter, i)) {
+ --i; // move iterator to the newly inserted processor
+ } else {
+ cerr << "Error restoring route: unable to restore processor" << endl;
+ }
- ProcessorList::iterator last = _processors.end();
- --last;
+ } else {
- if (prev_last == last) {
- cerr << "Could not fully restore state as some processors were not possible to create" << endl;
- continue;
+ // Otherwise, the processor already exists; just
+ // ensure it is at the location provided in the XML state
+ if (i != o) {
+ boost::shared_ptr<Processor> tmp = (*o);
+ _processors.erase (o); // remove the old copy
+ _processors.insert (i, tmp); // insert the processor at the correct location
+ --i; // move iterator to the correct processor
}
- 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);
+ // and make it (just) so
- --i; // move pointer to the newly processored processor
- continue;
+ (*i)->set_state (**niter, Stateful::current_state_version);
}
+ }
- // 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<Processor> tmp = (*o);
- // remove the old copy
- _processors.erase(o);
- // processor the processor at the correct location
- _processors.insert(i, tmp);
-
- --i; // move pointer so it points to the right processor
- }
+ /* note: there is no configure_processors() call because we figure that
+ the XML state represents a working signal route.
+ */
- (*i)->set_state( (**niter) );
- }
-
processors_changed ();
}
}
void
-Route::silence (nframes_t nframes, nframes_t offset)
+Route::silence (nframes_t nframes)
{
if (!_silent) {
- IO::silence (nframes, offset);
-
- if (_control_outs) {
- _control_outs->silence (nframes, offset);
- }
+ _output->silence (nframes);
- {
+ {
Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
-
+
if (lm.locked()) {
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, offset);
+ (*i)->silence (nframes);
}
- if (nframes == _session.get_block_size() && offset == 0) {
+ if (nframes == _session.get_block_size()) {
// _silent = true;
}
}
}
-
+
}
-}
+}
-int
-Route::set_control_outs (const vector<string>& ports)
+void
+Route::add_internal_return ()
{
- Glib::Mutex::Lock lm (_control_outs_lock);
- vector<string>::const_iterator i;
- size_t limit;
-
- delete _control_outs;
- _control_outs = 0;
-
- if (is_control() || is_master()) {
- /* no control outs for these two special busses */
- return 0;
+ if (!_intreturn) {
+ _intreturn.reset (new InternalReturn (_session));
+ add_processor (_intreturn, PreFader);
}
-
- if (ports.empty()) {
- return 0;
- }
-
- string coutname = _name;
- coutname += _("[control]");
-
- _control_outs = new IO (_session, coutname);
-
- /* our control outs need as many outputs as we
- have audio outputs. we track the changes in ::output_change_handler().
- */
-
- // XXX its stupid that we have to get this value twice
+}
- limit = n_outputs().n_audio();
-
- if (_control_outs->ensure_io (ChanCount::ZERO, ChanCount (DataType::AUDIO, n_outputs().get (DataType::AUDIO)), true, this)) {
- return -1;
- }
-
- /* 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 % ports.size()], this)) {
- error << string_compose (_("could not connect %1 to %2"), _control_outs->output(n)->name(), ports[n]) << endmsg;
- return -1;
+BufferSet*
+Route::get_return_buffer () const
+{
+ Glib::RWLock::ReaderLock rm (_processor_lock);
+
+ for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
+ boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
+
+ if (d) {
+ BufferSet* bs = d->get_buffers ();
+ return bs;
}
}
-
- return 0;
-}
-void
-Route::set_edit_group (RouteGroup *eg, void *src)
+ return 0;
+}
+void
+Route::release_return_buffer () const
{
- if (eg == _edit_group) {
- return;
- }
+ Glib::RWLock::ReaderLock rm (_processor_lock);
- if (_edit_group) {
- _edit_group->remove (this);
- }
+ for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
+ boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
- if ((_edit_group = eg) != 0) {
- _edit_group->add (this);
+ if (d) {
+ return d->release_buffers ();
+ }
}
-
- _session.set_dirty ();
- edit_group_changed (src); /* EMIT SIGNAL */
}
-void
-Route::drop_edit_group (void *src)
+int
+Route::listen_via (boost::shared_ptr<Route> route, Placement placement, bool /*active*/, bool aux)
{
- _edit_group = 0;
- _session.set_dirty ();
- edit_group_changed (src); /* EMIT SIGNAL */
-}
+ vector<string> ports;
+ vector<string>::const_iterator i;
-void
-Route::set_mix_group (RouteGroup *mg, void *src)
+ {
+ Glib::RWLock::ReaderLock rm (_processor_lock);
-{
- if (mg == _mix_group) {
- return;
+ 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) {
+
+ /* if the target is the control outs, then make sure
+ we take note of which i-send is doing that.
+ */
+
+ if (route == _session.control_out()) {
+ _control_outs = boost::dynamic_pointer_cast<Delivery>(d);
+ }
+
+ /* already listening via the specified IO: do nothing */
+
+ return 0;
+ }
+ }
}
- if (_mix_group) {
- _mix_group->remove (this);
+ boost::shared_ptr<InternalSend> listener;
+
+ try {
+ listener.reset (new InternalSend (_session, _mute_master, route, (aux ? Delivery::Aux : Delivery::Listen)));
+
+ } catch (failed_constructor& err) {
+ return -1;
}
- if ((_mix_group = mg) != 0) {
- _mix_group->add (this);
+ if (route == _session.control_out()) {
+ _control_outs = listener;
}
- _session.set_dirty ();
- mix_group_changed (src); /* EMIT SIGNAL */
-}
+ add_processor (listener, placement);
-void
-Route::drop_mix_group (void *src)
-{
- _mix_group = 0;
- _session.set_dirty ();
- mix_group_changed (src); /* EMIT SIGNAL */
+ return 0;
}
void
-Route::set_comment (string cmt, void *src)
-{
- _comment = cmt;
- comment_changed (src);
- _session.set_dirty ();
-}
-
-bool
-Route::feeds (boost::shared_ptr<Route> other)
+Route::drop_listen (boost::shared_ptr<Route> route)
{
- uint32_t i, j;
-
- IO& self = *this;
- uint32_t no = self.n_outputs().n_total();
- uint32_t ni = other->n_inputs ().n_total();
+ ProcessorStreams err;
+ ProcessorList::iterator tmp;
- for (i = 0; i < no; ++i) {
- for (j = 0; j < ni; ++j) {
- if (self.output(i)->connected_to (other->input(j)->name())) {
- return true;
- }
- }
- }
+ Glib::RWLock::ReaderLock rl(_processor_lock);
+ rl.acquire ();
- /* check IOProcessors which may also interconnect Routes */
+ again:
+ for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ) {
- for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); r++) {
+ boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
- boost::shared_ptr<IOProcessor> redirect = boost::dynamic_pointer_cast<IOProcessor>(*r);
+ if (d && d->target_route() == route) {
+ rl.release ();
+ remove_processor (*x, &err);
+ rl.acquire ();
- if ( ! redirect)
- continue;
+ /* list could have been demolished while we dropped the lock
+ so start over.
+ */
- // TODO: support internal redirects here
+ goto again;
+ }
+ }
- no = redirect->io()->n_outputs().n_total();
+ rl.release ();
- for (i = 0; i < no; ++i) {
- for (j = 0; j < ni; ++j) {
- if (redirect->io()->output(i)->connected_to (other->input (j)->name())) {
- return true;
- }
- }
- }
+ if (route == _session.control_out()) {
+ _control_outs.reset ();
}
+}
- /* check for control room outputs which may also interconnect Routes */
+void
+Route::set_route_group (RouteGroup *rg, void *src)
+{
+ if (rg == _route_group) {
+ return;
+ }
- if (_control_outs) {
+ if (_route_group) {
+ _route_group->remove (this);
+ }
- no = _control_outs->n_outputs().n_total();
-
- for (i = 0; i < no; ++i) {
- for (j = 0; j < ni; ++j) {
- if (_control_outs->output(i)->connected_to (other->input (j)->name())) {
- return true;
- }
- }
- }
+ if ((_route_group = rg) != 0) {
+ _route_group->add (this);
}
- return false;
+ _session.set_dirty ();
+ route_group_changed (src); /* EMIT SIGNAL */
+}
+
+void
+Route::drop_route_group (void *src)
+{
+ _route_group = 0;
+ _session.set_dirty ();
+ route_group_changed (src); /* EMIT SIGNAL */
}
void
-Route::set_mute_config (mute_type t, bool onoff, void *src)
+Route::set_comment (string cmt, void *src)
{
- switch (t) {
- case PRE_FADER:
- _mute_affects_pre_fader = onoff;
- pre_fader_changed(src); /* EMIT SIGNAL */
- break;
+ _comment = cmt;
+ comment_changed (src);
+ _session.set_dirty ();
+}
- case POST_FADER:
- _mute_affects_post_fader = onoff;
- post_fader_changed(src); /* EMIT SIGNAL */
- break;
+bool
+Route::feeds (boost::shared_ptr<Route> other, bool* only_send)
+{
+ DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
- case CONTROL_OUTS:
- _mute_affects_control_outs = onoff;
- control_outs_changed(src); /* EMIT SIGNAL */
- break;
+ if (_output->connected_to (other->input())) {
+ DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
+ if (only_send) {
+ *only_send = false;
+ }
- case MAIN_OUTS:
- _mute_affects_main_outs = onoff;
- main_outs_changed(src); /* EMIT SIGNAL */
- break;
+ return true;
}
-}
-bool
-Route::get_mute_config (mute_type t)
-{
- bool onoff = false;
- switch (t){
- case PRE_FADER:
- onoff = _mute_affects_pre_fader;
- break;
- case POST_FADER:
- onoff = _mute_affects_post_fader;
- break;
- case CONTROL_OUTS:
- onoff = _mute_affects_control_outs;
- break;
- case MAIN_OUTS:
- onoff = _mute_affects_main_outs;
- break;
+ 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;
+ }
+ return true;
+ } else {
+ DEBUG_TRACE (DEBUG::Graph, string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
+ }
+ } else {
+ DEBUG_TRACE (DEBUG::Graph, string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
+ }
+
}
-
- return onoff;
+
+ DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdoes NOT feed %1\n", other->name()));
+ return false;
}
void
-Route::handle_transport_stopped (bool abort_ignored, bool did_locate, bool can_flush_processors)
+Route::handle_transport_stopped (bool /*abort_ignored*/, bool did_locate, bool can_flush_processors)
{
nframes_t now = _session.transport_frame();
}
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
-
+
if (Config->get_plugins_stop_with_transport() && can_flush_processors) {
(*i)->deactivate ();
(*i)->activate ();
}
-
+
(*i)->transport_stopped (now);
}
}
- IO::transport_stopped (now);
-
_roll_delay = _initial_delay;
}
void
-Route::input_change_handler (IOChange change, void *ignored)
+Route::input_change_handler (IOChange change, void * /*src*/)
{
- if (change & ConfigurationChanged) {
- reset_processor_counts (0);
+ if ((change & ConfigurationChanged)) {
+ configure_processors (0);
}
}
void
-Route::output_change_handler (IOChange change, void *ignored)
+Route::output_change_handler (IOChange change, void * /*src*/)
{
- if (change & ConfigurationChanged) {
- if (_control_outs) {
- _control_outs->ensure_io (ChanCount::ZERO, ChanCount(DataType::AUDIO, n_outputs().n_audio()), true, this);
- }
-
- reset_processor_counts (0);
+ if ((change & ConfigurationChanged)) {
+
+ /* XXX resize all listeners to match _main_outs? */
+
+ // configure_processors (0);
}
}
if (n_outputs().n_audio() < 2) {
return 0;
}
-
- return max (n_inputs ().n_audio(), processor_max_outs.n_audio());
+
+ return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
}
-int
-Route::no_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset,
- bool session_state_changing, bool can_record, bool rec_monitors_input)
+int
+Route::no_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
+ bool session_state_changing, bool /*can_record*/, bool /*rec_monitors_input*/)
{
if (n_outputs().n_total() == 0) {
return 0;
}
- if (session_state_changing || !_active) {
- silence (nframes, offset);
+ if (session_state_changing || !_active || n_inputs() == ChanCount::ZERO) {
+ silence (nframes);
return 0;
}
- apply_gain_automation = false;
-
- if (n_inputs().n_total()) {
- passthru (start_frame, end_frame, nframes, offset, 0, false);
- } else {
- silence (nframes, offset);
- }
+ _amp->apply_gain_automation (false);
+ passthru (start_frame, end_frame, nframes, 0);
return 0;
}
nframes_t
-Route::check_initial_delay (nframes_t nframes, nframes_t& offset, nframes_t& transport_frame)
+Route::check_initial_delay (nframes_t nframes, nframes_t& transport_frame)
{
if (_roll_delay > nframes) {
_roll_delay -= nframes;
- silence (nframes, offset);
+ silence (nframes);
/* transport frame is not legal for caller to use */
return 0;
} else if (_roll_delay > 0) {
nframes -= _roll_delay;
-
- silence (_roll_delay, offset);
-
- offset += _roll_delay;
+ silence (_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;
}
int
-Route::roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset, int declick,
- bool can_record, bool rec_monitors_input)
+Route::roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame, int declick,
+ bool /*can_record*/, bool /*rec_monitors_input*/)
{
{
+ // automation snapshot can also be called from the non-rt context
+ // and it uses the processor list, so we try to acquire the lock here
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 processor list, so we take the lock out here
automation_snapshot (_session.transport_frame(), false);
}
}
- if ((n_outputs().n_total() == 0 && _processors.empty()) || n_inputs().n_total() == 0 || !_active) {
- silence (nframes, offset);
+ if (n_outputs().n_total() == 0) {
return 0;
}
-
- nframes_t unused = 0;
- if ((nframes = check_initial_delay (nframes, offset, unused)) == 0) {
+ if (!_active || n_inputs().n_total() == 0) {
+ silence (nframes);
return 0;
}
- _silent = false;
-
- apply_gain_automation = false;
+ nframes_t unused = 0;
- {
- Glib::Mutex::Lock am (data().control_lock(), Glib::TRY_LOCK);
-
- if (am.locked() && _session.transport_rolling()) {
-
- 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);
- }
- }
+ if ((nframes = check_initial_delay (nframes, unused)) == 0) {
+ return 0;
}
- passthru (start_frame, end_frame, nframes, offset, declick, false);
+ _silent = false;
+
+ passthru (start_frame, end_frame, nframes, declick);
return 0;
}
int
-Route::silent_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset,
- bool can_record, bool rec_monitors_input)
+Route::silent_roll (nframes_t nframes, sframes_t /*start_frame*/, sframes_t /*end_frame*/,
+ bool /*can_record*/, bool /*rec_monitors_input*/)
{
- silence (nframes, offset);
+ silence (nframes);
return 0;
}
void
Route::toggle_monitor_input ()
{
- for (PortSet::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
+ 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?
+ // 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->io()->outputs().begin();
- port != pi->io()->outputs().end(); ++port) {
-
+ 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;
}
void
Route::set_meter_point (MeterPoint p, void *src)
{
- if (_meter_point != p) {
- _meter_point = p;
- meter_change (src); /* EMIT SIGNAL */
- _session.set_dirty ();
+ if (_meter_point == p) {
+ return;
+ }
+
+ {
+ Glib::RWLock::WriterLock lm (_processor_lock);
+ ProcessorList as_it_was (_processors);
+
+ 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;
+ }
+
+ _processors.insert(loc, _meter);
+
+ if (configure_processors_unlocked (0)) {
+ _processors = as_it_was;
+ configure_processors_unlocked (0); // it worked before we tried to add it ...
+ return;
+ }
+
+ _meter->set_display_to_user (false);
+
+ } else {
+
+ // just make it visible and let the user move it
+
+ _meter->set_display_to_user (true);
+ }
+
+ }
+
+ _meter_point = p;
+ meter_change (src); /* EMIT SIGNAL */
+ processors_changed (); /* EMIT SIGNAL */
+ _session.set_dirty ();
+}
+
+void
+Route::put_control_outs_at (Placement p)
+{
+ if (!_control_outs) {
+ return;
+ }
+
+ {
+ Glib::RWLock::WriterLock lm (_processor_lock);
+ ProcessorList as_it_was (_processors);
+ // Move meter in the processors list
+ ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), _control_outs);
+ _processors.erase(loc);
+
+ switch (p) {
+ case PreFader:
+ loc = find(_processors.begin(), _processors.end(), _amp);
+ if (loc != _processors.begin()) {
+ --loc;
+ }
+ break;
+ case PostFader:
+ loc = find(_processors.begin(), _processors.end(), _amp);
+ assert (loc != _processors.end());
+ loc++;
+ break;
+ }
+
+ _processors.insert(loc, _control_outs);
+
+ if (configure_processors_unlocked (0)) {
+ _processors = as_it_was;
+ configure_processors_unlocked (0); // it worked before we tried to add it ...
+ return;
+ }
}
+
+ processors_changed (); /* EMIT SIGNAL */
+ _session.set_dirty ();
}
nframes_t
Route::update_total_latency ()
{
- nframes_t old = _own_latency;
-
- if (_user_latency) {
- _own_latency = _user_latency;
- } else {
- _own_latency = 0;
+ nframes_t old = _output->effective_latency();
+ nframes_t own_latency = _output->user_latency();
- for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- if ((*i)->active ()) {
- _own_latency += (*i)->signal_latency ();
- }
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ if ((*i)->active ()) {
+ own_latency += (*i)->signal_latency ();
}
}
-#undef DEBUG_LATENCY
-#ifdef DEBUG_LATENCY
- cerr << _name << ": internal redirect latency = " << _own_latency << endl;
-#endif
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal redirect latency = %2\n", _name, own_latency));
+
+ _output->set_port_latency (own_latency);
+
+ if (_output->user_latency() == 0) {
- 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
have to take into account any input latency.
*/
-
- _own_latency += input_latency ();
+ own_latency += _input->signal_latency ();
}
- if (old != _own_latency) {
+ if (old != own_latency) {
+ _output->set_latency_delay (own_latency);
signal_latency_changed (); /* EMIT SIGNAL */
}
-
-#ifdef DEBUG_LATENCY
- cerr << _name << ": input latency = " << input_latency() << " total = "
- << _own_latency << endl;
-#endif
- return _own_latency;
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: input latency = %2 total = %3\n", _name, _input->signal_latency(), own_latency));
+
+ return _output->effective_latency ();
}
void
Route::set_user_latency (nframes_t nframes)
{
- Latent::set_user_latency (nframes);
+ _output->set_user_latency (nframes);
_session.update_latency_compensation (false, false);
}
{
nframes_t old = _initial_delay;
- if (_own_latency < longest_session_latency) {
- _initial_delay = longest_session_latency - _own_latency;
+ if (_output->effective_latency() < longest_session_latency) {
+ _initial_delay = longest_session_latency - _output->effective_latency();
} else {
_initial_delay = 0;
}
void
Route::automation_snapshot (nframes_t now, bool force)
{
- if (!force && !should_snapshot(now)) {
- return;
- }
-
- IO::automation_snapshot (now, force);
-
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
(*i)->automation_snapshot (now, force);
}
}
-Route::ToggleControllable::ToggleControllable (std::string name, Route& s, ToggleType tp)
- : Controllable (name), route (s), type(tp)
+Route::SoloControllable::SoloControllable (std::string name, Route& r)
+ : AutomationControl (r.session(), Evoral::Parameter (SoloAutomation),
+ boost::shared_ptr<AutomationList>(), name)
+ , route (r)
{
-
+ boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
+ set_list (gl);
}
void
-Route::ToggleControllable::set_value (float val)
+Route::SoloControllable::set_value (float val)
{
bool bval = ((val >= 0.5f) ? true: false);
-
- switch (type) {
- case MuteControl:
- route.set_mute (bval, this);
- break;
- case SoloControl:
- route.set_solo (bval, this);
- break;
- default:
- break;
- }
+
+ route.set_solo (bval, this);
}
float
-Route::ToggleControllable::get_value (void) const
+Route::SoloControllable::get_value (void) const
{
- float val = 0.0f;
-
- switch (type) {
- case MuteControl:
- val = route.muted() ? 1.0f : 0.0f;
- break;
- case SoloControl:
- val = route.soloed() ? 1.0f : 0.0f;
- break;
- default:
- break;
- }
-
- return val;
+ return route.self_soloed() ? 1.0f : 0.0f;
}
-void
+void
Route::set_block_size (nframes_t nframes)
{
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
(*i)->set_block_size (nframes);
}
+
+ _session.ensure_buffers (n_process_buffers ());
}
void
Route::protect_automation ()
{
- Automatable::protect_automation();
-
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
(*i)->protect_automation();
}
*/
void
-Route::shift (nframes64_t pos, nframes64_t frames)
+Route::shift (nframes64_t /*pos*/, nframes64_t /*frames*/)
{
#ifdef THIS_NEEDS_FIXING_FOR_V3
{
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 ();
{
XMLNode& node (state (false));
XMLTree tree;
-
+
IO::set_name_in_state (*node.children().front(), name);
-
+
tree.set_root (&node);
return tree.write (path.c_str());
}
+
+
+bool
+Route::set_name (const string& str)
+{
+ bool ret;
+ string ioproc_name;
+ string name;
+
+ name = Route::ensure_track_or_route_name (str, _session);
+ SessionObject::set_name (name);
+
+ ret = (_input->set_name(name) && _output->set_name(name));
+
+ if (ret) {
+
+ Glib::RWLock::ReaderLock lm (_processor_lock);
+
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+
+ /* rename all I/O processors that have inputs or outputs */
+
+ boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
+
+ if (iop && (iop->output() || iop->input())) {
+ if (!iop->set_name (name)) {
+ ret = false;
+ }
+ }
+ }
+
+ }
+
+ return ret;
+}
+
+boost::shared_ptr<Send>
+Route::internal_send_for (boost::shared_ptr<const Route> target) const
+{
+ Glib::RWLock::ReaderLock lm (_processor_lock);
+
+ for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ boost::shared_ptr<InternalSend> send;
+
+ if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
+ if (send->target_route() == target) {
+ return send;
+ }
+ }
+ }
+
+ return boost::shared_ptr<Send>();
+}
+
+void
+Route::set_phase_invert (bool yn)
+{
+ if (_phase_invert != yn) {
+ _phase_invert = 0xffff; // XXX all channels
+ phase_invert_changed (); /* EMIT SIGNAL */
+ }
+}
+
+bool
+Route::phase_invert () const
+{
+ return _phase_invert != 0;
+}
+
+void
+Route::set_denormal_protection (bool yn)
+{
+ if (_denormal_protection != yn) {
+ _denormal_protection = yn;
+ denormal_protection_changed (); /* EMIT SIGNAL */
+ }
+}
+
+bool
+Route::denormal_protection () const
+{
+ return _denormal_protection;
+}
+
+void
+Route::set_active (bool yn)
+{
+ if (_active != yn) {
+ _active = yn;
+ _input->set_active (yn);
+ _output->set_active (yn);
+ active_changed (); // EMIT SIGNAL
+ }
+}
+
+void
+Route::meter ()
+{
+ Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
+
+ assert (_meter);
+
+ _meter->meter ();
+
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+
+ boost::shared_ptr<Send> s;
+ boost::shared_ptr<Return> r;
+
+ if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
+ s->meter()->meter();
+ } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
+ r->meter()->meter ();
+ }
+ }
+}
+
+boost::shared_ptr<Panner>
+Route::panner() const
+{
+
+ return _main_outs->panner();
+}
+
+boost::shared_ptr<AutomationControl>
+Route::gain_control() const
+{
+
+ return _amp->gain_control();
+}
+
+boost::shared_ptr<AutomationControl>
+Route::get_control (const Evoral::Parameter& param)
+{
+ /* either we own the control or .... */
+
+ boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(data().control (param));
+
+ if (!c) {
+
+ /* maybe one of our processors does or ... */
+
+ Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->data().control (param))) != 0) {
+ break;
+ }
+ }
+ }
+
+ if (!c) {
+
+ /* nobody does so we'll make a new one */
+
+ c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
+ add_control(c);
+ }
+
+ return c;
+}