/*
- 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
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-*/
+ * Copyright (C) 2000-2019 Paul Davis <paul@linuxaudiosystems.com>
+ * Copyright (C) 2006-2007 Sampo Savolainen <v2@iki.fi>
+ * Copyright (C) 2006-2014 David Robillard <d@drobilla.net>
+ * Copyright (C) 2006 Jesse Chappell <jesse@essej.net>
+ * Copyright (C) 2008-2012 Carl Hetherington <carl@carlh.net>
+ * Copyright (C) 2011-2012 Sakari Bergen <sakari.bergen@beatwaves.net>
+ * Copyright (C) 2013-2015 Nick Mainsbridge <mainsbridge@gmail.com>
+ * Copyright (C) 2013-2017 John Emmas <john@creativepost.co.uk>
+ * Copyright (C) 2013-2019 Robin Gareus <robin@gareus.org>
+ * Copyright (C) 2014-2018 Ben Loftis <ben@harrisonconsoles.com>
+ * Copyright (C) 2015-2018 Len Ovens <len@ovenwerks.net>
+ * Copyright (C) 2016 Julien "_FrnchFrgg_" RIVAUD <frnchfrgg@free.fr>
+ * Copyright (C) 2016 Tim Mayberry <mojofunk@gmail.com>
+ * Copyright (C) 2017-2018 Johannes Mueller <github@johannes-mueller.org>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
#ifdef WAF_BUILD
#include "libardour-config.h"
#include "ardour/delayline.h"
#include "ardour/midi_buffer.h"
#include "ardour/midi_port.h"
+#include "ardour/midi_track.h"
#include "ardour/monitor_control.h"
#include "ardour/monitor_processor.h"
#include "ardour/pannable.h"
#include "ardour/parameter_descriptor.h"
#include "ardour/phase_control.h"
#include "ardour/plugin_insert.h"
+#include "ardour/polarity_processor.h"
#include "ardour/port.h"
#include "ardour/port_insert.h"
#include "ardour/processor.h"
#include "ardour/profile.h"
+#include "ardour/revision.h"
#include "ardour/route.h"
#include "ardour/route_group.h"
#include "ardour/send.h"
, Muteable (sess, name)
, _active (true)
, _signal_latency (0)
- , _initial_delay (0)
- , _roll_delay (0)
, _disk_io_point (DiskIOPreFader)
, _pending_process_reorder (0)
, _pending_signals (0)
- , _pending_declick (true)
, _meter_point (MeterPostFader)
, _pending_meter_point (MeterPostFader)
- , _meter_type (MeterPeak)
, _denormal_protection (false)
, _recordable (true)
- , _silent (false)
- , _declickable (false)
, _have_internal_generator (false)
, _default_type (default_type)
+ , _loop_location (NULL)
, _track_number (0)
+ , _strict_io (false)
, _in_configure_processors (false)
, _initial_io_setup (false)
, _in_sidechain_setup (false)
- , _strict_io (false)
, _custom_meter_position_noted (false)
, _pinmgr_proxy (0)
, _patch_selector_dialog (0)
int
Route::init ()
{
- /* set default meter type */
- if (is_master()) {
- _meter_type = Config->get_meter_type_master ();
- }
- else if (dynamic_cast<Track*>(this)) {
- _meter_type = Config->get_meter_type_track ();
- } else {
- _meter_type = Config->get_meter_type_bus ();
- }
-
/* add standard controls */
_gain_control.reset (new GainControl (_session, GainAutomation));
*/
_amp.reset (new Amp (_session, X_("Fader"), _gain_control, true));
- add_processor (_amp, PostFader);
+ _amp->activate ();
+ _amp->set_owner (this);
+
+ _polarity.reset (new PolarityProcessor (_session, _phase_control));
+ _polarity->activate();
+ _polarity->set_owner (this);
if (is_monitor ()) {
_amp->set_display_name (_("Monitor"));
}
-#if 0 // not used - just yet
if (!is_master() && !is_monitor() && !is_auditioner()) {
- _delayline.reset (new DelayLine (_session, _name));
- add_processor (_delayline, PreFader);
+ _delayline.reset (new DelayLine (_session, name ()));
}
-#endif
/* and input trim */
*/
_trim->activate();
}
- else if (!dynamic_cast<Track*>(this) && ! ( is_monitor() || is_auditioner() )) {
+ else if (!dynamic_cast<Track*>(this) && ! (is_monitor() || is_auditioner())) {
/* regular bus */
_trim->activate();
}
_meter->set_display_to_user (false);
_meter->activate ();
+ /* set default meter type */
+ if (is_master()) {
+#ifdef MIXBUS
+ set_meter_type (MeterK14);
+#else
+ set_meter_type (Config->get_meter_type_master ());
+#endif
+ } else if (dynamic_cast<Track*>(this)) {
+ set_meter_type (Config->get_meter_type_track ());
+ } else {
+ set_meter_type (Config->get_meter_type_bus ());
+ }
+
_main_outs.reset (new Delivery (_session, _output, _pannable, _mute_master, _name, Delivery::Main));
_main_outs->activate ();
_monitor_control.reset (new MonitorProcessor (_session));
_monitor_control->activate ();
}
+ if (_presentation_info.flags() & PresentationInfo::FoldbackBus) {
+ panner_shell()->select_panner_by_uri ("http://ardour.org/plugin/panner_balance");
+ }
- /* now that we have _meter, its safe to connect to this */
-
+ /* now set up processor chain and invisible processors */
{
Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
- configure_processors (0);
+ {
+ Glib::Threads::RWLock::WriterLock lm (_processor_lock);
+ _processors.push_back (_amp);
+ }
+ if (!_session.loading()) {
+ configure_processors (0);
+ }
}
return 0;
}
string
-Route::ensure_track_or_route_name(string name, Session &session)
+Route::ensure_track_or_route_name (string newname) const
{
- string newname = name;
-
- while (!session.io_name_is_legal (newname)) {
+ while (!_session.io_name_is_legal (newname)) {
newname = bump_name_once (newname, ' ');
+ if (newname == name()) {
+ break;
+ }
}
-
return newname;
}
// _trim_control->route_set_value (val);
}
-void
-Route::maybe_declick (BufferSet&, samplecnt_t, int)
-{
- /* this is the "bus" implementation and they never declick.
- */
- return;
-}
-
/** Process this route for one (sub) cycle (process thread)
*
* @param bufs Scratch buffers to use for the signal path
void
Route::process_output_buffers (BufferSet& bufs,
samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes,
- int declick, bool gain_automation_ok)
+ bool gain_automation_ok, bool run_disk_reader)
{
/* Caller must hold process lock */
assert (!AudioEngine::instance()->process_lock().trylock());
Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
if (!lm.locked()) {
- // can this actually happen? functions calling process_output_buffers()
- // already take a reader-lock.
+ // can this actually happen?
+ // Places that need a WriterLock on (_processor_lock) must also take the process-lock.
bufs.silence (nframes, 0);
+ assert (0); // ...one way to find out.
return;
}
+ /* We should offset the route-owned ctrls by the given latency, however
+ * this only affects Mute. Other route-owned controls (solo, polarity..)
+ * are not automatable.
+ *
+ * Mute has its own issues since there's not a single mute-point,
+ * but in general
+ */
automation_run (start_sample, nframes);
+ if (_pannable) {
+ _pannable->automation_run (start_sample + _signal_latency, nframes);
+ }
+
/* figure out if we're going to use gain automation */
if (gain_automation_ok) {
_amp->set_gain_automation_buffer (_session.gain_automation_buffer ());
nframes);
}
- /* Tell main outs what to do about monitoring. We do this so that
- on a transition between monitoring states we get a de-clicking gain
- change in the _main_outs delivery, if config.get_use_monitor_fades()
- is true.
-
- We override this in the case where we have an internal generator.
- */
- bool silence = _have_internal_generator ? false : (monitoring_state () == MonitoringSilence);
-
- _main_outs->no_outs_cuz_we_no_monitor (silence);
-
- /* -------------------------------------------------------------------------------------------
- GLOBAL DECLICK (for transport changes etc.)
- ----------------------------------------------------------------------------------------- */
-
- maybe_declick (bufs, nframes, declick);
- _pending_declick = 0;
-
- /* -------------------------------------------------------------------------------------------
- DENORMAL CONTROL/PHASE INVERT
- ----------------------------------------------------------------------------------------- */
-
- if (!_phase_control->none()) {
-
- 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();
+ /* We align the playhead to output. The user hears what the clock says:
+ * When the playhead/clock says 1:00:00:00 the user will hear the audio sample
+ * at 1:00:00:00. sample_start will be [sample at] 1:00:00:00
+ *
+ * e.g. clock says Time T = 0, sample_start = 0
+ * Disk-read(play) -> latent-plugin (+10) -> fader-automation -> output (+5)
+ * -> total playback latency "disk -> out" is 15.
+ * -> at Time T= -15, the disk-reader reads sample T=0.
+ * By the Time T=0 is reached (dt=15 later) that sample is audible.
+ */
- if (_phase_control->inverted (chn)) {
- for (pframes_t nx = 0; nx < nframes; ++nx) {
- sp[nx] = -sp[nx];
- sp[nx] += 1.0e-27f;
- }
- } else {
- for (pframes_t nx = 0; nx < nframes; ++nx) {
- sp[nx] += 1.0e-27f;
- }
- }
- }
+ const double speed = (is_auditioner() ? 1.0 : _session.transport_speed ());
- } else {
+ const sampleoffset_t latency_offset = _signal_latency + _output->latency ();
+ if (speed < 0) {
+ /* when rolling backwards this can become negative */
+ start_sample -= latency_offset;
+ end_sample -= latency_offset;
+ } else {
+ start_sample += latency_offset;
+ end_sample += latency_offset;
+ }
- for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
- Sample* const sp = i->data();
+ /* Note: during intial pre-roll 'start_sample' as passed as argument can be negative.
+ * Functions calling process_output_buffers() will set "run_disk_reader"
+ * to false if the pre-roll count-down is larger than playback_latency ().
+ *
+ * playback_latency() is guarnteed to be <= _signal_latency + _output->latency ()
+ */
+ assert (!_disk_reader || !run_disk_reader || start_sample >= 0 || speed < 0);
- if (_phase_control->inverted (chn)) {
- for (pframes_t nx = 0; nx < nframes; ++nx) {
- sp[nx] = -sp[nx];
- }
- }
- }
+ /* however the disk-writer may need to pick up output from other tracks
+ * during pre-roll (in particular if this route has latent effects after the disk).
+ *
+ * e.g. track 1 play -> latency A --port--> track2 capture -> latency B ---> out
+ * total pre-roll = A + B.
+ *
+ * Note the disk-writer has built-in overlap detection (it's safe to run it early)
+ * given that
+ */
+ bool run_disk_writer = false;
+ if (_disk_writer && speed > 0) {
+ samplecnt_t latency_preroll = _session.remaining_latency_preroll ();
+ run_disk_writer = latency_preroll < nframes + (_signal_latency + _output->latency ());
+ if (end_sample - _disk_writer->input_latency () < _session.transport_sample ()) {
+ run_disk_writer = true;
}
+ }
- } else {
+ /* Tell main outs what to do about monitoring. We do this so that
+ * on a transition between monitoring states we get a de-clicking gain
+ * change in the _main_outs delivery, if config.get_use_monitor_fades()
+ * is true.
+ *
+ * We override this in the case where we have an internal generator.
+ *
+ * FIXME: when punching in/out this also depends on latency compensated time
+ * for this route. monitoring_state() does not currently handle that correctly,.
+ *
+ * Also during remaining_latency_preroll, transport_rolling () is false, but
+ * we may need to monitor disk instead.
+ */
+ const MonitorState ms = monitoring_state ();
+ const bool silent = _have_internal_generator ? false : (ms == MonitoringSilence);
- if (_denormal_protection || Config->get_denormal_protection()) {
+ _main_outs->no_outs_cuz_we_no_monitor (silent);
- for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
- Sample* const sp = i->data();
- for (pframes_t nx = 0; nx < nframes; ++nx) {
- sp[nx] += 1.0e-27f;
- }
- }
+ /* -------------------------------------------------------------------------------------------
+ DENORMAL CONTROL
+ ----------------------------------------------------------------------------------------- */
+ /* XXX We'll need to protect silent inputs as well as silent disk
+ * (when not monitoring input or monitoring disk and there's no region
+ * for a longer time).
+ *
+ * ...or simply drop that feature.
+ */
+ 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 (pframes_t nx = 0; nx < nframes; ++nx) {
+ sp[nx] += 1.0e-27f;
+ }
}
}
+
/* -------------------------------------------------------------------------------------------
and go ....
----------------------------------------------------------------------------------------- */
- /* set this to be true if the meter will already have been ::run() earlier */
- bool const meter_already_run = metering_state() == MeteringInput;
-
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) {
- if (meter_already_run && boost::dynamic_pointer_cast<PeakMeter> (*i)) {
- /* don't ::run() the meter, otherwise it will have its previous peak corrupted */
- continue;
- }
+ /* TODO check for split cycles here.
+ *
+ * start_frame, end_frame is adjusted by latency and may
+ * cross loop points.
+ */
#ifndef NDEBUG
/* if it has any inputs, make sure they match */
}
#endif
- /* should we NOT run plugins here if the route is inactive?
- do we catch route != active somewhere higher?
- */
+ bool re_inject_oob_data = false;
+ if ((*i) == _disk_reader) {
+ /* Well now, we've made it past the disk-writer and to the disk-reader.
+ * Time to decide what to do about monitoring.
+ *
+ * Even when not doing MonitoringDisk, we need to run the processors,
+ * so that it advances its internal buffers (IFF run_disk_reader is true).
+ *
+ */
+ if (ms == MonitoringDisk || ms == MonitoringSilence) {
+ /* this will clear out-of-band data, too (e.g. MIDI-PC, Panic etc.
+ * OOB data is written at the end of the cycle (nframes - 1),
+ * and jack does not re-order events, so we push them back later */
+ re_inject_oob_data = true;
+ bufs.silence (nframes, 0);
+ }
+ }
- if (boost::dynamic_pointer_cast<Send>(*i) != 0) {
- boost::dynamic_pointer_cast<Send>(*i)->set_delay_in(_signal_latency - latency);
+ double pspeed = speed;
+ if ((!run_disk_reader && (*i) == _disk_reader) || (!run_disk_writer && (*i) == _disk_writer)) {
+ /* run with speed 0, no-roll */
+ pspeed = 0;
}
- if (boost::dynamic_pointer_cast<PluginInsert>(*i) != 0) {
- 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);
+
+ if (speed < 0) {
+ (*i)->run (bufs, start_sample + latency, end_sample + latency, pspeed, nframes, *i != _processors.back());
+ } else {
+ (*i)->run (bufs, start_sample - latency, end_sample - latency, pspeed, 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());
+ /* Note: plugin latency may change. While the plugin does inform the session via
+ * processor_latency_changed(). But the session may not yet have gotten around to
+ * update the actual worste-case and update this track's _signal_latency.
+ *
+ * So there can be cases where adding up all latencies may not equal _signal_latency.
+ */
if ((*i)->active ()) {
- latency += (*i)->signal_latency ();
+ latency += (*i)->effective_latency ();
+ }
+
+ if (re_inject_oob_data) {
+ write_out_of_band_data (bufs, nframes);
+ }
+
+#if 0
+ if ((*i) == _delayline) {
+ latency += _delayline->delay ();
}
+#endif
}
}
_trim->setup_gain_automation (start, start + nframes, nframes);
latency = 0;
- const double speed = _session.transport_speed ();
+ bool seen_disk_io = false;
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
if (!include_endpoint && (*i) == endpoint) {
break;
}
+ if (!for_export && !seen_disk_io) {
+ if (boost::dynamic_pointer_cast<DiskReader> (*i)) {
+ seen_disk_io = true;
+ buffers.set_count ((*i)->output_streams());
+ }
+ continue;
+ }
+
/* if we're *not* exporting, stop processing if we come across a routing processor. */
if (!for_export && boost::dynamic_pointer_cast<PortInsert>(*i)) {
break;
*/
if ((*i) == _main_outs) {
assert ((*i)->does_routing());
- (*i)->run (buffers, start - latency, start - latency + nframes, speed, nframes, true);
+ (*i)->run (buffers, start - latency, start - latency + nframes, 1.0, nframes, true);
buffers.set_count ((*i)->output_streams());
}
if (!(*i)->does_routing() && !boost::dynamic_pointer_cast<PeakMeter>(*i)) {
(*i)->run (buffers, start - latency, start - latency + nframes, 1.0, nframes, true);
buffers.set_count ((*i)->output_streams());
- latency += (*i)->signal_latency ();
+ latency += (*i)->effective_latency ();
}
if ((*i) == endpoint) {
return latency;
}
+ bool seen_disk_io = false;
for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
if (!include_endpoint && (*i) == endpoint) {
break;
}
+ if (!for_export && !seen_disk_io) {
+ if (boost::dynamic_pointer_cast<DiskReader> (*i)) {
+ seen_disk_io = true;
+ }
+ continue;
+ }
if (!for_export && boost::dynamic_pointer_cast<PortInsert>(*i)) {
break;
}
break;
}
if (!(*i)->does_routing() && !boost::dynamic_pointer_cast<PeakMeter>(*i)) {
- latency += (*i)->signal_latency ();
+ latency += (*i)->effective_latency ();
}
if ((*i) == endpoint) {
break;
}
void
-Route::monitor_run (samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes, int declick)
+Route::monitor_run (samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes)
{
assert (is_monitor());
- BufferSet& bufs (_session.get_route_buffers (n_process_buffers()));
- fill_buffers_with_input (bufs, _input, nframes);
- passthru (bufs, start_sample, end_sample, nframes, declick, true);
+ Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
+ run_route (start_sample, end_sample, nframes, true, false);
}
void
-Route::passthru (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes, int declick, bool gain_automation_ok)
+Route::run_route (samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes, bool gain_automation_ok, bool run_disk_reader)
{
- _silent = false;
+ BufferSet& bufs (_session.get_route_buffers (n_process_buffers()));
+
+ fill_buffers_with_input (bufs, _input, nframes);
+
+ /* filter captured data before meter sees it */
+ filter_input (bufs);
if (is_monitor() && _session.listening() && !_session.is_auditioning()) {
bufs.silence (nframes, 0);
}
+ snapshot_out_of_band_data (nframes);
/* 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);
+ write_out_of_band_data (bufs, nframes);
/* run processor chain */
- process_output_buffers (bufs, start_sample, end_sample, nframes, declick, gain_automation_ok);
-}
+ process_output_buffers (bufs, start_sample, end_sample, nframes, gain_automation_ok, run_disk_reader);
-void
-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));
+ /* map events (e.g. MIDI-CC) back to control-parameters */
+ update_controls (bufs);
- bufs.set_count (_input->n_ports());
- write_out_of_band_data (bufs, start_sample, end_sample, nframes);
- process_output_buffers (bufs, start_sample, end_sample, nframes, declick, false);
+ flush_processor_buffers_locked (nframes);
}
void
processor->activate ();
}
+ boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (processor);
+ if (pi) {
+ pi->update_sidechain_name ();
+ }
+
return 0;
}
//A2 uses the "active" flag in the toplevel redirect node, not in the child plugin/IO
if (i != children.end()) {
if ((prop = (*i)->property (X_("active"))) != 0) {
- if ( string_to<bool> (prop->value()) && (!_session.get_bypass_all_loaded_plugins () || !processor->display_to_user () ) )
+ if (string_to<bool> (prop->value()) && (!_session.get_bypass_all_loaded_plugins () || !processor->display_to_user ()))
processor->activate();
else
processor->deactivate();
pi->set_strict_io (_strict_io);
+ if (is_auditioner()) {
+ continue;
+ }
+
PluginSetupOptions mask = None;
if (Config->get_ask_replace_instrument ()) {
mask |= CanReplace;
}
}
- _output->set_user_latency (0);
+ _output->unset_user_latency ();
}
reset_instrument_info ();
void
Route::clear_processors (Placement p)
{
- if (!_session.engine().connected()) {
+ if (!_session.engine().running()) {
return;
}
seen_amp = true;
}
- if ((*i) == _amp || (*i) == _meter || (*i) == _main_outs || (*i) == _delayline || (*i) == _trim) {
+ if (is_internal_processor (*i)) {
/* you can't remove these */
}
}
+bool
+Route::is_internal_processor (boost::shared_ptr<Processor> p) const
+{
+ if (p == _amp || p == _meter || p == _main_outs || p == _delayline || p == _trim || p == _polarity) {
+ return true;
+ }
+#ifdef MIXBUS
+ if (p == _ch_pre || p == _ch_post || p == _ch_eq || p == _ch_comp) {
+ return true;
+ }
+#endif
+ return false;
+}
+
int
Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err, bool need_process_lock)
{
/* these can never be removed */
- if (processor == _amp || processor == _meter || processor == _main_outs || processor == _delayline || processor == _trim) {
+ if (is_internal_processor (processor)) {
return 0;
}
- if (!_session.engine().connected()) {
+ if (!_session.engine().running()) {
return 1;
}
++i;
}
- _output->set_user_latency (0);
+ _output->unset_user_latency ();
}
if (!removed) {
Route::replace_processor (boost::shared_ptr<Processor> old, boost::shared_ptr<Processor> sub, ProcessorStreams* err)
{
/* these can never be removed */
- if (old == _amp || old == _meter || old == _main_outs || old == _delayline || old == _trim) {
+ if (is_internal_processor (old)) {
return 1;
}
/* and can't be used as substitute, either */
- if (sub == _amp || sub == _meter || sub == _main_outs || sub == _delayline || sub == _trim) {
+ if (is_internal_processor (sub)) {
return 1;
}
return 1;
}
- if (!AudioEngine::instance()->connected() || !old || !sub) {
+ if (!AudioEngine::instance()->running() || !old || !sub) {
return 1;
}
}
sub->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
- _output->set_user_latency (0);
+ _output->unset_user_latency ();
}
reset_instrument_info ();
{
ProcessorList deleted;
- if (!_session.engine().connected()) {
+ if (!_session.engine().running()) {
return 1;
}
/* these can never be removed */
- if (processor == _amp || processor == _meter || processor == _main_outs || processor == _delayline || processor == _trim) {
+ if (is_internal_processor (processor)) {
++i;
continue;
}
return 0;
}
- _output->set_user_latency (0);
+ _output->unset_user_latency ();
if (configure_processors_unlocked (err, &lm)) {
pstate.restore ();
bool
Route::add_remove_sidechain (boost::shared_ptr<Processor> proc, bool add)
{
+ if (_session.actively_recording ()) {
+ return false;
+ }
+
boost::shared_ptr<PluginInsert> pi;
if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
return false;
bool
Route::plugin_preset_output (boost::shared_ptr<Processor> proc, ChanCount outs)
{
+ if (_session.actively_recording ()) {
+ return false;
+ }
+
boost::shared_ptr<PluginInsert> pi;
if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
return false;
bool
Route::customize_plugin_insert (boost::shared_ptr<Processor> proc, uint32_t count, ChanCount outs, ChanCount sinks)
{
+ if (_session.actively_recording ()) {
+ return false;
+ }
boost::shared_ptr<PluginInsert> pi;
if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
return false;
XMLNode&
Route::get_state()
{
- return state(true);
+ return state (false);
}
XMLNode&
Route::get_template()
{
- return state(false);
+ return state (true);
}
XMLNode&
-Route::state(bool full_state)
+Route::state (bool save_template)
{
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;
+ if(save_template) {
+ XMLNode* child = node->add_child("ProgramVersion");
+ child->set_property("created-with", _session.created_with);
+
+ std::string modified_with = string_compose ("%1 %2", PROGRAM_NAME, revision);
+ child->set_property("modified-with", modified_with);
+ }
+
node->set_property (X_("id"), id ());
node->set_property (X_("name"), name());
node->set_property (X_("default-type"), _default_type);
node->set_property (X_("meter-point"), _meter_point);
node->set_property (X_("disk-io-point"), _disk_io_point);
- node->set_property (X_("meter-type"), _meter_type);
+ node->set_property (X_("meter-type"), _meter->meter_type ());
if (_route_group) {
node->set_property (X_("route-group"), _route_group->name());
node->add_child_nocopy (_solo_isolate_control->get_state ());
node->add_child_nocopy (_solo_safe_control->get_state ());
- node->add_child_nocopy (_input->state (full_state));
- node->add_child_nocopy (_output->state (full_state));
+ node->add_child_nocopy (_input->get_state ());
+ node->add_child_nocopy (_output->get_state ());
node->add_child_nocopy (_mute_master->get_state ());
node->add_child_nocopy (_mute_control->get_state ());
node->add_child_nocopy (_phase_control->get_state ());
- if (full_state) {
+ if (!skip_saving_automation) {
node->add_child_nocopy (Automatable::get_automation_xml_state ());
}
}
if (_pannable) {
- node->add_child_nocopy (_pannable->state (full_state));
+ node->add_child_nocopy (_pannable->get_state ());
}
{
Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
for (i = _processors.begin(); i != _processors.end(); ++i) {
- if (!full_state) {
+ if (*i == _delayline) {
+ continue;
+ }
+ if (save_template) {
/* template save: do not include internal sends functioning as
aux sends because the chance of the target ID
in the session where this template is used
}
}
}
- node->add_child_nocopy((*i)->state (full_state));
+ node->add_child_nocopy((*i)->get_state ());
}
}
set_disk_io_point (diop);
}
- node.get_property (X_("meter-type"), _meter_type);
+ MeterType meter_type;
+ if (node.get_property (X_("meter-type"), meter_type)) {
+ set_meter_type (meter_type);
+ }
_initial_io_setup = false;
}
}
+ if (_delayline) {
+ _delayline->set_name (name ());
+ }
+
return 0;
}
{
XMLNode* root = new XMLNode (X_("redirects"));
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- root->add_child_nocopy ((*i)->state (true));
+ root->add_child_nocopy ((*i)->get_state ());
}
return *root;
} else if (prop->value() == "meter") {
_meter->set_state (**niter, Stateful::current_state_version);
new_order.push_back (_meter);
+ } else if (prop->value() == "polarity") {
+ _polarity->set_state (**niter, Stateful::current_state_version);
+ new_order.push_back (_polarity);
} else if (prop->value() == "delay") {
- if (_delayline) {
- _delayline->set_state (**niter, Stateful::current_state_version);
- new_order.push_back (_delayline);
- }
+ // skip -- internal
} else if (prop->value() == "main-outs") {
_main_outs->set_state (**niter, Stateful::current_state_version);
} else if (prop->value() == "intreturn") {
*/
_processors = new_order;
- if (must_configure) {
+ /* When a required/existing internal processor is not in the list, it needs to
+ * be added via configure_processors() -> setup_invisible_processors()
+ */
+ if (_monitor_control) {
+ must_configure |= find (_processors.begin(), _processors.end(), _monitor_control) == _processors.end ();
+ }
+ if (_main_outs) {
+ must_configure |= find (_processors.begin(), _processors.end(), _main_outs) == _processors.end ();
+ }
+ if (_delayline) {
+ must_configure |= find (_processors.begin(), _processors.end(), _delayline) == _processors.end ();
+ }
+ if (_intreturn) {
+ must_configure |= find (_processors.begin(), _processors.end(), _intreturn) == _processors.end ();
+ }
+
+ if (must_configure && !_session.loading()) {
configure_processors_unlocked (0, &lm);
}
boost::bind (&Route::processor_selfdestruct, this, boost::weak_ptr<Processor> (processor)));
} else {
+ warning << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
return false;
}
return true;
}
-void
-Route::curve_reallocate ()
-{
-// _gain_automation_curve.finish_resize ();
-// _pan_automation_curve.finish_resize ();
-}
-
void
Route::silence (samplecnt_t nframes)
{
const samplepos_t now = _session.transport_sample ();
- if (!_silent) {
-
- _output->silence (nframes);
+ _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;
+ // update owned automated controllables
+ automation_run (now, nframes);
+ if (_pannable) {
+ _pannable->automation_run (now, nframes);
+ }
- if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
- /* evaluate automated automation controls */
- pi->automation_run (now, nframes);
- /* skip plugins, they don't need anything when we're not active */
- continue;
- }
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ boost::shared_ptr<PluginInsert> pi;
- (*i)->silence (nframes, now);
+ if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
+ /* evaluate automated automation controls */
+ pi->automation_run (now, nframes);
+ /* skip plugins, they don't need anything when we're not active */
+ continue;
}
- if (nframes == _session.get_block_size()) {
- // _silent = true;
- }
+ (*i)->silence (nframes, now);
}
}
return 0;
}
+int
+Route::add_foldback_send (boost::shared_ptr<Route> route)
+{
+ assert (route != _session.monitor_out ());
+ boost::shared_ptr<Processor> before = before_processor_for_placement (PreFader);
+
+ {
+ Glib::Threads::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) {
+ /* already listening via the specified IO: do nothing */
+ return 0;
+ }
+ }
+ }
+
+ try {
+
+ boost::shared_ptr<InternalSend> listener;
+
+ {
+ Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+ listener.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), route, Delivery::Foldback));
+ }
+
+ listener->panner_shell()->set_linked_to_route (false);
+ add_processor (listener, before);
+
+ } catch (failed_constructor& err) {
+ return -1;
+ }
+ _session.FBSendsChanged ();
+
+ return 0;
+}
+
void
Route::remove_aux_or_listen (boost::shared_ptr<Route> route)
{
ProcessorStreams err;
ProcessorList::iterator tmp;
+ bool do_fb_signal = false;
{
Glib::Threads::RWLock::ReaderLock rl(_processor_lock);
boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
if (d && d->target_route() == route) {
+ boost::shared_ptr<Send> snd = boost::dynamic_pointer_cast<Send>(d);
+ if (snd && snd->is_foldback()) {
+ do_fb_signal = true;
+ }
+
rl.release ();
if (remove_processor (*x, &err, false) > 0) {
rl.acquire ();
/* list could have been demolished while we dropped the lock
so start over.
*/
- if (_session.engine().connected()) {
+ if (_session.engine().running()) {
/* i/o processors cannot be removed if the engine is not running
* so don't live-loop in case the engine is N/A or dies
*/
}
}
}
+ if (do_fb_signal) {
+ _session.FBSendsChanged ();
+ }
+
}
void
bool
Route::direct_feeds_according_to_reality (boost::shared_ptr<Route> other, bool* via_send_only)
{
- DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
+ DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds from %1 (-> %2)?\n", _name, other->name()));
if (other->all_inputs().fed_by (_output)) {
- DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
+ DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS to %1\n", other->name()));
if (via_send_only) {
*via_send_only = false;
}
} else {
DEBUG_TRACE (DEBUG::Graph, string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
}
- } else {
- DEBUG_TRACE (DEBUG::Graph, string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
}
-
}
DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdoes NOT feed %1\n", other->name()));
void
Route::non_realtime_transport_stop (samplepos_t now, bool flush)
{
- {
- Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
-
- Automatable::non_realtime_transport_stop (now, flush);
+ Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
- for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ Automatable::non_realtime_transport_stop (now, flush);
- if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && flush)) {
- (*i)->flush ();
- }
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- (*i)->non_realtime_transport_stop (now, flush);
+ if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && flush)) {
+ (*i)->flush ();
}
+
+ (*i)->non_realtime_transport_stop (now, flush);
}
+}
+
+void
+Route::realtime_handle_transport_stopped ()
+{
+ Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
- _roll_delay = _initial_delay;
+ /* currently only by Plugin, queue note-off events */
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ (*i)->realtime_handle_transport_stopped ();
+ }
}
+
void
Route::input_change_handler (IOChange change, void * /*src*/)
{
+ if (_session.loading()) {
+ return;
+ }
+
if ((change.type & IOChange::ConfigurationChanged)) {
/* This is called with the process lock held if change
contains ConfigurationChanged
*/
configure_processors (0);
- _phase_control->resize (_input->n_ports().n_audio ());
io_changed (); /* EMIT SIGNAL */
}
}
}
-int
-Route::no_roll (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, bool session_state_changing)
+void
+Route::flush_processors ()
{
- Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
+ Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
- if (!lm.locked()) {
- return 0;
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ (*i)->flush ();
}
+}
- if (!_active) {
- silence_unlocked (nframes);
- return 0;
+samplecnt_t
+Route::playback_latency (bool incl_downstream) const
+{
+ samplecnt_t rv;
+ if (_disk_reader) {
+ rv = _disk_reader->output_latency ();
+ } else {
+ rv = _signal_latency;
}
-
- if (session_state_changing) {
- if (_session.transport_speed() != 0.0f) {
- /* we're rolling but some state is changing (e.g. our diskstream contents)
- so we cannot use them. Be silent till this is over.
-
- XXX note the absurdity of ::no_roll() being called when we ARE rolling!
- */
- silence_unlocked (nframes);
- return 0;
- }
- /* we're really not rolling, so we're either delivery silence or actually
- monitoring, both of which are safe to do while session_state_changing is true.
- */
+ if (incl_downstream) {
+ rv += _output->connected_latency (true);
+ } else {
+ rv += _output->latency ();
}
+ return rv;
+}
- BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
-
- fill_buffers_with_input (bufs, _input, nframes);
-
- if (_meter_point == MeterInput) {
- _meter->run (bufs, start_sample, end_sample, 0.0, nframes, true);
+pframes_t
+Route::latency_preroll (pframes_t nframes, samplepos_t& start_sample, samplepos_t& end_sample)
+{
+ samplecnt_t latency_preroll = _session.remaining_latency_preroll ();
+ if (latency_preroll == 0) {
+ return nframes;
+ }
+ if (!_disk_reader) {
+ start_sample -= latency_preroll;
+ end_sample -= latency_preroll;
+ return nframes;
}
- passthru (bufs, start_sample, end_sample, nframes, 0, true);
-
- flush_processor_buffers_locked (nframes);
+ if (latency_preroll > playback_latency ()) {
+ no_roll_unlocked (nframes, start_sample - latency_preroll, end_sample - latency_preroll, false);
+ return 0;
+ }
- return 0;
+ start_sample -= latency_preroll;
+ end_sample -= latency_preroll;
+ return nframes;
}
int
-Route::roll (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, int declick, bool& need_butler)
+Route::roll (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, bool& need_butler)
{
Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
if (!_active) {
silence_unlocked (nframes);
- if (_meter_point == MeterInput && ((_monitoring_control->monitoring_choice() & MonitorInput) || (!_disk_writer || _disk_writer->record_enabled()))) {
- _meter->reset();
- }
+ _meter->reset();
return 0;
}
- _silent = false;
+ if ((nframes = latency_preroll (nframes, start_sample, end_sample)) == 0) {
+ return 0;
+ }
- BufferSet& bufs = _session.get_route_buffers (n_process_buffers ());
+ run_route (start_sample, end_sample, nframes, (!_disk_writer || !_disk_writer->record_enabled()) && _session.transport_rolling(), true);
- fill_buffers_with_input (bufs, _input, nframes);
+ if ((_disk_reader && _disk_reader->need_butler()) || (_disk_writer && _disk_writer->need_butler())) {
+ need_butler = true;
+ }
+ return 0;
+}
- /* filter captured data before meter sees it */
- filter_input (bufs);
+int
+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);
- 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);
+ if (!lm.locked()) {
+ return 0;
}
- passthru (bufs, start_sample, end_sample, nframes, declick, ((_disk_writer && !_disk_writer->record_enabled()) && _session.transport_rolling()));
+ return no_roll_unlocked (nframes, start_sample, end_sample, session_state_changing);
+}
- if ((_disk_reader && _disk_reader->need_butler()) || (_disk_writer && _disk_writer->need_butler())) {
- need_butler = true;
+int
+Route::no_roll_unlocked (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, bool session_state_changing)
+{
+ /* Must be called with the processor lock held */
+
+ if (!_active) {
+ silence_unlocked (nframes);
+ _meter->reset();
+ return 0;
}
- flush_processor_buffers_locked (nframes);
+ if (session_state_changing) {
+ if (_session.transport_speed() != 0.0f) {
+ /* we're rolling but some state is changing (e.g. our diskstream contents)
+ so we cannot use them. Be silent till this is over.
+ XXX note the absurdity of ::no_roll() being called when we ARE rolling!
+ */
+ silence_unlocked (nframes);
+ _meter->reset();
+ 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.
+ */
+ }
+
+ run_route (start_sample, end_sample, nframes, false, false);
return 0;
}
return 0;
}
-void
-Route::flush_processors ()
-{
- Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
-
- for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- (*i)->flush ();
- }
-}
-
#ifdef __clang__
__attribute__((annotate("realtime")))
#endif
}
if (force || !AudioEngine::instance()->running()) {
- Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
- Glib::Threads::RWLock::WriterLock lm (_processor_lock);
- _pending_meter_point = p;
+ bool meter_visibly_changed = false;
+ {
+ Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
+ Glib::Threads::RWLock::WriterLock lm (_processor_lock);
+ _pending_meter_point = p;
+ if (set_meter_point_unlocked ()) {
+ meter_visibly_changed = true;
+ }
+ }
_meter->emit_configuration_changed();
meter_change (); /* EMIT SIGNAL */
- if (set_meter_point_unlocked()) {
- processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, true)); /* EMIT SIGNAL */
- } else {
- processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, false)); /* EMIT SIGNAL */
- }
+ processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
} else {
_pending_meter_point = p;
}
Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
Glib::Threads::RWLock::WriterLock lw (_processor_lock);
- // this aligns all tracks; but not tracks + busses
- samplecnt_t latency = _session.worst_track_roll_delay ();
- assert (latency >= _initial_delay);
- _capturing_processor.reset (new CapturingProcessor (_session, latency - _initial_delay));
- _capturing_processor->activate ();
-
+ /* Align all tracks for stem-export w/o processing.
+ * Compensate for all plugins between the this route's disk-reader
+ * and the common final downstream output (ie alignment point for playback).
+ */
+ _capturing_processor.reset (new CapturingProcessor (_session, playback_latency (true)));
configure_processors_unlocked (0, &lw);
-
+ _capturing_processor->activate ();
}
return _capturing_processor;
}
samplecnt_t
-Route::update_signal_latency (bool set_initial_delay)
+Route::update_signal_latency (bool apply_to_delayline)
{
+ // TODO: bail out if !active() and set/assume _signal_latency = 0,
+ // here or in Session::* ? -> also zero send latencies,
+ // and make sure that re-enabling a route updates things again...
+
+ samplecnt_t capt_lat_in = _input->connected_latency (false);
+ samplecnt_t play_lat_out = _output->connected_latency (true);
+
Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
- samplecnt_t l_in = _input->latency ();
- samplecnt_t l_out = 0;
+ samplecnt_t l_in = 0;
+ samplecnt_t l_out = _output->effective_latency ();
+ for (ProcessorList::reverse_iterator i = _processors.rbegin(); i != _processors.rend(); ++i) {
+ if (boost::shared_ptr<LatentSend> snd = boost::dynamic_pointer_cast<LatentSend> (*i)) {
+ snd->set_delay_in (l_out + _output->latency());
+ }
- for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- if ((*i)->active ()) {
- l_out += (*i)->signal_latency ();
- l_in += (*i)->signal_latency ();
+ if (boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) {
+ if (boost::shared_ptr<IO> pio = pi->sidechain_input ()) {
+ samplecnt_t lat = l_out + _output->latency();
+ pio->set_private_port_latencies (lat, true);
+ pio->set_public_port_latencies (lat, true);
+ }
}
- (*i)->set_input_latency (l_in);
(*i)->set_output_latency (l_out);
+ if ((*i)->active ()) { // XXX
+ l_out += (*i)->effective_latency ();
+ }
}
- l_out += _output->user_latency();
+ DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l_out));
+
+ _signal_latency = l_out;
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- (*i)->set_output_latency (l_out - (*i)->output_latency ());
- }
- DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l_out));
+ /* set sidechain, send and insert port latencies */
+ if (boost::shared_ptr<PortInsert> pi = boost::dynamic_pointer_cast<PortInsert> (*i)) {
+ if (pi->input ()) {
+ /* propagate playback latency from output to input */
+ pi->input ()->set_private_port_latencies (play_lat_out + l_in, true);
+ }
+ if (pi->output ()) {
+ /* propagate capture latency from input to output */
+ pi->output ()->set_private_port_latencies (capt_lat_in + l_in, false);
+ }
- _signal_latency = l_out;
+ } else if (boost::shared_ptr<Send> snd = boost::dynamic_pointer_cast<Send> (*i)) {
+ if (snd->output ()) {
+ /* set capture latency */
+ snd->output ()->set_private_port_latencies (capt_lat_in + l_in, false);
+ /* take send-target's playback latency into account */
+ snd->set_delay_out (snd->output ()->connected_latency (true));
+ /* InternalReturn::set_playback_offset() below, also calls set_delay_out() */
+ }
+ }
+
+ (*i)->set_input_latency (l_in);
+ (*i)->set_playback_offset (_signal_latency + _output->latency ());
+ (*i)->set_capture_offset (_input->latency ());
+ if ((*i)->active ()) {
+ l_in += (*i)->effective_latency ();
+ }
+ }
lm.release ();
- if (set_initial_delay) {
+ if (apply_to_delayline) {
/* see also Session::post_playback_latency() */
- set_latency_compensation (_session.worst_track_latency () + _session.worst_track_out_latency () - output ()->latency ());
+ apply_latency_compensation ();
}
if (_signal_latency != l_out) {
}
void
-Route::set_latency_compensation (samplecnt_t longest_session_latency)
+Route::apply_latency_compensation ()
{
- samplecnt_t old = _initial_delay;
- assert (!_disk_reader || _disk_reader->output_latency () <= _signal_latency);
+ if (_delayline) {
+ samplecnt_t old = _delayline->delay ();
- if (_disk_reader && _signal_latency < longest_session_latency) {
- _initial_delay = longest_session_latency - (_signal_latency - _disk_reader->input_latency ());
- } else {
- _initial_delay = 0;
- }
+ samplecnt_t play_lat_in = _input->connected_latency (true);
+ samplecnt_t play_lat_out = _output->connected_latency (true);
+ samplecnt_t latcomp = play_lat_in - play_lat_out - _signal_latency;
- DEBUG_TRACE (DEBUG::Latency, string_compose (
- "%1: compensate for maximum latency of %2,"
- "given own latency of %3, using initial delay of %4\n",
- name(), longest_session_latency, _signal_latency, _initial_delay));
+#if 0 // DEBUG
+ samplecnt_t capt_lat_in = _input->connected_latency (false);
+ samplecnt_t capt_lat_out = _output->connected_latency (false);
+ samplecnt_t latcomp_capt = capt_lat_out - capt_lat_in - _signal_latency;
- if (_initial_delay != old) {
- initial_delay_changed (); /* EMIT SIGNAL */
- }
+ cout << "ROUTE " << name() << " delay for " << latcomp << " (c: " << latcomp_capt << ")" << endl;
+#endif
+
+ _delayline->set_delay (latcomp > 0 ? latcomp : 0);
- if (_session.transport_stopped()) {
- _roll_delay = _initial_delay;
+ if (old != _delayline->delay ()) {
+ signal_latency_updated (); /* EMIT SIGNAL */
+ }
}
}
(*i)->protect_automation();
}
-/** @param declick 1 to set a pending declick fade-in,
- * -1 to set a pending declick fade-out
- */
-void
-Route::set_pending_declick (int declick)
-{
- if (_declickable) {
- /* this call is not allowed to turn off a pending declick */
- if (declick) {
- _pending_declick = declick;
- }
- } else {
- _pending_declick = 0;
- }
-}
-
/** Shift automation forwards from a particular place, thereby inserting time.
* Adds undo commands for any shifts that are performed.
*
void
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, samples);
- XMLNode &after = gc->alist()->get_state ();
- _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
- }
-
- /* gain automation */
- {
- boost::shared_ptr<AutomationControl> gc = _trim->gain_control();
-
- XMLNode &before = gc->alist()->get_state ();
- gc->alist()->shift (pos, samples);
- XMLNode &after = gc->alist()->get_state ();
- _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
- }
-
- // TODO mute automation ??
-
/* pan automation */
if (_pannable) {
ControlSet::Controls& c (_pannable->controls());
}
}
- /* redirect automation */
+ /* TODO mute automation, MuteControl */
+
+ /* processor automation (incl. gain, trim,..) */
{
Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
if (ac) {
boost::shared_ptr<AutomationList> al = ac->alist();
+ if (al->empty ()) {
+ continue;
+ }
XMLNode &before = al->get_state ();
al->shift (pos, samples);
XMLNode &after = al->get_state ();
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));
+ XMLNode& node (state (true));
node.set_property (X_("name"), name);
node.remove_nodes (X_("description"));
return true;
}
- string name = Route::ensure_track_or_route_name (str, _session);
- SessionObject::set_name (name);
+ string newname = Route::ensure_track_or_route_name (str);
+
+ if (newname == name()) {
+ return true;
+ }
+
+ SessionObject::set_name (newname);
+
+ for (uint32_t n = 0 ; ; ++n) {
+ boost::shared_ptr<PluginInsert> pi = boost::static_pointer_cast<PluginInsert> (nth_plugin (n));
+ if (!pi) {
+ break;
+ }
+ pi->update_sidechain_name ();
+ }
- bool ret = (_input->set_name(name) && _output->set_name(name));
+ bool ret = (_input->set_name(newname) && _output->set_name(newname));
if (ret) {
/* rename the main outs. Leave other IO processors
*/
if (_main_outs) {
- if (_main_outs->set_name (name)) {
+ if (_main_outs->set_name (newname)) {
/* XXX returning false here is stupid because
we already changed the route name.
*/
* @param name New name.
*/
void
-Route::set_name_in_state (XMLNode& node, string const & name, bool rename_playlist)
+Route::set_name_in_state (XMLNode& node, string const & name)
{
node.set_property (X_("name"), name);
if ((*i)->get_property (X_("role"), str) && str == X_("Main")) {
(*i)->set_property (X_("name"), name);
}
-
- } else if ((*i)->name() == X_("Diskstream")) {
-
- if (rename_playlist) {
- (*i)->set_property (X_("playlist"), name + ".1");
- }
- (*i)->set_property (X_("name"), name);
-
}
}
}
for (i = _processors.begin(); i != _processors.end(); ++i) {
if (boost::dynamic_pointer_cast<Send> (*i)) {
- if ((*i)->name().find (_("Monitor")) == 0) {
+ if ((*i) == _monitor_send) {
/* send to monitor section is not considered
- to be an accessible send.
- */
+ * to be an accessible send.
+ */
continue;
}
*/
for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
+
if ((*i)->active ()) {
- own_latency += (*i)->signal_latency ();
+ own_latency += (*i)->effective_latency ();
}
}
void
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.
- */
-
- LatencyRange range;
-
- range.min = value;
- range.max = value;
-
- {
- const PortSet& ports (_input->ports());
- for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
- p->set_public_latency_range (range, playback);
+ /* publish private latencies */
+ Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
+ for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*i);
+ if (!iop) {
+ continue;
}
- }
-
- {
- const PortSet& ports (_output->ports());
- for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
- p->set_public_latency_range (range, playback);
+ if (iop->input ()) {
+ iop->input ()->set_public_port_latencies (iop->input()->latency(), true);
+ }
+ if (iop->output ()) {
+ iop->output ()->set_public_port_latencies (iop->output()->latency(), false);
}
}
+
+ /* this is called to set the JACK-visible port latencies, which take
+ * latency compensation into account.
+ */
+ _input->set_public_port_latencies (value, playback);
+ _output->set_public_port_latencies (value, playback);
}
/** Put the invisible processors in the right place in _processors.
*/
ProcessorList new_processors;
+ ProcessorList foldback_sends;
ProcessorList::iterator dr;
ProcessorList::iterator dw;
/* find visible processors */
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ boost::shared_ptr<Send> auxsnd = boost::dynamic_pointer_cast<Send> ((*i));
if ((*i)->display_to_user ()) {
new_processors.push_back (*i);
}
+ else if (auxsnd && auxsnd->is_foldback ()) {
+ foldback_sends.push_back (*i);
+ }
}
/* find the amp */
ProcessorList::iterator after_amp = amp;
++after_amp;
- /* METER */
+ /* Pre-fader METER */
- if (_meter) {
- switch (_meter_point) {
- case MeterInput:
- assert (!_meter->display_to_user ());
- new_processors.push_front (_meter);
- break;
- case MeterPreFader:
- assert (!_meter->display_to_user ());
- new_processors.insert (amp, _meter);
- break;
- case MeterPostFader:
- /* do nothing here */
- break;
- case MeterOutput:
- /* do nothing here */
- break;
- case MeterCustom:
- /* the meter is visible, so we don't touch it here */
- break;
- }
+ if (_meter && _meter_point == MeterPreFader) {
+ /* add meter just before the fader */
+ assert (!_meter->display_to_user ());
+ new_processors.insert (amp, _meter);
}
/* MAIN OUTS */
new_processors.insert (meter_point, _meter);
}
+ /* Foldback Sends */
+
+ for (ProcessorList::iterator i = foldback_sends.begin(); i != foldback_sends.end(); ++i) {
+ new_processors.insert (amp, (*i));
+ }
+
/* MONITOR SEND */
if (_monitor_send && !is_monitor ()) {
}
}
-#if 0 // not used - just yet
- if (!is_master() && !is_monitor() && !is_auditioner()) {
- new_processors.push_front (_delayline);
- }
-#endif
-
/* MONITOR CONTROL */
if (_monitor_control && is_monitor ()) {
new_processors.push_front (_intreturn);
}
- /* EXPORT PROCESSOR */
-
/* DISK READER & WRITER (for Track objects) */
if (_disk_reader || _disk_writer) {
}
}
+ /* ensure dist-writer is before disk-reader */
+ if (_disk_reader && _disk_writer) {
+ ProcessorList::iterator reader_pos = find (new_processors.begin(), new_processors.end(), _disk_reader);
+ ProcessorList::iterator writer_pos = find (new_processors.begin(), new_processors.end(), _disk_writer);
+ assert (reader_pos != new_processors.end ());
+ assert (writer_pos != new_processors.end ());
+ if (std::distance (new_processors.begin(), reader_pos) < std::distance (new_processors.begin(), writer_pos)) {
+ new_processors.erase (reader_pos);
+ assert (writer_pos == find (new_processors.begin(), new_processors.end(), _disk_writer));
+ new_processors.insert (++writer_pos, _disk_reader);
+ }
+ }
+
+ /* EXPORT PROCESSOR */
if (_capturing_processor) {
assert (!_capturing_processor->display_to_user ());
ProcessorList::iterator reader_pos = find (new_processors.begin(), new_processors.end(), _disk_reader);
/* insert after disk-reader */
new_processors.insert (++reader_pos, _capturing_processor);
} else {
- new_processors.push_front (_capturing_processor);
+ ProcessorList::iterator return_pos = find (new_processors.begin(), new_processors.end(), _intreturn);
+ /* insert after return */
+ if (return_pos != new_processors.end()) {
+ new_processors.insert (++return_pos, _capturing_processor);
+ } else {
+ new_processors.push_front (_capturing_processor);
+ }
+ }
+ }
+
+ /* Polarity Invert */
+ if (_polarity) {
+ 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, _polarity);
+ } else {
+ ProcessorList::iterator return_pos = find (new_processors.begin(), new_processors.end(), _intreturn);
+ /* insert after return */
+ if (return_pos != new_processors.end()) {
+ new_processors.insert (++return_pos, _polarity);
+ } else {
+ new_processors.push_front (_polarity);
+ }
+ }
+ }
+
+ /* Input meter */
+ if (_meter && _meter_point == MeterInput) {
+ /* add meter just before the disk-writer (if any)
+ * otherwise at the top, but after the latency delayline
+ * (perhaps it should also be after intreturn on busses ??)
+ */
+ assert (!_meter->display_to_user ());
+ ProcessorList::iterator writer_pos = find (new_processors.begin(), new_processors.end(), _disk_writer);
+ if (writer_pos != new_processors.end()) {
+ /* insert before disk-writer */
+ new_processors.insert (writer_pos, _meter);
+ } else {
+ ProcessorList::iterator return_pos = find (new_processors.begin(), new_processors.end(), _intreturn);
+ /* insert after return */
+ if (return_pos != new_processors.end()) {
+ new_processors.insert (++return_pos, _meter);
+ } else {
+ new_processors.push_front (_meter);
+ }
}
}
+ if (!is_master() && !is_monitor() && !is_auditioner()) {
+ ProcessorList::iterator reader_pos = find (new_processors.begin(), new_processors.end(), _disk_reader);
+ if (reader_pos != new_processors.end()) {
+ /* insert before disk-reader */
+ new_processors.insert (reader_pos, _delayline);
+ } else {
+ new_processors.push_front (_delayline);
+ }
+ }
_processors = new_processors;
return boost::shared_ptr<Processor>();
}
-
+bool
+Route::is_track()
+{
+ return dynamic_cast<Track*>(this) != 0;
+}
void
Route::non_realtime_locate (samplepos_t pos)
_pannable->non_realtime_locate (pos);
}
- if (_delayline.get()) {
- _delayline.get()->flush();
+#if 0 // XXX mayhaps clear delayline here (and at stop?)
+ if (_delayline) {
+ _delayline->flush ();
}
+#endif
{
//Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
(*i)->non_realtime_locate (pos);
}
}
- _roll_delay = _initial_delay;
}
void
Route::pan_azimuth_control() const
{
#ifdef MIXBUS
-# undef MIXBUS_PORTS_H
-# include "../../gtk2_ardour/mixbus_ports.h"
- boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
- if (!plug) {
- return boost::shared_ptr<AutomationControl>();
+ if (_mixbus_send) {
+ return _mixbus_send->master_pan_ctrl ();
}
- return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_channel_post_pan)));
+ return boost::shared_ptr<AutomationControl>();
#else
if (!_pannable || !panner()) {
return boost::shared_ptr<AutomationControl>();
#ifdef MIXBUS
if (mixbus() && _ch_pre) {
//mono blend
- return boost::dynamic_pointer_cast<ARDOUR::AutomationControl>(_ch_pre->control(Evoral::Parameter(PluginAutomation, 0, 5)));
+ return boost::dynamic_pointer_cast<ARDOUR::AutomationControl>(_ch_pre->control(Evoral::Parameter(PluginAutomation, 0, 1)));
}
#endif
if (Profile->get_mixbus() || !_pannable || !panner()) {
Route::eq_gain_controllable (uint32_t band) const
{
#ifdef MIXBUS
- boost::shared_ptr<PluginInsert> eq = ch_eq();
+ boost::shared_ptr<PluginInsert> eq = _ch_eq;
if (!eq) {
return boost::shared_ptr<AutomationControl>();
return boost::shared_ptr<AutomationControl>();
}
- boost::shared_ptr<PluginInsert> eq = ch_eq();
+ boost::shared_ptr<PluginInsert> eq = _ch_eq;
if (!eq) {
return boost::shared_ptr<AutomationControl>();
Route::eq_shape_controllable (uint32_t band) const
{
#ifdef MIXBUS32C
- boost::shared_ptr<PluginInsert> eq = ch_eq();
if (is_master() || mixbus() || !eq) {
return boost::shared_ptr<AutomationControl>();
}
Route::eq_enable_controllable () const
{
#ifdef MIXBUS
- boost::shared_ptr<PluginInsert> eq = ch_eq();
+ boost::shared_ptr<PluginInsert> eq = _ch_eq;
if (!eq) {
return boost::shared_ptr<AutomationControl>();
Route::filter_freq_controllable (bool hpf) const
{
#ifdef MIXBUS
- boost::shared_ptr<PluginInsert> eq = ch_eq();
+ boost::shared_ptr<PluginInsert> eq = _ch_eq;
if (is_master() || mixbus() || !eq) {
return boost::shared_ptr<AutomationControl>();
Route::filter_enable_controllable (bool) const
{
#ifdef MIXBUS32C
- boost::shared_ptr<PluginInsert> eq = ch_eq();
+ boost::shared_ptr<PluginInsert> eq = _ch_eq;
if (is_master() || mixbus() || !eq) {
return boost::shared_ptr<AutomationControl>();
#endif
}
+boost::shared_ptr<AutomationControl>
+Route::tape_drive_controllable () const
+{
+#ifdef MIXBUS
+ if (_ch_pre) {
+ return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (_ch_pre->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 0)));
+ }
+#endif
+ return boost::shared_ptr<AutomationControl>();
+}
+
+boost::shared_ptr<ReadOnlyControl>
+Route::tape_drive_mtr_controllable () const
+{
+#ifdef MIXBUS
+ if (_ch_pre) {
+ return _ch_pre->control_output (is_master() ? 1 : 2);
+ }
+#endif
+ return boost::shared_ptr<ReadOnlyControl>();
+}
+
+boost::shared_ptr<ReadOnlyControl>
+Route::master_correlation_mtr_controllable (bool mm) const
+{
+#ifdef MIXBUS
+ if (is_master() && _ch_post) {
+ return _ch_post->control_output (mm ? 4 : 3);
+ }
+#endif
+ return boost::shared_ptr<ReadOnlyControl>();
+}
+
+boost::shared_ptr<AutomationControl>
+Route::master_limiter_enable_controllable () const
+{
+#ifdef MIXBUS
+ if (is_master() && _ch_post) {
+ return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (_ch_post->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 1)));
+ }
+#endif
+ return boost::shared_ptr<AutomationControl>();
+}
+
+boost::shared_ptr<ReadOnlyControl>
+Route::master_limiter_mtr_controllable () const
+{
+#ifdef MIXBUS
+ if (is_master() && _ch_post) {
+ return _ch_post->control_output (2);
+ }
+#endif
+ return boost::shared_ptr<ReadOnlyControl>();
+}
+
+boost::shared_ptr<ReadOnlyControl>
+Route::master_k_mtr_controllable () const
+{
+#ifdef MIXBUS
+ if (is_master() && _ch_post) {
+ return _ch_post->control_output (5);
+ }
+#endif
+ return boost::shared_ptr<ReadOnlyControl>();
+}
+
string
Route::eq_band_name (uint32_t band) const
{
} else {
switch (band) {
case 0: return _("lo");
- case 1: return _("lo mid");
- case 2: return _("hi mid");
+ case 1: return _("lm");
+ case 2: return _("hm");
case 3: return _("hi");
default: return string();
}
Route::comp_enable_controllable () const
{
#ifdef MIXBUS
- boost::shared_ptr<PluginInsert> comp = ch_comp();
-
- if (!comp) {
- return boost::shared_ptr<AutomationControl>();
+ if (_ch_comp) {
+ return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (_ch_comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 1)));
}
-
- return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 1)));
-#else
- return boost::shared_ptr<AutomationControl>();
#endif
+ return boost::shared_ptr<AutomationControl>();
}
boost::shared_ptr<AutomationControl>
Route::comp_threshold_controllable () const
{
#ifdef MIXBUS
- boost::shared_ptr<PluginInsert> comp = ch_comp();
-
- if (!comp) {
- return boost::shared_ptr<AutomationControl>();
+ if (_ch_comp) {
+ return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (_ch_comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
}
-
- return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
-
-#else
- return boost::shared_ptr<AutomationControl>();
#endif
+ return boost::shared_ptr<AutomationControl>();
}
boost::shared_ptr<AutomationControl>
Route::comp_speed_controllable () const
{
#ifdef MIXBUS
- boost::shared_ptr<PluginInsert> comp = ch_comp();
-
- if (!comp) {
- return boost::shared_ptr<AutomationControl>();
+ if (_ch_comp) {
+ return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (_ch_comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 3)));
}
-
- return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 3)));
-#else
- return boost::shared_ptr<AutomationControl>();
#endif
+ return boost::shared_ptr<AutomationControl>();
}
boost::shared_ptr<AutomationControl>
Route::comp_mode_controllable () const
{
#ifdef MIXBUS
- boost::shared_ptr<PluginInsert> comp = ch_comp();
-
- if (!comp) {
- return boost::shared_ptr<AutomationControl>();
+ if (_ch_comp) {
+ return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (_ch_comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 4)));
}
-
- return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 4)));
-#else
- return boost::shared_ptr<AutomationControl>();
#endif
+ return boost::shared_ptr<AutomationControl>();
}
boost::shared_ptr<AutomationControl>
Route::comp_makeup_controllable () const
{
#ifdef MIXBUS
- boost::shared_ptr<PluginInsert> comp = ch_comp();
-
- if (!comp) {
- return boost::shared_ptr<AutomationControl>();
+ if (_ch_comp) {
+ return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (_ch_comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 5)));
}
-
- return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 5)));
-#else
- return boost::shared_ptr<AutomationControl>();
#endif
+ return boost::shared_ptr<AutomationControl>();
}
boost::shared_ptr<ReadOnlyControl>
Route::comp_redux_controllable () const
{
#ifdef MIXBUS
- boost::shared_ptr<PluginInsert> comp = ch_comp();
-
- if (!comp) {
- return boost::shared_ptr<ReadOnlyControl>();
+ if (_ch_comp) {
+ return _ch_comp->control_output (6);
}
- if (is_master()) {
- return comp->control_output (2);
- } else {
- return comp->control_output (6);
- }
-
-#else
- return boost::shared_ptr<ReadOnlyControl>();
#endif
+ return boost::shared_ptr<ReadOnlyControl>();
}
string
}
boost::shared_ptr<AutomationControl>
-Route::send_level_controllable (uint32_t n) const
+Route::send_pan_azimuth_controllable (uint32_t n) const
{
#ifdef MIXBUS
-# undef MIXBUS_PORTS_H
-# include "../../gtk2_ardour/mixbus_ports.h"
- boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
- if (plug && !mixbus()) {
- uint32_t port_id = 0;
- switch (n) {
- case 0: port_id = port_channel_post_aux1_level; break;
- case 1: port_id = port_channel_post_aux2_level; break;
- case 2: port_id = port_channel_post_aux3_level; break;
- case 3: port_id = port_channel_post_aux4_level; break;
- case 4: port_id = port_channel_post_aux5_level; break;
- case 5: port_id = port_channel_post_aux6_level; break;
- case 6: port_id = port_channel_post_aux7_level; break;
- case 7: port_id = port_channel_post_aux8_level; break;
-# ifdef MIXBUS32C
- case 8: port_id = port_channel_post_aux9_level; break;
- case 9: port_id = port_channel_post_aux10_level; break;
- case 10: port_id = port_channel_post_aux11_level; break;
- case 11: port_id = port_channel_post_aux12_level; break;
-# endif
- default:
- break;
+ if (_mixbus_send) {
+ if (n < _mixbus_send->n_busses ()) {
+ return _mixbus_send->send_pan_ctrl (n + 1);
}
+ }
+#endif
+ return boost::shared_ptr<AutomationControl>();
+}
- if (port_id > 0) {
- return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_id)));
+boost::shared_ptr<AutomationControl>
+Route::send_level_controllable (uint32_t n) const
+{
+#ifdef MIXBUS
+ if (_mixbus_send) {
+ if (n < _mixbus_send->n_busses ()) {
+ return _mixbus_send->send_gain_ctrl (n + 1);
}
-# ifdef MIXBUS32C
- assert (n > 11);
- n -= 12;
-# else
- assert (n > 7);
- n -= 8;
-# endif
+ n -= _mixbus_send->n_busses ();
}
#endif
boost::shared_ptr<Send> s = boost::dynamic_pointer_cast<Send>(nth_send (n));
- if (!s) {
- return boost::shared_ptr<AutomationControl>();
+ if (s) {
+ return s->gain_control ();
}
- return s->gain_control ();
+ return boost::shared_ptr<AutomationControl>();
}
boost::shared_ptr<AutomationControl>
Route::send_enable_controllable (uint32_t n) const
{
#ifdef MIXBUS
-# undef MIXBUS_PORTS_H
-# include "../../gtk2_ardour/mixbus_ports.h"
- boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
- if (plug && !mixbus()) {
- uint32_t port_id = 0;
- switch (n) {
- case 0: port_id = port_channel_post_aux1_asgn; break;
- case 1: port_id = port_channel_post_aux2_asgn; break;
- case 2: port_id = port_channel_post_aux3_asgn; break;
- case 3: port_id = port_channel_post_aux4_asgn; break;
- case 4: port_id = port_channel_post_aux5_asgn; break;
- case 5: port_id = port_channel_post_aux6_asgn; break;
- case 6: port_id = port_channel_post_aux7_asgn; break;
- case 7: port_id = port_channel_post_aux8_asgn; break;
-# ifdef MIXBUS32C
- case 8: port_id = port_channel_post_aux9_asgn; break;
- case 9: port_id = port_channel_post_aux10_asgn; break;
- case 10: port_id = port_channel_post_aux11_asgn; break;
- case 11: port_id = port_channel_post_aux12_asgn; break;
-# endif
- default:
- break;
- }
-
- if (port_id > 0) {
- return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_id)));
+ if (_mixbus_send) {
+ if (n < _mixbus_send->n_busses ()) {
+ return _mixbus_send->send_enable_ctrl (n + 1);
}
-# ifdef MIXBUS32C
- assert (n > 11);
- n -= 12;
-# else
- assert (n > 7);
- n -= 8;
-# endif
}
#endif
/* although Ardour sends have enable/disable as part of the Processor
return boost::shared_ptr<AutomationControl>();
}
+boost::shared_ptr<AutomationControl>
+Route::send_pan_azimuth_enable_controllable (uint32_t n) const
+{
+#ifdef MIXBUS
+ if (_mixbus_send) {
+ if (n < _mixbus_send->n_busses ()) {
+ return _mixbus_send->send_pan_enable_ctrl (n + 1);
+ }
+ }
+#endif
+ return boost::shared_ptr<AutomationControl>();
+}
+
string
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;
-#else
- if (n < 8) {
+#ifdef MIXBUS
+ if (_mixbus_send) {
+ if (n < _mixbus_send->n_busses ()) {
return _session.get_mixbus (n)->name();
}
- n -= 8;
-# endif
+ n -= _mixbus_send->n_busses ();
}
#endif
boost::shared_ptr<Processor> p = nth_send (n);
if (p) {
return p->name();
- } else {
- return string();
}
+ return string();
}
boost::shared_ptr<AutomationControl>
Route::master_send_enable_controllable () const
{
#ifdef MIXBUS
- boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
- if (!plug) {
+ if (is_master() || is_monitor() || is_auditioner()) {
return boost::shared_ptr<AutomationControl>();
}
-# undef MIXBUS_PORTS_H
-# include "../../gtk2_ardour/mixbus_ports.h"
- return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_channel_post_mstr_assign)));
-#else
- return boost::shared_ptr<AutomationControl>();
+
+ if (_mixbus_send) {
+ return _mixbus_send->master_send_enable_ctrl ();
+ }
+
#endif
+ return boost::shared_ptr<AutomationControl>();
}
bool
return rv;
}
+void
+Route::set_meter_type (MeterType t)
+{
+ _meter->set_meter_type (t);
+}
+
+MeterType
+Route::meter_type () const
+{
+ return _meter->meter_type ();
+}
+
void
Route::set_disk_io_point (DiskIOPoint diop)
{
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
+void
+Route::set_loop (Location* l)
{
- /* 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;
- }
+ _loop_location = l;
+ Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
+ for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ (*i)->set_loop (l);
}
-
- 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
{
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;
+ return get_auto_monitoring_state();
}
-
-#endif
projects / ardour.git / blobdiff