#include "ardour/session.h"
#include "ardour/timestamps.h"
#include "ardour/utils.h"
+#include "ardour/graph.h"
#include "i18n.h"
Route::Route (Session& sess, string name, Flag flg, DataType default_type)
: SessionObject (sess, name)
- , AutomatableControls (sess)
+ , Automatable (sess)
+ , GraphNode( sess.route_graph )
, _active (true)
, _initial_delay (0)
, _roll_delay (0)
, _flags (flg)
, _pending_declick (true)
, _meter_point (MeterPostFader)
- , _phase_invert (0)
, _self_solo (false)
, _soloed_by_others_upstream (0)
, _soloed_by_others_downstream (0)
, _solo_control (new SoloControllable (X_("solo"), *this))
, _mute_control (new MuteControllable (X_("mute"), *this))
, _mute_master (new MuteMaster (sess, name))
- , _mute_points (MuteMaster::AllPoints)
, _have_internal_generator (false)
- , _physically_connected (false)
- , _graph_level (-1)
, _solo_safe (false)
, _default_type (default_type)
, _remote_control_id (0)
_solo_control->set_flags (Controllable::Flag (_solo_control->flags() | Controllable::Toggle));
_mute_control->set_flags (Controllable::Flag (_solo_control->flags() | Controllable::Toggle));
-
+
add_control (_solo_control);
add_control (_mute_control);
/* add amp processor */
- _amp.reset (new Amp (_session, _mute_master));
+ _amp.reset (new Amp (_session));
add_processor (_amp, PostFader);
/* add standard processors: meter, main outs, monitor out */
return _remote_control_id;
}
-long
+int32_t
Route::order_key (std::string const & name) const
{
OrderKeys::const_iterator i = order_keys.find (name);
}
void
-Route::set_order_key (std::string const & name, long n)
+Route::set_order_key (std::string const & name, int32_t n)
{
- order_keys[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
}
OrderKeys::iterator i;
- uint32_t key;
+ 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();
}
+ bool changed = false;
+
for (; i != order_keys.end(); ++i) {
- i->second = key;
+ if (i->second != key) {
+ i->second = key;
+ changed = true;
+ }
+ }
+
+ if (changed) {
+ order_key_changed (); /* EMIT SIGNAL */
}
}
string newname = name;
while (!session.io_name_is_legal (newname)) {
- newname = bump_name_once (newname);
+ newname = bump_name_once (newname, '.');
}
return newname;
----------------------------------------------------------------------------------------- */
if (declick > 0) {
- Amp::apply_gain (bufs, nframes, 0.0, 1.0);
+ Amp::declick (bufs, nframes, 1);
} else if (declick < 0) {
- Amp::apply_gain (bufs, nframes, 1.0, 0.0);
+ Amp::declick (bufs, nframes, -1);
}
_pending_declick = 0;
DENORMAL CONTROL/PHASE INVERT
----------------------------------------------------------------------------------------- */
- if (_phase_invert) {
+ if (_phase_invert.any ()) {
int chn = 0;
for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
Sample* const sp = i->data();
- if (_phase_invert & chn) {
+ if (_phase_invert[chn]) {
for (nframes_t nx = 0; nx < nframes; ++nx) {
sp[nx] = -sp[nx];
sp[nx] += 1.0e-27f;
for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
Sample* const sp = i->data();
- if (_phase_invert & (1<<chn)) {
+ if (_phase_invert[chn]) {
for (nframes_t nx = 0; nx < nframes; ++nx) {
sp[nx] = -sp[nx];
}
and go ....
----------------------------------------------------------------------------------------- */
- Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
-
- if (rm.locked()) {
- //cerr << name() << " upstream solo " << _soloed_by_others_upstream
- // << " downstream solo " << _soloed_by_others_downstream
- // << " self " << _self_solo
- //<< endl;
- for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
-
- if (bufs.count() != (*i)->input_streams()) {
- cerr << _name << " bufs = " << bufs.count()
- << " input for " << (*i)->name() << " = " << (*i)->input_streams()
- << endl;
- }
- assert (bufs.count() == (*i)->input_streams());
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- (*i)->run (bufs, start_frame, end_frame, nframes, *i != _processors.back());
- bufs.set_count ((*i)->output_streams());
+ if (bufs.count() != (*i)->input_streams()) {
+ cerr << _name << " bufs = " << bufs.count()
+ << " input for " << (*i)->name() << " = " << (*i)->input_streams()
+ << endl;
}
+ assert (bufs.count() == (*i)->input_streams());
+
+ (*i)->run (bufs, start_frame, end_frame, nframes, *i != _processors.back());
+ bufs.set_count ((*i)->output_streams());
}
}
assert (bufs.available() >= input_streams());
if (_input->n_ports() == ChanCount::ZERO) {
- silence (nframes);
+ silence_unlocked (nframes);
}
bufs.set_count (input_streams());
if (yn != _monitor_send->active()) {
if (yn) {
_monitor_send->activate ();
- } else {
+ _mute_master->set_soloed (true);
+ } else {
_monitor_send->deactivate ();
+ _mute_master->set_soloed (false);
}
listen_changed (src); /* EMIT SIGNAL */
_soloed_by_others_upstream += delta;
}
- DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 SbU delta %2 = %3 old = %4 sbd %5 ss %6 latched %7\n",
+ 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_solo_latched()));
+ _soloed_by_others_downstream, _self_solo, Config->get_exclusive_solo()));
/* push the inverse solo change to everything that feeds us.
((old_sbu == 0 && _soloed_by_others_upstream > 0) ||
(old_sbu > 0 && _soloed_by_others_upstream == 0))) {
- if (delta > 0 || Config->get_solo_latched()) {
+ 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();
/* XXX should we back-propagate as well? (April 2010: myself and chris goddard think not) */
+ bool changed = false;
+
if (yn) {
if (_solo_isolated == 0) {
_mute_master->set_solo_ignore (true);
+ changed = true;
}
_solo_isolated++;
- solo_isolated_changed (src);
} else {
if (_solo_isolated > 0) {
_solo_isolated--;
if (_solo_isolated == 0) {
_mute_master->set_solo_ignore (false);
+ changed = true;
}
- solo_isolated_changed (src);
}
}
+ if (changed) {
+ solo_isolated_changed (src);
+ }
}
bool
void
Route::set_mute_points (MuteMaster::MutePoint mp)
{
- _mute_points = mp;
- _mute_master->set_mute_points (MuteMaster::AllPoints);
+ _mute_master->set_mute_points (mp);
mute_points_changed (); /* EMIT SIGNAL */
- if (_mute_master->muted()) {
+ if (_mute_master->muted_by_self()) {
mute_changed (this); /* EMIT SIGNAL */
}
}
}
if (muted() != yn) {
- _mute_master->set_muted (yn);
+ _mute_master->set_muted_by_self (yn);
mute_changed (src); /* EMIT SIGNAL */
}
}
bool
Route::muted () const
{
- return _mute_master->muted();
+ return _mute_master->muted_by_self();
}
#if 0
}
processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
+ set_processor_positions ();
return 0;
}
}
processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
+ set_processor_positions ();
return 0;
}
processor_max_streams.reset();
_have_internal_generator = false;
processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
+ set_processor_positions ();
if (!already_deleting) {
_session.clear_deletion_in_progress();
processor->drop_references ();
processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
+ set_processor_positions ();
return 0;
}
}
processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
+ set_processor_positions ();
return 0;
}
uint32_t index = 0;
DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
-#ifndef NDEBUG
DEBUG_TRACE (DEBUG::Processors, "{\n");
for (list<boost::shared_ptr<Processor> >::const_iterator p = _processors.begin(); p != _processors.end(); ++p) {
DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID = %2\n", (*p)->name(), (*p)->id()));
}
DEBUG_TRACE (DEBUG::Processors, "}\n");
-#endif
for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
if ((*p)->can_support_io_configuration(in, out)) {
- DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1in = %2 out = %3\n",(*p)->name(), in, out));
+ DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 in = %2 out = %3\n",(*p)->name(), in, out));
configuration.push_back(make_pair(in, out));
in = out;
} else {
_session.ensure_buffers (n_process_buffers ());
}
+ DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
+
_in_configure_processors = false;
return 0;
}
if (true) {
processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
+ set_processor_positions ();
}
return 0;
}
node->add_property("active", _active?"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("meter-point", enum_2_string (_meter_point));
}
if ((prop = node.property (X_("phase-invert"))) != 0) {
- set_phase_invert (string_is_affirmative (prop->value()));
+ set_phase_invert (boost::dynamic_bitset<> (prop->value ()));
}
if ((prop = node.property (X_("denormal-protection"))) != 0) {
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 {
}
if ((prop = node.property (X_("phase-invert"))) != 0) {
- set_phase_invert (string_is_affirmative (prop->value()));
+ boost::dynamic_bitset<> p (_input->n_ports().n_audio ());
+ if (string_is_affirmative (prop->value ())) {
+ p.set ();
+ }
+ set_phase_invert (p);
}
if ((prop = node.property (X_("denormal-protection"))) != 0) {
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 {
}
processors_changed (RouteProcessorChange ());
+ set_processor_positions ();
}
void
void
Route::silence (nframes_t nframes)
{
- if (!_silent) {
-
- _output->silence (nframes);
-
- {
- Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
+ Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
+ if (!lm.locked()) {
+ return;
+ }
- if (lm.locked()) {
- for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- boost::shared_ptr<PluginInsert> pi;
+ silence_unlocked (nframes);
+}
- if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
- // skip plugins, they don't need anything when we're not active
- continue;
- }
+void
+Route::silence_unlocked (nframes_t nframes)
+{
+ /* Must be called with the processor lock held */
+
+ if (!_silent) {
- (*i)->silence (nframes);
- }
+ _output->silence (nframes);
- if (nframes == _session.get_block_size()) {
- // _silent = 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;
}
-
}
}
return false;
}
-void
-Route::check_physical_connections ()
-{
- _physically_connected = _output->physically_connected ();
-}
-
void
Route::handle_transport_stopped (bool /*abort_ignored*/, bool did_locate, bool can_flush_processors)
{
- nframes_t now = _session.transport_frame();
+ framepos_t now = _session.transport_frame();
{
Glib::RWLock::ReaderLock lm (_processor_lock);
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)->deactivate ();
(*i)->activate ();
+ (*i)->flush ();
}
(*i)->transport_stopped (now);
{
if ((change & ConfigurationChanged)) {
configure_processors (0);
+ _phase_invert.resize (_input->n_ports().n_audio ());
+ io_changed (); /* EMIT SIGNAL */
}
}
Route::no_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
bool session_state_changing, bool /*can_record*/, bool /*rec_monitors_input*/)
{
+ 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 (nframes);
+ silence_unlocked (nframes);
return 0;
}
if (session_state_changing) {
XXX note the absurdity of ::no_roll() being called when we ARE rolling!
*/
- silence (nframes);
+ silence_unlocked (nframes);
return 0;
}
/* we're really not rolling, so we're either delivery silence or actually
if (_roll_delay > nframes) {
_roll_delay -= nframes;
- silence (nframes);
+ silence_unlocked (nframes);
/* transport frame is not legal for caller to use */
return 0;
} else if (_roll_delay > 0) {
nframes -= _roll_delay;
- silence (_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.
Route::roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame, int declick,
bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
{
- {
- // automation snapshot can also be called from the non-rt context
- // and it uses the processor list, so we try to acquire the lock here
- Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
-
- if (lm.locked()) {
- automation_snapshot (_session.transport_frame(), false);
- }
+ 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 (nframes);
+ silence_unlocked (nframes);
return 0;
}
Glib::RWLock::ReaderLock lm (_processor_lock);
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- (*i)->deactivate ();
- (*i)->activate ();
+ (*i)->flush ();
}
}
}
void
-Route::SoloControllable::set_value (float val)
+Route::SoloControllable::set_value (double val)
{
bool bval = ((val >= 0.5f) ? true: false);
# if 0
#endif
}
-float
+double
Route::SoloControllable::get_value (void) const
{
if (Config->get_solo_control_is_listen_control()) {
}
void
-Route::MuteControllable::set_value (float val)
+Route::MuteControllable::set_value (double val)
{
bool bval = ((val >= 0.5f) ? true: false);
# if 0
#endif
}
-float
+double
Route::MuteControllable::get_value (void) const
{
return route.muted() ? 1.0f : 0.0f;
return boost::shared_ptr<Send>();
}
+/** @param c Audio channel index.
+ * @param yn true to invert phase, otherwise false.
+ */
void
-Route::set_phase_invert (bool yn)
+Route::set_phase_invert (uint32_t c, bool yn)
{
- if (_phase_invert != yn) {
- if (yn) {
- _phase_invert = 0xffff; // XXX all channels
- } else {
- _phase_invert = 0; // XXX no channels
- }
+ if (_phase_invert[c] != yn) {
+ _phase_invert[c] = yn;
+ phase_invert_changed (); /* EMIT SIGNAL */
+ _session.set_dirty ();
+ }
+}
+void
+Route::set_phase_invert (boost::dynamic_bitset<> p)
+{
+ if (_phase_invert != p) {
+ _phase_invert = p;
phase_invert_changed (); /* EMIT SIGNAL */
_session.set_dirty ();
}
}
bool
+Route::phase_invert (uint32_t c) const
+{
+ return _phase_invert[c];
+}
+
+boost::dynamic_bitset<>
Route::phase_invert () const
{
- return _phase_invert != 0;
+ return _phase_invert;
}
void
return false;
}
+MuteMaster::MutePoint
+Route::mute_points () const
+{
+ return _mute_master->mute_points ();
+}
+
void
-Route::set_graph_level (int32_t l)
+Route::set_processor_positions ()
{
- _graph_level = l;
+ Glib::RWLock::ReaderLock lm (_processor_lock);
+
+ bool had_amp = false;
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ (*i)->set_pre_fader (!had_amp);
+ if (boost::dynamic_pointer_cast<Amp> (*i)) {
+ had_amp = true;
+ }
+ }
}
+