/*
- 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 <cassert>
#include <algorithm>
-#include <sigc++/bind.h>
#include "pbd/xml++.h"
#include "pbd/enumwriter.h"
-#include "pbd/stacktrace.h"
#include "pbd/memento_command.h"
+#include "pbd/stacktrace.h"
+#include "pbd/convert.h"
#include "evoral/Curve.hpp"
#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/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"
using namespace PBD;
uint32_t Route::order_key_cnt = 0;
-sigc::signal<void, string const &> Route::SyncOrderKeys;
+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)
, AutomatableControls (sess)
+ , _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 (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))
+ , _mute_points (MuteMaster::AllPoints)
+ , _have_internal_generator (false)
+ , _solo_safe (false)
, _default_type (default_type)
-
-{
- init ();
-
- /* add standard processors other than amp (added by ::init()) */
-
- _meter.reset (new PeakMeter (_session));
- add_processor (_meter, PreFader);
-
- if (_flags & ControlOut) {
- /* where we listen to tracks */
- _intreturn.reset (new InternalReturn (_session));
- add_processor (_intreturn, PreFader);
- }
-
- _main_outs.reset (new Delivery (_session, _output, _mute_master, _name, Delivery::Main));
- add_processor (_main_outs, PostFader);
-
- /* now that we have _meter, its safe to connect to this */
-
- _meter_connection = Metering::connect (mem_fun (*this, &Route::meter));
-}
-
-Route::Route (Session& sess, const XMLNode& node, DataType default_type)
- : SessionObject (sess, "toBeReset")
- , AutomatableControls (sess)
- , _solo_control (new SoloControllable (X_("solo"), *this))
- , _mute_master (new MuteMaster (sess, "toBeReset"))
- , _default_type (default_type)
+ , _remote_control_id (0)
+ , _in_configure_processors (false)
{
- init ();
-
- _set_state (node, false);
-
- /* now that we have _meter, its safe to connect to this */
-
- _meter_connection = Metering::connect (mem_fun (*this, &Route::meter));
+ processor_max_streams.reset();
+ order_keys[N_("signal")] = order_key_cnt++;
}
-void
+int
Route::init ()
{
- _solo_level = 0;
- _solo_isolated = false;
- _active = true;
- processor_max_streams.reset();
- _solo_safe = false;
- _recordable = true;
- order_keys[N_("signal")] = order_key_cnt++;
- _silent = false;
- _meter_point = MeterPostFader;
- _initial_delay = 0;
- _roll_delay = 0;
- _have_internal_generator = false;
- _declickable = false;
- _pending_declick = true;
- _remote_control_id = 0;
- _in_configure_processors = false;
-
- _route_group = 0;
-
- _phase_invert = 0;
- _denormal_protection = false;
-
/* add standard controls */
- add_control (_solo_control);
- add_control (_mute_master);
+ _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);
+
/* input and output objects */
_input.reset (new IO (_session, _name, IO::Input, _default_type));
_output.reset (new IO (_session, _name, IO::Output, _default_type));
- _input->changed.connect (mem_fun (this, &Route::input_change_handler));
- _output->changed.connect (mem_fun (this, &Route::output_change_handler));
+ _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));
/* add amp processor */
_amp.reset (new Amp (_session, _mute_master));
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);
+ }
+
+ /* now that we have _meter, its safe to connect to this */
+
+ Metering::Meter.connect_same_thread (*this, (boost::bind (&Route::meter, this)));
+
+ return 0;
}
Route::~Route ()
{
- Metering::disconnect (_meter_connection);
+ DEBUG_TRACE (DEBUG::Destruction, string_compose ("route %1 destructor\n", _name));
+
+ /* do this early so that we don't get incoming signals as we are going through destruction
+ */
- clear_processors (PreFader);
- clear_processors (PostFader);
+ drop_connections ();
+
+ /* 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 ();
+ }
}
}
for (OrderKeys::iterator x = order_keys.begin(); x != order_keys.end(); ++x) {
x->second = n;
}
- }
+ }
_session.set_dirty ();
}
{
string newname = name;
- while (session.route_by_name (newname) != NULL) {
+ while (!session.io_name_is_legal (newname)) {
newname = bump_name_once (newname);
}
void
Route::set_gain (gain_t val, void *src)
{
- if (src != 0 && _route_group && src != _route_group && _route_group->active_property (RouteGroup::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;
return;
}
}
-
+
_route_group->apply (&Route::inc_gain, factor, _route_group);
} else {
-
+
_route_group->apply (&Route::set_gain, val, _route_group);
}
return;
- }
+ }
if (val == _amp->gain()) {
return;
/** 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)
*
void
Route::process_output_buffers (BufferSet& bufs,
sframes_t start_frame, sframes_t end_frame, nframes_t nframes,
- bool with_processors, int declick)
+ bool /*with_processors*/, int declick)
{
bool monitor;
/* figure out if we're going to use gain automation */
_amp->setup_gain_automation (start_frame, end_frame, nframes);
-
+
/* tell main outs what to do about monitoring */
_main_outs->no_outs_cuz_we_no_monitor (!monitor);
Amp::apply_gain (bufs, nframes, 0.0, 1.0);
} else if (declick < 0) {
Amp::apply_gain (bufs, nframes, 1.0, 0.0);
- }
+ }
_pending_declick = 0;
-
+
/* -------------------------------------------------------------------------------------------
DENORMAL CONTROL/PHASE INVERT
----------------------------------------------------------------------------------------- */
if (_phase_invert) {
-
+
int chn = 0;
if (_denormal_protection || Config->get_denormal_protection()) {
-
+
for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
Sample* const sp = i->data();
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 & (1<<chn)) {
for (nframes_t nx = 0; nx < nframes; ++nx) {
sp[nx] = -sp[nx];
}
- }
+ }
}
}
} else {
if (_denormal_protection || Config->get_denormal_protection()) {
-
+
for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
Sample* const sp = i->data();
for (nframes_t nx = 0; nx < nframes; ++nx) {
}
}
- }
+ }
}
/* -------------------------------------------------------------------------------------------
if (rm.locked()) {
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- bufs.set_count (ChanCount::max(bufs.count(), (*i)->input_streams()));
- (*i)->run (bufs, start_frame, end_frame, nframes);
- bufs.set_count (ChanCount::max(bufs.count(), (*i)->output_streams()));
- }
- if (!_processors.empty()) {
- bufs.set_count (ChanCount::max (bufs.count(), _processors.back()->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());
}
}
}
_silent = false;
- assert (bufs.available() >= _input->n_ports());
-
+ assert (bufs.available() >= input_streams());
+
if (_input->n_ports() == ChanCount::ZERO) {
silence (nframes);
}
-
- bufs.set_count (_input->n_ports());
- if (is_control() && _session.listening()) {
-
+ bufs.set_count (input_streams());
+
+ if (is_monitor() && _session.listening() && !_session.is_auditioning()) {
+
/* 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 {
-
+
for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
-
+
BufferSet::iterator o = bufs.begin(*t);
PortSet& ports (_input->ports());
-
+
for (PortSet::iterator i = ports.begin(*t); i != ports.end(*t); ++i, ++o) {
o->read_from (i->get_buffer(nframes), nframes);
}
}
}
+ write_out_of_band_data (bufs, start_frame, end_frame, nframes);
process_output_buffers (bufs, start_frame, end_frame, nframes, true, declick);
}
void
Route::passthru_silence (sframes_t start_frame, sframes_t end_frame, nframes_t nframes, int declick)
{
- process_output_buffers (_session.get_silent_buffers (n_process_buffers()), start_frame, end_frame, nframes, true, 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);
}
void
Route::set_listen (bool yn, void* src)
{
- if (_control_outs) {
- if (yn != _control_outs->active()) {
+ if (_solo_safe) {
+ return;
+ }
+
+ if (_monitor_send) {
+ if (yn != _monitor_send->active()) {
if (yn) {
- _control_outs->activate ();
+ _monitor_send->activate ();
} else {
- _control_outs->deactivate ();
+ _monitor_send->deactivate ();
}
listen_changed (src); /* EMIT SIGNAL */
bool
Route::listening () const
{
- if (_control_outs) {
- return _control_outs->active ();
+ if (_monitor_send) {
+ return _monitor_send->active ();
} else {
return false;
}
}
+void
+Route::set_solo_safe (bool yn, void *src)
+{
+ if (_solo_safe != yn) {
+ _solo_safe = yn;
+ solo_safe_changed (src);
+ }
+}
+
+bool
+Route::solo_safe() const
+{
+ return _solo_safe;
+}
+
void
Route::set_solo (bool yn, void *src)
{
- if (_solo_safe || _solo_isolated) {
+ if (_solo_safe) {
return;
}
- if (_route_group && src != _route_group && _route_group->active_property (RouteGroup::Solo)) {
+ 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() != yn) {
- mod_solo_level (yn ? 1 : -1);
- solo_changed (src); /* EMIT SIGNAL */
+ if (self_soloed() != yn) {
+ set_self_solo (yn);
+ set_mute_master_solo ();
+ solo_changed (true, src); /* EMIT SIGNAL */
_solo_control->Changed (); /* EMIT SIGNAL */
- }
+ }
+}
+
+void
+Route::set_self_solo (bool yn)
+{
+ _self_solo = yn;
}
void
-Route::mod_solo_level (int32_t delta)
+Route::mod_solo_by_others (int32_t delta)
{
+ if (_solo_safe) {
+ return;
+ }
+
if (delta < 0) {
- if (_solo_level >= (uint32_t) delta) {
- _solo_level += delta;
+ if (_soloed_by_others >= (uint32_t) abs (delta)) {
+ _soloed_by_others += delta;
} else {
- _solo_level = 0;
+ _soloed_by_others = 0;
}
} else {
- _solo_level += delta;
+ _soloed_by_others += delta;
}
- /* tell main outs what the solo situation is
- */
+ set_mute_master_solo ();
+ solo_changed (false, this);
+}
+
+void
+Route::set_mute_master_solo ()
+{
+ int32_t level;
- _main_outs->set_solo_level (_solo_level);
- _main_outs->set_solo_isolated (_solo_isolated);
+ if (self_soloed()) {
+ level = 2;
+ } else if (soloed_by_others()) {
+ level = 1;
+ } else {
+ level = 0;
+ }
+
+ _mute_master->set_solo_level (level);
}
void
Route::set_solo_isolated (bool yn, void *src)
{
- if (_route_group && src != _route_group && _route_group->active_property (RouteGroup::Solo)) {
+ if (is_master() || is_monitor() || is_hidden()) {
+ return;
+ }
+
+ 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;
}
+
+ /* forward propagate solo-isolate status to everything fed by this route, but not those via sends only */
+
+ boost::shared_ptr<RouteList> routes = _session.get_routes ();
+ for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
- if (yn != _solo_isolated) {
- _solo_isolated = yn;
+ if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) {
+ continue;
+ }
- /* tell main outs what the solo situation is
- */
+ bool sends_only;
+ bool does_feed = direct_feeds (*i, &sends_only); // we will recurse anyway, so don't use ::feeds()
- _main_outs->set_solo_level (_solo_level);
- _main_outs->set_solo_isolated (_solo_isolated);
+ if (does_feed && !sends_only) {
+ (*i)->set_solo_isolated (yn, (*i)->route_group());
+ }
+ }
- solo_isolated_changed (src);
+ /* XXX should we back-propagate as well? (April 2010: myself and chris goddard think not) */
+
+ if (yn) {
+ _solo_isolated++;
+ _mute_master->clear_muted_by_others ();
+ } else {
+ if (_solo_isolated > 0) {
+ _solo_isolated--;
+ }
}
+
}
bool
-Route::solo_isolated () const
+Route::solo_isolated () const
{
- return _solo_isolated;
+ return _solo_isolated > 0;
+}
+
+void
+Route::set_mute_points (MuteMaster::MutePoint mp)
+{
+ _mute_points = mp;
+ _mute_master->set_mute_points (MuteMaster::AllPoints);
+ mute_points_changed (); /* EMIT SIGNAL */
+
+ if (_mute_master->muted()) {
+ mute_changed (this); /* EMIT SIGNAL */
+ }
}
void
Route::set_mute (bool yn, void *src)
{
- if (_route_group && src != _route_group && _route_group->active_property (RouteGroup::Mute)) {
+ 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 (muted() != yn) {
- _mute_master->mute (yn);
- mute_changed (src);
+ if (self_muted() != yn) {
+ _mute_master->set_self_muted (yn);
+ mute_changed (src); /* EMIT SIGNAL */
}
-}
+}
+
+bool
+Route::muted () const
+{
+ return self_muted() || muted_by_others();
+}
+
+bool
+Route::self_muted() const
+{
+ return _mute_master->self_muted ();
+}
bool
-Route::muted() const
+Route::muted_by_others() const
+{
+ return _mute_master->muted_by_others ();
+}
+
+void
+Route::mod_muted_by_others (int delta)
{
- return _mute_master->muted ();
+ bool old = muted ();
+
+ if (_solo_isolated) {
+ return;
+ }
+
+ _mute_master->mod_muted_by_others (delta);
+
+ if (old != muted()) {
+ mute_changed (this);
+ }
}
#if 0
/** Add a processor to the route.
- * If @a iter is not NULL, it must point to an iterator in _processors and the new
+ * @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, ProcessorList::iterator iter, ProcessorStreams* err)
+Route::add_processor (boost::shared_ptr<Processor> processor, ProcessorList::iterator iter, ProcessorStreams* err, bool activation_allowed)
{
ChanCount old_pms = processor_max_streams;
// Set up processor list channels. This will set processor->[input|output]_streams(),
// configure redirect ports properly, etc.
-
if (configure_processors_unlocked (err)) {
ProcessorList::iterator ploc = loc;
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;
}
-
+
}
-
- // XXX: do we want to emit the signal here ? change call order.
- if (!boost::dynamic_pointer_cast<InternalSend>(processor)) {
+
+ /* is this the monitor send ? if so, make sure we keep track of it */
+
+ boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
+
+ if (isend && _session.monitor_out() && (isend->target_id() == _session.monitor_out()->id())) {
+ _monitor_send = isend;
+ }
+
+ if (activation_allowed && (processor != _monitor_send)) {
processor->activate ();
}
- processor->ActiveChanged.connect (bind (mem_fun (_session, &Session::update_latency_compensation), false, false));
+
+ 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 */
+
return 0;
}
bool
-Route::add_processor_from_xml (const XMLNode& node, ProcessorList::iterator iter)
+Route::add_processor_from_xml_2X (const XMLNode& node, int version, ProcessorList::iterator iter)
{
const XMLProperty *prop;
- if (node.name() != "Processor") {
- return false;
- }
-
try {
- if ((prop = node.property ("type")) != 0) {
-
- boost::shared_ptr<Processor> processor;
-
- if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
- prop->value() == "lv2" ||
- prop->value() == "vst" ||
- prop->value() == "audiounit") {
-
- processor.reset (new PluginInsert(_session, node));
-
- } else if (prop->value() == "port") {
+ boost::shared_ptr<Processor> processor;
- processor.reset (new PortInsert (_session, _mute_master, node));
-
- } else if (prop->value() == "send") {
-
- processor.reset (new Send (_session, _mute_master, node));
+ if (node.name() == "Insert") {
- } else if (prop->value() == "meter") {
+ if ((prop = node.property ("type")) != 0) {
- if (_meter) {
- if (_meter->set_state (node)) {
- return false;
- } else {
- return true;
- }
- }
+ if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
+ prop->value() == "lv2" ||
+ prop->value() == "vst" ||
+ prop->value() == "audiounit") {
- _meter.reset (new PeakMeter (_session, node));
- processor = _meter;
-
- } else if (prop->value() == "amp") {
+ processor.reset (new PluginInsert (_session));
- /* amp always exists */
-
- processor = _amp;
- if (processor->set_state (node)) {
- return false;
} else {
- /* never any reason to add it */
- return true;
+
+ processor.reset (new PortInsert (_session, _mute_master));
}
-
- } else if (prop->value() == "listen" || prop->value() == "deliver") {
- /* XXX need to generalize */
+ }
- } else if (prop->value() == "intsend") {
+ } else if (node.name() == "Send") {
- processor.reset (new InternalSend (_session, _mute_master, node));
+ processor.reset (new Send (_session, _mute_master));
- } else if (prop->value() == "intreturn") {
-
- if (_intreturn) {
- if (_intreturn->set_state (node)) {
- return false;
- } else {
- return true;
- }
- }
- _intreturn.reset (new InternalReturn (_session, node));
- processor = _intreturn;
+ } else {
- } else if (prop->value() == "main-outs") {
-
- if (_main_outs) {
- if (_main_outs->set_state (node)) {
- return false;
- } else {
- return true;
- }
- }
+ error << string_compose(_("unknown Processor type \"%1\"; ignored"), node.name()) << endmsg;
+ return false;
+ }
- _main_outs.reset (new Delivery (_session, _output, _mute_master, node));
- processor = _main_outs;
+ if (processor->set_state (node, version)) {
+ return false;
+ }
- } else {
- error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
- }
-
- if (iter == _processors.end() && processor->visible() && !_processors.empty()) {
- /* check for invisible processors stacked at the end and leave them there */
- ProcessorList::iterator p;
- p = _processors.end();
+ if (iter == _processors.end() && processor->display_to_user() && !_processors.empty()) {
+ /* check for invisible processors stacked at the end and leave them there */
+ ProcessorList::iterator p;
+ p = _processors.end();
+ --p;
+ while (!(*p)->display_to_user() && p != _processors.begin()) {
--p;
- while (!(*p)->visible() && p != _processors.begin()) {
- --p;
- }
- ++p;
- iter = p;
}
-
- return (add_processor (processor, iter) == 0);
-
- } else {
- error << _("Processor XML node has no type property") << endmsg;
- return false;
+ ++p;
+ iter = p;
}
+
+ return (add_processor (processor, iter) == 0);
}
catch (failed_constructor &err) {
}
int
-Route::add_processors (const ProcessorList& others, Placement placement, ProcessorStreams* err)
+Route::add_processors (const ProcessorList& others, boost::shared_ptr<Processor> before, ProcessorStreams* err)
{
ProcessorList::iterator loc;
- if (placement == PreFader) {
- /* generic pre-fader: insert immediately before the amp */
- loc = find(_processors.begin(), _processors.end(), _amp);
- } else {
- /* generic post-fader: insert at end */
- loc = _processors.end();
- if (!_processors.empty()) {
- /* check for invisible processors stacked at the end and leave them there */
- ProcessorList::iterator p;
- p = _processors.end();
- --p;
- cerr << "Let's check " << (*p)->name() << " vis ? " << (*p)->visible() << endl;
- while (!(*p)->visible() && p != _processors.begin()) {
- --p;
- }
- ++p;
- loc = p;
- }
+ 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);
{
Glib::RWLock::WriterLock lm (_processor_lock);
- ProcessorList::iterator existing_end = _processors.end();
- --existing_end;
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);
_processors.erase(m);
}
}
-
+
boost::shared_ptr<PluginInsert> pi;
-
+
if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
pi->set_count (1);
-
- ChanCount m = max(pi->input_streams(), pi->output_streams());
- if (m > potential_max_streams)
+
+ ChanCount m = max (pi->input_streams(), pi->output_streams());
+
+ if (m > potential_max_streams) {
potential_max_streams = m;
+ }
+ }
+
+ ProcessorList::iterator inserted = _processors.insert (iter, *i);
+
+ if ((*i)->active()) {
+ (*i)->activate ();
}
- _processors.insert (iter, *i);
-
if (configure_processors_unlocked (err)) {
- ++existing_end;
- _processors.erase (existing_end, _processors.end());
+ _processors.erase (inserted);
configure_processors_unlocked (0); // it worked before we tried to add it ...
return -1;
}
-
- (*i)->ActiveChanged.connect (bind (mem_fun (_session, &Session::update_latency_compensation), false, false));
+
+ (*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 */
return 0;
}
Route::disable_processors (Placement p)
{
Glib::RWLock::ReaderLock lm (_processor_lock);
-
+
ProcessorList::iterator start, end;
placement_range(p, start, end);
-
+
for (ProcessorList::iterator i = start; i != end; ++i) {
(*i)->deactivate ();
}
_session.set_dirty ();
}
-/** Turn off all redirects
+/** Turn off all redirects
*/
void
Route::disable_processors ()
{
Glib::RWLock::ReaderLock lm (_processor_lock);
-
+
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
(*i)->deactivate ();
}
-
+
_session.set_dirty ();
}
Route::disable_plugins (Placement p)
{
Glib::RWLock::ReaderLock lm (_processor_lock);
-
+
ProcessorList::iterator start, end;
placement_range(p, start, end);
-
+
for (ProcessorList::iterator i = start; i != end; ++i) {
if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
(*i)->deactivate ();
}
}
-
+
_session.set_dirty ();
}
Route::disable_plugins ()
{
Glib::RWLock::ReaderLock lm (_processor_lock);
-
+
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
(*i)->deactivate ();
}
}
-
+
_session.set_dirty ();
}
Route::ab_plugins (bool forward)
{
Glib::RWLock::ReaderLock lm (_processor_lock);
-
+
if (forward) {
/* forward = turn off all active redirects, and mark them so that the next time
}
}
}
-
+
_session.set_dirty ();
}
-
-
+
+
/** Remove processors with a given placement.
* @param p Placement of processors to remove.
*/
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;
- ProcessorList::iterator amp_loc = find(_processors.begin(), _processors.end(), _amp);
- if (p == PreFader) {
- // Get rid of PreFader processors
- for (ProcessorList::iterator i = _processors.begin(); i != amp_loc; ++i) {
- (*i)->drop_references ();
- }
- // Keep the rest
- for (ProcessorList::iterator i = amp_loc; i != _processors.end(); ++i) {
- new_list.push_back (*i);
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+
+ if (*i == _amp) {
+ seen_amp = true;
}
- } else {
- // Keep PreFader processors
- for (ProcessorList::iterator i = _processors.begin(); i != amp_loc; ++i) {
+
+ if ((*i) == _amp || (*i) == _meter || (*i) == _main_outs) {
+
+ /* you can't remove these */
+
new_list.push_back (*i);
- }
- new_list.push_back (_amp);
- // Get rid of PostFader processors
- for (ProcessorList::iterator i = amp_loc; i != _processors.end(); ++i) {
- (*i)->drop_references ();
+
+ } 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;
+ }
+ }
}
}
processor_max_streams.reset();
_have_internal_generator = false;
- processors_changed (); /* EMIT SIGNAL */
+ processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
if (!already_deleting) {
_session.clear_deletion_in_progress();
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;
}
processor->drop_references ();
- processors_changed (); /* EMIT SIGNAL */
+ processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
return 0;
}
+int
+Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
+{
+ ProcessorList deleted;
+
+ if (!_session.engine().connected()) {
+ return 1;
+ }
+
+ processor_max_streams.reset();
+
+ {
+ Glib::RWLock::WriterLock lm (_processor_lock);
+ ProcessorList::iterator i;
+ boost::shared_ptr<Processor> processor;
+
+ ProcessorList as_we_were = _processors;
+
+ for (i = _processors.begin(); i != _processors.end(); ) {
+
+ processor = *i;
+
+ /* these can never be removed */
+
+ if (processor == _amp || processor == _meter || processor == _main_outs) {
+ ++i;
+ continue;
+ }
+
+ /* see if its in the list of processors to delete */
+
+ if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
+ ++i;
+ continue;
+ }
+
+ /* stop IOProcessors that send to JACK ports
+ from causing noise as a result of no longer being
+ run.
+ */
+
+ boost::shared_ptr<IOProcessor> iop;
+
+ if ((iop = boost::dynamic_pointer_cast<IOProcessor> (processor)) != 0) {
+ iop->disconnect ();
+ }
+
+ deleted.push_back (processor);
+ i = _processors.erase (i);
+ }
+
+ if (deleted.empty()) {
+ /* none of those in the requested list were found */
+ return 0;
+ }
+
+ _output->set_user_latency (0);
+
+ 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;
+ }
+
+ _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;
+ break;
+ }
+ }
+ }
+ }
+
+ /* now try to do what we need to so that those that were removed will be deleted */
+
+ for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
+ (*i)->drop_references ();
+ }
+
+ processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
+
+ return 0;
+}
+
+
int
Route::configure_processors (ProcessorStreams* err)
{
return 0;
}
+ChanCount
+Route::input_streams () const
+{
+ return _input->n_ports ();
+}
+
/** Configure the input/output configuration of each processor in the processors list.
* Return 0 on success, otherwise configuration is impossible.
*/
_in_configure_processors = true;
// Check each processor in order to see if we can configure as requested
- ChanCount in = _input->n_ports ();
+ ChanCount in = input_streams ();
ChanCount out;
list< pair<ChanCount,ChanCount> > configuration;
uint32_t index = 0;
-
+
+ DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
+#ifndef NDEBUG
+ DEBUG_TRACE (DEBUG::Processors, "{\n");
+ for (list<boost::shared_ptr<Processor> >::const_iterator p = _processors.begin(); p != _processors.end(); ++p) {
+ DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID = %2\n", (*p)->name(), (*p)->id()));
+ }
+ DEBUG_TRACE (DEBUG::Processors, "}\n");
+#endif
+
for (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));
configuration.push_back(make_pair(in, out));
in = out;
} else {
return -1;
}
}
-
+
// We can, so configure everything
list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
out = c->second;
}
- // Ensure route outputs match last processor's outputs
- if (out != _output->n_ports ()) {
- _output->ensure_io (out, false, this);
+ if (_meter) {
+ _meter->reset_max_channels (processor_max_streams);
+ }
+
+ /* make sure we have sufficient scratch buffers to cope with the new processor
+ configuration */
+ {
+ Glib::Mutex::Lock em (_session.engine().process_lock ());
+ _session.ensure_buffers (n_process_buffers ());
}
_in_configure_processors = false;
}
bool first_is_on = _processors.front()->active();
-
+
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
if (first_is_on) {
(*i)->deactivate ();
(*i)->activate ();
}
}
-
+
_session.set_dirty ();
}
}
}
}
-
+
_session.set_dirty ();
}
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 visible. There maybe additional
+ 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.
*/
ProcessorList as_it_will_be;
oiter = _processors.begin();
- niter = new_order.begin();
+ niter = new_order.begin();
while (niter != new_order.end()) {
-
+
/* 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.
+ 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
+ /* no more elements in the old list, so just stick the rest of
the new order onto the temp list.
*/
break;
} else {
-
- if (!(*oiter)->visible()) {
+
+ if (!(*oiter)->display_to_user()) {
as_it_will_be.push_back (*oiter);
++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());
_processors = as_it_was_before;
processor_max_streams = old_pms;
return -1;
- }
- }
+ }
+ }
- processors_changed (); /* EMIT SIGNAL */
+ if (true) {
+ processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
+ }
return 0;
}
}
string order_string;
- OrderKeys::iterator x = order_keys.begin();
+ OrderKeys::iterator x = order_keys.begin();
while (x != order_keys.end()) {
order_string += string ((*x).first);
order_string += '=';
snprintf (buf, sizeof(buf), "%ld", (*x).second);
order_string += buf;
-
+
++x;
if (x == order_keys.end()) {
order_string += ':';
}
node->add_property ("order-keys", order_string);
+ node->add_property ("self-solo", (_self_solo ? "yes" : "no"));
+ snprintf (buf, sizeof (buf), "%d", _soloed_by_others);
+ node->add_property ("soloed-by-others", buf);
node->add_child_nocopy (_input->state (full_state));
node->add_child_nocopy (_output->state (full_state));
if (_extra_xml){
node->add_child_copy (*_extra_xml);
}
-
+
return *node;
}
int
-Route::set_state (const XMLNode& node)
+Route::set_state (const XMLNode& node, int version)
{
- return _set_state (node, true);
+ return _set_state (node, version, true);
}
int
-Route::_set_state (const XMLNode& node, bool call_base)
+Route::_set_state (const XMLNode& node, int version, bool /*call_base*/)
{
+ if (version < 3000) {
+ return _set_state_2X (node, version);
+ }
XMLNodeList nlist;
XMLNodeConstIterator niter;
if ((prop = node.property (X_("name"))) != 0) {
Route::set_name (prop->value());
- }
+ }
if ((prop = node.property ("id")) != 0) {
_id = prop->value ();
XMLNode processor_state (X_("processor_state"));
for (niter = nlist.begin(); niter != nlist.end(); ++niter){
-
+
child = *niter;
if (child->name() == IO::state_node_name) {
if ((prop = child->property (X_("direction"))) == 0) {
continue;
}
-
+
if (prop->value() == "Input") {
- _input->set_state (*child);
+ _input->set_state (*child, version);
} else if (prop->value() == "Output") {
- _output->set_state (*child);
+ _output->set_state (*child, version);
}
}
-
+
if (child->name() == X_("Processor")) {
processor_state.add_child_copy (*child);
}
}
set_processor_state (processor_state);
-
- if ((prop = node.property ("solo_level")) != 0) {
- _solo_level = 0; // needed for mod_solo_level() to work
- mod_solo_level (atoi (prop->value()));
+
+ if ((prop = node.property ("self-solo")) != 0) {
+ set_self_solo (string_is_affirmative (prop->value()));
+ }
+
+ if ((prop = node.property ("soloed-by-others")) != 0) {
+ _soloed_by_others = 0; // needed for mod_solo_by_others () to work
+ mod_solo_by_others (atoi (prop->value()));
}
if ((prop = node.property ("solo-isolated")) != 0) {
- set_solo_isolated (prop->value() == "yes", this);
+ set_solo_isolated (string_is_affirmative (prop->value()), this);
}
if ((prop = node.property (X_("phase-invert"))) != 0) {
- set_phase_invert (prop->value()=="yes"?true:false);
+ set_phase_invert (string_is_affirmative (prop->value()));
}
if ((prop = node.property (X_("denormal-protection"))) != 0) {
- set_denormal_protection (prop->value()=="yes"?true:false);
+ set_denormal_protection (string_is_affirmative (prop->value()));
}
-
+
if ((prop = node.property (X_("active"))) != 0) {
- bool yn = (prop->value() == "yes");
+ bool yn = string_is_affirmative (prop->value());
_active = !yn; // force switch
set_active (yn);
}
- if ((prop = node.property (X_("soloed"))) != 0) {
- bool yn = (prop->value()=="yes");
-
- /* XXX force reset of solo status */
-
- set_solo (yn, this);
- }
-
if ((prop = node.property (X_("meter-point"))) != 0) {
- _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
- }
-
- if ((prop = node.property (X_("route-group"))) != 0) {
- RouteGroup* route_group = _session.route_group_by_name(prop->value());
- if (route_group == 0) {
- error << string_compose(_("Route %1: unknown route group \"%2 in saved state (ignored)"), _name, prop->value()) << endmsg;
- } else {
- set_route_group (route_group, this);
+ MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
+ set_meter_point (mp);
+ if (_meter) {
+ _meter->set_display_to_user (_meter_point == MeterCustom);
}
}
_extra_xml = new XMLNode (*child);
} else if (child->name() == X_("Controllable") && (prop = child->property("name")) != 0) {
-
+
if (prop->value() == "solo") {
- _solo_control->set_state (*child);
+ _solo_control->set_state (*child, version);
_session.add_controllable (_solo_control);
- }
+ }
} else if (child->name() == X_("RemoteControl")) {
if ((prop = child->property (X_("id"))) != 0) {
}
} else if (child->name() == X_("MuteMaster")) {
- _mute_master->set_state (*child);
+ _mute_master->set_state (*child, version);
}
}
return 0;
}
-XMLNode&
-Route::get_processor_state ()
+int
+Route::_set_state_2X (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));
+ XMLNodeList nlist;
+ XMLNodeConstIterator niter;
+ XMLNode *child;
+ XMLPropertyList plist;
+ const XMLProperty *prop;
+
+ /* 2X things which still remain to be handled:
+ * default-type
+ * automation
+ * controlouts
+ */
+
+ if (node.name() != "Route") {
+ error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
+ return -1;
}
- return *root;
-}
+ if ((prop = node.property (X_("flags"))) != 0) {
+ _flags = Flag (string_2_enum (prop->value(), _flags));
+ } else {
+ _flags = Flag (0);
+ }
+
+ if ((prop = node.property (X_("phase-invert"))) != 0) {
+ set_phase_invert (string_is_affirmative (prop->value()));
+ }
-void
-Route::set_processor_state (const XMLNode& node)
-{
- const XMLNodeList &nlist = node.children();
- XMLNodeConstIterator niter;
- ProcessorList::iterator i, o;
+ if ((prop = node.property (X_("denormal-protection"))) != 0) {
+ set_denormal_protection (string_is_affirmative (prop->value()));
+ }
- // Iterate through existing processors, remove those which are not in the state list
+ if ((prop = node.property (X_("soloed"))) != 0) {
+ bool yn = string_is_affirmative (prop->value());
- for (i = _processors.begin(); i != _processors.end(); ) {
+ /* XXX force reset of solo status */
- /* leave amp alone, always */
+ set_solo (yn, this);
+ }
- if ((*i) == _amp) {
- ++i;
- continue;
+ 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;
+ }
+ }
+
+ 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;
+ }
+ }
+
+ 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";
+ }
+ }
+
+ _mute_master->set_mute_points (mute_point);
}
+ }
+
+ if ((prop = node.property (X_("meter-point"))) != 0) {
+ _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
+ }
+
+ /* 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) {
+
+ long n;
- ProcessorList::iterator tmp = i;
- ++tmp;
+ string::size_type colon, equal;
+ string remaining = prop->value();
- bool processorInStateList = false;
+ while (remaining.length()) {
- for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
+ if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
+ error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
+ << endmsg;
+ } else {
+ if (sscanf (remaining.substr (equal+1).c_str(), "%ld", &n) != 1) {
+ error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
+ << endmsg;
+ } else {
+ set_order_key (remaining.substr (0, equal), n);
+ }
+ }
- XMLProperty* id_prop = (*niter)->property(X_("id"));
+ colon = remaining.find_first_of (':');
- if (id_prop && (*i)->id() == id_prop->value()) {
- processorInStateList = true;
+ if (colon != string::npos) {
+ remaining = remaining.substr (colon+1);
+ } else {
break;
}
}
-
- if (!processorInStateList) {
- remove_processor (*i);
- }
+ }
+
+ /* add standard processors */
+
+ //_meter.reset (new PeakMeter (_session));
+ //add_processor (_meter, PreFader);
- i = tmp;
+ if (is_monitor()) {
+ /* where we listen to tracks */
+ _intreturn.reset (new InternalReturn (_session));
+ add_processor (_intreturn, PreFader);
+
+ _monitor_control.reset (new MonitorProcessor (_session));
+ add_processor (_monitor_control, PostFader);
}
- // 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
+ _main_outs.reset (new Delivery (_session, _output, _mute_master, _name, Delivery::Main));
+ add_processor (_main_outs, PostFader);
- i = _processors.begin();
+ /* IOs */
- for (niter = nlist.begin(); niter != nlist.end(); ++niter, ++i) {
-
- XMLProperty* prop = (*niter)->property ("type");
+ nlist = node.children ();
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
- o = i;
+ child = *niter;
- // Check whether the next processor in the list is the right one,
- // except for "amp" which is always there and may not have the
- // old ID since it is always created anew in every Route
-
- if (prop->value() != "amp") {
- while (o != _processors.end()) {
- XMLProperty* id_prop = (*niter)->property(X_("id"));
- if (id_prop && (*o)->id() == id_prop->value()) {
- break;
+ if (child->name() == IO::state_node_name) {
+
+ /* there is a note in IO::set_state_2X() about why we have to call
+ this directly.
+ */
+
+ _input->set_state_2X (*child, version, true);
+ _output->set_state_2X (*child, version, false);
+
+ if ((prop = child->property (X_("name"))) != 0) {
+ Route::set_name (prop->value ());
+ }
+
+ if ((prop = child->property (X_("id"))) != 0) {
+ _id = prop->value ();
+ }
+
+ if ((prop = child->property (X_("active"))) != 0) {
+ bool yn = string_is_affirmative (prop->value());
+ _active = !yn; // force switch
+ set_active (yn);
+ }
+
+ if ((prop = child->property (X_("gain"))) != 0) {
+ gain_t val;
+
+ 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) {
+
+ io_child = *io_niter;
- ++o;
+ if (io_child->name() == X_("Panner")) {
+ _main_outs->panner()->set_state(*io_child, version);
+ }
}
}
+ }
+
+ XMLNodeList redirect_nodes;
- // If the processor (*niter) is not on the route,
- // create it and move it to the correct location
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter){
- if (o == _processors.end()) {
+ child = *niter;
- if (add_processor_from_xml (**niter, i)) {
- --i; // move iterator to the newly inserted processor
- } else {
- cerr << "Error restoring route: unable to restore processor" << endl;
+ if (child->name() == X_("Send") || child->name() == X_("Insert")) {
+ redirect_nodes.push_back(child);
+ }
+
+ }
+
+ set_processor_state_2X (redirect_nodes, version);
+
+ 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() == X_("Controllable") && (prop = child->property("name")) != 0) {
+
+ if (prop->value() == "solo") {
+ _solo_control->set_state (*child, version);
+ _session.add_controllable (_solo_control);
}
- } else {
+ } 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);
+ }
- // Otherwise, the processor already exists; just
- // ensure it is at the location provided in the XML state
+ }
+ }
+
+ return 0;
+}
- if (i != o) {
- boost::shared_ptr<Processor> tmp = (*o);
- _processors.erase (o); // remove the old copy
- _processors.insert (i, tmp); // insert the processor at the correct location
- --i; // move iterator to the correct processor
+XMLNode&
+Route::get_processor_state ()
+{
+ XMLNode* root = new XMLNode (X_("redirects"));
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ root->add_child_nocopy ((*i)->state (true));
+ }
+
+ return *root;
+}
+
+void
+Route::set_processor_state_2X (XMLNodeList const & nList, int version)
+{
+ /* We don't bother removing existing processors not in nList, as this
+ method will only be called when creating a Route from scratch, not
+ for undo purposes. Just put processors in at the appropriate place
+ in the list.
+ */
+
+ for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
+ add_processor_from_xml_2X (**i, version, _processors.begin ());
+ }
+}
+
+void
+Route::set_processor_state (const XMLNode& node)
+{
+ const XMLNodeList &nlist = node.children();
+ XMLNodeConstIterator niter;
+ ProcessorList 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;
+ }
}
- // and make it (just) so
-
- (*i)->set_state (**niter);
- }
- }
-
- /* note: there is no configure_processors() call because we figure that
- the XML state represents a working signal route.
- */
+ // 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;
+ }
+
+ processor->set_state (**niter, Stateful::current_state_version);
+ new_order.push_back (processor);
+ must_configure = true;
+ }
+ }
+ }
+
+ {
+ Glib::RWLock::WriterLock lm (_processor_lock);
+ _processors = new_order;
+ if (must_configure) {
+ configure_processors_unlocked (0);
+ }
+ }
- processors_changed ();
+ processors_changed (RouteProcessorChange ());
}
void
if (!_silent) {
_output->silence (nframes);
-
- {
+
+ {
Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
-
+
if (lm.locked()) {
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
boost::shared_ptr<PluginInsert> pi;
// skip plugins, they don't need anything when we're not active
continue;
}
-
+
(*i)->silence (nframes);
}
}
}
}
-
+
}
-}
+}
void
Route::add_internal_return ()
Route::get_return_buffer () const
{
Glib::RWLock::ReaderLock rm (_processor_lock);
-
+
for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
-
+
if (d) {
BufferSet* bs = d->get_buffers ();
return bs;
}
}
-
+
return 0;
}
Route::release_return_buffer () const
{
Glib::RWLock::ReaderLock rm (_processor_lock);
-
+
for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
-
+
if (d) {
return d->release_buffers ();
}
}
int
-Route::listen_via (boost::shared_ptr<Route> route, Placement placement, bool active, bool aux)
+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.control_out()) {
- _control_outs = boost::dynamic_pointer_cast<Delivery>(d);
+ 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 {
- listener.reset (new InternalSend (_session, _mute_master, route, (aux ? Delivery::Aux : Delivery::Listen)));
+
+ 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.control_out()) {
- _control_outs = listener;
+ if (route == _session.monitor_out()) {
+ _monitor_send = listener;
}
- add_processor (listener, placement);
-
- return 0;
-}
+ 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)
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);
so start over.
*/
- goto again;
- }
+ goto again;
+ }
}
rl.release ();
- if (route == _session.control_out()) {
- _control_outs.reset ();
+ if (route == _session.monitor_out()) {
+ _monitor_send.reset ();
}
}
void
-Route::set_route_group (RouteGroup *rg, void *src)
+Route::set_comment (string cmt, void *src)
{
- if (rg == _route_group) {
- return;
- }
+ _comment = cmt;
+ comment_changed (src);
+ _session.set_dirty ();
+}
- if (_route_group) {
- _route_group->remove (this);
- }
+bool
+Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
+{
+ FeedRecord fr (other, via_sends_only);
- if ((_route_group = rg) != 0) {
- _route_group->add (this);
- }
+ pair<FedBy::iterator,bool> result = _fed_by.insert (fr);
- _session.set_dirty ();
- route_group_changed (src); /* EMIT SIGNAL */
+ 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::drop_route_group (void *src)
+Route::clear_fed_by ()
{
- _route_group = 0;
- _session.set_dirty ();
- route_group_changed (src); /* EMIT SIGNAL */
+ _fed_by.clear ();
}
-void
-Route::set_comment (string cmt, void *src)
+bool
+Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
{
- _comment = cmt;
- comment_changed (src);
- _session.set_dirty ();
+ 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::feeds (boost::shared_ptr<Route> other)
+Route::direct_feeds (boost::shared_ptr<Route> other, bool* only_send)
{
- // cerr << _name << endl;
+ DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
if (_output->connected_to (other->input())) {
- // cerr << "\tdirect FEEDS " << other->name() << endl;
+ DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
+ if (only_send) {
+ *only_send = false;
+ }
+
return true;
}
- for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); r++) {
-
+
+ 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)) {
- // cerr << "\tIOP " << iop->name() << " feeds " << other->name() << endl;
+ 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 {
- // cerr << "\tIOP " << iop->name() << " does NOT feeds " << other->name() << endl;
+ 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()));
}
+
}
- // cerr << "\tdoes NOT FEED " << other->name() << endl;
+ DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdoes NOT feed %1\n", other->name()));
return false;
}
void
-Route::handle_transport_stopped (bool abort_ignored, bool did_locate, bool can_flush_processors)
+Route::handle_transport_stopped (bool /*abort_ignored*/, bool did_locate, bool can_flush_processors)
{
nframes_t now = _session.transport_frame();
}
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
-
+
if (Config->get_plugins_stop_with_transport() && can_flush_processors) {
(*i)->deactivate ();
(*i)->activate ();
}
-
+
(*i)->transport_stopped (now);
}
}
}
void
-Route::input_change_handler (IOChange change, void *src)
+Route::input_change_handler (IOChange change, void * /*src*/)
{
if ((change & ConfigurationChanged)) {
configure_processors (0);
}
void
-Route::output_change_handler (IOChange change, void *src)
+Route::output_change_handler (IOChange change, void * /*src*/)
{
if ((change & ConfigurationChanged)) {
-
+
/* XXX resize all listeners to match _main_outs? */
-
+
// configure_processors (0);
}
}
if (n_outputs().n_audio() < 2) {
return 0;
}
-
+
return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
}
-int
-Route::no_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
- bool session_state_changing, bool can_record, bool rec_monitors_input)
+int
+Route::no_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
+ bool session_state_changing, bool /*can_record*/, bool /*rec_monitors_input*/)
{
if (n_outputs().n_total() == 0) {
return 0;
}
- if (session_state_changing || !_active || n_inputs() == ChanCount::ZERO) {
+ if (!_active || n_inputs() == ChanCount::ZERO) {
silence (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 (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);
nframes -= _roll_delay;
silence (_roll_delay);
- /* we've written _roll_delay of samples into the
+ /* we've written _roll_delay of samples into the
output ports, so make a note of that for
future reference.
*/
int
Route::roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame, int declick,
- bool can_record, bool rec_monitors_input)
+ bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
{
{
// automation snapshot can also be called from the non-rt context
silence (nframes);
return 0;
}
-
+
nframes_t unused = 0;
if ((nframes = check_initial_delay (nframes, unused)) == 0) {
}
int
-Route::silent_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
- bool can_record, bool rec_monitors_input)
+Route::silent_roll (nframes_t nframes, sframes_t /*start_frame*/, sframes_t /*end_frame*/,
+ bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
{
silence (nframes);
return 0;
// 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;
}
}
void
-Route::set_meter_point (MeterPoint p, void *src)
+Route::set_meter_point (MeterPoint p)
{
- if (_meter_point != p) {
- _meter_point = p;
+ /* CAN BE CALLED FROM PROCESS CONTEXT */
- // Move meter in the processors list
- 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;
+ 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);
}
- _processors.insert(loc, _meter);
-
- meter_change (src); /* EMIT SIGNAL */
- processors_changed (); /* EMIT SIGNAL */
- _session.set_dirty ();
}
+
+ _meter_point = p;
+ meter_change (); /* EMIT SIGNAL */
+
+ bool const meter_visibly_changed = (_meter->display_to_user() != meter_was_visible_to_user);
+
+ processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
}
+
void
-Route::put_control_outs_at (Placement p)
+Route::put_monitor_send_at (Placement p)
{
- if (!_control_outs) {
+ if (!_monitor_send) {
return;
}
- // Move meter in the processors list
- ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), _control_outs);
- _processors.erase(loc);
+ {
+ 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);
- switch (p) {
- case PreFader:
- loc = find(_processors.begin(), _processors.end(), _amp);
- if (loc != _processors.begin()) {
- --loc;
+ if (configure_processors_unlocked (0)) {
+ _processors = as_it_was;
+ configure_processors_unlocked (0); // it worked before we tried to add it ...
+ return;
}
- break;
- case PostFader:
- loc = find(_processors.begin(), _processors.end(), _amp);
- assert (loc != _processors.end());
- loc++;
- break;
}
- _processors.insert(loc, _control_outs);
-
- processors_changed (); /* EMIT SIGNAL */
+ processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
_session.set_dirty ();
}
}
}
-#undef DEBUG_LATENCY
-#ifdef DEBUG_LATENCY
- cerr << _name << ": internal redirect latency = " << own_latency << endl;
-#endif
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal redirect latency = %2\n", _name, own_latency));
_output->set_port_latency (own_latency);
-
+
if (_output->user_latency() == 0) {
/* this (virtual) function is used for pure Routes,
port, not prerecorded material, and therefore we
have to take into account any input latency.
*/
-
+
own_latency += _input->signal_latency ();
}
_output->set_latency_delay (own_latency);
signal_latency_changed (); /* EMIT SIGNAL */
}
-
-#ifdef DEBUG_LATENCY
- cerr << _name << ": input latency = " << _input->signal_latency() << " total = "
- << own_latency << endl;
-#endif
+
+ 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::automation_snapshot (nframes_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),
+ : AutomationControl (r.session(), Evoral::Parameter (SoloAutomation),
boost::shared_ptr<AutomationList>(), name)
, route (r)
{
Route::SoloControllable::set_value (float 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
}
float
Route::SoloControllable::get_value (void) const
{
- return route.soloed() ? 1.0f : 0.0f;
+ 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::MuteControllable::set_value (float 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);
+ _session.set_mute (rl, bval);
+#else
+ route.set_mute (bval, this);
+#endif
+}
+
+float
+Route::MuteControllable::get_value (void) const
+{
+ return route.self_muted() ? 1.0f : 0.0f;
}
-void
+void
Route::set_block_size (nframes_t nframes)
{
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
(*i)->set_block_size (nframes);
}
- _session.ensure_buffers(processor_max_streams);
+
+ _session.ensure_buffers (n_process_buffers ());
}
void
*/
void
-Route::shift (nframes64_t pos, nframes64_t frames)
+Route::shift (nframes64_t /*pos*/, nframes64_t /*frames*/)
{
#ifdef THIS_NEEDS_FIXING_FOR_V3
{
Glib::RWLock::ReaderLock lm (redirect_lock);
for (RedirectList::iterator i = _redirects.begin (); i != _redirects.end (); ++i) {
-
+
set<uint32_t> a;
(*i)->what_has_automation (a);
-
+
for (set<uint32_t>::const_iterator j = a.begin (); j != a.end (); ++j) {
AutomationList & al = (*i)->automation_list (*j);
XMLNode &before = al.get_state ();
{
XMLNode& node (state (false));
XMLTree tree;
-
+
IO::set_name_in_state (*node.children().front(), name);
-
+
tree.set_root (&node);
return tree.write (path.c_str());
}
name = Route::ensure_track_or_route_name (str, _session);
SessionObject::set_name (name);
-
+
ret = (_input->set_name(name) && _output->set_name(name));
if (ret) {
-
+
Glib::RWLock::ReaderLock lm (_processor_lock);
-
+
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
-
+
/* rename all I/O processors that have inputs or outputs */
boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
boost::shared_ptr<InternalSend> send;
-
+
if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
if (send->target_route() == target) {
return send;
}
}
}
-
+
return boost::shared_ptr<Send>();
}
Route::set_phase_invert (bool yn)
{
if (_phase_invert != yn) {
- _phase_invert = 0xffff; // XXX all channels
+ if (yn) {
+ _phase_invert = 0xffff; // XXX all channels
+ } else {
+ _phase_invert = 0; // XXX no channels
+ }
+
phase_invert_changed (); /* EMIT SIGNAL */
+ _session.set_dirty ();
}
}
Route::meter ()
{
Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
+
+ assert (_meter);
+
_meter->meter ();
+
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+
+ boost::shared_ptr<Send> s;
+ boost::shared_ptr<Return> r;
+
+ if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
+ s->meter()->meter();
+ } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
+ r->meter()->meter ();
+ }
+ }
}
boost::shared_ptr<Panner>
Route::panner() const
{
-
return _main_outs->panner();
}
boost::shared_ptr<AutomationControl>
Route::gain_control() const
{
-
return _amp->gain_control();
}
{
/* either we own the control or .... */
- boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(data().control (param));
+ 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 ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->data().control (param))) != 0) {
+ if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
break;
}
}
}
-
+
if (!c) {
/* nobody does so we'll make a new one */
return c;
}
+
+boost::shared_ptr<Processor>
+Route::nth_plugin (uint32_t n)
+{
+ Glib::RWLock::ReaderLock lm (_processor_lock);
+ ProcessorList::iterator i;
+
+ for (i = _processors.begin(); i != _processors.end(); ++i) {
+ if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
+ if (n-- == 0) {
+ return *i;
+ }
+ }
+ }
+
+ return boost::shared_ptr<Processor> ();
+}
+
+boost::shared_ptr<Processor>
+Route::nth_send (uint32_t n)
+{
+ Glib::RWLock::ReaderLock lm (_processor_lock);
+ ProcessorList::iterator i;
+
+ for (i = _processors.begin(); i != _processors.end(); ++i) {
+ if (boost::dynamic_pointer_cast<Send> (*i)) {
+ if (n-- == 0) {
+ return *i;
+ }
+ }
+ }
+
+ return boost::shared_ptr<Processor> ();
+}
+
+bool
+Route::has_io_processor_named (const string& name)
+{
+ 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;
+}
projects / ardour.git / blobdiff