#include "pbd/xml++.h"
#include "pbd/enumwriter.h"
+#include "pbd/locale_guard.h"
#include "pbd/memento_command.h"
#include "pbd/stacktrace.h"
#include "pbd/types_convert.h"
#include "ardour/capturing_processor.h"
#include "ardour/debug.h"
#include "ardour/delivery.h"
+#include "ardour/disk_reader.h"
+#include "ardour/disk_writer.h"
#include "ardour/event_type_map.h"
#include "ardour/gain_control.h"
#include "ardour/internal_return.h"
#include "ardour/delayline.h"
#include "ardour/midi_buffer.h"
#include "ardour/midi_port.h"
+#include "ardour/monitor_control.h"
#include "ardour/monitor_processor.h"
#include "ardour/pannable.h"
#include "ardour/panner.h"
, Muteable (sess, name)
, _active (true)
, _signal_latency (0)
- , _signal_latency_at_amp_position (0)
- , _signal_latency_at_trim_position (0)
, _initial_delay (0)
, _roll_delay (0)
+ , _disk_io_point (DiskIOPreFader)
, _pending_process_reorder (0)
, _pending_signals (0)
, _pending_declick (true)
, _strict_io (false)
, _custom_meter_position_noted (false)
, _pinmgr_proxy (0)
+ , _patch_selector_dialog (0)
{
processor_max_streams.reset();
}
}
void
-Route::maybe_declick (BufferSet&, framecnt_t, int)
+Route::maybe_declick (BufferSet&, samplecnt_t, int)
{
/* this is the "bus" implementation and they never declick.
*/
/** 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 start_sample Initial transport sample
+ * @param end_sample Final transport sample
+ * @param nframes Number of samples to output (to ports)
*
- * Note that (end_frame - start_frame) may not be equal to nframes when the
+ * Note that (end_sample - start_sample) may not be equal to nframes when the
* transport speed isn't 1.0 (eg varispeed).
*/
void
Route::process_output_buffers (BufferSet& bufs,
- framepos_t start_frame, framepos_t end_frame, pframes_t nframes,
+ samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes,
int declick, bool gain_automation_ok)
{
/* Caller must hold process lock */
return;
}
- _mute_control->automation_run (start_frame, nframes);
+ automation_run (start_sample, nframes);
/* figure out if we're going to use gain automation */
if (gain_automation_ok) {
_amp->set_gain_automation_buffer (_session.gain_automation_buffer ());
_amp->setup_gain_automation (
- start_frame + _signal_latency_at_amp_position,
- end_frame + _signal_latency_at_amp_position,
+ start_sample + _amp->output_latency (),
+ end_sample + _amp->output_latency (),
nframes);
_trim->set_gain_automation_buffer (_session.trim_automation_buffer ());
_trim->setup_gain_automation (
- start_frame + _signal_latency_at_trim_position,
- end_frame + _signal_latency_at_trim_position,
+ start_sample + _trim->output_latency (),
+ end_sample + _trim->output_latency (),
nframes);
- } else {
- _amp->apply_gain_automation (false);
- _trim->apply_gain_automation (false);
}
/* Tell main outs what to do about monitoring. We do this so that
/* set this to be true if the meter will already have been ::run() earlier */
bool const meter_already_run = metering_state() == MeteringInput;
- framecnt_t latency = 0;
- const double speed = _session.transport_speed ();
+ samplecnt_t latency = 0;
+ const double speed = (is_auditioner() ? 1.0 : _session.transport_speed ());
for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
boost::dynamic_pointer_cast<Send>(*i)->set_delay_in(_signal_latency - latency);
}
if (boost::dynamic_pointer_cast<PluginInsert>(*i) != 0) {
- const framecnt_t longest_session_latency = _initial_delay + _signal_latency;
+ const samplecnt_t longest_session_latency = _initial_delay + _signal_latency;
boost::dynamic_pointer_cast<PluginInsert>(*i)->set_sidechain_latency (
_initial_delay + latency, longest_session_latency - latency);
}
- (*i)->run (bufs, start_frame - latency, end_frame - latency, speed, nframes, *i != _processors.back());
+ //cerr << name() << " run " << (*i)->name() << endl;
+ (*i)->run (bufs, start_sample - latency, end_sample - latency, speed, nframes, *i != _processors.back());
bufs.set_count ((*i)->output_streams());
if ((*i)->active ()) {
}
void
-Route::bounce_process (BufferSet& buffers, framepos_t start, framecnt_t nframes,
+Route::bounce_process (BufferSet& buffers, samplepos_t start, samplecnt_t nframes,
boost::shared_ptr<Processor> endpoint,
bool include_endpoint, bool for_export, bool for_freeze)
{
return;
}
- framecnt_t latency = bounce_get_latency(_amp, false, for_export, for_freeze);
+ samplecnt_t latency = bounce_get_latency(_amp, false, for_export, for_freeze);
_amp->set_gain_automation_buffer (_session.gain_automation_buffer ());
_amp->setup_gain_automation (start - latency, start - latency + nframes, nframes);
}
}
-framecnt_t
+samplecnt_t
Route::bounce_get_latency (boost::shared_ptr<Processor> endpoint,
bool include_endpoint, bool for_export, bool for_freeze) const
{
- framecnt_t latency = 0;
+ samplecnt_t latency = 0;
if (!endpoint && !include_endpoint) {
return latency;
}
}
void
-Route::monitor_run (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
+Route::monitor_run (samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes, int declick)
{
assert (is_monitor());
BufferSet& bufs (_session.get_route_buffers (n_process_buffers()));
fill_buffers_with_input (bufs, _input, nframes);
- passthru (bufs, start_frame, end_frame, nframes, declick);
+ passthru (bufs, start_sample, end_sample, nframes, declick, true);
}
void
-Route::passthru (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
+Route::passthru (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes, int declick, bool gain_automation_ok)
{
_silent = false;
bufs.silence (nframes, 0);
}
- write_out_of_band_data (bufs, start_frame, end_frame, nframes);
- process_output_buffers (bufs, start_frame, end_frame, nframes, declick, true);
+ /* append immediate messages to the first MIDI buffer (thus sending it to the first output port) */
+
+ write_out_of_band_data (bufs, start_sample, end_sample, nframes);
+
+ /* run processor chain */
+
+ process_output_buffers (bufs, start_sample, end_sample, nframes, declick, gain_automation_ok);
}
void
-Route::passthru_silence (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
+Route::passthru_silence (samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes, int declick)
{
BufferSet& bufs (_session.get_route_buffers (n_process_buffers(), true));
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, declick, false);
+ write_out_of_band_data (bufs, start_sample, end_sample, nframes);
+ process_output_buffers (bufs, start_sample, end_sample, nframes, declick, false);
}
void
loc = _processors.end ();
}
- if (!AudioEngine::instance()->connected()) {
- return 1;
- }
-
if (others.empty()) {
return 0;
}
_session.set_deletion_in_progress();
}
+ ProcessorList old_list = _processors;
{
Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
Glib::Threads::RWLock::WriterLock lm (_processor_lock);
_processors = new_list;
configure_processors_unlocked (&err, &lm); // this can't fail
}
+ /* drop references w/o process-lock (I/O procs may re-take it in ~IO() */
+ old_list.clear ();
processor_max_streams.reset();
_have_internal_generator = false;
- processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
+ reset_instrument_info ();
set_processor_positions ();
- reset_instrument_info ();
+ processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
if (!already_deleting) {
_session.clear_deletion_in_progress();
lm->acquire ();
return -1;
}
+
processor_max_streams = ChanCount::max(processor_max_streams, c->first);
processor_max_streams = ChanCount::max(processor_max_streams, c->second);
g_atomic_int_set (&_pending_process_reorder, 1);
}
+ /* update processor input/output latency
+ * (total signal_latency does not change)
+ */
+ update_signal_latency (true);
+
return 0;
}
XMLNode&
Route::state(bool full_state)
{
- LocaleGuard lg;
if (!_session._template_state_dir.empty()) {
foreach_processor (sigc::bind (sigc::mem_fun (*this, &Route::set_plugin_state_dir), _session._template_state_dir));
}
XMLNode *node = new XMLNode("Route");
ProcessorList::iterator i;
- node->set_property ("id", id ());
- node->set_property ("name", name());
- node->set_property ("default-type", _default_type);
- node->set_property ("strict-io", _strict_io);
+ node->set_property (X_("id"), id ());
+ node->set_property (X_("name"), name());
+ node->set_property (X_("default-type"), _default_type);
+ node->set_property (X_("strict-io"), _strict_io);
node->add_child_nocopy (_presentation_info.get_state());
- node->set_property ("active", _active);
- node->set_property ("denormal-protection", _denormal_protection);
- node->set_property ("meter-point", _meter_point);
+ node->set_property (X_("active"), _active);
+ node->set_property (X_("denormal-protection"), _denormal_protection);
+ node->set_property (X_("meter-point"), _meter_point);
+ node->set_property (X_("disk-io-point"), _disk_io_point);
- node->set_property ("meter-type", _meter_type);
+ node->set_property (X_("meter-type"), _meter_type);
if (_route_group) {
- node->set_property ("route-group", _route_group->name());
+ node->set_property (X_("route-group"), _route_group->name());
}
node->add_child_nocopy (_solo_control->get_state ());
}
}
+ DiskIOPoint diop;
+ if (node.get_property (X_("disk-io-point"), diop)) {
+ if (_disk_writer) {
+ _disk_writer->set_display_to_user (diop == DiskIOCustom);
+ }
+ if (_disk_reader) {
+ _disk_reader->set_display_to_user (diop == DiskIOCustom);
+ }
+ set_disk_io_point (diop);
+ }
+
node.get_property (X_("meter-type"), _meter_type);
_initial_io_setup = false;
} else if (prop->value() == "capture") {
/* CapturingProcessor should never be restored, it's always
added explicitly when needed */
+ } else if (prop->value() == "diskreader" && _disk_reader) {
+ _disk_reader->set_state (**niter, Stateful::current_state_version);
+ new_order.push_back (_disk_reader);
+ } else if (prop->value() == "diskwriter" && _disk_writer) {
+ _disk_writer->set_state (**niter, Stateful::current_state_version);
+ new_order.push_back (_disk_writer);
} else {
- ProcessorList::iterator o;
-
- for (o = _processors.begin(); o != _processors.end(); ++o) {
- XMLProperty const * 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 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, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), boost::shared_ptr<Route>(), Delivery::Aux, true));
-
- } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
- prop->value() == "lv2" ||
- prop->value() == "windows-vst" ||
- prop->value() == "mac-vst" ||
- prop->value() == "lxvst" ||
- prop->value() == "luaproc" ||
- prop->value() == "audiounit") {
-
- if (_session.get_disable_all_loaded_plugins ()) {
- processor.reset (new UnknownProcessor (_session, **niter));
- } else {
- processor.reset (new PluginInsert (_session));
- processor->set_owner (this);
- if (_strict_io) {
- boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(processor);
- pi->set_strict_io (true);
- }
-
- }
- } else if (prop->value() == "port") {
-
- processor.reset (new PortInsert (_session, _pannable, _mute_master));
-
- } else if (prop->value() == "send") {
-
- processor.reset (new Send (_session, _pannable, _mute_master, Delivery::Send, true));
- boost::shared_ptr<Send> send = boost::dynamic_pointer_cast<Send> (processor);
- send->SelfDestruct.connect_same_thread (*this,
- boost::bind (&Route::processor_selfdestruct, this, boost::weak_ptr<Processor> (processor)));
-
- } 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));
- }
-
- /* subscribe to Sidechain IO changes */
- boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (processor);
- if (pi && pi->has_sidechain ()) {
- pi->sidechain_input ()->changed.connect_same_thread (*this, boost::bind (&Route::sidechain_change_handler, this, _1, _2));
- }
-
- /* we have to note the monitor send here, otherwise a new one will be created
- and the state of this one will be lost.
- */
- boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
- if (isend && isend->role() == Delivery::Listen) {
- _monitor_send = isend;
- }
-
- /* it doesn't matter if invisible processors are added here, as they
- will be sorted out by setup_invisible_processors () shortly.
- */
-
- new_order.push_back (processor);
- must_configure = true;
- }
+ set_processor_state (**niter, prop, new_order, must_configure);
}
}
+ ProcessorList old_list = _processors; // keep a copy
{
Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
Glib::Threads::RWLock::WriterLock lm (_processor_lock);
}
}
}
+ /* drop references w/o process-lock (I/O procs may re-take it in ~IO() */
+ old_list.clear ();
reset_instrument_info ();
processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
set_processor_positions ();
}
+bool
+Route::set_processor_state (XMLNode const & node, XMLProperty const* prop, ProcessorList& new_order, bool& must_configure)
+{
+ ProcessorList::iterator o;
+
+ for (o = _processors.begin(); o != _processors.end(); ++o) {
+ XMLProperty const * id_prop = node.property(X_("id"));
+ if (id_prop && (*o)->id() == id_prop->value()) {
+ (*o)->set_state (node, Stateful::current_state_version);
+ new_order.push_back (*o);
+ break;
+ }
+ }
+
+ // If the processor (node) 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, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), boost::shared_ptr<Route>(), Delivery::Aux, true));
+
+ } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
+ prop->value() == "lv2" ||
+ prop->value() == "windows-vst" ||
+ prop->value() == "mac-vst" ||
+ prop->value() == "lxvst" ||
+ prop->value() == "luaproc" ||
+ prop->value() == "audiounit") {
+
+ if (_session.get_disable_all_loaded_plugins ()) {
+ processor.reset (new UnknownProcessor (_session, node));
+ } else {
+ processor.reset (new PluginInsert (_session));
+ processor->set_owner (this);
+ if (_strict_io) {
+ boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(processor);
+ pi->set_strict_io (true);
+ }
+
+ }
+ } else if (prop->value() == "port") {
+
+ processor.reset (new PortInsert (_session, _pannable, _mute_master));
+
+ } else if (prop->value() == "send") {
+
+ processor.reset (new Send (_session, _pannable, _mute_master, Delivery::Send, true));
+ boost::shared_ptr<Send> send = boost::dynamic_pointer_cast<Send> (processor);
+ send->SelfDestruct.connect_same_thread (*this,
+ boost::bind (&Route::processor_selfdestruct, this, boost::weak_ptr<Processor> (processor)));
+
+ } else {
+ return false;
+ }
+
+ if (processor->set_state (node, Stateful::current_state_version) != 0) {
+ /* This processor could not be configured. Turn it into a UnknownProcessor */
+ processor.reset (new UnknownProcessor (_session, node));
+ }
+
+ /* subscribe to Sidechain IO changes */
+ boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (processor);
+ if (pi && pi->has_sidechain ()) {
+ pi->sidechain_input ()->changed.connect_same_thread (*this, boost::bind (&Route::sidechain_change_handler, this, _1, _2));
+ }
+
+ /* we have to note the monitor send here, otherwise a new one will be created
+ and the state of this one will be lost.
+ */
+ boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
+ if (isend && isend->role() == Delivery::Listen) {
+ _monitor_send = isend;
+ }
+
+ /* it doesn't matter if invisible processors are added here, as they
+ will be sorted out by setup_invisible_processors () shortly.
+ */
+
+ new_order.push_back (processor);
+ must_configure = true;
+ }
+ return true;
+}
+
void
Route::curve_reallocate ()
{
}
void
-Route::silence (framecnt_t nframes)
+Route::silence (samplecnt_t nframes)
{
Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
if (!lm.locked()) {
}
void
-Route::silence_unlocked (framecnt_t nframes)
+Route::silence_unlocked (samplecnt_t nframes)
{
/* Must be called with the processor lock held */
- const framepos_t now = _session.transport_frame ();
+ const samplepos_t now = _session.transport_sample ();
if (!_silent) {
_output->silence (nframes);
+ // update owned automated controllables
+ automation_run (now, nframes);
+
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
+ /* evaluate automated automation controls */
+ pi->automation_run (now, nframes);
+ /* skip plugins, they don't need anything when we're not active */
continue;
}
/** 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)
+Route::non_realtime_transport_stop (samplepos_t now, bool flush)
{
- framepos_t now = _session.transport_frame();
-
{
Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
- Automatable::transport_stopped (now);
+ Automatable::non_realtime_transport_stop (now, flush);
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && can_flush_processors)) {
+ if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && flush)) {
(*i)->flush ();
}
- (*i)->transport_stopped (now);
+ (*i)->non_realtime_transport_stop (now, flush);
}
}
}
void
-Route::flush_processor_buffers_locked (framecnt_t nframes)
+Route::flush_processor_buffers_locked (samplecnt_t nframes)
{
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery> (*i);
}
int
-Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
+Route::no_roll (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, bool session_state_changing)
{
Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
fill_buffers_with_input (bufs, _input, nframes);
if (_meter_point == MeterInput) {
- _meter->run (bufs, start_frame, end_frame, 0.0, nframes, true);
+ _meter->run (bufs, start_sample, end_sample, 0.0, nframes, true);
}
- _amp->apply_gain_automation (false);
- _trim->apply_gain_automation (false);
- passthru (bufs, start_frame, end_frame, nframes, 0);
+ passthru (bufs, start_sample, end_sample, nframes, 0, true);
flush_processor_buffers_locked (nframes);
}
int
-Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& /* need_butler */)
+Route::roll (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, int declick, bool& need_butler)
{
Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
+
if (!lm.locked()) {
return 0;
}
if (!_active) {
silence_unlocked (nframes);
- return 0;
- }
-
- framepos_t unused = 0;
-
- if ((nframes = check_initial_delay (nframes, unused)) == 0) {
+ if (_meter_point == MeterInput && ((_monitoring_control->monitoring_choice() & MonitorInput) || (!_disk_writer || _disk_writer->record_enabled()))) {
+ _meter->reset();
+ }
return 0;
}
_silent = false;
- BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
+ BufferSet& bufs = _session.get_route_buffers (n_process_buffers ());
fill_buffers_with_input (bufs, _input, nframes);
- if (_meter_point == MeterInput) {
- _meter->run (bufs, start_frame, end_frame, 1.0, nframes, true);
+ /* filter captured data before meter sees it */
+ filter_input (bufs);
+
+ if (_meter_point == MeterInput &&
+ ((_monitoring_control->monitoring_choice() & MonitorInput) || (_disk_writer && _disk_writer->record_enabled()))) {
+ _meter->run (bufs, start_sample, end_sample, 1.0 /*speed()*/, nframes, true);
}
- passthru (bufs, start_frame, end_frame, nframes, declick);
+ passthru (bufs, start_sample, end_sample, nframes, declick, (!_disk_writer || !_disk_writer->record_enabled()) && _session.transport_rolling());
+
+ if ((_disk_reader && _disk_reader->need_butler()) || (_disk_writer && _disk_writer->need_butler())) {
+ need_butler = true;
+ }
flush_processor_buffers_locked (nframes);
}
int
-Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& /* need_butler */)
+Route::silent_roll (pframes_t nframes, samplepos_t /*start_sample*/, samplepos_t /*end_sample*/, bool& /* need_butler */)
{
silence (nframes);
flush_processor_buffers_locked (nframes);
}
if (changed) {
set_processor_positions ();
+ /* update processor input/output latency
+ * (total signal_latency does not change)
+ */
+ update_signal_latency (true);
}
if (emissions != 0) {
g_atomic_int_set (&_pending_signals, emissions);
Glib::Threads::RWLock::WriterLock lw (_processor_lock);
// this aligns all tracks; but not tracks + busses
- assert (_session.worst_track_latency () >= _initial_delay);
- _capturing_processor.reset (new CapturingProcessor (_session, _session.worst_track_latency () - _initial_delay));
+ samplecnt_t latency = _session.worst_track_roll_delay ();
+ assert (latency >= _initial_delay);
+ _capturing_processor.reset (new CapturingProcessor (_session, latency - _initial_delay));
_capturing_processor->activate ();
configure_processors_unlocked (0, &lw);
return _capturing_processor;
}
-framecnt_t
-Route::update_signal_latency ()
+samplecnt_t
+Route::update_signal_latency (bool set_initial_delay)
{
- framecnt_t l = _output->user_latency();
- framecnt_t lamp = 0;
- bool before_amp = true;
- framecnt_t ltrim = 0;
- bool before_trim = true;
+ Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
+
+ samplecnt_t l_in = _input->latency ();
+ samplecnt_t l_out = _output->user_latency();
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
if ((*i)->active ()) {
- l += (*i)->signal_latency ();
- }
- if ((*i) == _amp) {
- before_amp = false;
+ l_in += (*i)->signal_latency ();
}
- if ((*i) == _trim) {
- before_amp = false;
- }
- if (before_amp) {
- lamp = l;
- }
- if (before_trim) {
- lamp = l;
+ (*i)->set_input_latency (l_in);
+ }
+
+ for (ProcessorList::reverse_iterator i = _processors.rbegin(); i != _processors.rend(); ++i) {
+ (*i)->set_output_latency (l_out);
+ if ((*i)->active ()) {
+ l_out += (*i)->signal_latency ();
}
}
- DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l));
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l_out));
+
+ _signal_latency = l_out;
+
+ lm.release ();
- // TODO: (lamp - _signal_latency) to sync to output (read-ahed), currently _roll_delay shifts this around
- _signal_latency_at_amp_position = lamp;
- _signal_latency_at_trim_position = ltrim;
+ if (set_initial_delay) {
+ /* see also Session::post_playback_latency() */
+ set_latency_compensation (_session.worst_track_latency () + _session.worst_track_out_latency () - output ()->latency ());
+ }
- if (_signal_latency != l) {
- _signal_latency = l;
+ if (_signal_latency != l_out) {
signal_latency_changed (); /* EMIT SIGNAL */
}
}
void
-Route::set_user_latency (framecnt_t nframes)
+Route::set_user_latency (samplecnt_t nframes)
{
_output->set_user_latency (nframes);
_session.update_latency_compensation ();
}
void
-Route::set_latency_compensation (framecnt_t longest_session_latency)
+Route::set_latency_compensation (samplecnt_t longest_session_latency)
{
- framecnt_t old = _initial_delay;
+ samplecnt_t old = _initial_delay;
+ assert (!_disk_reader || _disk_reader->output_latency () <= _signal_latency);
- if (_signal_latency < longest_session_latency) {
- _initial_delay = longest_session_latency - _signal_latency;
+ if (_disk_reader && _disk_reader->output_latency () < longest_session_latency) {
+ _initial_delay = longest_session_latency - _disk_reader->output_latency ();
} else {
_initial_delay = 0;
}
* Adds undo commands for any shifts that are performed.
*
* @param pos Position to start shifting from.
- * @param frames Amount to shift forwards by.
+ * @param samples Amount to shift forwards by.
*/
void
-Route::shift (framepos_t pos, framecnt_t frames)
+Route::shift (samplepos_t pos, samplecnt_t samples)
{
/* gain automation */
{
boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
XMLNode &before = gc->alist()->get_state ();
- gc->alist()->shift (pos, frames);
+ gc->alist()->shift (pos, samples);
XMLNode &after = gc->alist()->get_state ();
_session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
}
boost::shared_ptr<AutomationControl> gc = _trim->gain_control();
XMLNode &before = gc->alist()->get_state ();
- gc->alist()->shift (pos, frames);
+ gc->alist()->shift (pos, samples);
XMLNode &after = gc->alist()->get_state ();
_session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
}
if (pc) {
boost::shared_ptr<AutomationList> al = pc->alist();
XMLNode& before = al->get_state ();
- al->shift (pos, frames);
+ al->shift (pos, samples);
XMLNode& after = al->get_state ();
_session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
}
if (ac) {
boost::shared_ptr<AutomationList> al = ac->alist();
XMLNode &before = al->get_state ();
- al->shift (pos, frames);
+ al->shift (pos, samples);
XMLNode &after = al->get_state ();
_session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
}
}
int
-Route::save_as_template (const string& path, const string& name)
+Route::save_as_template (const string& path, const string& name, const string& description)
{
std::string state_dir = path.substr (0, path.find_last_of ('.')); // strip template_suffix
PBD::Unwinder<std::string> uw (_session._template_state_dir, state_dir);
XMLNode& node (state (false));
+ node.set_property (X_("name"), name);
+
+ node.remove_nodes (X_("description"));
+ if (!description.empty()) {
+ XMLNode* desc = new XMLNode(X_("description"));
+ XMLNode* desc_cont = new XMLNode(X_("content"), description);
+ desc->add_child_nocopy (*desc_cont);
+
+ node.add_child_nocopy (*desc);
+ }
XMLTree tree;
}
-framecnt_t
-Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecnt_t our_latency) const
+samplecnt_t
+Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, samplecnt_t our_latency) const
{
/* we assume that all our input ports feed all our output ports. its not
universally true, but the alternative is way too corner-case to worry about.
return all_connections.max;
}
-framecnt_t
+samplecnt_t
Route::set_private_port_latencies (bool playback) const
{
- framecnt_t own_latency = 0;
+ samplecnt_t own_latency = 0;
/* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD
OR LATENCY CALLBACK.
}
void
-Route::set_public_port_latencies (framecnt_t value, bool playback) const
+Route::set_public_port_latencies (samplecnt_t value, bool playback) const
{
/* this is called to set the JACK-visible port latencies, which take
latency compensation into account.
*/
ProcessorList new_processors;
+ ProcessorList::iterator dr;
+ ProcessorList::iterator dw;
/* find visible processors */
/* TRIM CONTROL */
- if (_trim && _trim->active()) {
+ ProcessorList::iterator trim = new_processors.end();
+
+ if (_trim->active()) {
assert (!_trim->display_to_user ());
new_processors.push_front (_trim);
+ trim = new_processors.begin();
}
/* INTERNAL RETURN */
/* EXPORT PROCESSOR */
+ /* DISK READER & WRITER (for Track objects) */
+
+ if (_disk_reader || _disk_writer) {
+ switch (_disk_io_point) {
+ case DiskIOPreFader:
+ if (trim != new_processors.end()) {
+ /* insert BEFORE TRIM */
+ if (_disk_writer) {
+ new_processors.insert (trim, _disk_writer);
+ }
+ if (_disk_reader) {
+ new_processors.insert (trim, _disk_reader);
+ }
+ } else {
+ if (_disk_writer) {
+ new_processors.push_front (_disk_writer);
+ }
+ if (_disk_reader) {
+ new_processors.push_front (_disk_reader);
+ }
+ }
+ break;
+ case DiskIOPostFader:
+ /* insert BEFORE main outs */
+ if (_disk_writer) {
+ new_processors.insert (main, _disk_writer);
+ }
+ if (_disk_reader) {
+ new_processors.insert (main, _disk_reader);
+ }
+ break;
+ case DiskIOCustom:
+ /* reader and writer are visible under this condition, so they
+ * are not invisible and thus not handled here.
+ */
+ break;
+ }
+ }
+
if (_capturing_processor) {
assert (!_capturing_processor->display_to_user ());
- new_processors.push_front (_capturing_processor);
+ ProcessorList::iterator reader_pos = find (new_processors.begin(), new_processors.end(), _disk_reader);
+ if (reader_pos != new_processors.end()) {
+ /* insert after disk-reader */
+ new_processors.insert (++reader_pos, _capturing_processor);
+ } else {
+ new_processors.push_front (_capturing_processor);
+ }
}
+
_processors = new_processors;
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
return boost::shared_ptr<Processor> ();
}
-/** @return the monitoring state, or in other words what data we are pushing
- * into the route (data from the inputs, data from disk or silence)
- */
-MonitorState
-Route::monitoring_state () const
-{
- return MonitoringInput;
-}
-
/** @return what we should be metering; either the data coming from the input
* IO or the data that is flowing through the route.
*/
void
-Route::non_realtime_locate (framepos_t pos)
+Route::non_realtime_locate (samplepos_t pos)
{
+ Automatable::non_realtime_locate (pos);
+
if (_pannable) {
- _pannable->transport_located (pos);
+ _pannable->non_realtime_locate (pos);
}
if (_delayline.get()) {
Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- (*i)->transport_located (pos);
+ (*i)->non_realtime_locate (pos);
}
}
_roll_delay = _initial_delay;
boost::shared_ptr<AudioPort> source_port = io->audio (i);
AudioBuffer& buf (bufs.get_audio (i%n_buffers));
-
if (i < n_buffers) {
/* first time through just copy a channel into
# undef MIXBUS_PORTS_H
# include "../../gtk2_ardour/mixbus_ports.h"
boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
- if (plug) {
+ if (plug && !mixbus()) {
uint32_t port_id = 0;
switch (n) {
case 0: port_id = port_channel_post_aux1_level; break;
# undef MIXBUS_PORTS_H
# include "../../gtk2_ardour/mixbus_ports.h"
boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
- if (plug) {
+ if (plug && !mixbus()) {
uint32_t port_id = 0;
switch (n) {
case 0: port_id = port_channel_post_aux1_asgn; break;
Route::send_name (uint32_t n) const
{
#ifdef MIXBUS
+ boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
+ if (plug && !mixbus()) {
# ifdef MIXBUS32C
- if (n < 12) {
- return _session.get_mixbus (n)->name();
- }
- n -= 12;
+ if (n < 12) {
+ return _session.get_mixbus (n)->name();
+ }
+ n -= 12;
#else
- if (n < 8) {
- return _session.get_mixbus (n)->name();
- }
- n -= 8;
+ if (n < 8) {
+ return _session.get_mixbus (n)->name();
+ }
+ n -= 8;
# endif
+ }
#endif
boost::shared_ptr<Processor> p = nth_send (n);
if (p) {
return boost::shared_ptr<AutomationControl> ();
}
+
+SlavableControlList
+Route::slavables () const
+{
+ SlavableControlList rv;
+ rv.push_back (_gain_control);
+ rv.push_back (_mute_control);
+ rv.push_back (_solo_control);
+ return rv;
+}
+
+void
+Route::set_disk_io_point (DiskIOPoint diop)
+{
+ bool display = false;
+
+ cerr << "set disk io to " << enum_2_string (diop) << endl;
+
+ switch (diop) {
+ case DiskIOCustom:
+ display = true;
+ break;
+ default:
+ display = false;
+ }
+
+ if (_disk_writer) {
+ _disk_writer->set_display_to_user (display);
+ }
+
+ if (_disk_reader) {
+ _disk_reader->set_display_to_user (display);
+ }
+
+ const bool changed = (diop != _disk_io_point);
+
+ _disk_io_point = diop;
+
+ if (changed) {
+ Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
+ configure_processors (0);
+ }
+
+ processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
+}
+
+#ifdef USE_TRACKS_CODE_FEATURES
+
+/* This is the Tracks version of Track::monitoring_state().
+ *
+ * Ardour developers: try to flag or fix issues if parts of the libardour API
+ * change in ways that invalidate this
+ */
+
+MonitorState
+Route::monitoring_state () const
+{
+ /* Explicit requests */
+
+ if (_monitoring != MonitorInput) {
+ return MonitoringInput;
+ }
+
+ if (_monitoring & MonitorDisk) {
+ return MonitoringDisk;
+ }
+
+ /* This is an implementation of the truth table in doc/monitor_modes.pdf;
+ I don't think it's ever going to be too pretty too look at.
+ */
+
+ // GZ: NOT USED IN TRACKS
+ //bool const auto_input = _session.config.get_auto_input ();
+ //bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
+ //bool const tape_machine_mode = Config->get_tape_machine_mode ();
+
+ bool const roll = _session.transport_rolling ();
+ bool const track_rec = _diskstream->record_enabled ();
+ bool session_rec = _session.actively_recording ();
+
+ if (track_rec) {
+
+ if (!session_rec && roll) {
+ return MonitoringDisk;
+ } else {
+ return MonitoringInput;
+ }
+
+ } else {
+
+ if (roll) {
+ return MonitoringDisk;
+ }
+ }
+
+ return MonitoringSilence;
+}
+
+#else
+
+/* This is the Ardour/Mixbus version of Track::monitoring_state().
+ *
+ * Tracks developers: do NOT modify this method under any circumstances.
+ */
+
+MonitorState
+Route::monitoring_state () const
+{
+ if (!_disk_reader) {
+ return MonitoringInput;
+ }
+
+ /* Explicit requests */
+ MonitorChoice m (_monitoring_control->monitoring_choice());
+
+ if (m != MonitorAuto) {
+
+ MonitorState ms ((MonitorState) 0);
+
+ if (m & MonitorInput) {
+ ms = MonitoringInput;
+ }
+
+ if (m & MonitorDisk) {
+ ms = MonitorState (ms | MonitoringDisk);
+ }
+
+ return ms;
+ }
+
+ switch (_session.config.get_session_monitoring ()) {
+ case MonitorDisk:
+ return MonitoringDisk;
+ break;
+ case MonitorInput:
+ return MonitoringInput;
+ break;
+ default:
+ break;
+ }
+
+ /* This is an implementation of the truth table in doc/monitor_modes.pdf;
+ I don't think it's ever going to be too pretty too look at.
+ */
+
+ bool const roll = _session.transport_rolling ();
+ bool const track_rec = _disk_writer->record_enabled ();
+ bool const auto_input = _session.config.get_auto_input ();
+ bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
+ bool const tape_machine_mode = Config->get_tape_machine_mode ();
+ bool session_rec;
+
+ /* I suspect that just use actively_recording() is good enough all the
+ * time, but just to keep the semantics the same as they were before
+ * sept 26th 2012, we differentiate between the cases where punch is
+ * enabled and those where it is not.
+ *
+ * rg: I suspect this is not the case: monitoring may differ
+ */
+
+ if (_session.config.get_punch_in() || _session.config.get_punch_out() || _session.preroll_record_punch_enabled ()) {
+ session_rec = _session.actively_recording ();
+ } else {
+ session_rec = _session.get_record_enabled();
+ }
+
+ if (track_rec) {
+
+ if (!session_rec && roll && auto_input) {
+ return MonitoringDisk;
+ } else {
+ return software_monitor ? MonitoringInput : MonitoringSilence;
+ }
+
+ } else {
+
+ if (tape_machine_mode) {
+
+ return MonitoringDisk;
+
+ } else {
+
+ if (!roll && auto_input) {
+ return software_monitor ? MonitoringInput : MonitoringSilence;
+ } else {
+ return MonitoringDisk;
+ }
+
+ }
+ }
+
+ abort(); /* NOTREACHED */
+ return MonitoringSilence;
+}
+
+#endif
projects / ardour.git / blobdiff