/*
- 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 <sigc++/bind.h>
-#include <pbd/xml++.h>
-#include <pbd/enumwriter.h>
-#include <pbd/stacktrace.h>
-
-#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 <algorithm>
+
+#include "pbd/xml++.h"
+#include "pbd/enumwriter.h"
+#include "pbd/memento_command.h"
+#include "pbd/stacktrace.h"
+#include "pbd/convert.h"
+
+#include "evoral/Curve.hpp"
+
+#include "ardour/amp.h"
+#include "ardour/audio_port.h"
+#include "ardour/audioengine.h"
+#include "ardour/buffer.h"
+#include "ardour/buffer_set.h"
+#include "ardour/configuration.h"
+#include "ardour/cycle_timer.h"
+#include "ardour/debug.h"
+#include "ardour/delivery.h"
+#include "ardour/dB.h"
+#include "ardour/internal_send.h"
+#include "ardour/internal_return.h"
+#include "ardour/ladspa_plugin.h"
+#include "ardour/meter.h"
+#include "ardour/mix.h"
+#include "ardour/monitor_processor.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 "ardour/graph.h"
+#include "ardour/unknown_processor.h"
#include "i18n.h"
using namespace PBD;
uint32_t Route::order_key_cnt = 0;
-sigc::signal<void> Route::SyncOrderKeys;
-
-Route::Route (Session& sess, string name, int input_min, int input_max, int output_min, int output_max, Flag flg, DataType default_type)
- : IO (sess, name, input_min, input_max, output_min, output_max, default_type),
- _flags (flg),
- _solo_control (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 (new ToggleControllable (X_("solo"), *this, ToggleControllable::SoloControl)),
- _mute_control (new ToggleControllable (X_("mute"), *this, ToggleControllable::MuteControl))
-{
- init ();
- _set_state (node, false);
+PBD::Signal1<void,string const&> Route::SyncOrderKeys;
+PBD::Signal0<void> Route::RemoteControlIDChange;
+
+Route::Route (Session& sess, string name, Flag flg, DataType default_type)
+ : SessionObject (sess, name)
+ , Automatable (sess)
+ , GraphNode( sess.route_graph )
+ , _active (true)
+ , _initial_delay (0)
+ , _roll_delay (0)
+ , _flags (flg)
+ , _pending_declick (true)
+ , _meter_point (MeterPostFader)
+ , _self_solo (false)
+ , _soloed_by_others_upstream (0)
+ , _soloed_by_others_downstream (0)
+ , _solo_isolated (0)
+ , _denormal_protection (false)
+ , _recordable (true)
+ , _silent (false)
+ , _declickable (false)
+ , _solo_control (new SoloControllable (X_("solo"), *this))
+ , _mute_control (new MuteControllable (X_("mute"), *this))
+ , _mute_master (new MuteMaster (sess, name))
+ , _have_internal_generator (false)
+ , _solo_safe (false)
+ , _default_type (default_type)
+ , _remote_control_id (0)
+ , _in_configure_processors (false)
+{
+ processor_max_streams.reset();
+ order_keys[N_("signal")] = order_key_cnt++;
}
-void
+int
Route::init ()
{
- 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++;
- _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;
+ /* add standard controls */
- _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;
+ _solo_control->set_flags (Controllable::Flag (_solo_control->flags() | Controllable::Toggle));
+ _mute_control->set_flags (Controllable::Flag (_mute_control->flags() | Controllable::Toggle));
+
+ add_control (_solo_control);
+ add_control (_mute_control);
+
+ /* 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_same_thread (*this, boost::bind (&Route::input_change_handler, this, _1, _2));
+ _output->changed.connect_same_thread (*this, boost::bind (&Route::output_change_handler, this, _1, _2));
+
+ _input->PortCountChanging.connect_same_thread (*this, boost::bind (&Route::input_port_count_changing, this, _1));
+
+ /* add amp processor */
+
+ _amp.reset (new Amp (_session));
+ add_processor (_amp, PostFader);
+
+ /* add standard processors: meter, main outs, monitor out */
+
+ _meter.reset (new PeakMeter (_session));
+ _meter->set_display_to_user (false);
+
+ add_processor (_meter, PostFader);
+
+ _main_outs.reset (new Delivery (_session, _output, _mute_master, _name, Delivery::Main));
+
+ add_processor (_main_outs, PostFader);
+
+ if (is_monitor()) {
+ /* where we listen to tracks */
+ _intreturn.reset (new InternalReturn (_session));
+ add_processor (_intreturn, PreFader);
+
+ ProcessorList::iterator i;
+
+ for (i = _processors.begin(); i != _processors.end(); ++i) {
+ if (*i == _intreturn) {
+ ++i;
+ break;
+ }
+ }
+
+ /* the thing that provides proper control over a control/monitor/listen bus
+ (such as per-channel cut, dim, solo, invert, etc).
+ It always goes right after the internal return;
+ */
+ _monitor_control.reset (new MonitorProcessor (_session));
+ add_processor (_monitor_control, i);
+
+ /* no panning on the monitor main outs */
+
+ _main_outs->panner()->set_bypassed (true);
+ }
+
+ if (is_master() || is_monitor() || is_hidden()) {
+ _mute_master->set_solo_ignore (true);
+ }
- _control_outs = 0;
+ /* now that we have _meter, its safe to connect to this */
- input_changed.connect (mem_fun (this, &Route::input_change_handler));
- output_changed.connect (mem_fun (this, &Route::output_change_handler));
+ Metering::Meter.connect_same_thread (*this, (boost::bind (&Route::meter, this)));
+
+ return 0;
}
Route::~Route ()
{
- clear_processors (PreFader);
- clear_processors (PostFader);
+ DEBUG_TRACE (DEBUG::Destruction, string_compose ("route %1 destructor\n", _name));
- for (OrderKeys::iterator i = order_keys.begin(); i != order_keys.end(); ++i) {
- free ((void*)(i->first));
- }
+ /* do this early so that we don't get incoming signals as we are going through destruction
+ */
+
+ drop_connections ();
- if (_control_outs) {
- delete _control_outs;
+ /* don't use clear_processors here, as it depends on the session which may
+ be half-destroyed by now
+ */
+
+ Glib::RWLock::WriterLock lm (_processor_lock);
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ (*i)->drop_references ();
}
+
+ _processors.clear ();
}
void
-Route::set_remote_control_id (uint32_t id)
+Route::set_remote_control_id (uint32_t id, bool notify_class_listeners)
{
if (id != _remote_control_id) {
_remote_control_id = id;
RemoteControlIDChanged ();
+ if (notify_class_listeners) {
+ RemoteControlIDChange ();
+ }
}
}
return _remote_control_id;
}
-long
-Route::order_key (const char* name) const
+int32_t
+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, int32_t n)
{
- order_keys[strdup(name)] = n;
+ bool changed = false;
+
+ /* This method looks more complicated than it should, but
+ it's important that we don't emit order_key_changed unless
+ it actually has, as expensive things happen on receipt of that
+ signal.
+ */
+
+ if (order_keys.find(name) == order_keys.end() || order_keys[name] != n) {
+ order_keys[name] = n;
+ changed = true;
+ }
if (Config->get_sync_all_route_ordering()) {
for (OrderKeys::iterator x = order_keys.begin(); x != order_keys.end(); ++x) {
- x->second = n;
+ if (x->second != n) {
+ x->second = n;
+ changed = true;
+ }
}
- }
+ }
- _session.set_dirty ();
+ if (changed) {
+ order_key_changed (); /* EMIT SIGNAL */
+ _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 ()
+Route::sync_order_keys (std::string const & base)
{
- uint32_t key;
-
if (order_keys.empty()) {
return;
}
+
+ OrderKeys::iterator i;
+ int32_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) */
+ key = i->second;
+ i = order_keys.begin();
+ }
+
+ bool changed = false;
- OrderKeys::iterator x = order_keys.begin();
- key = x->second;
- ++x;
+ for (; i != order_keys.end(); ++i) {
+ if (i->second != key) {
+ i->second = key;
+ changed = true;
+ }
+ }
- for (; x != order_keys.end(); ++x) {
- x->second = key;
+ if (changed) {
+ order_key_changed (); /* EMIT SIGNAL */
}
}
{
string newname = name;
- while (session.route_by_name (newname)!=NULL)
- {
- newname = bump_name_once (newname);
+ while (!session.io_name_is_legal (newname)) {
+ newname = bump_name_once (newname, '.');
}
return newname;
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->is_active() && _route_group->is_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)
+ framepos_t start_frame, framepos_t end_frame, pframes_t nframes,
+ bool /*with_processors*/, int declick,
+ bool gain_automation_ok)
{
- // 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;
+ monitor = true;
}
- 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;
- }
+ if (!declick) {
+ declick = _pending_declick;
}
- /* ----------------------------------------------------------------------------------------------------
+ /* figure out if we're going to use gain automation */
+ if (gain_automation_ok) {
+ _amp->setup_gain_automation (start_frame, end_frame, nframes);
+ } else {
+ _amp->apply_gain_automation (false);
+ }
+
+ /* tell main outs what to do about monitoring */
+ _main_outs->no_outs_cuz_we_no_monitor (!monitor);
+
+
+ /* -------------------------------------------------------------------------------------------
GLOBAL DECLICK (for transport changes etc.)
- -------------------------------------------------------------------------------------------------- */
+ ----------------------------------------------------------------------------------------- */
if (declick > 0) {
- Amp::run_in_place (bufs, nframes, 0.0, 1.0, false);
- _pending_declick = 0;
+ Amp::declick (bufs, nframes, 1);
} 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;
- }
- }
-
-
- /* ----------------------------------------------------------------------------------------------------
- INPUT METERING & MONITORING
- -------------------------------------------------------------------------------------------------- */
-
- if (meter && (_meter_point == MeterInput)) {
- _meter->run_in_place(bufs, start_frame, end_frame, nframes, offset);
- }
-
- if (!_soloed && _mute_affects_pre_fader && (mute_gain != dmg)) {
- Amp::run_in_place (bufs, nframes, mute_gain, dmg, false);
- mute_gain = dmg;
- mute_declick_applied = true;
+ Amp::declick (bufs, nframes, -1);
}
- 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 {
+ _pending_declick = 0;
- co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
-
- }
- }
+ /* -------------------------------------------------------------------------------------------
+ DENORMAL CONTROL/PHASE INVERT
+ ----------------------------------------------------------------------------------------- */
- /* -----------------------------------------------------------------------------------------------------
- DENORMAL CONTROL
- -------------------------------------------------------------------------------------------------- */
+ if (_phase_invert.any ()) {
- if (_denormal_protection || Config->get_denormal_protection()) {
+ int chn = 0;
- 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;
- }
- }
- }
+ if (_denormal_protection || Config->get_denormal_protection()) {
- /* ----------------------------------------------------------------------------------------------------
- PRE-FADER REDIRECTS
- -------------------------------------------------------------------------------------------------- */
+ for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
+ Sample* const sp = i->data();
- 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;
+ if (_phase_invert[chn]) {
+ for (pframes_t nx = 0; nx < nframes; ++nx) {
+ sp[nx] = -sp[nx];
+ sp[nx] += 1.0e-27f;
}
- }
- } 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;
+ } else {
+ for (pframes_t nx = 0; nx < nframes; ++nx) {
+ sp[nx] += 1.0e-27f;
}
}
}
- }
- }
-
- // This really should already be true...
- 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;
- }
-
- /* ----------------------------------------------------------------------------------------------------
- PRE-FADER METERING & MONITORING
- -------------------------------------------------------------------------------------------------- */
-
- 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 not recording or recording and requiring any monitor signal, then apply gain */
-
- if ( // not recording
+ for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
+ Sample* const sp = i->data();
- !(record_enabled() && _session.actively_recording()) ||
-
- // OR recording
-
- // AND software monitoring required
-
- Config->get_monitoring_model() == SoftwareMonitoring) {
-
- if (apply_gain_automation) {
-
- if (_phase_invert) {
- for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
- Sample* const sp = i->data();
-
- for (nframes_t nx = 0; nx < nframes; ++nx) {
- sp[nx] *= -gab[nx];
- }
- }
- } else {
- for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
- Sample* const sp = i->data();
-
- for (nframes_t nx = 0; nx < nframes; ++nx) {
- sp[nx] *= gab[nx];
+ if (_phase_invert[chn]) {
+ for (pframes_t nx = 0; nx < nframes; ++nx) {
+ sp[nx] = -sp[nx];
}
}
}
-
- if (apply_gain_automation && _session.transport_rolling() && nframes > 0) {
- _effective_gain = gab[nframes-1];
- }
-
- } else {
-
- /* manual (scalar) gain */
-
- if (_gain != dg) {
-
- Amp::run_in_place (bufs, nframes, _gain, dg, _phase_invert);
- _gain = dg;
-
- } else if (_gain != 0 && (_phase_invert || _gain != 1.0)) {
-
- /* no need to interpolate current gain value,
- but its non-unity, so apply it. if the gain
- is zero, do nothing because we'll ship silence
- below.
- */
-
- gain_t this_gain;
-
- if (_phase_invert) {
- this_gain = -_gain;
- } else {
- this_gain = _gain;
- }
-
- for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
- Sample* const sp = i->data();
- apply_gain_to_buffer(sp,nframes,this_gain);
- }
-
- } else if (_gain == 0) {
- for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
- i->clear();
- }
- }
}
} else {
- /* actively recording, no monitoring required; leave buffers as-is to save CPU cycles */
-
- }
-
- /* ----------------------------------------------------------------------------------------------------
- POST-FADER REDIRECTS
- -------------------------------------------------------------------------------------------------- */
+ if (_denormal_protection || Config->get_denormal_protection()) {
- /* 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 (_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 (pframes_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;
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- if ( // silent anyway
+ if (boost::dynamic_pointer_cast<UnknownProcessor> (*i)) {
+ break;
+ }
+
+ 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());
+
+ /* should we NOT run plugins here if the route is inactive?
+ do we catch route != active somewhere higher?
+ */
- (_gain == 0 && !apply_gain_automation) ||
-
- // muted by solo of another track
+ (*i)->run (bufs, start_frame, end_frame, nframes, *i != _processors.back());
+ bufs.set_count ((*i)->output_streams());
+ }
+}
- !solo_audible ||
-
- // muted by mute of this track
+ChanCount
+Route::n_process_buffers ()
+{
+ return max (_input->n_ports(), processor_max_streams);
+}
- !mute_audible ||
+void
+Route::passthru (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
+{
+ BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers());
- // recording but not s/w monitoring
-
- (no_monitor && record_enabled() && (!Config->get_auto_input() || _session.actively_recording()))
+ _silent = false;
- ) {
-
- co->silence (nframes, offset);
-
- } else {
+ assert (bufs.available() >= input_streams());
- co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
- }
- }
+ if (_input->n_ports() == ChanCount::ZERO) {
+ silence_unlocked (nframes);
+ }
- /* ----------------------------------------------------------------------
- GLOBAL MUTE
- ----------------------------------------------------------------------*/
+ bufs.set_count (input_streams());
- 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
- -------------------------------------------------------------------------------------------------- */
+ if (is_monitor() && _session.listening() && !_session.is_auditioning()) {
- solo_audible = dsg > 0;
- mute_audible = dmg > 0 || !_mute_affects_main_outs;
-
- if (n_outputs().get(_default_type) == 0) {
-
- /* relax */
+ /* control/monitor bus ignores input ports when something is
+ feeding the listen "stream". data will "arrive" into the
+ route from the intreturn processor element.
+ */
+ 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
+ for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
- (_gain == 0 && !apply_gain_automation) ||
-
- // muted by solo of another track, but not using control outs for solo
+ BufferSet::iterator o = bufs.begin(*t);
+ PortSet& ports (_input->ports());
- (!solo_audible && (Config->get_solo_model() != SoloBus)) ||
-
- // muted by mute of this track
+ for (PortSet::iterator i = ports.begin(*t); i != ports.end(*t); ++i, ++o) {
+ o->read_from (i->get_buffer(nframes), nframes);
+ }
+ }
+ }
- !mute_audible
+ write_out_of_band_data (bufs, start_frame, end_frame, nframes);
+ process_output_buffers (bufs, start_frame, end_frame, nframes, true, declick, true);
+}
- ) {
+void
+Route::passthru_silence (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
+{
+ BufferSet& bufs (_session.get_silent_buffers (n_process_buffers()));
+ bufs.set_count (_input->n_ports());
+ write_out_of_band_data (bufs, start_frame, end_frame, nframes);
+ process_output_buffers (bufs, start_frame, end_frame, nframes, true, declick, false);
+}
- /* 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::set_listen (bool yn, void* src)
+{
+ if (_solo_safe) {
+ return;
+ }
+
+ if (_monitor_send) {
+ if (yn != _monitor_send->active()) {
+ if (yn) {
+ _monitor_send->activate ();
+ _mute_master->set_soloed (true);
+ } else {
+ _monitor_send->deactivate ();
+ _mute_master->set_soloed (false);
}
- IO::silence (nframes, offset);
-
- } else {
-
- deliver_output(bufs, start_frame, end_frame, nframes, offset);
-
+ 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 (_monitor_send) {
+ return _monitor_send->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();
-
- switch (Config->get_monitoring_model()) {
- case HardwareMonitoring:
- case ExternalMonitoring:
- no_monitor = true;
- break;
- default:
- no_monitor = false;
- }
-
- declick = _pending_declick;
-
- {
- Glib::Mutex::Lock cm (_control_outs_lock, Glib::TRY_LOCK);
-
- if (cm.locked()) {
- co = _control_outs;
- } else {
- co = 0;
- }
- }
-
- {
- Glib::Mutex::Lock dm (declick_lock, Glib::TRY_LOCK);
-
- if (dm.locked()) {
- dmg = desired_mute_gain;
- dsg = desired_solo_gain;
- dg = _desired_gain;
- } else {
- dmg = mute_gain;
- dsg = solo_gain;
- dg = _gain;
- }
- }
+ if (_solo_safe != yn) {
+ _solo_safe = yn;
+ solo_safe_changed (src);
+ }
+}
- /* ----------------------------------------------------------------------------------------------------
- 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)
- */
+bool
+Route::solo_safe() const
+{
+ return _solo_safe;
+}
- {
- 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 (bool yn, void *src)
+{
+ if (_solo_safe) {
+ return;
}
- /* ----------------------------------------------------------------------------------------------------
- INPUT METERING & MONITORING
- -------------------------------------------------------------------------------------------------- */
-
- if (meter && (_meter_point == MeterInput)) {
- _meter->run_in_place(bufs, start_frame, end_frame, nframes, offset);
+ if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
+ _route_group->apply (&Route::set_solo, 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 (self_soloed() != yn) {
+ set_self_solo (yn);
+ set_mute_master_solo ();
+ solo_changed (true, src); /* EMIT SIGNAL */
+ _solo_control->Changed (); /* EMIT SIGNAL */
}
+}
- /* ----------------------------------------------------------------------------------------------------
- PRE-FADER REDIRECTS
- -------------------------------------------------------------------------------------------------- */
+void
+Route::set_self_solo (bool yn)
+{
+ _self_solo = yn;
+}
- // This really should already be true...
- bufs.set_count(pre_fader_streams());
-
+void
+Route::mod_solo_by_others_upstream (int32_t delta)
+{
+ if (_solo_safe) {
+ return;
+ }
- 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()))
+ uint32_t old_sbu = _soloed_by_others_upstream;
- ) {
-
- co->silence (nframes, offset);
-
+ if (delta < 0) {
+ if (_soloed_by_others_upstream >= (uint32_t) abs (delta)) {
+ _soloed_by_others_upstream += delta;
} else {
+ _soloed_by_others_upstream = 0;
+ }
+ } else {
+ _soloed_by_others_upstream += delta;
+ }
+
+ DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 SbU delta %2 = %3 old = %4 sbd %5 ss %6 exclusive %7\n",
+ name(), delta, _soloed_by_others_upstream, old_sbu,
+ _soloed_by_others_downstream, _self_solo, Config->get_exclusive_solo()));
+
+ /* push the inverse solo change to everything that feeds us.
+
+ This is important for solo-within-group. When we solo 1 track out of N that
+ feed a bus, that track will cause mod_solo_by_upstream (+1) to be called
+ on the bus. The bus then needs to call mod_solo_by_downstream (-1) on all
+ tracks that feed it. This will silence them if they were audible because
+ of a bus solo, but the newly soloed track will still be audible (because
+ it is self-soloed).
+
+ but .. do this only when we are being told to solo-by-upstream (i.e delta = +1),
+ not in reverse.
+ */
+
+ if ((_self_solo || _soloed_by_others_downstream) &&
+ ((old_sbu == 0 && _soloed_by_others_upstream > 0) ||
+ (old_sbu > 0 && _soloed_by_others_upstream == 0))) {
+
+ if (delta > 0 || !Config->get_exclusive_solo()) {
+ DEBUG_TRACE (DEBUG::Solo, "\t ... INVERT push\n");
+ for (FedBy::iterator i = _fed_by.begin(); i != _fed_by.end(); ++i) {
+ boost::shared_ptr<Route> sr = i->r.lock();
+ if (sr) {
+ sr->mod_solo_by_others_downstream (-delta);
+ }
+ }
+ }
+ }
+
+ set_mute_master_solo ();
+ solo_changed (false, this);
+}
- co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
- }
- }
-
- /* ----------------------------------------------------------------------------------------------------
- GAIN STAGE
- -------------------------------------------------------------------------------------------------- */
-
- /* if not recording or recording and requiring any monitor signal, then apply gain */
-
- if ( // not recording
-
- !(record_enabled() && _session.actively_recording()) ||
-
- // OR recording
-
- // AND software monitoring required
+void
+Route::mod_solo_by_others_downstream (int32_t delta)
+{
+ if (_solo_safe) {
+ return;
+ }
- 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];
- }
-
+ if (delta < 0) {
+ if (_soloed_by_others_downstream >= (uint32_t) abs (delta)) {
+ _soloed_by_others_downstream += delta;
} else {
-
- /* manual (scalar) gain */
-
- if (_gain != dg) {
-
- Amp::run_in_place (bufs, nframes, _gain, dg, _phase_invert);
- _gain = dg;
-
- } else if (_gain != 0 && (_phase_invert || _gain != 1.0)) {
-
- /* no need to interpolate current gain value,
- but its non-unity, so apply it. if the gain
- is zero, do nothing because we'll ship silence
- below.
- */
-
- gain_t this_gain;
-
- if (_phase_invert) {
- this_gain = -_gain;
- } else {
- this_gain = _gain;
- }
-
- for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
- Sample* const sp = i->data();
- apply_gain_to_buffer(sp,nframes,this_gain);
- }
-
- } else if (_gain == 0) {
- for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
- i->clear();
- }
- }
+ _soloed_by_others_downstream = 0;
}
-
} else {
-
- /* actively recording, no monitoring required; leave buffers as-is to save CPU cycles */
-
+ _soloed_by_others_downstream += delta;
}
+ DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 SbD delta %2 = %3\n", name(), delta, _soloed_by_others_downstream));
- /* ----------------------------------------------------------------------------------------------------
- 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 {
+ set_mute_master_solo ();
+ solo_changed (false, this);
+}
- co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
- }
- }
+void
+Route::set_mute_master_solo ()
+{
+ _mute_master->set_soloed (self_soloed() || soloed_by_others_downstream() || soloed_by_others_upstream());
+}
- /* ----------------------------------------------------------------------------------------------------
- MAIN OUTPUT STAGE
- -------------------------------------------------------------------------------------------------- */
+void
+Route::set_solo_isolated (bool yn, void *src)
+{
+ if (is_master() || is_monitor() || is_hidden()) {
+ return;
+ }
- solo_audible = dsg > 0;
- mute_audible = dmg > 0 || !_mute_affects_main_outs;
+ if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
+ _route_group->apply (&Route::set_solo_isolated, yn, _route_group);
+ return;
+ }
- 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 {
+ /* forward propagate solo-isolate status to everything fed by this route, but not those via sends only */
- if ( // silent anyway
+ boost::shared_ptr<RouteList> routes = _session.get_routes ();
+ for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
- (_gain == 0 && !apply_gain_automation) ||
-
- // muted by solo of another track, but not using control outs for solo
+ if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) {
+ continue;
+ }
- (!solo_audible && (Config->get_solo_model() != SoloBus)) ||
-
- // muted by mute of this track
-
- !mute_audible
-
- ) {
+ bool sends_only;
+ bool does_feed = direct_feeds (*i, &sends_only); // we will recurse anyway, so don't use ::feeds()
+
+ if (does_feed && !sends_only) {
+ (*i)->set_solo_isolated (yn, (*i)->route_group());
+ }
+ }
- /* 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();
- }
+ /* XXX should we back-propagate as well? (April 2010: myself and chris goddard think not) */
- IO::silence (nframes, offset);
-
- } else {
-
- deliver_output(bufs, start_frame, end_frame, nframes, offset);
+ bool changed = false;
+ if (yn) {
+ if (_solo_isolated == 0) {
+ _mute_master->set_solo_ignore (true);
+ changed = true;
+ }
+ _solo_isolated++;
+ } else {
+ if (_solo_isolated > 0) {
+ _solo_isolated--;
+ if (_solo_isolated == 0) {
+ _mute_master->set_solo_ignore (false);
+ changed = true;
+ }
}
-
}
-}
-#endif /* NEW_POB */
-
-ChanCount
-Route::n_process_buffers ()
-{
- return max (n_inputs(), processor_max_outs);
+ if (changed) {
+ solo_isolated_changed (src);
+ }
}
-void
-Route::passthru (nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset, int declick, bool meter_first)
+bool
+Route::solo_isolated () const
{
- 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);
+ return _solo_isolated > 0;
}
void
-Route::passthru_silence (nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset, int declick, bool meter)
+Route::set_mute_points (MuteMaster::MutePoint mp)
{
- process_output_buffers (_session.get_silent_buffers (n_process_buffers()), start_frame, end_frame, nframes, offset, true, declick, meter);
+ _mute_master->set_mute_points (mp);
+ mute_points_changed (); /* EMIT SIGNAL */
+
+ if (_mute_master->muted_by_self()) {
+ mute_changed (this); /* EMIT SIGNAL */
+ _mute_control->Changed (); /* EMIT SIGNAL */
+ }
}
void
-Route::set_solo (bool yn, void *src)
+Route::set_mute (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);
+ if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_mute()) {
+ _route_group->apply (&Route::set_mute, yn, _route_group);
return;
}
- if (_soloed != yn) {
- _soloed = yn;
- solo_changed (src); /* EMIT SIGNAL */
- _solo_control->Changed (); /* EMIT SIGNAL */
+ if (muted() != yn) {
+ _mute_master->set_muted_by_self (yn);
+ mute_changed (src); /* EMIT SIGNAL */
+ _mute_control->Changed (); /* EMIT SIGNAL */
}
}
-void
-Route::set_solo_mute (bool yn)
+bool
+Route::muted () const
{
- Glib::Mutex::Lock lm (declick_lock);
-
- /* Called by Session in response to another Route being soloed.
- */
-
- desired_solo_gain = (yn?0.0:1.0);
+ return _mute_master->muted_by_self();
}
-void
-Route::set_solo_safe (bool yn, void *src)
+#if 0
+static void
+dump_processors(const string& name, const list<boost::shared_ptr<Processor> >& procs)
{
- if (_solo_safe != yn) {
- _solo_safe = yn;
- solo_safe_changed (src); /* EMIT SIGNAL */
+ 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
-void
-Route::set_mute (bool yn, void *src)
-
+int
+Route::add_processor (boost::shared_ptr<Processor> processor, Placement placement, ProcessorStreams* err)
{
- if (_mix_group && src != _mix_group && _mix_group->is_active()) {
- _mix_group->apply (&Route::set_mute, yn, _mix_group);
- return;
- }
+ ProcessorList::iterator loc;
- if (_muted != yn) {
- _muted = yn;
- mute_changed (src); /* EMIT SIGNAL */
-
- _mute_control->Changed (); /* EMIT SIGNAL */
-
- Glib::Mutex::Lock lm (declick_lock);
- desired_mute_gain = (yn?0.0f:1.0f);
+ /* 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.
+ */
+
+ 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);
}
+
+ return add_processor (processor, loc, err);
}
+
+/** Add a processor to the route.
+ * @a iter must point to an iterator in _processors and the new
+ * processor will be inserted immediately before this location. Otherwise,
+ * @a position is used.
+ */
int
-Route::add_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err)
+Route::add_processor (boost::shared_ptr<Processor> processor, ProcessorList::iterator iter, ProcessorStreams* err, bool activation_allowed)
{
- ChanCount old_pmo = processor_max_outs;
+ ChanCount old_pms = processor_max_streams;
- if (!_session.engine().connected()) {
+ if (!_session.engine().connected() || !processor) {
return 1;
}
boost::shared_ptr<PluginInsert> pi;
boost::shared_ptr<PortInsert> porti;
- //processor->set_default_type(_default_type);
+ ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), processor);
+
+ if (processor == _amp || processor == _meter || processor == _main_outs) {
+ // Ensure only one of these are in the list at any time
+ if (loc != _processors.end()) {
+ if (iter == loc) { // Already in place, do nothing
+ return 0;
+ } else { // New position given, relocate
+ _processors.erase (loc);
+ }
+ }
+
+ } else {
+ if (loc != _processors.end()) {
+ cerr << "ERROR: Processor added to route twice!" << endl;
+ return 1;
+ }
+
+ loc = iter;
+ }
- _processors.push_back (processor);
+ _processors.insert (loc, 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;
+
+ {
+ Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+
+ 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;
+ }
}
if ((pi = boost::dynamic_pointer_cast<PluginInsert>(processor)) != 0) {
-
+
if (pi->natural_input_streams() == ChanCount::ZERO) {
/* generator plugin */
_have_internal_generator = true;
}
-
+
}
-
- // Ensure peak vector sizes before the plugin is activated
- ChanCount potential_max_streams;
+ /* is this the monitor send ? if so, make sure we keep track of it */
- 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()));
+ boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
- _meter->configure_io (potential_max_streams, potential_max_streams);
+ if (isend && _session.monitor_out() && (isend->target_id() == _session.monitor_out()->id())) {
+ _monitor_send = isend;
+ }
- // 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));
+ if (activation_allowed && (processor != _monitor_send)) {
+ processor->activate ();
+ }
- _user_latency = 0;
- }
-
- if (processor_max_outs != old_pmo || old_pmo == ChanCount::ZERO) {
- reset_panner ();
+ processor->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false, false));
+
+ _output->set_user_latency (0);
}
- processors_changed (); /* EMIT SIGNAL */
-
+ processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
+ set_processor_positions ();
+
return 0;
}
-int
-Route::add_processors (const ProcessorList& others, ProcessorStreams* err)
+bool
+Route::add_processor_from_xml_2X (const XMLNode& node, int version)
{
- ChanCount old_pmo = processor_max_outs;
+ const XMLProperty *prop;
- if (!_session.engine().connected()) {
- return 1;
- }
+ try {
+ boost::shared_ptr<Processor> processor;
- {
- Glib::RWLock::WriterLock lm (_processor_lock);
+ /* bit of a hack: get the `placement' property from the <Redirect> tag here
+ so that we can add the processor in the right place (pre/post-fader)
+ */
- ProcessorList::iterator existing_end = _processors.end();
- --existing_end;
+ XMLNodeList const & children = node.children ();
+ XMLNodeList::const_iterator i = children.begin ();
+
+ while (i != children.end() && (*i)->name() != X_("Redirect")) {
+ ++i;
+ }
- ChanCount potential_max_streams;
+ Placement placement = PreFader;
- 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;
+ if (i != children.end()) {
+ if ((prop = (*i)->property (X_("placement"))) != 0) {
+ placement = Placement (string_2_enum (prop->value(), placement));
}
+ }
- // Ensure peak vector sizes before the plugin is activated
- _meter->configure_io (potential_max_streams, potential_max_streams);
+ if (node.name() == "Insert") {
- _processors.push_back (*i);
-
- if (_reset_processor_counts (err)) {
- ++existing_end;
- _processors.erase (existing_end, _processors.end());
- _reset_processor_counts (0); // it worked before we tried to add it ...
- return -1;
- }
-
- (*i)->activate ();
- (*i)->ActiveChanged.connect (bind (mem_fun (_session, &Session::update_latency_compensation), false, false));
- }
+ if ((prop = node.property ("type")) != 0) {
- _user_latency = 0;
- }
-
- if (processor_max_outs != old_pmo || old_pmo == ChanCount::ZERO) {
- reset_panner ();
+ if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
+ prop->value() == "lv2" ||
+ prop->value() == "vst" ||
+ prop->value() == "audiounit") {
+
+ processor.reset (new PluginInsert (_session));
+
+ } else {
+
+ processor.reset (new PortInsert (_session, _mute_master));
+ }
+
+ }
+
+ } else if (node.name() == "Send") {
+
+ processor.reset (new Send (_session, _mute_master));
+
+ } else {
+
+ error << string_compose(_("unknown Processor type \"%1\"; ignored"), node.name()) << endmsg;
+ return false;
+ }
+
+ if (processor->set_state (node, version)) {
+ return false;
+ }
+
+ return (add_processor (processor, placement) == 0);
+ }
+
+ catch (failed_constructor &err) {
+ warning << _("processor could not be created. Ignored.") << endmsg;
+ return false;
+ }
+}
+
+int
+Route::add_processors (const ProcessorList& others, boost::shared_ptr<Processor> before, ProcessorStreams* err)
+{
+ ProcessorList::iterator loc;
+
+ 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);
+ }
+
+ return add_processors (others, loc, err);
+}
+
+int
+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_pms = processor_max_streams;
+
+ if (!_session.engine().connected()) {
+ return 1;
+ }
+
+ if (others.empty()) {
+ return 0;
+ }
+
+ {
+ Glib::RWLock::WriterLock lm (_processor_lock);
+
+ 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) {
+ potential_max_streams = m;
+ }
+ }
+
+ ProcessorList::iterator inserted = _processors.insert (iter, *i);
+
+ if ((*i)->active()) {
+ (*i)->activate ();
+ }
+
+ {
+ Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+ if (configure_processors_unlocked (err)) {
+ _processors.erase (inserted);
+ configure_processors_unlocked (0); // it worked before we tried to add it ...
+ return -1;
+ }
+ }
+
+ (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false, false));
+ }
+
+ _output->set_user_latency (0);
}
- processors_changed (); /* EMIT SIGNAL */
+ processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
+ set_processor_positions ();
+
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
*/
-
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)->set_active (false);
- }
+
+ 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)->set_active (false);
+ (*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)->set_active (false);
+
+ 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 ();
}
/** 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)->set_active (false);
+ (*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
}
if ((*i)->active()) {
- (*i)->set_active (false);
+ (*i)->deactivate ();
(*i)->set_next_ab_is_active (true);
} else {
(*i)->set_next_ab_is_active (false);
}
if ((*i)->get_next_ab_is_active()) {
- (*i)->set_active (true);
+ (*i)->activate ();
} else {
- (*i)->set_active (false);
+ (*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
- for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
- if ((*i)->placement() == PreFader) {
- 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;
- }
- /* FIXME: can't see how this test can ever fire */
- if (processor_max_outs != old_pmo) {
- reset_panner ();
+ {
+ Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+ configure_processors_unlocked (&err); // this can't fail
+ }
}
-
- processor_max_outs.reset();
+
+ processor_max_streams.reset();
_have_internal_generator = false;
- processors_changed (); /* EMIT SIGNAL */
+ processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
+ set_processor_positions ();
+
+ 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)) {
- /* get back to where we where */
- _processors.insert (i, processor);
- /* we know this will work, because it worked before :) */
- _reset_processor_counts (0);
- return -1;
+ {
+ Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+
+ if (configure_processors_unlocked (err)) {
+ /* get back to where we where */
+ _processors.insert (i, processor);
+ /* we know this will work, because it worked before :) */
+ configure_processors_unlocked (0);
+ return -1;
+ }
}
_have_internal_generator = false;
for (i = _processors.begin(); i != _processors.end(); ++i) {
boost::shared_ptr<PluginInsert> pi;
-
+
if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
if (pi->is_generator()) {
_have_internal_generator = true;
}
}
- if (old_pmo != processor_max_outs) {
- reset_panner ();
- }
-
processor->drop_references ();
+ processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
+ set_processor_positions ();
- 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);
-}
+ ProcessorList deleted;
+ if (!_session.engine().connected()) {
+ return 1;
+ }
-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.
- */
+ processor_max_streams.reset();
- /* ... but it should/will be... */
-
- for (r = _processors.begin(); r != _processors.end(); ++r) {
+ {
+ Glib::RWLock::WriterLock lm (_processor_lock);
+ ProcessorList::iterator i;
+ boost::shared_ptr<Processor> processor;
- boost::shared_ptr<PluginInsert> plugin_insert;
- boost::shared_ptr<PortInsert> port_insert;
+ ProcessorList as_we_were = _processors;
- if ((plugin_insert = boost::dynamic_pointer_cast<PluginInsert>(*r)) != 0) {
+ for (i = _processors.begin(); i != _processors.end(); ) {
- ++insert_cnt;
- proc_map[(*r)->placement()].push_back (ProcessorCount (*r));
+ processor = *i;
- /* reset plugin counts back to one for now so
- that we have a predictable, controlled
- state to try to configure.
- */
+ /* these can never be removed */
- plugin_insert->set_count (1);
+ if (processor == _amp || processor == _meter || processor == _main_outs) {
+ ++i;
+ continue;
+ }
- } else if ((port_insert = boost::dynamic_pointer_cast<PortInsert>(*r)) != 0) {
-
- ++insert_cnt;
- proc_map[(*r)->placement()].push_back (ProcessorCount (*r));
+ /* see if its in the list of processors to delete */
- } else if (boost::dynamic_pointer_cast<Send> (*r) != 0) {
- ++send_cnt;
- }
- }
-
- if (insert_cnt == 0) {
- if (send_cnt) {
- goto recompute;
- } else {
- ret = 0;
- goto streamcount;
- }
- }
+ if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
+ ++i;
+ continue;
+ }
- /* Now process each placement in order, checking to see if we
- can really do what has been requested.
- */
+ /* stop IOProcessors that send to JACK ports
+ from causing noise as a result of no longer being
+ run.
+ */
- /* A: PreFader */
-
- if (check_some_processor_counts (proc_map[PreFader], n_inputs (), err)) {
- goto streamcount;
- }
+ boost::shared_ptr<IOProcessor> iop;
- if (!proc_map[PreFader].empty()) {
- previous_initial_streams = n_inputs ();
- for (list<ProcessorCount>::iterator i = proc_map[PreFader].begin(); i != proc_map[PreFader].end(); i++) {
- if (i->processor->can_support_io_configuration (previous_initial_streams, initial_streams) < 0) {
- goto streamcount;
+ if ((iop = boost::dynamic_pointer_cast<IOProcessor> (processor)) != 0) {
+ iop->disconnect ();
}
- previous_initial_streams = initial_streams;
+
+ deleted.push_back (processor);
+ i = _processors.erase (i);
}
- }
- /* B: PostFader */
+ if (deleted.empty()) {
+ /* none of those in the requested list were found */
+ return 0;
+ }
- if (check_some_processor_counts (proc_map[PostFader], initial_streams, err)) {
- goto streamcount;
- }
+ _output->set_user_latency (0);
- if (!proc_map[PostFader].empty()) {
- for (list<ProcessorCount>::iterator i = proc_map[PostFader].begin(); i != proc_map[PostFader].end(); i++) {
- if (i->processor->can_support_io_configuration (previous_initial_streams, initial_streams) < 0) {
- goto streamcount;
+ {
+ Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+
+ 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;
}
- previous_initial_streams = initial_streams;
}
- }
-
- /* OK, everything can be set up correctly, so lets do it */
-
- apply_some_processor_counts (proc_map[PreFader]);
- apply_some_processor_counts (proc_map[PostFader]);
-
- /* recompute max outs of any processor */
- ret = 0;
-
- recompute:
-
- processor_max_outs.reset ();
- prev = _processors.end();
+ _have_internal_generator = false;
- for (r = _processors.begin(); r != _processors.end(); prev = r, ++r) {
- boost::shared_ptr<Send> s;
+ for (i = _processors.begin(); i != _processors.end(); ++i) {
+ boost::shared_ptr<PluginInsert> pi;
- if ((s = boost::dynamic_pointer_cast<Send> (*r)) != 0) {
- if (r == _processors.begin()) {
- s->expect_inputs (n_inputs());
- } else {
- s->expect_inputs ((*prev)->output_streams());
+ if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
+ if (pi->is_generator()) {
+ _have_internal_generator = true;
+ break;
+ }
}
-
- } else {
-
- /* don't pay any attention to send output configuration, since it doesn't
- affect the route.
- */
-
- max_audio = max ((*r)->output_streams ().n_audio(), max_audio);
- max_midi = max ((*r)->output_streams ().n_midi(), max_midi);
}
}
- processor_max_outs.set (DataType::AUDIO, max_audio);
- processor_max_outs.set (DataType::MIDI, max_midi);
-
- /* we're done */
- return 0;
+ /* 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);
+ processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
+ set_processor_positions ();
- return ret;
-}
+ return 0;
+}
-int32_t
-Route::apply_some_processor_counts (list<ProcessorCount>& iclist)
+/** Caller must hold process lock */
+int
+Route::configure_processors (ProcessorStreams* err)
{
- list<ProcessorCount>::iterator i;
+ assert (!AudioEngine::instance()->process_lock().trylock());
- for (i = iclist.begin(); i != iclist.end(); ++i) {
+ if (!_in_configure_processors) {
+ Glib::RWLock::WriterLock lm (_processor_lock);
+ return configure_processors_unlocked (err);
+ }
+ return 0;
+}
- ProcessorCount& pc (*i);
+ChanCount
+Route::input_streams () const
+{
+ return _input->n_ports ();
+}
- cerr << "now applying for " << (*i).processor->name() << " in = " << pc.in.n_audio() << " out = " << pc.out.n_audio() << endl;
+list<pair<ChanCount, ChanCount> >
+Route::try_configure_processors (ChanCount in, ProcessorStreams* err)
+{
+ Glib::RWLock::ReaderLock lm (_processor_lock);
- if (pc.processor->configure_io (pc.in, pc.out)) {
- return -1;
- }
+ return try_configure_processors_unlocked (in, err);
+}
- /* make sure that however many we have, they are all active */
+list<pair<ChanCount, ChanCount> >
+Route::try_configure_processors_unlocked (ChanCount in, ProcessorStreams* err)
+{
+ // Check each processor in order to see if we can configure as requested
+ ChanCount out;
+ list<pair<ChanCount, ChanCount> > configuration;
+ uint32_t index = 0;
- pc.processor->activate ();
- }
+ DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
+ DEBUG_TRACE (DEBUG::Processors, "{\n");
- 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.
- */
-bool
-Route::check_some_processor_counts (list<ProcessorCount>& iclist, ChanCount required_inputs, ProcessorStreams* err)
-{
- list<ProcessorCount>::iterator i;
- size_t index = 0;
-
- if (err) {
- err->index = 0;
- err->count = required_inputs;
- }
+ for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
- for (i = iclist.begin(); i != iclist.end(); ++i, ++index) {
-
- cerr << "Checking whether " << (*i).processor->name() << " can support " << required_inputs.n_audio() << " inputs\n";
-
- if (!(*i).processor->can_support_io_configuration (required_inputs, (*i).out)) {
+ if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
+ DEBUG_TRACE (DEBUG::Processors, "--- CONFIGURE ABORTED due to unknown processor.\n");
+ break;
+ }
+
+ if ((*p)->can_support_io_configuration(in, out)) {
+ DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID=%2 in=%3 out=%4\n",(*p)->name(), (*p)->id(), in, out));
+ configuration.push_back(make_pair(in, out));
+ in = out;
+ } else {
if (err) {
err->index = index;
- err->count = required_inputs;
+ err->count = in;
}
- return true;
+ DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
+ DEBUG_TRACE (DEBUG::Processors, string_compose ("---- %1 cannot support in=%2 out=%3\n", (*p)->name(), in, out));
+ DEBUG_TRACE (DEBUG::Processors, "}\n");
+ return list<pair<ChanCount, ChanCount> > ();
}
-
- (*i).in = required_inputs;
- required_inputs = (*i).out;
}
- return false;
+ DEBUG_TRACE (DEBUG::Processors, "}\n");
+
+ return configuration;
}
+/** Set the input/output configuration of each processor in the processors list.
+ * Caller must hold process lock.
+ * Return 0 on success, otherwise configuration is impossible.
+ */
int
-Route::copy_processors (const Route& other, Placement placement, ProcessorStreams* err)
+Route::configure_processors_unlocked (ProcessorStreams* err)
{
- ChanCount old_pmo = processor_max_outs;
-
- ProcessorList to_be_deleted;
-
- {
- Glib::RWLock::WriterLock lm (_processor_lock);
- ProcessorList::iterator tmp;
- ProcessorList the_copy;
-
- the_copy = _processors;
-
- /* remove all relevant processors */
-
- for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ) {
- tmp = i;
- ++tmp;
-
- if ((*i)->placement() == placement) {
- to_be_deleted.push_back (*i);
- _processors.erase (i);
- }
-
- i = tmp;
- }
-
- /* now copy the relevant ones from "other" */
-
- for (ProcessorList::const_iterator i = other._processors.begin(); i != other._processors.end(); ++i) {
- if ((*i)->placement() == placement) {
- _processors.push_back (IOProcessor::clone (*i));
- }
- }
-
- /* reset plugin stream handling */
-
- if (_reset_processor_counts (err)) {
-
- /* FAILED COPY ATTEMPT: we have to restore order */
+ assert (!AudioEngine::instance()->process_lock().trylock());
- /* delete all cloned processors */
-
- for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ) {
-
- tmp = i;
- ++tmp;
+ if (_in_configure_processors) {
+ return 0;
+ }
- if ((*i)->placement() == placement) {
- _processors.erase (i);
- }
-
- i = tmp;
- }
+ _in_configure_processors = true;
- /* restore the natural order */
+ list<pair<ChanCount, ChanCount> > configuration = try_configure_processors_unlocked (input_streams (), err);
- _processors = the_copy;
- processor_max_outs = old_pmo;
+ if (configuration.empty ()) {
+ _in_configure_processors = false;
+ return -1;
+ }
- /* we failed, even though things are OK again */
+ ChanCount out;
- return -1;
+ list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
+ for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
- } else {
-
- /* SUCCESSFUL COPY ATTEMPT: delete the processors we removed pre-copy */
- to_be_deleted.clear ();
- _user_latency = 0;
+ if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
+ break;
}
+
+ (*p)->configure_io(c->first, c->second);
+ processor_max_streams = ChanCount::max(processor_max_streams, c->first);
+ processor_max_streams = ChanCount::max(processor_max_streams, c->second);
+ out = c->second;
}
- if (processor_max_outs != old_pmo || old_pmo == ChanCount::ZERO) {
- reset_panner ();
+ if (_meter) {
+ _meter->reset_max_channels (processor_max_streams);
}
- processors_changed (); /* EMIT SIGNAL */
+ /* make sure we have sufficient scratch buffers to cope with the new processor
+ configuration */
+ _session.ensure_buffers (n_process_buffers ());
+
+ DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
+
+ _in_configure_processors = false;
return 0;
}
}
bool first_is_on = _processors.front()->active();
-
+
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- (*i)->set_active (!first_is_on);
+ if (first_is_on) {
+ (*i)->deactivate ();
+ } else {
+ (*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) {
- (*i)->set_active (state);
+ if ((*i) == _amp) {
+ before_amp = false;
+ continue;
+ }
+ if (p == PreFader && before_amp) {
+ if (state) {
+ (*i)->activate ();
+ } else {
+ (*i)->deactivate ();
+ }
}
}
-
+
_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)) {
- _processors = as_it_was_before;
- processor_max_outs = old_pmo;
- return -1;
- }
- }
+ /* 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());
- reset_panner ();
- processors_changed (); /* EMIT SIGNAL */
+ {
+ Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+
+ if (configure_processors_unlocked (err)) {
+ _processors = as_it_was_before;
+ processor_max_streams = old_pms;
+ return -1;
+ }
+ }
+ }
+
+ if (true) {
+ processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
+ set_processor_positions ();
+ }
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");
+ string p;
+ boost::to_string (_phase_invert, p);
+ node->add_property("phase-invert", p);
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_child_nocopy (IO::state (full_state));
+ node->add_property ("self-solo", (_self_solo ? "yes" : "no"));
+ snprintf (buf, sizeof (buf), "%d", _soloed_by_others_upstream);
+ node->add_property ("soloed-by-upstream", buf);
+ snprintf (buf, sizeof (buf), "%d", _soloed_by_others_downstream);
+ node->add_property ("soloed-by-downstream", buf);
+ node->add_property ("solo-isolated", solo_isolated() ? "yes" : "no");
+ node->add_property ("solo-safe", _solo_safe ? "yes" : "no");
+
+ 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_("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);
- 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);
-
- 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;
-
- }
- }
+ XMLNode *child;
+ const XMLProperty *prop;
+ if (node.name() != "Route"){
+ error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
+ return -1;
}
- return 0;
-}
-
-void
-Route::set_deferred_state ()
-{
- XMLNodeList nlist;
- XMLNodeConstIterator niter;
-
- if (!deferred_state) {
- return;
+ if ((prop = node.property (X_("name"))) != 0) {
+ Route::set_name (prop->value());
}
- nlist = deferred_state->children();
-
- for (niter = nlist.begin(); niter != nlist.end(); ++niter){
- add_processor_from_xml (**niter);
+ if ((prop = node.property ("id")) != 0) {
+ _id = prop->value ();
}
- delete deferred_state;
- deferred_state = 0;
-}
-
-void
-Route::add_processor_from_xml (const XMLNode& node)
-{
- const XMLProperty *prop;
+ if ((prop = node.property (X_("flags"))) != 0) {
+ _flags = Flag (string_2_enum (prop->value(), _flags));
+ } else {
+ _flags = Flag (0);
+ }
- // 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;
- }
-
- // use "Processor" in XML?
- } else if (node.name() == "Processor") {
-
- try {
- if ((prop = node.property ("type")) != 0) {
+ if (is_master() || is_monitor() || is_hidden()) {
+ _mute_master->set_solo_ignore (true);
+ }
- boost::shared_ptr<Processor> processor;
- bool have_insert = false;
+ /* add all processors (except amp, which is always present) */
- 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") {
+ nlist = node.children();
+ XMLNode processor_state (X_("processor_state"));
- processor.reset (new PortInsert (_session, node));
-
- } else if (prop->value() == "send") {
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter){
- processor.reset (new Send (_session, node));
- have_insert = true;
+ child = *niter;
- } else {
+ if (child->name() == IO::state_node_name) {
+ if ((prop = child->property (X_("direction"))) == 0) {
+ continue;
+ }
- 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() == "Input") {
+ _input->set_state (*child, version);
+ } else if (prop->value() == "Output") {
+ _output->set_state (*child, version);
}
}
- catch (failed_constructor &err) {
- warning << _("processor could not be created. Ignored.") << endmsg;
- return;
+ if (child->name() == X_("Processor")) {
+ processor_state.add_child_copy (*child);
}
}
-}
-
-int
-Route::set_state (const XMLNode& node)
-{
- return _set_state (node, true);
-}
-
-int
-Route::_set_state (const XMLNode& node, bool call_base)
-{
- XMLNodeList nlist;
- XMLNodeConstIterator niter;
- XMLNode *child;
- XMLPropertyList plist;
- const XMLProperty *prop;
-
- if (node.name() != "Route"){
- error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
- return -1;
- }
- if ((prop = node.property (X_("flags"))) != 0) {
- _flags = Flag (string_2_enum (prop->value(), _flags));
- } else {
- _flags = Flag (0);
- }
-
- if ((prop = node.property (X_("default-type"))) != 0) {
- _default_type = DataType(prop->value());
- assert(_default_type != DataType::NIL);
- }
+ set_processor_state (processor_state);
- if ((prop = node.property (X_("phase-invert"))) != 0) {
- set_phase_invert (prop->value()=="yes"?true:false, this);
+ if ((prop = node.property ("self-solo")) != 0) {
+ set_self_solo (string_is_affirmative (prop->value()));
}
- 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");
+ if ((prop = node.property ("soloed-by-upstream")) != 0) {
+ _soloed_by_others_upstream = 0; // needed for mod_.... () to work
+ mod_solo_by_others_upstream (atoi (prop->value()));
}
- if ((prop = node.property (X_("muted"))) != 0) {
- bool yn = prop->value()=="yes"?true:false;
-
- /* force reset of mute status */
-
- _muted = !yn;
- set_mute(yn, this);
- mute_gain = desired_mute_gain;
+ if ((prop = node.property ("soloed-by-downstream")) != 0) {
+ _soloed_by_others_downstream = 0; // needed for mod_.... () to work
+ mod_solo_by_others_downstream (atoi (prop->value()));
}
- if ((prop = node.property (X_("soloed"))) != 0) {
- bool yn = prop->value()=="yes"?true:false;
-
- /* force reset of solo status */
-
- _soloed = !yn;
- set_solo (yn, this);
- solo_gain = desired_solo_gain;
+ if ((prop = node.property ("solo-isolated")) != 0) {
+ set_solo_isolated (string_is_affirmative (prop->value()), this);
}
- if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
- _mute_affects_pre_fader = (prop->value()=="yes")?true:false;
+ if ((prop = node.property ("solo-safe")) != 0) {
+ set_solo_safe (string_is_affirmative (prop->value()), this);
}
- 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 (boost::dynamic_bitset<> (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_("active"))) != 0) {
+ bool yn = string_is_affirmative (prop->value());
+ _active = !yn; // force switch
+ set_active (yn);
}
- 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;
- } else {
- set_edit_group(edit_group, this);
+ if ((prop = node.property (X_("meter-point"))) != 0) {
+ MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
+ set_meter_point (mp);
+ if (_meter) {
+ _meter->set_display_to_user (_meter_point == MeterCustom);
}
}
if ((prop = node.property (X_("order-keys"))) != 0) {
- long n;
+ int32_t n;
string::size_type colon, equal;
string remaining = prop->value();
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) {
+ if (sscanf (remaining.substr (equal+1).c_str(), "%d", &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).c_str(), n);
+ set_order_key (remaining.substr (0, equal), n);
}
}
}
}
- nlist = node.children();
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter){
+ child = *niter;
- if (deferred_state) {
- delete deferred_state;
- }
-
- deferred_state = new XMLNode(X_("deferred state"));
-
- /* set parent class properties before anything else */
-
- 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);
- }
-
- }
-
- _set_processor_states(processor_nodes);
-
-
- 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]");
-
- _control_outs = new IO (_session, 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++ */
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() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
if (prop->value() == "solo") {
- _solo_control->set_state (*child);
- _session.add_controllable (_solo_control);
+ _solo_control->set_state (*child, version);
}
- 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);
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);
+ } else if (child->name() == X_("MuteMaster")) {
+ _mute_master->set_state (*child, version);
}
}
return 0;
}
-void
-Route::_set_processor_states(const XMLNodeList &nlist)
+int
+Route::_set_state_2X (const XMLNode& node, int version)
{
+ XMLNodeList nlist;
XMLNodeConstIterator niter;
- char buf[64];
+ XMLNode *child;
+ const XMLProperty *prop;
- ProcessorList::iterator i, o;
+ /* 2X things which still remain to be handled:
+ * default-type
+ * automation
+ * controlouts
+ */
- // 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;
+ if (node.name() != "Route") {
+ error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
+ return -1;
+ }
- bool processorInStateList = false;
+ if ((prop = node.property (X_("flags"))) != 0) {
+ _flags = Flag (string_2_enum (prop->value(), _flags));
+ } else {
+ _flags = Flag (0);
+ }
- (*i)->id().print (buf, sizeof (buf));
-
+ if ((prop = node.property (X_("phase-invert"))) != 0) {
+ boost::dynamic_bitset<> p (_input->n_ports().n_audio ());
+ if (string_is_affirmative (prop->value ())) {
+ p.set ();
+ }
+ set_phase_invert (p);
+ }
- for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
+ if ((prop = node.property (X_("denormal-protection"))) != 0) {
+ set_denormal_protection (string_is_affirmative (prop->value()));
+ }
- // 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);
- }
+ if ((prop = node.property (X_("soloed"))) != 0) {
+ bool yn = string_is_affirmative (prop->value());
+ /* XXX force reset of solo status */
- i = tmp;
+ set_solo (yn, this);
}
+ if ((prop = node.property (X_("muted"))) != 0) {
+
+ bool first = true;
+ bool muted = string_is_affirmative (prop->value());
+
+ if (muted){
+
+ string mute_point;
+
+ if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
+
+ if (string_is_affirmative (prop->value())){
+ mute_point = mute_point + "PreFader";
+ first = false;
+ }
+ }
+
+ if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
+
+ if (string_is_affirmative (prop->value())){
+
+ if (!first) {
+ mute_point = mute_point + ",";
+ }
+
+ mute_point = mute_point + "PostFader";
+ first = false;
+ }
+ }
- // 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;
+ if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
+
+ if (string_is_affirmative (prop->value())){
+
+ if (!first) {
+ mute_point = mute_point + ",";
+ }
+
+ mute_point = mute_point + "Listen";
+ first = false;
+ }
+ }
- 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;
+ if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
+
+ if (string_is_affirmative (prop->value())){
+
+ if (!first) {
+ mute_point = mute_point + ",";
+ }
+
+ mute_point = mute_point + "Main";
+ }
+ }
- ++o;
+ _mute_master->set_mute_points (mute_point);
}
+ }
- 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
+ if ((prop = node.property (X_("meter-point"))) != 0) {
+ _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
+ }
- ProcessorList::iterator prev_last = _processors.end();
- --prev_last; // We need this to check whether adding succeeded
-
- add_processor_from_xml (**niter);
+ /* do not carry over edit/mix groups from 2.X because (a) its hard (b) they
+ don't mean the same thing.
+ */
+
+ if ((prop = node.property (X_("order-keys"))) != 0) {
- ProcessorList::iterator last = _processors.end();
- --last;
+ int32_t n;
- if (prev_last == last) {
- cerr << "Could not fully restore state as some processors were not possible to create" << endl;
- continue;
+ 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(), "%d", &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);
+ }
}
- 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);
+ colon = remaining.find_first_of (':');
- --i; // move pointer to the newly processored processor
- continue;
+ if (colon != string::npos) {
+ remaining = remaining.substr (colon+1);
+ } else {
+ break;
+ }
}
+ }
- // 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);
+ /* IOs */
- --i; // move pointer so it points to the right processor
- }
+ nlist = node.children ();
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
- (*i)->set_state( (**niter) );
- }
-
- processors_changed ();
-}
+ child = *niter;
-void
-Route::curve_reallocate ()
-{
-// _gain_automation_curve.finish_resize ();
-// _pan_automation_curve.finish_resize ();
-}
+ if (child->name() == IO::state_node_name) {
-void
-Route::silence (nframes_t nframes, nframes_t offset)
-{
- if (!_silent) {
+ /* there is a note in IO::set_state_2X() about why we have to call
+ this directly.
+ */
- IO::silence (nframes, offset);
+ _input->set_state_2X (*child, version, true);
+ _output->set_state_2X (*child, version, false);
- if (_control_outs) {
- _control_outs->silence (nframes, offset);
- }
+ if ((prop = child->property (X_("name"))) != 0) {
+ Route::set_name (prop->value ());
+ }
- {
- Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
+ 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 (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;
- }
+ if ((prop = child->property (X_("gain"))) != 0) {
+ gain_t val;
- (*i)->silence (nframes, offset);
+ if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
+ _amp->gain_control()->set_value (val);
}
+ }
+
+ /* Set up Panners in the IO */
+ XMLNodeList io_nlist = child->children ();
+
+ XMLNodeConstIterator io_niter;
+ XMLNode *io_child;
+
+ for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
- if (nframes == _session.get_block_size() && offset == 0) {
- // _silent = true;
+ io_child = *io_niter;
+
+ if (io_child->name() == X_("Panner")) {
+ _main_outs->panner()->set_state(*io_child, version);
+ } else if (io_child->name() == X_("Automation")) {
+ /* IO's automation is for the fader */
+ _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
}
}
}
-
}
-}
-int
-Route::set_control_outs (const vector<string>& ports)
-{
- Glib::Mutex::Lock lm (_control_outs_lock);
- vector<string>::const_iterator i;
- size_t limit;
-
- if (_control_outs) {
- delete _control_outs;
- _control_outs = 0;
- }
+ XMLNodeList redirect_nodes;
- if (is_control() || is_master()) {
- /* no control outs for these two special busses */
- return 0;
- }
-
- 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
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter){
- 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;
+ child = *niter;
+
+ if (child->name() == X_("Send") || child->name() == X_("Insert")) {
+ redirect_nodes.push_back(child);
}
+
}
-
- return 0;
-}
-void
-Route::set_edit_group (RouteGroup *eg, void *src)
+ set_processor_state_2X (redirect_nodes, version);
-{
- if (eg == _edit_group) {
- return;
- }
+ 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();
+
+ } else if (child->name() == X_("extra")) {
+
+ _extra_xml = new XMLNode (*child);
+
+ } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
+ if (prop->value() == X_("solo")) {
+ _solo_control->set_state (*child, version);
+ } else if (prop->value() == X_("mute")) {
+ _mute_control->set_state (*child, version);
+ }
+
+ } else if (child->name() == X_("RemoteControl")) {
+ if ((prop = child->property (X_("id"))) != 0) {
+ int32_t x;
+ sscanf (prop->value().c_str(), "%d", &x);
+ set_remote_control_id (x);
+ }
- if (_edit_group) {
- _edit_group->remove (this);
+ }
}
- if ((_edit_group = eg) != 0) {
- _edit_group->add (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));
}
- _session.set_dirty ();
- edit_group_changed (src); /* EMIT SIGNAL */
+ return *root;
}
void
-Route::drop_edit_group (void *src)
+Route::set_processor_state_2X (XMLNodeList const & nList, int version)
{
- _edit_group = 0;
- _session.set_dirty ();
- edit_group_changed (src); /* EMIT SIGNAL */
+ /* 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);
+ }
}
void
-Route::set_mix_group (RouteGroup *mg, void *src)
-
+Route::set_processor_state (const XMLNode& node)
{
- if (mg == _mix_group) {
- return;
- }
+ const XMLNodeList &nlist = node.children();
+ XMLNodeConstIterator niter;
+ ProcessorList new_order;
+ bool must_configure = false;
+
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
+
+ XMLProperty* prop = (*niter)->property ("type");
+
+ if (prop->value() == "amp") {
+ _amp->set_state (**niter, Stateful::current_state_version);
+ new_order.push_back (_amp);
+ } else if (prop->value() == "meter") {
+ _meter->set_state (**niter, Stateful::current_state_version);
+ new_order.push_back (_meter);
+ } else if (prop->value() == "main-outs") {
+ _main_outs->set_state (**niter, Stateful::current_state_version);
+ new_order.push_back (_main_outs);
+ } else if (prop->value() == "intreturn") {
+ if (!_intreturn) {
+ _intreturn.reset (new InternalReturn (_session));
+ must_configure = true;
+ }
+ _intreturn->set_state (**niter, Stateful::current_state_version);
+ new_order.push_back (_intreturn);
+ } else if (is_monitor() && prop->value() == "monitor") {
+ if (!_monitor_control) {
+ _monitor_control.reset (new MonitorProcessor (_session));
+ must_configure = true;
+ }
+ _monitor_control->set_state (**niter, Stateful::current_state_version);
+ new_order.push_back (_monitor_control);
+ } else {
+ ProcessorList::iterator o;
+
+ for (o = _processors.begin(); o != _processors.end(); ++o) {
+ XMLProperty* id_prop = (*niter)->property(X_("id"));
+ if (id_prop && (*o)->id() == id_prop->value()) {
+ (*o)->set_state (**niter, Stateful::current_state_version);
+ new_order.push_back (*o);
+ break;
+ }
+ }
- if (_mix_group) {
- _mix_group->remove (this);
- }
+ // If the processor (*niter) is not on the route then create it
+
+ if (o == _processors.end()) {
+
+ boost::shared_ptr<Processor> processor;
+
+ if (prop->value() == "intsend") {
+
+ processor.reset (new InternalSend (_session, _mute_master, boost::shared_ptr<Route>(), Delivery::Role (0)));
+
+ } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
+ prop->value() == "lv2" ||
+ prop->value() == "vst" ||
+ prop->value() == "audiounit") {
+
+ processor.reset (new PluginInsert(_session));
+
+ } else if (prop->value() == "port") {
+
+ processor.reset (new PortInsert (_session, _mute_master));
+
+ } else if (prop->value() == "send") {
+
+ processor.reset (new Send (_session, _mute_master));
+
+ } else {
+ error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
+ continue;
+ }
+
+ if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
+ /* This processor could not be configured. Turn it into a UnknownProcessor */
+ processor.reset (new UnknownProcessor (_session, **niter));
+ }
+
+ new_order.push_back (processor);
+ must_configure = true;
+ }
+ }
+ }
- if ((_mix_group = mg) != 0) {
- _mix_group->add (this);
- }
+ {
+ Glib::RWLock::WriterLock lm (_processor_lock);
+ _processors = new_order;
+ if (must_configure) {
+ Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+ configure_processors_unlocked (0);
+ }
+ }
- _session.set_dirty ();
- mix_group_changed (src); /* EMIT SIGNAL */
+ processors_changed (RouteProcessorChange ());
+ set_processor_positions ();
}
void
-Route::drop_mix_group (void *src)
+Route::curve_reallocate ()
{
- _mix_group = 0;
- _session.set_dirty ();
- mix_group_changed (src); /* EMIT SIGNAL */
+// _gain_automation_curve.finish_resize ();
+// _pan_automation_curve.finish_resize ();
}
void
-Route::set_comment (string cmt, void *src)
+Route::silence (framecnt_t nframes)
{
- _comment = cmt;
- comment_changed (src);
- _session.set_dirty ();
+ Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
+ if (!lm.locked()) {
+ return;
+ }
+
+ silence_unlocked (nframes);
}
-bool
-Route::feeds (boost::shared_ptr<Route> other)
+void
+Route::silence_unlocked (framecnt_t nframes)
{
- uint32_t i, j;
+ /* Must be called with the processor lock held */
+
+ if (!_silent) {
- IO& self = *this;
- uint32_t no = self.n_outputs().n_total();
- uint32_t ni = other->n_inputs ().n_total();
+ _output->silence (nframes);
- for (i = 0; i < no; ++i) {
- for (j = 0; j < ni; ++j) {
- if (self.output(i)->connected_to (other->input(j)->name())) {
- return true;
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ boost::shared_ptr<PluginInsert> pi;
+
+ if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
+ // skip plugins, they don't need anything when we're not active
+ continue;
}
+
+ (*i)->silence (nframes);
+ }
+
+ if (nframes == _session.get_block_size()) {
+ // _silent = true;
}
}
+}
- /* 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);
-
- if ( ! redirect)
- continue;
-
- // 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 (redirect->io()->output(i)->connected_to (other->input (j)->name())) {
- return true;
- }
- }
- }
+void
+Route::add_internal_return ()
+{
+ if (!_intreturn) {
+ _intreturn.reset (new InternalReturn (_session));
+ add_processor (_intreturn, PreFader);
}
+}
- /* check for control room outputs which may also interconnect Routes */
+BufferSet*
+Route::get_return_buffer () const
+{
+ Glib::RWLock::ReaderLock rm (_processor_lock);
- if (_control_outs) {
+ for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
+ boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
- 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 (d) {
+ BufferSet* bs = d->get_buffers ();
+ return bs;
}
}
- return false;
+ return 0;
}
void
-Route::set_mute_config (mute_type t, bool onoff, void *src)
+Route::release_return_buffer () const
{
- switch (t) {
- case PRE_FADER:
- _mute_affects_pre_fader = onoff;
- pre_fader_changed(src); /* EMIT SIGNAL */
- break;
+ Glib::RWLock::ReaderLock rm (_processor_lock);
- case POST_FADER:
- _mute_affects_post_fader = onoff;
- post_fader_changed(src); /* EMIT SIGNAL */
- break;
+ for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
+ boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
- case CONTROL_OUTS:
- _mute_affects_control_outs = onoff;
- control_outs_changed(src); /* EMIT SIGNAL */
- break;
+ if (d) {
+ return d->release_buffers ();
+ }
+ }
+}
- case MAIN_OUTS:
- _mute_affects_main_outs = onoff;
- main_outs_changed(src); /* EMIT SIGNAL */
- break;
+int
+Route::listen_via (boost::shared_ptr<Route> route, Placement placement, bool /*active*/, bool aux)
+{
+ vector<string> ports;
+ vector<string>::const_iterator i;
+
+ {
+ Glib::RWLock::ReaderLock rm (_processor_lock);
+
+ for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
+
+ boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
+
+ if (d && d->target_route() == route) {
+
+ /* if the target is the control outs, then make sure
+ we take note of which i-send is doing that.
+ */
+
+ if (route == _session.monitor_out()) {
+ _monitor_send = boost::dynamic_pointer_cast<Delivery>(d);
+ }
+
+ /* already listening via the specified IO: do nothing */
+
+ return 0;
+ }
+ }
}
+
+ boost::shared_ptr<InternalSend> listener;
+
+ try {
+
+ if (is_master()) {
+
+ if (route == _session.monitor_out()) {
+ /* master never sends to control outs */
+ return 0;
+ } else {
+ listener.reset (new InternalSend (_session, _mute_master, route, (aux ? Delivery::Aux : Delivery::Listen)));
+ }
+
+ } else {
+ listener.reset (new InternalSend (_session, _mute_master, route, (aux ? Delivery::Aux : Delivery::Listen)));
+ }
+
+ } catch (failed_constructor& err) {
+ return -1;
+ }
+
+ if (route == _session.monitor_out()) {
+ _monitor_send = listener;
+ }
+
+ if (placement == PostFader) {
+ /* put it *really* at the end, not just after the panner (main outs)
+ */
+ add_processor (listener, _processors.end());
+ } else {
+ add_processor (listener, PreFader);
+ }
+
+ return 0;
+}
+
+void
+Route::drop_listen (boost::shared_ptr<Route> route)
+{
+ ProcessorStreams err;
+ ProcessorList::iterator tmp;
+
+ Glib::RWLock::ReaderLock rl(_processor_lock);
+ rl.acquire ();
+
+ again:
+ for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ) {
+
+ boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
+
+ if (d && d->target_route() == route) {
+ rl.release ();
+ remove_processor (*x, &err);
+ rl.acquire ();
+
+ /* list could have been demolished while we dropped the lock
+ so start over.
+ */
+
+ goto again;
+ }
+ }
+
+ rl.release ();
+
+ if (route == _session.monitor_out()) {
+ _monitor_send.reset ();
+ }
+}
+
+void
+Route::set_comment (string cmt, void *src)
+{
+ _comment = cmt;
+ comment_changed (src);
+ _session.set_dirty ();
}
bool
-Route::get_mute_config (mute_type t)
+Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
{
- bool onoff = false;
+ FeedRecord fr (other, via_sends_only);
+
+ pair<FedBy::iterator,bool> result = _fed_by.insert (fr);
+
+ if (!result.second) {
+
+ /* already a record for "other" - make sure sends-only information is correct */
+ if (!via_sends_only && result.first->sends_only) {
+ FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
+ frp->sends_only = false;
+ }
+ }
+
+ return result.second;
+}
+
+void
+Route::clear_fed_by ()
+{
+ _fed_by.clear ();
+}
+
+bool
+Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
+{
+ const FedBy& fed_by (other->fed_by());
+
+ for (FedBy::iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
+ boost::shared_ptr<Route> sr = f->r.lock();
+
+ if (sr && (sr.get() == this)) {
+
+ if (via_sends_only) {
+ *via_sends_only = f->sends_only;
+ }
+
+ return true;
+ }
+ }
+
+ return false;
+}
+
+bool
+Route::direct_feeds (boost::shared_ptr<Route> other, bool* only_send)
+{
+ DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
+
+ if (_output->connected_to (other->input())) {
+ DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
+ if (only_send) {
+ *only_send = false;
+ }
+
+ return true;
+ }
+
- 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()));
+ }
+
+ }
+
+ DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdoes NOT feed %1\n", other->name()));
+ return false;
+}
+
+/** Called from the (non-realtime) butler thread when the transport is stopped */
+void
+Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool did_locate, bool can_flush_processors)
+{
+ framepos_t now = _session.transport_frame();
+
+ {
+ Glib::RWLock::ReaderLock lm (_processor_lock);
+
+ if (!did_locate) {
+ automation_snapshot (now, true);
+ }
+
+ Automatable::transport_stopped (now);
+
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+
+ if (Config->get_plugins_stop_with_transport() && can_flush_processors) {
+ (*i)->flush ();
+ }
+
+ (*i)->transport_stopped (now);
+ }
+ }
+
+ _roll_delay = _initial_delay;
+}
+
+/** Called with the process lock held if change contains ConfigurationChanged */
+void
+Route::input_change_handler (IOChange change, void * /*src*/)
+{
+ if ((change.type & IOChange::ConfigurationChanged)) {
+ configure_processors (0);
+ _phase_invert.resize (_input->n_ports().n_audio ());
+ io_changed (); /* EMIT SIGNAL */
+ }
+}
+
+/** Called with the process lock held if change contains ConfigurationChanged */
+void
+Route::output_change_handler (IOChange change, void * /*src*/)
+{
+ if ((change.type & IOChange::ConfigurationChanged)) {
+
+ /* XXX resize all listeners to match _main_outs? */
+
+ /* Auto-connect newly-created outputs, unless we're auto-connecting to master
+ and we are master (as an auto-connect in this situation would cause a
+ feedback loop)
+ */
+ AutoConnectOption ac = Config->get_output_auto_connect ();
+ if (ac == AutoConnectPhysical || (ac == AutoConnectMaster && !is_master ())) {
+
+ ChanCount start = change.before;
+
+ for (DataType::iterator i = DataType::begin(); i != DataType::end(); ++i) {
+ if (change.before.get(*i) < change.after.get(*i)) {
+ /* the existing ChanCounts don't matter for this call as they are only
+ to do with matching input and output indices, and we are only changing
+ outputs here.
+ */
+ ChanCount dummy;
+
+ /* only auto-connect the newly-created outputs, not the ones that were
+ already there
+ */
+ start.set (*i, start.get (*i) + 1);
+
+ _session.auto_connect_route (this, dummy, dummy, false, ChanCount(), change.before);
+ }
+ }
+ }
+
+ // configure_processors (0);
+ }
+}
+
+uint32_t
+Route::pans_required () const
+{
+ if (n_outputs().n_audio() < 2) {
+ return 0;
+ }
+
+ return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
+}
+
+int
+Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
+ bool session_state_changing, bool /*can_record*/, bool /*rec_monitors_input*/)
+{
+ Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
+ if (!lm.locked()) {
+ return 0;
+ }
+
+ if (n_outputs().n_total() == 0) {
+ return 0;
+ }
+
+ if (!_active || n_inputs() == ChanCount::ZERO) {
+ silence_unlocked (nframes);
+ return 0;
+ }
+ if (session_state_changing) {
+ if (_session.transport_speed() != 0.0f) {
+ /* we're rolling but some state is changing (e.g. our diskstream contents)
+ so we cannot use them. Be silent till this is over.
+
+ XXX note the absurdity of ::no_roll() being called when we ARE rolling!
+ */
+ silence_unlocked (nframes);
+ return 0;
+ }
+ /* we're really not rolling, so we're either delivery silence or actually
+ monitoring, both of which are safe to do while session_state_changing is true.
+ */
+ }
+
+ _amp->apply_gain_automation (false);
+ passthru (start_frame, end_frame, nframes, 0);
+
+ return 0;
+}
+
+framecnt_t
+Route::check_initial_delay (framecnt_t nframes, framecnt_t& transport_frame)
+{
+ if (_roll_delay > nframes) {
+
+ _roll_delay -= nframes;
+ silence_unlocked (nframes);
+ /* transport frame is not legal for caller to use */
+ return 0;
+
+ } else if (_roll_delay > 0) {
+
+ nframes -= _roll_delay;
+ silence_unlocked (_roll_delay);
+ /* we've written _roll_delay of samples into the
+ output ports, so make a note of that for
+ future reference.
+ */
+ _main_outs->increment_output_offset (_roll_delay);
+ transport_frame += _roll_delay;
+
+ _roll_delay = 0;
+ }
+
+ return nframes;
+}
+
+int
+Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick,
+ bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
+{
+ Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
+ if (!lm.locked()) {
+ return 0;
+ }
+
+ automation_snapshot (_session.transport_frame(), false);
+
+ if (n_outputs().n_total() == 0) {
+ return 0;
+ }
+
+ if (!_active || n_inputs().n_total() == 0) {
+ silence_unlocked (nframes);
+ return 0;
+ }
+
+ framecnt_t unused = 0;
+
+ if ((nframes = check_initial_delay (nframes, unused)) == 0) {
+ return 0;
+ }
+
+ _silent = false;
+
+ passthru (start_frame, end_frame, nframes, declick);
+
+ return 0;
+}
+
+int
+Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/,
+ bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
+{
+ silence (nframes);
+ return 0;
+}
+
+void
+Route::toggle_monitor_input ()
+{
+ for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
+ i->ensure_monitor_input( ! i->monitoring_input());
+ }
+}
+
+bool
+Route::has_external_redirects () const
+{
+ // FIXME: what about sends? - they don't return a signal back to ardour?
+
+ boost::shared_ptr<const PortInsert> pi;
+
+ for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
+
+ if ((pi = boost::dynamic_pointer_cast<const PortInsert>(*i)) != 0) {
+
+ for (PortSet::const_iterator port = pi->output()->ports().begin(); port != pi->output()->ports().end(); ++port) {
+
+ string port_name = port->name();
+ string client_name = port_name.substr (0, port_name.find(':'));
+
+ /* only say "yes" if the redirect is actually in use */
+
+ if (client_name != "ardour" && pi->active()) {
+ return true;
+ }
+ }
+ }
}
+
+ return false;
+}
+
+void
+Route::flush_processors ()
+{
+ /* XXX shouldn't really try to take this lock, since
+ this is called from the RT audio thread.
+ */
+
+ Glib::RWLock::ReaderLock lm (_processor_lock);
+
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ (*i)->flush ();
+ }
+}
+
+void
+Route::set_meter_point (MeterPoint p)
+{
+ /* CAN BE CALLED FROM PROCESS CONTEXT */
+
+ if (_meter_point == p) {
+ return;
+ }
+
+ bool meter_was_visible_to_user = _meter->display_to_user ();
+
+ {
+ Glib::RWLock::WriterLock lm (_processor_lock);
+
+ if (p != MeterCustom) {
+ // Move meter in the processors list to reflect the new position
+ ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
+ _processors.erase(loc);
+ switch (p) {
+ case MeterInput:
+ loc = _processors.begin();
+ break;
+ case MeterPreFader:
+ loc = find (_processors.begin(), _processors.end(), _amp);
+ break;
+ case MeterPostFader:
+ loc = _processors.end();
+ break;
+ default:
+ break;
+ }
+
+ ChanCount m_in;
+
+ if (loc == _processors.begin()) {
+ m_in = _input->n_ports();
+ } else {
+ ProcessorList::iterator before = loc;
+ --before;
+ m_in = (*before)->output_streams ();
+ }
+
+ _meter->reflect_inputs (m_in);
+
+ _processors.insert (loc, _meter);
+
+ /* we do not need to reconfigure the processors, because the meter
+ (a) is always ready to handle processor_max_streams
+ (b) is always an N-in/N-out processor, and thus moving
+ it doesn't require any changes to the other processors.
+ */
+
+ _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 (); /* EMIT SIGNAL */
+
+ bool const meter_visibly_changed = (_meter->display_to_user() != meter_was_visible_to_user);
- return onoff;
+ processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
+}
+
+void
+Route::put_monitor_send_at (Placement p)
+{
+ if (!_monitor_send) {
+ return;
+ }
+
+ {
+ Glib::RWLock::WriterLock lm (_processor_lock);
+ ProcessorList as_it_was (_processors);
+ ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), _monitor_send);
+ _processors.erase(loc);
+
+ switch (p) {
+ case PreFader:
+ loc = find(_processors.begin(), _processors.end(), _amp);
+ if (loc != _processors.begin()) {
+ --loc;
+ }
+ break;
+ case PostFader:
+ loc = _processors.end();
+ break;
+ }
+
+ _processors.insert (loc, _monitor_send);
+
+ {
+ Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+
+ if (configure_processors_unlocked (0)) {
+ _processors = as_it_was;
+ configure_processors_unlocked (0); // it worked before we tried to add it ...
+ return;
+ }
+ }
+ }
+
+ processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
+ _session.set_dirty ();
+}
+
+framecnt_t
+Route::update_total_latency ()
+{
+ framecnt_t old = _output->effective_latency();
+ framecnt_t own_latency = _output->user_latency();
+
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ if ((*i)->active ()) {
+ own_latency += (*i)->signal_latency ();
+ }
+ }
+
+ 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) {
+
+ /* this (virtual) function is used for pure Routes,
+ not derived classes like AudioTrack. this means
+ that the data processed here comes from an input
+ port, not prerecorded material, and therefore we
+ have to take into account any input latency.
+ */
+
+ own_latency += _input->signal_latency ();
+ }
+
+ if (old != own_latency) {
+ _output->set_latency_delay (own_latency);
+ signal_latency_changed (); /* EMIT SIGNAL */
+ }
+
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: input latency = %2 total = %3\n", _name, _input->signal_latency(), own_latency));
+
+ return _output->effective_latency ();
+}
+
+void
+Route::set_user_latency (framecnt_t nframes)
+{
+ _output->set_user_latency (nframes);
+ _session.update_latency_compensation (false, false);
+}
+
+void
+Route::set_latency_delay (framecnt_t longest_session_latency)
+{
+ framecnt_t old = _initial_delay;
+
+ if (_output->effective_latency() < longest_session_latency) {
+ _initial_delay = longest_session_latency - _output->effective_latency();
+ } 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 (framepos_t now, bool force)
+{
+ panner()->automation_snapshot (now, force);
+
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ (*i)->automation_snapshot (now, force);
+ }
+}
+
+Route::SoloControllable::SoloControllable (std::string name, Route& r)
+ : AutomationControl (r.session(), Evoral::Parameter (SoloAutomation),
+ boost::shared_ptr<AutomationList>(), name)
+ , route (r)
+{
+ boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
+ set_list (gl);
+}
+
+void
+Route::SoloControllable::set_value (double val)
+{
+ bool bval = ((val >= 0.5f) ? true: false);
+# if 0
+ this is how it should be done
+
+ boost::shared_ptr<RouteList> rl (new RouteList);
+ rl->push_back (route);
+
+ if (Config->get_solo_control_is_listen_control()) {
+ _session.set_listen (rl, bval);
+ } else {
+ _session.set_solo (rl, bval);
+ }
+#else
+ route.set_solo (bval, this);
+#endif
+}
+
+double
+Route::SoloControllable::get_value (void) const
+{
+ if (Config->get_solo_control_is_listen_control()) {
+ return route.listening() ? 1.0f : 0.0f;
+ } else {
+ return route.self_soloed() ? 1.0f : 0.0f;
+ }
+}
+
+Route::MuteControllable::MuteControllable (std::string name, Route& r)
+ : AutomationControl (r.session(), Evoral::Parameter (MuteAutomation),
+ boost::shared_ptr<AutomationList>(), name)
+ , route (r)
+{
+ boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MuteAutomation)));
+ set_list (gl);
}
void
-Route::handle_transport_stopped (bool abort_ignored, bool did_locate, bool can_flush_processors)
+Route::MuteControllable::set_value (double val)
{
- nframes_t now = _session.transport_frame();
-
- {
- Glib::RWLock::ReaderLock lm (_processor_lock);
+ bool bval = ((val >= 0.5f) ? true: false);
+# if 0
+ this is how it should be done
+
+ boost::shared_ptr<RouteList> rl (new RouteList);
+ rl->push_back (route);
+ _session.set_mute (rl, bval);
+#else
+ route.set_mute (bval, this);
+#endif
+}
- if (!did_locate) {
- automation_snapshot (now, true);
- }
+double
+Route::MuteControllable::get_value (void) const
+{
+ return route.muted() ? 1.0f : 0.0f;
+}
- 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);
- }
+void
+Route::set_block_size (pframes_t nframes)
+{
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ (*i)->set_block_size (nframes);
}
-
- IO::transport_stopped (now);
-
- _roll_delay = _initial_delay;
+
+ _session.ensure_buffers (n_process_buffers ());
}
void
-Route::input_change_handler (IOChange change, void *ignored)
+Route::protect_automation ()
{
- if (change & ConfigurationChanged) {
- reset_processor_counts (0);
- }
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
+ (*i)->protect_automation();
}
void
-Route::output_change_handler (IOChange change, void *ignored)
+Route::set_pending_declick (int declick)
{
- if (change & ConfigurationChanged) {
- if (_control_outs) {
- _control_outs->ensure_io (ChanCount::ZERO, ChanCount(DataType::AUDIO, n_outputs().n_audio()), true, this);
+ if (_declickable) {
+ /* this call is not allowed to turn off a pending declick unless "force" is true */
+ if (declick) {
+ _pending_declick = declick;
}
-
- reset_processor_counts (0);
+ // cerr << _name << ": after setting to " << declick << " pending declick = " << _pending_declick << endl;
+ } else {
+ _pending_declick = 0;
}
+
}
-uint32_t
-Route::pans_required () const
-{
- if (n_outputs().n_audio() < 2) {
- return 0;
+/** 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 (framepos_t pos, framecnt_t frames)
+{
+ /* gain automation */
+ {
+ boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
+
+ XMLNode &before = gc->alist()->get_state ();
+ gc->alist()->shift (pos, frames);
+ XMLNode &after = gc->alist()->get_state ();
+ _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
+ }
+
+ /* pan automation */
+ {
+ boost::shared_ptr<AutomationControl> pc;
+ uint32_t npans = _main_outs->panner()->npanners();
+
+ for (uint32_t p = 0; p < npans; ++p) {
+ pc = _main_outs->panner()->pan_control (0, p);
+ if (pc) {
+ boost::shared_ptr<AutomationList> al = pc->alist();
+ XMLNode& before = al->get_state ();
+ al->shift (pos, frames);
+ XMLNode& after = al->get_state ();
+ _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
+ }
+ }
+ }
+
+ /* redirect automation */
+ {
+ Glib::RWLock::ReaderLock lm (_processor_lock);
+ for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
+
+ set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
+
+ for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
+ boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
+ if (ac) {
+ boost::shared_ptr<AutomationList> al = ac->alist();
+ XMLNode &before = al->get_state ();
+ al->shift (pos, frames);
+ XMLNode &after = al->get_state ();
+ _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
+ }
+ }
+ }
}
-
- 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().n_total() == 0) {
- return 0;
- }
- if (session_state_changing || !_active) {
- silence (nframes, offset);
- return 0;
- }
+int
+Route::save_as_template (const string& path, const string& name)
+{
+ XMLNode& node (state (false));
+ XMLTree tree;
- apply_gain_automation = false;
-
- if (n_inputs().n_total()) {
- passthru (start_frame, end_frame, nframes, offset, 0, false);
- } else {
- silence (nframes, offset);
- }
+ IO::set_name_in_state (*node.children().front(), name);
- return 0;
+ tree.set_root (&node);
+ return tree.write (path.c_str());
}
-nframes_t
-Route::check_initial_delay (nframes_t nframes, nframes_t& offset, nframes_t& transport_frame)
+
+bool
+Route::set_name (const string& str)
{
- if (_roll_delay > nframes) {
+ bool ret;
+ string ioproc_name;
+ string name;
- _roll_delay -= nframes;
- silence (nframes, offset);
- /* transport frame is not legal for caller to use */
- return 0;
+ name = Route::ensure_track_or_route_name (str, _session);
+ SessionObject::set_name (name);
- } else if (_roll_delay > 0) {
+ ret = (_input->set_name(name) && _output->set_name(name));
- nframes -= _roll_delay;
+ if (ret) {
- silence (_roll_delay, offset);
+ Glib::RWLock::ReaderLock lm (_processor_lock);
- offset += _roll_delay;
- transport_frame += _roll_delay;
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- _roll_delay = 0;
- }
+ /* rename all I/O processors that have inputs or outputs */
- return nframes;
-}
+ boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
-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)
-{
- {
- 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 (iop && (iop->output() || iop->input())) {
+ if (!iop->set_name (name)) {
+ ret = false;
+ }
+ }
}
- }
- if ((n_outputs().n_total() == 0 && _processors.empty()) || n_inputs().n_total() == 0 || !_active) {
- silence (nframes, offset);
- return 0;
}
-
- nframes_t unused = 0;
- if ((nframes = check_initial_delay (nframes, offset, unused)) == 0) {
- return 0;
- }
+ return ret;
+}
- _silent = false;
+boost::shared_ptr<Send>
+Route::internal_send_for (boost::shared_ptr<const Route> target) const
+{
+ Glib::RWLock::ReaderLock lm (_processor_lock);
- apply_gain_automation = false;
+ for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ boost::shared_ptr<InternalSend> send;
- {
- 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 ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
+ if (send->target_route() == target) {
+ return send;
}
}
}
- passthru (start_frame, end_frame, nframes, offset, declick, false);
-
- return 0;
+ return boost::shared_ptr<Send>();
}
-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)
+/** @param c Audio channel index.
+ * @param yn true to invert phase, otherwise false.
+ */
+void
+Route::set_phase_invert (uint32_t c, bool yn)
{
- silence (nframes, offset);
- return 0;
+ if (_phase_invert[c] != yn) {
+ _phase_invert[c] = yn;
+ phase_invert_changed (); /* EMIT SIGNAL */
+ _session.set_dirty ();
+ }
}
void
-Route::toggle_monitor_input ()
+Route::set_phase_invert (boost::dynamic_bitset<> p)
{
- for (PortSet::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
- i->ensure_monitor_input( ! i->monitoring_input());
+ if (_phase_invert != p) {
+ _phase_invert = p;
+ phase_invert_changed (); /* EMIT SIGNAL */
+ _session.set_dirty ();
}
}
bool
-Route::has_external_redirects () const
+Route::phase_invert (uint32_t c) const
{
- // FIXME: what about sends?
-
- 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) {
+ return _phase_invert[c];
+}
- for (PortSet::const_iterator port = pi->io()->outputs().begin();
- port != pi->io()->outputs().end(); ++port) {
-
- string port_name = port->name();
- string client_name = port_name.substr (0, port_name.find(':'));
+boost::dynamic_bitset<>
+Route::phase_invert () const
+{
+ return _phase_invert;
+}
- /* only say "yes" if the redirect is actually in use */
-
- if (client_name != "ardour" && pi->active()) {
- return true;
- }
- }
- }
+void
+Route::set_denormal_protection (bool yn)
+{
+ if (_denormal_protection != yn) {
+ _denormal_protection = yn;
+ denormal_protection_changed (); /* EMIT SIGNAL */
}
+}
- return false;
+bool
+Route::denormal_protection () const
+{
+ return _denormal_protection;
}
void
-Route::flush_processors ()
+Route::set_active (bool yn)
{
- /* XXX shouldn't really try to take this lock, since
- this is called from the RT audio thread.
- */
+ if (_active != yn) {
+ _active = yn;
+ _input->set_active (yn);
+ _output->set_active (yn);
+ active_changed (); // EMIT SIGNAL
+ }
+}
- Glib::RWLock::ReaderLock lm (_processor_lock);
+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) {
- (*i)->deactivate ();
- (*i)->activate ();
+
+ 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 ();
+ }
}
}
-void
-Route::set_meter_point (MeterPoint p, void *src)
+boost::shared_ptr<Panner>
+Route::panner() const
{
- if (_meter_point != p) {
- _meter_point = p;
- meter_change (src); /* EMIT SIGNAL */
- _session.set_dirty ();
- }
+ return _main_outs->panner();
}
-nframes_t
-Route::update_total_latency ()
+boost::shared_ptr<AutomationControl>
+Route::gain_control() const
+{
+ return _amp->gain_control();
+}
+
+boost::shared_ptr<AutomationControl>
+Route::get_control (const Evoral::Parameter& param)
{
- nframes_t old = _own_latency;
+ /* either we own the control or .... */
- if (_user_latency) {
- _own_latency = _user_latency;
- } else {
- _own_latency = 0;
+ boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(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 ((*i)->active ()) {
- _own_latency += (*i)->signal_latency ();
+ if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
+ break;
}
}
}
-#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.
- */
-
+ if (!c) {
- _own_latency += input_latency ();
- }
+ /* nobody does so we'll make a new one */
- if (old != _own_latency) {
- signal_latency_changed (); /* EMIT SIGNAL */
+ c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
+ add_control(c);
}
-
-#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);
+ return c;
}
-void
-Route::set_latency_delay (nframes_t longest_session_latency)
+boost::shared_ptr<Processor>
+Route::nth_plugin (uint32_t n)
{
- nframes_t old = _initial_delay;
-
- if (_own_latency < longest_session_latency) {
- _initial_delay = longest_session_latency - _own_latency;
- } else {
- _initial_delay = 0;
- }
+ Glib::RWLock::ReaderLock lm (_processor_lock);
+ ProcessorList::iterator i;
- if (_initial_delay != old) {
- initial_delay_changed (); /* EMIT SIGNAL */
+ for (i = _processors.begin(); i != _processors.end(); ++i) {
+ if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
+ if (n-- == 0) {
+ return *i;
+ }
+ }
}
- if (_session.transport_stopped()) {
- _roll_delay = _initial_delay;
- }
+ return boost::shared_ptr<Processor> ();
}
-void
-Route::automation_snapshot (nframes_t now, bool force)
+boost::shared_ptr<Processor>
+Route::nth_send (uint32_t n)
{
- if (!force && !should_snapshot(now)) {
- return;
- }
-
- IO::automation_snapshot (now, force);
+ Glib::RWLock::ReaderLock lm (_processor_lock);
+ ProcessorList::iterator i;
- for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- (*i)->automation_snapshot (now, force);
+ for (i = _processors.begin(); i != _processors.end(); ++i) {
+ if (boost::dynamic_pointer_cast<Send> (*i)) {
+ if (n-- == 0) {
+ return *i;
+ }
+ }
}
-}
-Route::ToggleControllable::ToggleControllable (std::string name, Route& s, ToggleType tp)
- : Controllable (name), route (s), type(tp)
-{
-
+ return boost::shared_ptr<Processor> ();
}
-void
-Route::ToggleControllable::set_value (float val)
+bool
+Route::has_io_processor_named (const string& name)
{
- 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;
- }
+ Glib::RWLock::ReaderLock lm (_processor_lock);
+ ProcessorList::iterator i;
+
+ for (i = _processors.begin(); i != _processors.end(); ++i) {
+ if (boost::dynamic_pointer_cast<Send> (*i) ||
+ boost::dynamic_pointer_cast<PortInsert> (*i)) {
+ if ((*i)->name() == name) {
+ return true;
+ }
+ }
+ }
+
+ return false;
}
-float
-Route::ToggleControllable::get_value (void) const
+MuteMaster::MutePoint
+Route::mute_points () 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 _mute_master->mute_points ();
}
-void
-Route::set_block_size (nframes_t nframes)
+void
+Route::set_processor_positions ()
{
+ Glib::RWLock::ReaderLock lm (_processor_lock);
+
+ bool had_amp = false;
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- (*i)->set_block_size (nframes);
+ (*i)->set_pre_fader (!had_amp);
+ if (boost::dynamic_pointer_cast<Amp> (*i)) {
+ had_amp = true;
+ }
}
}
-void
-Route::protect_automation ()
+/** Called when there is a proposed change to the input port count */
+bool
+Route::input_port_count_changing (ChanCount to)
{
- Automatable::protect_automation();
-
- for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
- (*i)->protect_automation();
+ list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
+ if (c.empty()) {
+ /* The processors cannot be configured with the new input arrangement, so
+ block the change.
+ */
+ return true;
+ }
+
+ /* The change is ok */
+ return false;
}
-void
-Route::set_pending_declick (int declick)
+list<string>
+Route::unknown_processors () const
{
- if (_declickable) {
- /* this call is not allowed to turn off a pending declick unless "force" is true */
- if (declick) {
- _pending_declick = declick;
+ list<string> p;
+
+ Glib::RWLock::ReaderLock lm (_processor_lock);
+ for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
+ p.push_back ((*i)->name ());
}
- // cerr << _name << ": after setting to " << declick << " pending declick = " << _pending_declick << endl;
- } else {
- _pending_declick = 0;
}
+ return p;
}
-