#include <cassert>
#include <sigc++/bind.h>
-#include <pbd/xml++.h>
-#include <pbd/enumwriter.h>
-
-#include <ardour/timestamps.h>
-#include <ardour/buffer.h>
-#include <ardour/audioengine.h>
-#include <ardour/route.h>
-#include <ardour/insert.h>
-#include <ardour/send.h>
-#include <ardour/session.h>
-#include <ardour/utils.h>
-#include <ardour/configuration.h>
-#include <ardour/cycle_timer.h>
-#include <ardour/route_group.h>
-#include <ardour/port.h>
-#include <ardour/ladspa_plugin.h>
-#include <ardour/panner.h>
-#include <ardour/dB.h>
-#include <ardour/mix.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/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/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/dB.h"
+#include "ardour/amp.h"
+#include "ardour/meter.h"
+#include "ardour/buffer_set.h"
+#include "ardour/mix.h"
+#include "ardour/profile.h"
#include "i18n.h"
using namespace ARDOUR;
using namespace PBD;
-
uint32_t Route::order_key_cnt = 0;
+sigc::signal<void,const char*> Route::SyncOrderKeys;
-
-Route::Route (Session& sess, string name, int input_min, int input_max, int output_min, int output_max, Flag flg, DataType default_type)
- : IO (sess, name, input_min, input_max, output_min, output_max, default_type),
- _flags (flg),
- _solo_control (X_("solo"), *this, ToggleControllable::SoloControl),
- _mute_control (X_("mute"), *this, ToggleControllable::MuteControl)
+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)
+ , _flags (flg)
+ , _solo_control (new ToggleControllable (X_("solo"), *this, ToggleControllable::SoloControl))
+ , _mute_control (new ToggleControllable (X_("mute"), *this, ToggleControllable::MuteControl))
{
init ();
}
Route::Route (Session& sess, const XMLNode& node, DataType default_type)
- : IO (sess, *node.child ("IO"), default_type),
- _solo_control (X_("solo"), *this, ToggleControllable::SoloControl),
- _mute_control (X_("mute"), *this, ToggleControllable::MuteControl)
+ : 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))
{
init ();
_set_state (node, false);
void
Route::init ()
{
- redirect_max_outs = 0;
+ processor_max_outs.reset();
_muted = false;
_soloed = false;
_solo_safe = false;
+ _recordable = true;
+ _active = true;
_phase_invert = false;
+ _denormal_protection = false;
order_keys[strdup (N_("signal"))] = order_key_cnt++;
- _active = true;
_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;
- _ignore_gain_on_deliver = true;
_edit_group = 0;
_mix_group = 0;
Route::~Route ()
{
- clear_redirects (this);
+ clear_processors (PreFader);
+ clear_processors (PostFader);
for (OrderKeys::iterator i = order_keys.begin(); i != order_keys.end(); ++i) {
free ((void*)(i->first));
}
- if (_control_outs) {
- delete _control_outs;
- }
+ delete _control_outs;
}
void
Route::set_order_key (const char* name, long n)
{
order_keys[strdup(name)] = n;
+
+ if (Config->get_sync_all_route_ordering()) {
+ for (OrderKeys::iterator x = order_keys.begin(); x != order_keys.end(); ++x) {
+ x->second = n;
+ }
+ }
+
_session.set_dirty ();
}
+void
+Route::sync_order_keys (const char* base)
+{
+ if (order_keys.empty()) {
+ return;
+ }
+
+ OrderKeys::iterator i;
+ uint32_t key;
+
+ if ((i = order_keys.find (base)) == order_keys.end()) {
+ /* key doesn't exist, use the first existing key (during session initialization) */
+ i = order_keys.begin();
+ key = i->second;
+ ++i;
+ } else {
+ /* key exists - use it and reset all others (actually, itself included) */
+ i = order_keys.begin();
+ key = i->second;
+ }
+
+ for (; i != order_keys.end(); ++i) {
+ i->second = key;
+ }
+}
+
+string
+Route::ensure_track_or_route_name(string name, Session &session)
+{
+ string newname = name;
+
+ while (session.route_by_name (newname) != NULL) {
+ newname = bump_name_once (newname);
+ }
+
+ return newname;
+}
+
+
void
Route::inc_gain (gain_t fraction, void *src)
{
if (_mix_group->is_relative()) {
-
- gain_t usable_gain = gain();
+ gain_t usable_gain = gain();
if (usable_gain < 0.000001f) {
- usable_gain=0.000001f;
+ usable_gain = 0.000001f;
}
gain_t delta = val;
if (delta < 0.000001f) {
- delta=0.000001f;
+ delta = 0.000001f;
}
delta -= usable_gain;
- if (delta == 0.0f) return;
+ if (delta == 0.0f)
+ return;
gain_t factor = delta / usable_gain;
if (factor > 0.0f) {
factor = _mix_group->get_max_factor(factor);
if (factor == 0.0f) {
- gain_changed (src);
+ _gain_control->Changed(); /* EMIT SIGNAL */
return;
}
} else {
factor = _mix_group->get_min_factor(factor);
if (factor == 0.0f) {
- gain_changed (src);
+ _gain_control->Changed(); /* EMIT SIGNAL */
return;
}
}
IO::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 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 (vector<Sample*>& bufs, uint32_t nbufs,
- nframes_t start_frame, nframes_t end_frame,
- nframes_t nframes, nframes_t offset, bool with_redirects, int declick,
- bool meter)
+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)
{
- uint32_t n;
- RedirectList::iterator i;
+ // 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;
- vector<Sample*>::iterator bufiter;
IO *co;
bool mute_audible;
bool solo_audible;
declick = _pending_declick;
{
- Glib::Mutex::Lock cm (control_outs_lock, Glib::TRY_LOCK);
+ Glib::Mutex::Lock cm (_control_outs_lock, Glib::TRY_LOCK);
if (cm.locked()) {
co = _control_outs;
}
}
- /* ----------------------------------------------------------------------------------------------------
+ /* -------------------------------------------------------------------------------------------
GLOBAL DECLICK (for transport changes etc.)
- -------------------------------------------------------------------------------------------------- */
+ ----------------------------------------------------------------------------------------- */
if (declick > 0) {
- apply_declick (bufs, nbufs, nframes, 0.0, 1.0, false);
+ Amp::run_in_place (bufs, nframes, 0.0, 1.0, false);
_pending_declick = 0;
} else if (declick < 0) {
- apply_declick (bufs, nbufs, nframes, 1.0, 0.0, false);
+ Amp::run_in_place (bufs, nframes, 1.0, 0.0, false);
_pending_declick = 0;
} else {
/* no global declick */
if (solo_gain != dsg) {
- apply_declick (bufs, nbufs, nframes, solo_gain, dsg, false);
+ Amp::run_in_place (bufs, nframes, solo_gain, dsg, false);
solo_gain = dsg;
}
}
- /* ----------------------------------------------------------------------------------------------------
+ /* -------------------------------------------------------------------------------------------
INPUT METERING & MONITORING
- -------------------------------------------------------------------------------------------------- */
+ ----------------------------------------------------------------------------------------- */
if (meter && (_meter_point == MeterInput)) {
- for (n = 0; n < nbufs; ++n) {
- _peak_power[n] = Session::compute_peak (bufs[n], nframes, _peak_power[n]);
- }
+ _meter->run_in_place(bufs, start_frame, end_frame, nframes, offset);
}
if (!_soloed && _mute_affects_pre_fader && (mute_gain != dmg)) {
- apply_declick (bufs, nbufs, nframes, mute_gain, dmg, false);
+ Amp::run_in_place (bufs, nframes, mute_gain, dmg, false);
mute_gain = dmg;
mute_declick_applied = true;
}
// TODO: this is probably wrong
- (no_monitor && record_enabled() && (!Config->get_auto_input() || _session.actively_recording()))
+ ( no_monitor && record_enabled()
+ && (!Config->get_auto_input() || _session.actively_recording()) )
) {
} else {
- co->deliver_output (bufs, nbufs, nframes, offset);
+ co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
}
}
- /* ----------------------------------------------------------------------------------------------------
+ /* -------------------------------------------------------------------------------------------
+ DENORMAL CONTROL
+ ----------------------------------------------------------------------------------------- */
+
+ if (_denormal_protection || Config->get_denormal_protection()) {
+
+ 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
- -------------------------------------------------------------------------------------------------- */
+ ----------------------------------------------------------------------------------------- */
- if (with_redirects) {
- Glib::RWLock::ReaderLock rm (redirect_lock, Glib::TRY_LOCK);
+ if (with_processors) {
+ Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
if (rm.locked()) {
if (mute_gain > 0 || !_mute_affects_pre_fader) {
- for (i = _redirects.begin(); i != _redirects.end(); ++i) {
+ for (i = _processors.begin(); i != _processors.end(); ++i) {
switch ((*i)->placement()) {
case PreFader:
- if (dsg == 0) {
- if (boost::dynamic_pointer_cast<Send>(*i) || boost::dynamic_pointer_cast<PortInsert>(*i)) {
- (*i)->silence (nframes, offset);
- }
- } else {
- (*i)->run (bufs, nbufs, nframes, offset);
- }
+ (*i)->run_in_place (bufs, start_frame, end_frame, nframes, offset);
break;
case PostFader:
post_fader_work = true;
}
}
} else {
- for (i = _redirects.begin(); i != _redirects.end(); ++i) {
+ for (i = _processors.begin(); i != _processors.end(); ++i) {
switch ((*i)->placement()) {
case PreFader:
(*i)->silence (nframes, offset);
}
}
-
+ /* 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) {
- apply_declick (bufs, nbufs, nframes, mute_gain, dmg, false);
+ Amp::run_in_place (bufs, nframes, mute_gain, dmg, false);
mute_gain = dmg;
mute_declick_applied = true;
}
- /* ----------------------------------------------------------------------------------------------------
+ /* -------------------------------------------------------------------------------------------
PRE-FADER METERING & MONITORING
- -------------------------------------------------------------------------------------------------- */
+ ----------------------------------------------------------------------------------------- */
if (meter && (_meter_point == MeterPreFader)) {
- for (n = 0; n < nbufs; ++n) {
- _peak_power[n] = Session::compute_peak (bufs[n], nframes, _peak_power[n]);
- }
+ _meter->run_in_place(bufs, start_frame, end_frame, nframes, offset);
}
// rec-enabled but not s/w monitoring
- (no_monitor && record_enabled() && (!Config->get_auto_input() || _session.actively_recording()))
+ ( no_monitor && record_enabled()
+ && (!Config->get_auto_input() || _session.actively_recording()) )
) {
} else {
- co->deliver_output (bufs, nbufs, nframes, offset);
-
+ co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
}
}
- /* ----------------------------------------------------------------------------------------------------
+ /* -------------------------------------------------------------------------------------------
GAIN STAGE
- -------------------------------------------------------------------------------------------------- */
+ ----------------------------------------------------------------------------------------- */
/* if not recording or recording and requiring any monitor signal, then apply gain */
!(record_enabled() && _session.actively_recording()) ||
- // OR recording
+ // OR recording
- // h/w monitoring not in use
-
- (!Config->get_monitoring_model() == HardwareMonitoring &&
-
- // AND software monitoring required
+ // AND software monitoring required
- Config->get_monitoring_model() == SoftwareMonitoring)) {
+ Config->get_monitoring_model() == SoftwareMonitoring) {
if (apply_gain_automation) {
if (_phase_invert) {
- for (n = 0; n < nbufs; ++n) {
- Sample *sp = bufs[n];
+ 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 (n = 0; n < nbufs; ++n) {
- Sample *sp = bufs[n];
+ 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 (_gain != dg) {
- apply_declick (bufs, nbufs, nframes, _gain, dg, _phase_invert);
+ Amp::run_in_place (bufs, nframes, _gain, dg, _phase_invert);
_gain = dg;
} else if (_gain != 0 && (_phase_invert || _gain != 1.0)) {
this_gain = _gain;
}
- for (n = 0; n < nbufs; ++n) {
- Sample *sp = bufs[n];
- Session::apply_gain_to_buffer(sp,nframes,this_gain);
+ for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
+ Sample* const sp = i->data();
+ apply_gain_to_buffer(sp,nframes,this_gain);
}
} else if (_gain == 0) {
- for (n = 0; n < nbufs; ++n) {
- memset (bufs[n], 0, sizeof (Sample) * nframes);
+ for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
+ i->clear();
}
}
}
}
- /* ----------------------------------------------------------------------------------------------------
+ /* -------------------------------------------------------------------------------------------
POST-FADER REDIRECTS
- -------------------------------------------------------------------------------------------------- */
+ ----------------------------------------------------------------------------------------- */
- /* note that post_fader_work cannot be true unless with_redirects was also true, so don't test both */
+ /* note that post_fader_work cannot be true unless with_processors was also true,
+ so don't test both
+ */
if (post_fader_work) {
- Glib::RWLock::ReaderLock rm (redirect_lock, Glib::TRY_LOCK);
+ Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
if (rm.locked()) {
if (mute_gain > 0 || !_mute_affects_post_fader) {
- for (i = _redirects.begin(); i != _redirects.end(); ++i) {
+ for (i = _processors.begin(); i != _processors.end(); ++i) {
switch ((*i)->placement()) {
case PreFader:
break;
case PostFader:
- if (dsg == 0) {
- if (boost::dynamic_pointer_cast<Send>(*i) || boost::dynamic_pointer_cast<PortInsert>(*i)) {
- (*i)->silence (nframes, offset);
- }
- } else {
- (*i)->run (bufs, nbufs, nframes, offset);
- }
+ (*i)->run_in_place (bufs, start_frame, end_frame, nframes, offset);
break;
}
}
} else {
- for (i = _redirects.begin(); i != _redirects.end(); ++i) {
+ for (i = _processors.begin(); i != _processors.end(); ++i) {
switch ((*i)->placement()) {
case PreFader:
break;
}
if (!_soloed && (mute_gain != dmg) && !mute_declick_applied && _mute_affects_control_outs) {
- apply_declick (bufs, nbufs, nframes, mute_gain, dmg, false);
+ Amp::run_in_place (bufs, nframes, mute_gain, dmg, false);
mute_gain = dmg;
mute_declick_applied = true;
}
- /* ----------------------------------------------------------------------------------------------------
+ /* -------------------------------------------------------------------------------------------
CONTROL OUTPUT STAGE
- -------------------------------------------------------------------------------------------------- */
+ ----------------------------------------------------------------------------------------- */
if ((_meter_point == MeterPostFader) && co) {
if ( // silent anyway
- (_gain == 0 && !apply_gain_automation) ||
-
- // muted by solo of another track
+ (_gain == 0 && !apply_gain_automation) ||
+
+ // muted by solo of another track
!solo_audible ||
-
- // muted by mute of this track
+
+ // muted by mute of this track
!mute_audible ||
- // recording but not s/w monitoring
+ // recording but not s/w monitoring
- (no_monitor && record_enabled() && (!Config->get_auto_input() || _session.actively_recording()))
+ ( no_monitor && record_enabled()
+ && (!Config->get_auto_input() || _session.actively_recording()) )
) {
-
+
co->silence (nframes, offset);
} else {
- co->deliver_output_no_pan (bufs, nbufs, nframes, offset);
+ co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
}
}
- /* ----------------------------------------------------------------------
+ /* -------------------------------------------------------------------------------------------
GLOBAL MUTE
- ----------------------------------------------------------------------*/
+ ----------------------------------------------------------------------------------------- */
if (!_soloed && (mute_gain != dmg) && !mute_declick_applied && _mute_affects_main_outs) {
- apply_declick (bufs, nbufs, nframes, mute_gain, dmg, false);
+ Amp::run_in_place (bufs, nframes, mute_gain, dmg, false);
mute_gain = dmg;
mute_declick_applied = true;
}
- /* ----------------------------------------------------------------------------------------------------
+ /* -------------------------------------------------------------------------------------------
MAIN OUTPUT STAGE
- -------------------------------------------------------------------------------------------------- */
+ ----------------------------------------------------------------------------------------- */
solo_audible = dsg > 0;
mute_audible = dmg > 0 || !_mute_affects_main_outs;
- if (n_outputs() == 0) {
+ if (n_outputs().get(_default_type) == 0) {
/* relax */
- } else if (no_monitor && record_enabled() && (!Config->get_auto_input() || _session.actively_recording())) {
+ } else if (no_monitor && record_enabled()
+ && (!Config->get_auto_input() || _session.actively_recording())) {
IO::silence (nframes, offset);
if ( // silent anyway
- (_gain == 0 && !apply_gain_automation) ||
-
- // muted by solo of another track, but not using control outs for solo
+ (_gain == 0 && !apply_gain_automation) ||
+
+ // muted by solo of another track, but not using control outs for solo
- (!solo_audible && (Config->get_solo_model() != SoloBus)) ||
-
- // muted by mute of this track
+ (!solo_audible && (Config->get_solo_model() != SoloBus)) ||
+
+ // muted by mute of this track
- !mute_audible
+ !mute_audible
) {
/* don't use Route::silence() here, because that causes
- all outputs (sends, port inserts, etc. to be silent).
+ all outputs (sends, port processors, etc. to be silent).
*/
if (_meter_point == MeterPostFader) {
- reset_peak_meters ();
+ peak_meter().reset();
}
-
+
IO::silence (nframes, offset);
} else {
- if ((_session.transport_speed() > 1.5f ||
- _session.transport_speed() < -1.5f) &&
- Config->get_quieten_at_speed()) {
- pan (bufs, nbufs, nframes, offset, speed_quietning);
- } else {
- // cerr << _name << " panner state = " << _panner->automation_state() << endl;
- if (!_panner->empty() &&
- (_panner->automation_state() & Play ||
- ((_panner->automation_state() & Touch) && !_panner->touching()))) {
- pan_automated (bufs, nbufs, start_frame, end_frame, nframes, offset);
- } else {
- pan (bufs, nbufs, nframes, offset, 1.0);
- }
- }
+ deliver_output(bufs, start_frame, end_frame, nframes, offset);
+
}
}
- /* ----------------------------------------------------------------------------------------------------
+ /* -------------------------------------------------------------------------------------------
POST-FADER METERING
- -------------------------------------------------------------------------------------------------- */
+ ----------------------------------------------------------------------------------------- */
if (meter && (_meter_point == MeterPostFader)) {
-// cerr << "meter post" << endl;
-
if ((_gain == 0 && !apply_gain_automation) || dmg == 0) {
- uint32_t no = n_outputs();
- for (n = 0; n < no; ++n) {
- _peak_power[n] = 0;
- }
+ _meter->reset();
} else {
- uint32_t no = n_outputs();
- for (n = 0; n < no; ++n) {
- _peak_power[n] = Session::compute_peak (output(n)->get_buffer (nframes) + offset, nframes, _peak_power[n]);
- }
+ _meter->run_in_place(output_buffers(), start_frame, end_frame, nframes, offset);
}
}
}
-uint32_t
-Route::n_process_buffers ()
-{
- return max (n_inputs(), redirect_max_outs);
-}
-
+#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::passthru (nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset, int declick, bool meter_first)
+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)
{
- vector<Sample*>& bufs = _session.get_passthru_buffers();
- uint32_t limit = n_process_buffers ();
-
- _silent = false;
+ // 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();
- collect_input (bufs, limit, nframes, offset);
+ switch (Config->get_monitoring_model()) {
+ case HardwareMonitoring:
+ case ExternalMonitoring:
+ no_monitor = true;
+ break;
+ default:
+ no_monitor = false;
+ }
-#define meter_stream meter_first
+ declick = _pending_declick;
- if (meter_first) {
- for (uint32_t n = 0; n < limit; ++n) {
- _peak_power[n] = Session::compute_peak (bufs[n], nframes, _peak_power[n]);
+ {
+ Glib::Mutex::Lock cm (_control_outs_lock, Glib::TRY_LOCK);
+
+ if (cm.locked()) {
+ co = _control_outs;
+ } else {
+ co = 0;
}
- meter_stream = false;
- } else {
- meter_stream = true;
}
+
+ {
+ Glib::Mutex::Lock dm (declick_lock, Glib::TRY_LOCK);
- process_output_buffers (bufs, limit, start_frame, end_frame, nframes, offset, true, declick, meter_stream);
-
-#undef meter_stream
-}
-
-void
-Route::set_phase_invert (bool yn, void *src)
-{
- if (_phase_invert != yn) {
- _phase_invert = yn;
- }
- // phase_invert_changed (src); /* EMIT SIGNAL */
-}
-
-void
-Route::set_solo (bool yn, void *src)
-{
- if (_solo_safe) {
- return;
+ if (dm.locked()) {
+ dmg = desired_mute_gain;
+ dsg = desired_solo_gain;
+ dg = _desired_gain;
+ } else {
+ dmg = mute_gain;
+ dsg = solo_gain;
+ dg = _gain;
+ }
}
- if (_mix_group && src != _mix_group && _mix_group->is_active()) {
- _mix_group->apply (&Route::set_solo, yn, _mix_group);
- return;
- }
+ /* -------------------------------------------------------------------------------------------
+ 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)
+ ----------------------------------------------------------------------------------------- */
- if (_soloed != yn) {
- _soloed = yn;
- solo_changed (src); /* EMIT SIGNAL */
- _solo_control.Changed (); /* EMIT SIGNAL */
+ {
+ 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_solo_mute (bool yn)
-{
- Glib::Mutex::Lock lm (declick_lock);
+
+ /* -------------------------------------------------------------------------------------------
+ INPUT METERING & MONITORING
+ ----------------------------------------------------------------------------------------- */
- /* Called by Session in response to another Route being soloed.
- */
-
- desired_solo_gain = (yn?0.0:1.0);
-}
+ if (meter && (_meter_point == MeterInput)) {
+ _meter->run_in_place(bufs, start_frame, end_frame, nframes, offset);
+ }
-void
-Route::set_solo_safe (bool yn, void *src)
-{
- if (_solo_safe != yn) {
- _solo_safe = yn;
- solo_safe_changed (src); /* EMIT SIGNAL */
+ 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;
}
-}
-void
-Route::set_mute (bool yn, void *src)
+ /* -------------------------------------------------------------------------------------------
+ PRE-FADER REDIRECTS
+ ----------------------------------------------------------------------------------------- */
-{
- if (_mix_group && src != _mix_group && _mix_group->is_active()) {
- _mix_group->apply (&Route::set_mute, yn, _mix_group);
- return;
- }
+ // This really should already be true...
+ bufs.set_count(pre_fader_streams());
+
- if (_muted != yn) {
- _muted = yn;
- mute_changed (src); /* EMIT SIGNAL */
+ if ((_meter_point == MeterPreFader) && co) {
- _mute_control.Changed (); /* EMIT SIGNAL */
+ solo_audible = dsg > 0;
+ mute_audible = dmg > 0 || !_mute_affects_pre_fader;
- Glib::Mutex::Lock lm (declick_lock);
- desired_mute_gain = (yn?0.0f:1.0f);
- }
-}
-
-int
-Route::add_redirect (boost::shared_ptr<Redirect> redirect, void *src, uint32_t* err_streams)
-{
- uint32_t old_rmo = redirect_max_outs;
-
- if (!_session.engine().connected()) {
- return 1;
- }
-
- {
- Glib::RWLock::WriterLock lm (redirect_lock);
-
- boost::shared_ptr<PluginInsert> pi;
- boost::shared_ptr<PortInsert> porti;
-
- uint32_t potential_max_streams = 0;
-
- if ((pi = boost::dynamic_pointer_cast<PluginInsert>(redirect)) != 0) {
- pi->set_count (1);
-
- if (pi->input_streams() == 0) {
- /* instrument plugin */
- _have_internal_generator = true;
- }
-
- potential_max_streams = max(pi->input_streams(), pi->output_streams());
+ if ( // muted by solo of another track
- } else if ((porti = boost::dynamic_pointer_cast<PortInsert>(redirect)) != 0) {
-
- /* force new port inserts to start out with an i/o configuration
- that matches this route's i/o configuration.
-
- the "inputs" for the port are supposed to match the output
- of this route.
-
- the "outputs" of the route should match the inputs of this
- route. XXX shouldn't they match the number of active signal
- streams at the point of insertion?
-
- */
-
- porti->ensure_io (n_outputs (), n_inputs(), false, this);
- }
-
- // Ensure peak vector sizes before the plugin is activated
- while (_peak_power.size() < potential_max_streams) {
- _peak_power.push_back(0);
- }
- while (_visible_peak_power.size() < potential_max_streams) {
- _visible_peak_power.push_back(-INFINITY);
- }
- while (_max_peak_power.size() < potential_max_streams) {
- _max_peak_power.push_back(-INFINITY);
- }
-
- _redirects.push_back (redirect);
+ !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 (_reset_plugin_counts (err_streams)) {
- _redirects.pop_back ();
- _reset_plugin_counts (0); // it worked before we tried to add it ...
- return -1;
- }
+ ) {
+
+ co->silence (nframes, offset);
+
+ } else {
- redirect->activate ();
- redirect->active_changed.connect (mem_fun (*this, &Route::redirect_active_proxy));
- }
+ co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
+ }
+ }
- if (redirect_max_outs != old_rmo || old_rmo == 0) {
- reset_panner ();
- }
-
-
- redirects_changed (src); /* EMIT SIGNAL */
- return 0;
-}
-
-int
-Route::add_redirects (const RedirectList& others, void *src, uint32_t* err_streams)
-{
- uint32_t old_rmo = redirect_max_outs;
-
- if (!_session.engine().connected()) {
- return 1;
- }
+ /* -------------------------------------------------------------------------------------------
+ GAIN STAGE
+ ----------------------------------------------------------------------------------------- */
- {
- Glib::RWLock::WriterLock lm (redirect_lock);
+ /* if not recording or recording and requiring any monitor signal, then apply gain */
- RedirectList::iterator existing_end = _redirects.end();
- --existing_end;
+ if ( // not recording
- uint32_t potential_max_streams = 0;
+ !(record_enabled() && _session.actively_recording()) ||
+
+ // OR recording
+
+ // AND software monitoring required
- for (RedirectList::const_iterator i = others.begin(); i != others.end(); ++i) {
-
- boost::shared_ptr<PluginInsert> pi;
+ Config->get_monitoring_model() == SoftwareMonitoring) {
+
+ if (apply_gain_automation) {
- if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
- pi->set_count (1);
-
- uint32_t m = max(pi->input_streams(), pi->output_streams());
- if (m > potential_max_streams)
- potential_max_streams = m;
+ 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.
+ */
- // Ensure peak vector sizes before the plugin is activated
- while (_peak_power.size() < potential_max_streams) {
- _peak_power.push_back(0);
+ gain_t this_gain;
+
+ if (_phase_invert) {
+ this_gain = -_gain;
+ } else {
+ this_gain = _gain;
+ }
+
+ for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
+ Sample* const sp = i->data();
+ apply_gain_to_buffer(sp,nframes,this_gain);
+ }
+
+ } else if (_gain == 0) {
+ for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
+ i->clear();
+ }
}
- while (_visible_peak_power.size() < potential_max_streams) {
- _visible_peak_power.push_back(-INFINITY);
+ }
+
+ } else {
+
+ /* actively recording, no monitoring required; leave buffers as-is to save CPU cycles */
+
+ }
+
+ /* -------------------------------------------------------------------------------------------
+ CONTROL OUTPUT STAGE
+ ----------------------------------------------------------------------------------------- */
+
+ if ((_meter_point == MeterPostFader) && co) {
+
+ solo_audible = solo_gain > 0;
+ mute_audible = dmg > 0 || !_mute_affects_control_outs;
+
+ if ( // silent anyway
+
+ (_gain == 0 && !apply_gain_automation) ||
+
+ // muted by solo of another track
+
+ !solo_audible ||
+
+ // muted by mute of this track
+
+ !mute_audible ||
+
+ // recording but not s/w monitoring
+
+ (no_monitor && record_enabled() && (!Config->get_auto_input() || _session.actively_recording()))
+
+ ) {
+
+ co->silence (nframes, offset);
+
+ } else {
+
+ co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
+ }
+ }
+
+ /* -------------------------------------------------------------------------------------------
+ MAIN OUTPUT STAGE
+ ----------------------------------------------------------------------------------------- */
+
+ solo_audible = dsg > 0;
+ mute_audible = dmg > 0 || !_mute_affects_main_outs;
+
+ if (n_outputs().get(_default_type) == 0) {
+
+ /* relax */
+
+ } else if (no_monitor && record_enabled()
+ && (!Config->get_auto_input() || _session.actively_recording())) {
+
+ IO::silence (nframes, offset);
+
+ } else {
+
+ if ( // silent anyway
+
+ (_gain == 0 && !apply_gain_automation) ||
+
+ // muted by solo of another track, but not using control outs for solo
+
+ (!solo_audible && (Config->get_solo_model() != SoloBus)) ||
+
+ // muted by mute of this track
+
+ !mute_audible
+
+ ) {
+
+ /* don't use Route::silence() here, because that causes
+ all outputs (sends, port processors, etc. to be silent).
+ */
+
+ if (_meter_point == MeterPostFader) {
+ peak_meter().reset();
}
- while (_max_peak_power.size() < potential_max_streams) {
- _max_peak_power.push_back(-INFINITY);
+
+ IO::silence (nframes, offset);
+
+ } else {
+
+ deliver_output(bufs, start_frame, end_frame, nframes, offset);
+
+ }
+
+ }
+}
+
+#endif /* NEW_POB */
+
+ChanCount
+Route::n_process_buffers ()
+{
+ return max (n_inputs(), processor_max_outs);
+}
+
+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());
+
+ _silent = false;
+
+ collect_input (bufs, nframes, offset);
+
+ 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);
+}
+
+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);
+}
+
+void
+Route::set_solo (bool yn, void *src)
+{
+ if (_solo_safe) {
+ return;
+ }
+
+ if (_mix_group && src != _mix_group && _mix_group->is_active()) {
+ _mix_group->apply (&Route::set_solo, yn, _mix_group);
+ return;
+ }
+
+ if (_soloed != yn) {
+ _soloed = yn;
+ solo_changed (src); /* EMIT SIGNAL */
+ _solo_control->Changed (); /* EMIT SIGNAL */
+ }
+
+ catch_up_on_solo_mute_override ();
+}
+
+void
+Route::catch_up_on_solo_mute_override ()
+{
+ if (Config->get_solo_model() != InverseMute) {
+ return;
+ }
+
+ {
+
+ Glib::Mutex::Lock lm (declick_lock);
+
+ if (_muted) {
+ if (Config->get_solo_mute_override()) {
+ desired_mute_gain = (_soloed?1.0:0.0);
+ } else {
+ desired_mute_gain = 0.0;
}
+ } else {
+ desired_mute_gain = 1.0;
+ }
+ }
+}
+
+void
+Route::set_solo_mute (bool yn)
+{
+ Glib::Mutex::Lock lm (declick_lock);
+
+ /* Called by Session in response to another Route being soloed.
+ */
+
+ desired_solo_gain = (yn?0.0:1.0);
+}
+
+void
+Route::set_solo_safe (bool yn, void *src)
+{
+ if (_solo_safe != yn) {
+ _solo_safe = yn;
+ solo_safe_changed (src); /* EMIT SIGNAL */
+ }
+}
+
+void
+Route::set_mute (bool yn, void *src)
+
+{
+ if (_mix_group && src != _mix_group && _mix_group->is_active()) {
+ _mix_group->apply (&Route::set_mute, yn, _mix_group);
+ return;
+ }
+
+ 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);
+ }
+ }
+}
+
+int
+Route::add_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err)
+{
+ ChanCount old_pmo = processor_max_outs;
+
+ if (!_session.engine().connected()) {
+ return 1;
+ }
+
+ {
+ Glib::RWLock::WriterLock lm (_processor_lock);
+
+ boost::shared_ptr<PluginInsert> pi;
+ boost::shared_ptr<PortInsert> porti;
- _redirects.push_back (*i);
+ //processor->set_default_type(_default_type);
+
+ _processors.push_back (processor);
+
+ // Set up processor list channels. This will set processor->[input|output]_streams(),
+ // configure redirect ports properly, etc.
+ if (_reset_processor_counts (err)) {
+ _processors.pop_back ();
+ _reset_processor_counts (0); // it worked before we tried to add it ...
+ return -1;
+ }
+
+ if ((pi = boost::dynamic_pointer_cast<PluginInsert>(processor)) != 0) {
+
+ if (pi->natural_input_streams() == ChanCount::ZERO) {
+ /* generator plugin */
+ _have_internal_generator = true;
+ }
- if (_reset_plugin_counts (err_streams)) {
+ }
+
+ // 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()));
+
+ _meter->configure_io (potential_max_streams, potential_max_streams);
+
+ // XXX: do we want to emit the signal here ? change call order.
+ processor->activate ();
+ processor->ActiveChanged.connect (bind (mem_fun (_session, &Session::update_latency_compensation), false, false));
+
+ _user_latency = 0;
+ }
+
+ if (processor_max_outs != old_pmo || old_pmo == ChanCount::ZERO) {
+ reset_panner ();
+ }
+
+ processors_changed (); /* EMIT SIGNAL */
+
+ return 0;
+}
+
+int
+Route::add_processors (const ProcessorList& others, 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;
+
+ if (!_session.engine().connected()) {
+ return 1;
+ }
+
+ {
+ Glib::RWLock::WriterLock lm (_processor_lock);
+
+ ProcessorList::iterator existing_end = _processors.end();
+ --existing_end;
+
+ ChanCount potential_max_streams;
+
+ for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
+
+ boost::shared_ptr<PluginInsert> pi;
+
+ if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
+ pi->set_count (1);
+
+ ChanCount m = max(pi->input_streams(), pi->output_streams());
+ if (m > potential_max_streams)
+ potential_max_streams = m;
+ }
+
+ // Ensure peak vector sizes before the plugin is activated
+ _meter->configure_io (potential_max_streams, potential_max_streams);
+
+ _processors.push_back (*i);
+
+ if (_reset_processor_counts (err)) {
++existing_end;
- _redirects.erase (existing_end, _redirects.end());
- _reset_plugin_counts (0); // it worked before we tried to add it ...
+ _processors.erase (existing_end, _processors.end());
+ _reset_processor_counts (0); // it worked before we tried to add it ...
return -1;
}
- (*i)->activate ();
- (*i)->active_changed.connect (mem_fun (*this, &Route::redirect_active_proxy));
+ (*i)->ActiveChanged.connect (bind (mem_fun (_session, &Session::update_latency_compensation), false, false));
}
+
+ _user_latency = 0;
}
- if (redirect_max_outs != old_rmo || old_rmo == 0) {
+ if (processor_max_outs != old_pmo || old_pmo == ChanCount::ZERO) {
reset_panner ();
}
- redirects_changed (src); /* EMIT SIGNAL */
+ processors_changed (); /* EMIT SIGNAL */
return 0;
}
+/** Turn off all processors with a given placement
+ * @param p Placement of processors to disable
+ */
+void
+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 ();
+ }
+ }
+
+ _session.set_dirty ();
+}
+
+/** 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 ();
+}
+
+/** Turn off all redirects with a given placement
+ * @param p Placement of redirects to disable
+ */
+void
+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) {
+ (*i)->deactivate ();
+ }
+ }
+
+ _session.set_dirty ();
+}
+
+/** Turn off all plugins
+ */
+void
+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 ();
+}
+
+
+void
+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
+ we go the other way, we will revert them
+ */
+
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
+ continue;
+ }
+
+ if ((*i)->active()) {
+ (*i)->deactivate ();
+ (*i)->set_next_ab_is_active (true);
+ } else {
+ (*i)->set_next_ab_is_active (false);
+ }
+ }
+
+ } else {
+
+ /* backward = if the redirect was marked to go active on the next ab, do so */
+
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+
+ if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
+ continue;
+ }
+
+ if ((*i)->get_next_ab_is_active()) {
+ (*i)->activate ();
+ } else {
+ (*i)->deactivate ();
+ }
+ }
+ }
+
+ _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 ();
+ }
+}
+
+
+/** Remove processors with a given placement.
+ * @param p Placement of processors to remove.
+ */
void
-Route::clear_redirects (void *src)
+Route::clear_processors (Placement p)
{
- uint32_t old_rmo = redirect_max_outs;
+ const ChanCount old_pmo = processor_max_outs;
if (!_session.engine().connected()) {
return;
}
{
- Glib::RWLock::WriterLock lm (redirect_lock);
- RedirectList::iterator i;
- for (i = _redirects.begin(); i != _redirects.end(); ++i) {
- (*i)->drop_references ();
+ Glib::RWLock::WriterLock lm (_processor_lock);
+ ProcessorList new_list;
+
+ 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 */
+ new_list.push_back (*i);
+ }
}
- _redirects.clear ();
+
+ _processors = new_list;
}
- if (redirect_max_outs != old_rmo) {
+ /* FIXME: can't see how this test can ever fire */
+ if (processor_max_outs != old_pmo) {
reset_panner ();
}
- redirect_max_outs = 0;
+ processor_max_outs.reset();
_have_internal_generator = false;
- redirects_changed (src); /* EMIT SIGNAL */
+ processors_changed (); /* EMIT SIGNAL */
}
int
-Route::remove_redirect (boost::shared_ptr<Redirect> redirect, void *src, uint32_t* err_streams)
+Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err)
{
- uint32_t old_rmo = redirect_max_outs;
+ ChanCount old_pmo = processor_max_outs;
if (!_session.engine().connected()) {
return 1;
}
- redirect_max_outs = 0;
+ processor_max_outs.reset();
{
- Glib::RWLock::WriterLock lm (redirect_lock);
- RedirectList::iterator i;
+ Glib::RWLock::WriterLock lm (_processor_lock);
+ ProcessorList::iterator i;
bool removed = false;
- for (i = _redirects.begin(); i != _redirects.end(); ++i) {
- if (*i == redirect) {
+ for (i = _processors.begin(); i != _processors.end(); ++i) {
+ if (*i == processor) {
- RedirectList::iterator tmp;
+ ProcessorList::iterator tmp;
- /* move along, see failure case for reset_plugin_counts()
- where we may need to reinsert the redirect.
+ /* move along, see failure case for reset_processor_counts()
+ where we may need to reprocessor the processor.
*/
tmp = i;
run.
*/
- boost::shared_ptr<Send> send;
- boost::shared_ptr<PortInsert> port_insert;
+ boost::shared_ptr<IOProcessor> redirect;
- if ((send = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
- send->disconnect_inputs (this);
- send->disconnect_outputs (this);
- } else if ((port_insert = boost::dynamic_pointer_cast<PortInsert> (*i)) != 0) {
- port_insert->disconnect_inputs (this);
- port_insert->disconnect_outputs (this);
+ if ((redirect = boost::dynamic_pointer_cast<IOProcessor> (*i)) != 0) {
+ redirect->io()->disconnect_inputs (this);
+ redirect->io()->disconnect_outputs (this);
}
- _redirects.erase (i);
+ _processors.erase (i);
i = tmp;
removed = true;
break;
}
+
+ _user_latency = 0;
}
if (!removed) {
return 1;
}
- if (_reset_plugin_counts (err_streams)) {
+ if (_reset_processor_counts (err)) {
/* get back to where we where */
- _redirects.insert (i, redirect);
+ _processors.insert (i, processor);
/* we know this will work, because it worked before :) */
- _reset_plugin_counts (0);
+ _reset_processor_counts (0);
return -1;
}
- bool foo = false;
+ _have_internal_generator = false;
- for (i = _redirects.begin(); i != _redirects.end(); ++i) {
+ for (i = _processors.begin(); i != _processors.end(); ++i) {
boost::shared_ptr<PluginInsert> pi;
if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
if (pi->is_generator()) {
- foo = true;
+ _have_internal_generator = true;
+ break;
}
}
}
-
- _have_internal_generator = foo;
}
- if (old_rmo != redirect_max_outs) {
+ if (old_pmo != processor_max_outs) {
reset_panner ();
}
- redirect->drop_references ();
+ processor->drop_references ();
- redirects_changed (src); /* EMIT SIGNAL */
+ processors_changed (); /* EMIT SIGNAL */
return 0;
}
int
-Route::reset_plugin_counts (uint32_t* lpc)
+Route::reset_processor_counts (ProcessorStreams* err)
{
- Glib::RWLock::WriterLock lm (redirect_lock);
- return _reset_plugin_counts (lpc);
+ Glib::RWLock::WriterLock lm (_processor_lock);
+ return _reset_processor_counts (err);
}
int
-Route::_reset_plugin_counts (uint32_t* err_streams)
-{
- RedirectList::iterator r;
- uint32_t i_cnt;
- uint32_t s_cnt;
- map<Placement,list<InsertCount> > insert_map;
- nframes_t initial_streams;
-
- redirect_max_outs = 0;
- i_cnt = 0;
- s_cnt = 0;
+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 _redirects
+ 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 = _redirects.begin(); r != _redirects.end(); ++r) {
+ for (r = _processors.begin(); r != _processors.end(); ++r) {
- boost::shared_ptr<Insert> insert;
+ boost::shared_ptr<PluginInsert> plugin_insert;
+ boost::shared_ptr<PortInsert> port_insert;
- /* do this here in case we bomb out before we get to the end of
- this function.
- */
+ if ((plugin_insert = boost::dynamic_pointer_cast<PluginInsert>(*r)) != 0) {
- redirect_max_outs = max ((*r)->output_streams (), redirect_max_outs);
-
- if ((insert = boost::dynamic_pointer_cast<Insert>(*r)) != 0) {
- ++i_cnt;
- insert_map[insert->placement()].push_back (InsertCount (insert));
+ ++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.
*/
- boost::shared_ptr<PluginInsert> pi;
-
- if ((pi = boost::dynamic_pointer_cast<PluginInsert>(insert)) != 0) {
- pi->set_count (1);
- }
+ plugin_insert->set_count (1);
+
+ } else if ((port_insert = boost::dynamic_pointer_cast<PortInsert>(*r)) != 0) {
+
+ ++insert_cnt;
+ proc_map[(*r)->placement()].push_back (ProcessorCount (*r));
} else if (boost::dynamic_pointer_cast<Send> (*r) != 0) {
- ++s_cnt;
+ ++send_cnt;
}
}
-
- if (i_cnt == 0) {
- if (s_cnt) {
+
+ if (insert_cnt == 0) {
+ if (send_cnt) {
goto recompute;
} else {
- return 0;
+ ret = 0;
+ goto streamcount;
}
}
/* A: PreFader */
- if (check_some_plugin_counts (insert_map[PreFader], n_inputs (), err_streams)) {
- return -1;
+ if (check_some_processor_counts (proc_map[PreFader], n_inputs (), err)) {
+ goto streamcount;
}
- /* figure out the streams that will feed into PreFader */
-
- if (!insert_map[PreFader].empty()) {
- InsertCount& ic (insert_map[PreFader].back());
- initial_streams = ic.insert->compute_output_streams (ic.cnt);
- } else {
- initial_streams = n_inputs ();
+ if (!proc_map[PreFader].empty()) {
+ previous_initial_streams = n_inputs ();
+ for (list<ProcessorCount>::iterator i = proc_map[PreFader].begin(); i != proc_map[PreFader].end(); i++) {
+ if (i->processor->can_support_io_configuration (previous_initial_streams, initial_streams) == false) {
+ goto streamcount;
+ }
+ previous_initial_streams = initial_streams;
+ }
}
/* B: PostFader */
- if (check_some_plugin_counts (insert_map[PostFader], initial_streams, err_streams)) {
- return -1;
+ if (check_some_processor_counts (proc_map[PostFader], initial_streams, err)) {
+ goto streamcount;
+ }
+
+ if (!proc_map[PostFader].empty()) {
+ for (list<ProcessorCount>::iterator i = proc_map[PostFader].begin(); i != proc_map[PostFader].end(); i++) {
+ if (i->processor->can_support_io_configuration (previous_initial_streams, initial_streams) == false) {
+ goto streamcount;
+ }
+ previous_initial_streams = initial_streams;
+ }
}
/* OK, everything can be set up correctly, so lets do it */
- apply_some_plugin_counts (insert_map[PreFader]);
- apply_some_plugin_counts (insert_map[PostFader]);
+ apply_some_processor_counts (proc_map[PreFader]);
+ apply_some_processor_counts (proc_map[PostFader]);
+
+ /* recompute max outs of any processor */
- /* recompute max outs of any redirect */
+ ret = 0;
recompute:
- redirect_max_outs = 0;
- RedirectList::iterator prev = _redirects.end();
+ processor_max_outs.reset ();
+ prev = _processors.end();
- for (r = _redirects.begin(); r != _redirects.end(); prev = r, ++r) {
+ for (r = _processors.begin(); r != _processors.end(); prev = r, ++r) {
boost::shared_ptr<Send> s;
if ((s = boost::dynamic_pointer_cast<Send> (*r)) != 0) {
- if (r == _redirects.begin()) {
- s->expect_inputs (n_inputs());
- } else {
- s->expect_inputs ((*prev)->output_streams());
- }
- } else {
-
/* don't pay any attention to send output configuration, since it doesn't
affect the route.
*/
- redirect_max_outs = max ((*r)->output_streams (), redirect_max_outs);
-
- }
- }
-
- /* we're done */
-
- return 0;
-}
-
-int32_t
-Route::apply_some_plugin_counts (list<InsertCount>& iclist)
-{
- list<InsertCount>::iterator i;
-
- for (i = iclist.begin(); i != iclist.end(); ++i) {
-
- if ((*i).insert->configure_io ((*i).cnt, (*i).in, (*i).out)) {
- return -1;
- }
- /* make sure that however many we have, they are all active */
- (*i).insert->activate ();
- }
-
- return 0;
-}
-
-int32_t
-Route::check_some_plugin_counts (list<InsertCount>& iclist, int32_t required_inputs, uint32_t* err_streams)
-{
- list<InsertCount>::iterator i;
-
- for (i = iclist.begin(); i != iclist.end(); ++i) {
-
- if (((*i).cnt = (*i).insert->can_support_input_configuration (required_inputs)) < 0) {
- if (err_streams) {
- *err_streams = required_inputs;
- }
- return -1;
- }
-
- (*i).in = required_inputs;
- (*i).out = (*i).insert->compute_output_streams ((*i).cnt);
-
- required_inputs = (*i).out;
- }
-
- return 0;
-}
-
-int
-Route::copy_redirects (const Route& other, Placement placement, uint32_t* err_streams)
-{
- uint32_t old_rmo = redirect_max_outs;
-
- if (err_streams) {
- *err_streams = 0;
- }
-
- RedirectList to_be_deleted;
-
- {
- Glib::RWLock::WriterLock lm (redirect_lock);
- RedirectList::iterator tmp;
- RedirectList the_copy;
-
- the_copy = _redirects;
-
- /* remove all relevant redirects */
-
- for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ) {
- tmp = i;
- ++tmp;
-
- if ((*i)->placement() == placement) {
- to_be_deleted.push_back (*i);
- _redirects.erase (i);
- }
-
- i = tmp;
- }
-
- /* now copy the relevant ones from "other" */
-
- for (RedirectList::const_iterator i = other._redirects.begin(); i != other._redirects.end(); ++i) {
- if ((*i)->placement() == placement) {
- _redirects.push_back (Redirect::clone (*i));
+ if (r == _processors.begin()) {
+ s->expect_inputs (n_inputs());
+ } else {
+ s->expect_inputs ((*prev)->output_streams());
}
- }
- /* reset plugin stream handling */
+ } else {
+
+ max_audio = max ((*r)->output_streams ().n_audio(), max_audio);
+ max_midi = max ((*r)->output_streams ().n_midi(), max_midi);
+ }
+ }
- if (_reset_plugin_counts (err_streams)) {
+ processor_max_outs.set (DataType::AUDIO, max_audio);
+ processor_max_outs.set (DataType::MIDI, max_midi);
+
+ /* we're done */
+ return 0;
- /* FAILED COPY ATTEMPT: we have to restore order */
+ 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);
+ }
- /* delete all cloned redirects */
+ processor_max_outs.set (DataType::AUDIO, max_audio);
+ processor_max_outs.set (DataType::MIDI, max_midi);
- for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ) {
+ return ret;
+}
- tmp = i;
- ++tmp;
+int32_t
+Route::apply_some_processor_counts (list<ProcessorCount>& iclist)
+{
+ list<ProcessorCount>::iterator i;
+
+ for (i = iclist.begin(); i != iclist.end(); ++i) {
- if ((*i)->placement() == placement) {
- _redirects.erase (i);
- }
-
- i = tmp;
- }
+ ProcessorCount& pc (*i);
- /* restore the natural order */
+ if (pc.processor->configure_io (pc.in, pc.out)) {
+ return -1;
+ }
- _redirects = the_copy;
- redirect_max_outs = old_rmo;
+ /* make sure that however many we have, they are all active */
- /* we failed, even though things are OK again */
+ pc.processor->activate ();
+ }
- return -1;
+ return 0;
+}
- } else {
+/** 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.
+ */
+bool
+Route::check_some_processor_counts (list<ProcessorCount>& iclist, ChanCount required_inputs, ProcessorStreams* err)
+{
+ list<ProcessorCount>::iterator i;
+ size_t index = 0;
- /* SUCCESSFUL COPY ATTEMPT: delete the redirects we removed pre-copy */
- to_be_deleted.clear ();
- }
+ if (err) {
+ err->index = 0;
+ err->count = required_inputs;
}
- if (redirect_max_outs != old_rmo || old_rmo == 0) {
- reset_panner ();
+ for (i = iclist.begin(); i != iclist.end(); ++i, ++index) {
+
+ if (!(*i).processor->can_support_io_configuration (required_inputs, (*i).out)) {
+ if (err) {
+ err->index = index;
+ err->count = required_inputs;
+ }
+ return true;
+ }
+
+ (*i).in = required_inputs;
+ required_inputs = (*i).out;
}
- redirects_changed (this); /* EMIT SIGNAL */
- return 0;
+ return false;
}
void
-Route::all_redirects_flip ()
+Route::all_processors_flip ()
{
- Glib::RWLock::ReaderLock lm (redirect_lock);
+ Glib::RWLock::ReaderLock lm (_processor_lock);
- if (_redirects.empty()) {
+ if (_processors.empty()) {
return;
}
- bool first_is_on = _redirects.front()->active();
+ bool first_is_on = _processors.front()->active();
- for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
- (*i)->set_active (!first_is_on, this);
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ if (first_is_on) {
+ (*i)->deactivate ();
+ } else {
+ (*i)->activate ();
+ }
}
+
+ _session.set_dirty ();
}
+/** Set all processors with a given placement to a given active state.
+ * @param p Placement of processors to change.
+ * @param state New active state for those processors.
+ */
void
-Route::all_redirects_active (bool state)
+Route::all_processors_active (Placement p, bool state)
{
- Glib::RWLock::ReaderLock lm (redirect_lock);
+ Glib::RWLock::ReaderLock lm (_processor_lock);
- if (_redirects.empty()) {
+ if (_processors.empty()) {
return;
}
- for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
- (*i)->set_active (state, this);
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ if ((*i)->placement() == p) {
+ if (state) {
+ (*i)->activate ();
+ } else {
+ (*i)->deactivate ();
+ }
+ }
}
+
+ _session.set_dirty ();
}
-struct RedirectSorter {
- bool operator() (boost::shared_ptr<const Redirect> a, boost::shared_ptr<const Redirect> b) {
+struct ProcessorSorter {
+ bool operator() (boost::shared_ptr<const Processor> a, boost::shared_ptr<const Processor> b) {
return a->sort_key() < b->sort_key();
}
};
int
-Route::sort_redirects (uint32_t* err_streams)
+Route::sort_processors (ProcessorStreams* err)
{
{
- RedirectSorter comparator;
- Glib::RWLock::WriterLock lm (redirect_lock);
- uint32_t old_rmo = redirect_max_outs;
+ ProcessorSorter comparator;
+ Glib::RWLock::WriterLock lm (_processor_lock);
+ ChanCount old_pmo = processor_max_outs;
/* the sweet power of C++ ... */
- RedirectList as_it_was_before = _redirects;
+ ProcessorList as_it_was_before = _processors;
- _redirects.sort (comparator);
+ _processors.sort (comparator);
- if (_reset_plugin_counts (err_streams)) {
- _redirects = as_it_was_before;
- redirect_max_outs = old_rmo;
+ if (_reset_processor_counts (err)) {
+ _processors = as_it_was_before;
+ processor_max_outs = old_pmo;
return -1;
}
}
reset_panner ();
- redirects_changed (this); /* EMIT SIGNAL */
+ processors_changed (); /* EMIT SIGNAL */
return 0;
}
Route::state(bool full_state)
{
XMLNode *node = new XMLNode("Route");
- RedirectList:: iterator i;
+ ProcessorList::iterator i;
char buf[32];
if (_flags) {
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("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());
node->add_property ("order-keys", order_string);
node->add_child_nocopy (IO::state (full_state));
- node->add_child_nocopy (_solo_control.get_state ());
- node->add_child_nocopy (_mute_control.get_state ());
+ node->add_child_nocopy (_solo_control->get_state ());
+ node->add_child_nocopy (_mute_control->get_state ());
- XMLNode* remote_control_node = new XMLNode (X_("remote_control"));
+ 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);
cmt->add_content (_comment);
}
- for (i = _redirects.begin(); i != _redirects.end(); ++i) {
+ for (i = _processors.begin(); i != _processors.end(); ++i) {
node->add_child_nocopy((*i)->state (full_state));
}
return *node;
}
+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;
+}
+
+int
+Route::set_processor_state (const XMLNode& root)
+{
+ if (root.name() != X_("redirects")) {
+ return -1;
+ }
+
+ XMLNodeList nlist;
+ XMLNodeList nnlist;
+ XMLNodeConstIterator iter;
+ XMLNodeConstIterator niter;
+ Glib::RWLock::ReaderLock lm (_processor_lock);
+
+ nlist = root.children();
+
+ for (iter = nlist.begin(); iter != nlist.end(); ++iter){
+
+ /* iter now points to a IOProcessor state node */
+
+ nnlist = (*iter)->children ();
+
+ for (niter = nnlist.begin(); niter != nnlist.end(); ++niter) {
+
+ /* find the IO child node, since it contains the ID we need */
+
+ /* XXX OOP encapsulation violation, ugh */
+
+ if ((*niter)->name() == IO::state_node_name) {
+
+ XMLProperty* prop = (*niter)->property (X_("id"));
+
+ if (!prop) {
+ warning << _("IOProcessor node has no ID, ignored") << endmsg;
+ break;
+ }
+
+ ID id = prop->value ();
+
+ /* 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;
+
+ }
+ }
+
+ }
+
+ return 0;
+}
+
void
Route::set_deferred_state ()
{
nlist = deferred_state->children();
for (niter = nlist.begin(); niter != nlist.end(); ++niter){
- add_redirect_from_xml (**niter);
+ add_processor_from_xml (**niter);
}
delete deferred_state;
}
void
-Route::add_redirect_from_xml (const XMLNode& node)
+Route::add_processor_from_xml (const XMLNode& node)
{
const XMLProperty *prop;
+ // legacy sessions use a different node name for sends
if (node.name() == "Send") {
-
-
+
try {
boost::shared_ptr<Send> send (new Send (_session, node));
- add_redirect (send, this);
+ add_processor (send);
}
catch (failed_constructor &err) {
return;
}
- } else if (node.name() == "Insert") {
+ // use "Processor" in XML?
+ } else if (node.name() == "Processor") {
try {
if ((prop = node.property ("type")) != 0) {
- boost::shared_ptr<Insert> insert;
+ boost::shared_ptr<Processor> processor;
+ bool have_insert = false;
- if (prop->value() == "ladspa" || prop->value() == "Ladspa" || prop->value() == "vst") {
-
- insert.reset (new PluginInsert(_session, node));
+ 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") {
- insert.reset (new PortInsert (_session, node));
+ processor.reset (new Send (_session, node));
+ have_insert = true;
} else {
- error << string_compose(_("unknown Insert type \"%1\"; ignored"), prop->value()) << endmsg;
+ error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
}
-
- add_redirect (insert, this);
+
+ add_processor (processor);
} else {
- error << _("Insert XML node has no type property") << endmsg;
+ error << _("Processor XML node has no type property") << endmsg;
}
}
-
+
catch (failed_constructor &err) {
- warning << _("insert could not be created. Ignored.") << endmsg;
+ warning << _("processor could not be created. Ignored.") << endmsg;
return;
}
}
}
if ((prop = node.property (X_("phase-invert"))) != 0) {
- set_phase_invert(prop->value()=="yes"?true:false, this);
+ set_phase_invert (prop->value()=="yes"?true:false, this);
}
+ 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");
}
_mute_affects_main_outs = (prop->value()=="yes")?true:false;
}
+ if ((prop = node.property (X_("meter-point"))) != 0) {
+ _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
+ }
+
if ((prop = node.property (X_("edit-group"))) != 0) {
RouteGroup* edit_group = _session.edit_group_by_name(prop->value());
if(edit_group == 0) {
nlist = node.children();
- if (deferred_state) {
- delete deferred_state;
- }
-
+ delete deferred_state;
deferred_state = new XMLNode(X_("deferred state"));
/* set parent class properties before anything else */
break;
}
}
+
+ XMLNodeList processor_nodes;
for (niter = nlist.begin(); niter != nlist.end(); ++niter){
child = *niter;
- if (child->name() == X_("Send")) {
-
-
- if (!IO::ports_legal) {
+ if (child->name() == X_("Send") || child->name() == X_("Processor")) {
+ processor_nodes.push_back(child);
+ }
- deferred_state->add_child_copy (*child);
+ }
- } else {
- add_redirect_from_xml (*child);
- }
+ _set_processor_states(processor_nodes);
- } else if (child->name() == X_("Insert")) {
-
- if (!IO::ports_legal) {
-
- deferred_state->add_child_copy (*child);
- } else {
-
- add_redirect_from_xml (*child);
- }
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter){
+ child = *niter;
+ // All processors have been applied already
- } else if (child->name() == X_("Automation")) {
+ if (child->name() == X_("Automation")) {
if ((prop = child->property (X_("path"))) != 0) {
load_automation (prop->value());
string coutname = _name;
coutname += _("[control]");
+ delete _control_outs;
_control_outs = new IO (_session, coutname);
_control_outs->set_state (**(child->children().begin()));
XMLNode *cmt = *(child->children().begin());
_comment = cmt->content();
- } else if (child->name() == X_("extra")) {
+ } else if (child->name() == X_("Extra")) {
_extra_xml = new XMLNode (*child);
- } else if (child->name() == X_("controllable") && (prop = child->property("name")) != 0) {
+ } else if (child->name() == X_("Controllable") && (prop = child->property("name")) != 0) {
if (prop->value() == "solo") {
- _solo_control.set_state (*child);
- _session.add_controllable (&_solo_control);
- }
- else if (prop->value() == "mute") {
- _mute_control.set_state (*child);
- _session.add_controllable (&_mute_control);
+ _solo_control->set_state (*child);
+ _session.add_controllable (_solo_control);
+ } else if (prop->value() == "mute") {
+ _mute_control->set_state (*child);
+ _session.add_controllable (_mute_control);
}
}
- else if (child->name() == X_("remote_control")) {
+ else if (child->name() == X_("RemoteControl")) {
if ((prop = child->property (X_("id"))) != 0) {
int32_t x;
sscanf (prop->value().c_str(), "%d", &x);
return 0;
}
+void
+Route::_set_processor_states(const XMLNodeList &nlist)
+{
+ XMLNodeConstIterator niter;
+ char buf[64];
+
+ ProcessorList::iterator i, o;
+
+ // Iterate through existing processors, remove those which are not in the state list
+ for (i = _processors.begin(); i != _processors.end(); ) {
+ ProcessorList::iterator tmp = i;
+ ++tmp;
+
+ bool 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) {
+ 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
+ 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;
+ }
+
+ 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);
+
+ ProcessorList::iterator last = _processors.end();
+ --last;
+
+ if (prev_last == last) {
+ cerr << "Could not fully restore state as some processors were not possible to create" << endl;
+ continue;
+
+ }
+
+ boost::shared_ptr<Processor> tmp = (*last);
+ // remove the processor from the wrong location
+ _processors.erase(last);
+ // processor the new processor at the current location
+ _processors.insert(i, tmp);
+
+ --i; // move pointer to the newly processored processor
+ continue;
+ }
+
+ // 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
+ }
+
+ (*i)->set_state( (**niter) );
+ }
+
+ processors_changed ();
+}
+
void
Route::curve_reallocate ()
{
{
if (!_silent) {
- // reset_peak_meters ();
-
IO::silence (nframes, offset);
if (_control_outs) {
}
{
- Glib::RWLock::ReaderLock lm (redirect_lock, Glib::TRY_LOCK);
+ Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
if (lm.locked()) {
- for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
boost::shared_ptr<PluginInsert> pi;
if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
// skip plugins, they don't need anything when we're not active
int
Route::set_control_outs (const vector<string>& ports)
{
- Glib::Mutex::Lock lm (control_outs_lock);
+ Glib::Mutex::Lock lm (_control_outs_lock);
vector<string>::const_iterator i;
+ size_t limit;
+
+ delete _control_outs;
+ _control_outs = 0;
- if (_control_outs) {
- delete _control_outs;
- _control_outs = 0;
- }
+ if (is_control() || is_master()) {
+ /* no control outs for these two special busses */
+ return 0;
+ }
if (ports.empty()) {
return 0;
_control_outs = new IO (_session, coutname);
/* our control outs need as many outputs as we
- have outputs. we track the changes in ::output_change_handler().
+ have audio outputs. we track the changes in ::output_change_handler().
*/
+
+ // XXX its stupid that we have to get this value twice
- _control_outs->ensure_io (0, n_outputs(), true, this);
+ 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;
+ }
+ }
return 0;
}
uint32_t i, j;
IO& self = *this;
- uint32_t no = self.n_outputs();
- uint32_t ni = other->n_inputs ();
+ uint32_t no = self.n_outputs().n_total();
+ uint32_t ni = other->n_inputs ().n_total();
for (i = 0; i < no; ++i) {
for (j = 0; j < ni; ++j) {
}
}
- /* check Redirects which may also interconnect Routes */
+ /* check IOProcessors which may also interconnect Routes */
+
+ for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); r++) {
+
+ boost::shared_ptr<IOProcessor> redirect = boost::dynamic_pointer_cast<IOProcessor>(*r);
- for (RedirectList::iterator r = _redirects.begin(); r != _redirects.end(); r++) {
+ if ( ! redirect)
+ continue;
- no = (*r)->n_outputs();
+ // TODO: support internal redirects here
+
+ no = redirect->io()->n_outputs().n_total();
for (i = 0; i < no; ++i) {
for (j = 0; j < ni; ++j) {
- if ((*r)->output(i)->connected_to (other->input (j)->name())) {
+ if (redirect->io()->output(i)->connected_to (other->input (j)->name())) {
return true;
}
}
if (_control_outs) {
- no = _control_outs->n_outputs();
+ no = _control_outs->n_outputs().n_total();
for (i = 0; i < no; ++i) {
for (j = 0; j < ni; ++j) {
}
void
-Route::set_active (bool yn)
-{
- _active = yn;
- active_changed(); /* EMIT SIGNAL */
-}
-
-void
-Route::handle_transport_stopped (bool abort_ignored, bool did_locate, bool can_flush_redirects)
+Route::handle_transport_stopped (bool abort_ignored, bool did_locate, bool can_flush_processors)
{
nframes_t now = _session.transport_frame();
{
- Glib::RWLock::ReaderLock lm (redirect_lock);
+ Glib::RWLock::ReaderLock lm (_processor_lock);
if (!did_locate) {
- automation_snapshot (now);
+ automation_snapshot (now, true);
}
- for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- if (Config->get_plugins_stop_with_transport() && can_flush_redirects) {
+ if (Config->get_plugins_stop_with_transport() && can_flush_processors) {
(*i)->deactivate ();
(*i)->activate ();
}
Route::input_change_handler (IOChange change, void *ignored)
{
if (change & ConfigurationChanged) {
- reset_plugin_counts (0);
+ reset_processor_counts (0);
}
}
{
if (change & ConfigurationChanged) {
if (_control_outs) {
- _control_outs->ensure_io (0, n_outputs(), true, this);
+ _control_outs->ensure_io (ChanCount::ZERO, ChanCount(DataType::AUDIO, n_outputs().n_audio()), true, this);
}
- reset_plugin_counts (0);
+ reset_processor_counts (0);
}
}
uint32_t
Route::pans_required () const
{
- if (n_outputs() < 2) {
+ if (n_outputs().n_audio() < 2) {
return 0;
}
- return max (n_inputs (), redirect_max_outs);
+ return max (n_inputs ().n_audio(), processor_max_outs.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)
{
- if (n_outputs() == 0) {
+ if (n_outputs().n_total() == 0) {
return 0;
}
apply_gain_automation = false;
- if (n_inputs()) {
+ if (n_inputs().n_total()) {
passthru (start_frame, end_frame, nframes, offset, 0, false);
} else {
silence (nframes, offset);
bool can_record, bool rec_monitors_input)
{
{
- Glib::RWLock::ReaderLock lm (redirect_lock, Glib::TRY_LOCK);
+ Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
if (lm.locked()) {
// automation snapshot can also be called from the non-rt context
- // and it uses the redirect list, so we take the lock out here
- automation_snapshot (_session.transport_frame());
+ // and it uses the processor list, so we take the lock out here
+ automation_snapshot (_session.transport_frame(), false);
}
}
- if ((n_outputs() == 0 && _redirects.empty()) || n_inputs() == 0 || !_active) {
+ if ((n_outputs().n_total() == 0 && _processors.empty()) || n_inputs().n_total() == 0 || !_active) {
silence (nframes, offset);
return 0;
}
apply_gain_automation = false;
{
- Glib::Mutex::Lock am (automation_lock, Glib::TRY_LOCK);
+ Glib::Mutex::Lock am (data().control_lock(), Glib::TRY_LOCK);
if (am.locked() && _session.transport_rolling()) {
- nframes_t start_frame = end_frame - nframes;
-
- if (gain_automation_playback()) {
- apply_gain_automation = _gain_automation_curve.rt_safe_get_vector (start_frame, end_frame, _session.gain_automation_buffer(), nframes);
+ 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);
}
}
}
void
Route::toggle_monitor_input ()
{
- for (vector<Port*>::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
- (*i)->ensure_monitor_input(!(*i)->monitoring_input());
+ for (PortSet::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
+ i->ensure_monitor_input( ! i->monitoring_input());
}
}
bool
Route::has_external_redirects () const
{
+ // FIXME: what about sends?
+
boost::shared_ptr<const PortInsert> pi;
- for (RedirectList::const_iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
+ for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
if ((pi = boost::dynamic_pointer_cast<const PortInsert>(*i)) != 0) {
- uint32_t no = pi->n_outputs();
-
- for (uint32_t n = 0; n < no; ++n) {
+ for (PortSet::const_iterator port = pi->io()->outputs().begin();
+ port != pi->io()->outputs().end(); ++port) {
- string port_name = pi->output(n)->name();
+ 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 */
}
void
-Route::flush_redirects ()
+Route::flush_processors ()
{
/* XXX shouldn't really try to take this lock, since
this is called from the RT audio thread.
*/
- Glib::RWLock::ReaderLock lm (redirect_lock);
+ Glib::RWLock::ReaderLock lm (_processor_lock);
- for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
(*i)->deactivate ();
(*i)->activate ();
}
nframes_t
Route::update_total_latency ()
{
- _own_latency = 0;
+ nframes_t old = _own_latency;
+
+ if (_user_latency) {
+ _own_latency = _user_latency;
+ } else {
+ _own_latency = 0;
- for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
- if ((*i)->active ()) {
- _own_latency += (*i)->latency ();
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ if ((*i)->active ()) {
+ _own_latency += (*i)->signal_latency ();
+ }
}
}
+#undef DEBUG_LATENCY
+#ifdef DEBUG_LATENCY
+ cerr << _name << ": internal redirect latency = " << _own_latency << endl;
+#endif
+
set_port_latency (_own_latency);
+
+ if (!_user_latency) {
+ /* this (virtual) function is used for pure Routes,
+ not derived classes like AudioTrack. this means
+ that the data processed here comes from an input
+ port, not prerecorded material, and therefore we
+ have to take into account any input latency.
+ */
- /* this (virtual) function is used for pure Routes,
- not derived classes like AudioTrack. this means
- that the data processed here comes from an input
- port, not prerecorded material, and therefore we
- have to take into account any input latency.
- */
- _own_latency += input_latency ();
+ _own_latency += input_latency ();
+ }
+
+ if (old != _own_latency) {
+ signal_latency_changed (); /* EMIT SIGNAL */
+ }
+
+#ifdef DEBUG_LATENCY
+ cerr << _name << ": input latency = " << input_latency() << " total = "
+ << _own_latency << endl;
+#endif
return _own_latency;
}
+void
+Route::set_user_latency (nframes_t nframes)
+{
+ Latent::set_user_latency (nframes);
+ _session.update_latency_compensation (false, false);
+}
+
void
Route::set_latency_delay (nframes_t longest_session_latency)
{
- _initial_delay = longest_session_latency - _own_latency;
+ nframes_t old = _initial_delay;
+
+ if (_own_latency < longest_session_latency) {
+ _initial_delay = longest_session_latency - _own_latency;
+ } else {
+ _initial_delay = 0;
+ }
+
+ if (_initial_delay != old) {
+ initial_delay_changed (); /* EMIT SIGNAL */
+ }
if (_session.transport_stopped()) {
_roll_delay = _initial_delay;
}
void
-Route::automation_snapshot (nframes_t now)
+Route::automation_snapshot (nframes_t now, bool force)
{
- IO::automation_snapshot (now);
+ if (!force && !should_snapshot(now)) {
+ return;
+ }
+
+ IO::automation_snapshot (now, force);
- for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
- (*i)->automation_snapshot (now);
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ (*i)->automation_snapshot (now, force);
}
}
void
Route::set_block_size (nframes_t nframes)
{
- for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
(*i)->set_block_size (nframes);
}
}
-void
-Route::redirect_active_proxy (Redirect* ignored, void* ignored_src)
-{
- _session.update_latency_compensation (false, false);
-}
-
void
Route::protect_automation ()
{
- switch (gain_automation_state()) {
- case Write:
- case Touch:
- set_gain_automation_state (Off);
- break;
- default:
- break;
- }
-
- switch (panner().automation_state ()) {
- case Write:
- case Touch:
- panner().set_automation_state (Off);
- break;
- default:
- break;
- }
+ Automatable::protect_automation();
- for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
- boost::shared_ptr<PluginInsert> pi;
- if ((pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
- pi->protect_automation ();
- }
- }
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
+ (*i)->protect_automation();
}
void
}
}
+
+/** Shift automation forwards from a particular place, thereby inserting time.
+ * Adds undo commands for any shifts that are performed.
+ *
+ * @param pos Position to start shifting from.
+ * @param frames Amount to shift forwards by.
+ */
+
+void
+Route::shift (nframes64_t pos, nframes64_t frames)
+{
+#ifdef THIS_NEEDS_FIXING_FOR_V3
+
+ /* gain automation */
+ XMLNode &before = _gain_control->get_state ();
+ _gain_control->shift (pos, frames);
+ XMLNode &after = _gain_control->get_state ();
+ _session.add_command (new MementoCommand<AutomationList> (_gain_automation_curve, &before, &after));
+
+ /* pan automation */
+ for (std::vector<StreamPanner*>::iterator i = _panner->begin (); i != _panner->end (); ++i) {
+ Curve & c = (*i)->automation ();
+ XMLNode &before = c.get_state ();
+ c.shift (pos, frames);
+ XMLNode &after = c.get_state ();
+ _session.add_command (new MementoCommand<AutomationList> (c, &before, &after));
+ }
+
+ /* redirect automation */
+ {
+ Glib::RWLock::ReaderLock lm (redirect_lock);
+ for (RedirectList::iterator i = _redirects.begin (); i != _redirects.end (); ++i) {
+
+ set<uint32_t> a;
+ (*i)->what_has_automation (a);
+
+ for (set<uint32_t>::const_iterator j = a.begin (); j != a.end (); ++j) {
+ AutomationList & al = (*i)->automation_list (*j);
+ XMLNode &before = al.get_state ();
+ al.shift (pos, frames);
+ XMLNode &after = al.get_state ();
+ _session.add_command (new MementoCommand<AutomationList> (al, &before, &after));
+ }
+ }
+ }
+#endif
+
+}
projects / ardour.git / blobdiff