, _meter_type (MeterPeak)
, _denormal_protection (false)
, _recordable (true)
- , _silent (false)
, _declickable (false)
, _have_internal_generator (false)
, _default_type (default_type)
}
if (!is_master() && !is_monitor() && !is_auditioner()) {
- _delayline.reset (new DelayLine (_session, name () + ":in"));
+ _delayline.reset (new DelayLine (_session, name ()));
}
/* and input trim */
start_sample += _output->latency ();
end_sample += _output->latency ();
+ const double speed = (is_auditioner() ? 1.0 : _session.transport_speed ());
+
/* 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 ().
* given that
*/
bool run_disk_writer = false;
- if (_disk_writer) {
+ 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;
+ }
}
/* Tell main outs what to do about monitoring. We do this so that
* 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.
*/
- bool silence = _have_internal_generator ? false : (monitoring_state () == MonitoringSilence);
+ MonitorState ms = monitoring_state ();
+ bool silence = _have_internal_generator ? false : (ms == MonitoringSilence);
_main_outs->no_outs_cuz_we_no_monitor (silence);
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) {
* cross loop points.
*/
- if (meter_already_run && boost::dynamic_pointer_cast<PeakMeter> (*i)) {
- /* don't ::run() the meter, otherwise it will have its previous peak corrupted */
- continue;
- }
-
#ifndef NDEBUG
/* if it has any inputs, make sure they match */
if (boost::dynamic_pointer_cast<UnknownProcessor> (*i) == 0 && (*i)->input_streams() != ChanCount::ZERO) {
}
#endif
- if (boost::dynamic_pointer_cast<Send>(*i) != 0) {
- // inform the reader that we're sending a late signal,
- // relative to original (output aligned) start_sample
- boost::dynamic_pointer_cast<Send>(*i)->set_delay_in (latency);
- }
if (boost::dynamic_pointer_cast<PluginInsert>(*i) != 0) {
/* set potential sidechain ports, capture and playback latency.
* This effectively sets jack port latency which should include
/* input->latency() + */ latency, /* output->latency() + */ playback_latency);
}
+ 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);
+ }
+ }
+
double pspeed = speed;
if ((!run_disk_reader && (*i) == _disk_reader) || (!run_disk_writer && (*i) == _disk_writer)) {
/* run with speed 0, no-roll */
}
(*i)->run (bufs, start_sample - latency, end_sample - latency, pspeed, nframes, *i != _processors.back());
+
bufs.set_count ((*i)->output_streams());
/* Note: plugin latency may change. While the plugin does inform the session via
if ((*i)->active ()) {
latency += (*i)->signal_latency ();
}
+
+ if (re_inject_oob_data) {
+ write_out_of_band_data (bufs, nframes);
+ }
+
#if 0
if ((*i) == _delayline) {
latency += _delayline->get_delay ();
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_sample, end_sample, nframes, declick, true, false);
+ Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
+ run_route (start_sample, end_sample, nframes, declick, true, false);
}
void
-Route::passthru (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes, int declick, bool gain_automation_ok, bool run_disk_reader)
+Route::run_route (samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes, int declick, 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, 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, false);
+ flush_processor_buffers_locked (nframes);
}
void
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));
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 ());
}
}
}
}
+ 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;
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 (!_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);
}
}
}
}
-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 (!lm.locked()) {
- return 0;
- }
-
- if (!_active) {
- silence_unlocked (nframes);
- return 0;
- }
-
- if (session_state_changing) {
- if (_session.transport_speed() != 0.0f) {
- /* we're rolling but some state is changing (e.g. our diskstream contents)
- so we cannot use them. Be silent till this is over.
-
- XXX note the absurdity of ::no_roll() being called when we ARE rolling!
- */
- silence_unlocked (nframes);
- return 0;
- }
- /* we're really not rolling, so we're either delivery silence or actually
- monitoring, both of which are safe to do while session_state_changing is true.
- */
- }
-
- no_roll_unlocked (nframes, start_sample, end_sample);
-
- return 0;
-}
-
void
-Route::no_roll_unlocked (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample)
+Route::flush_processors ()
{
- 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);
+ Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
- if (_meter_point == MeterInput) {
- _meter->run (bufs, start_sample, end_sample, 0.0, nframes, true);
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ (*i)->flush ();
}
-
- passthru (bufs, start_sample, end_sample, nframes, 0, true, false);
-
- flush_processor_buffers_locked (nframes);
}
samplecnt_t
return nframes;
}
- samplecnt_t route_offset = playback_latency ();
-
- if (latency_preroll > route_offset + nframes) {
- no_roll_unlocked (nframes, start_sample - latency_preroll, end_sample - latency_preroll);
+ if (latency_preroll > playback_latency ()) {
+ no_roll_unlocked (nframes, start_sample - latency_preroll, end_sample - latency_preroll, false);
return 0;
}
- if (latency_preroll > route_offset) {
-
- samplecnt_t skip = latency_preroll - route_offset;
- no_roll_unlocked (skip, start_sample - latency_preroll, start_sample - latency_preroll + skip);
-
- if (nframes == skip) {
- return 0;
- }
-
- Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
- for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
- if (iop) {
- iop->increment_port_buffer_offset (skip);
- }
- }
- _input->increment_port_buffer_offset (skip);
- _output->increment_port_buffer_offset (skip);
-
- start_sample -= route_offset;
- end_sample -= route_offset;
-
- return nframes - skip;
- }
-
start_sample -= latency_preroll;
end_sample -= latency_preroll;
return nframes;
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;
}
+
if ((nframes = latency_preroll (nframes, start_sample, end_sample)) == 0) {
return 0;
}
- _silent = false;
-
- BufferSet& bufs = _session.get_route_buffers (n_process_buffers ());
+ run_route (start_sample, end_sample, nframes, declick, (!_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(), true);
+ 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, 0, 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
samplecnt_t
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...
+
Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
- samplecnt_t l_in = 0; // _input->latency ();
+ samplecnt_t l_in = 0;
samplecnt_t l_out = _output->user_latency();
for (ProcessorList::reverse_iterator i = _processors.rbegin(); i != _processors.rend(); ++i) {
+ if (boost::shared_ptr<Send> snd = boost::dynamic_pointer_cast<Send> (*i)) {
+ snd->set_delay_in (l_out + _output->latency());
+ }
(*i)->set_output_latency (l_out);
if ((*i)->active ()) {
l_out += (*i)->signal_latency ();
_signal_latency = l_out;
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- if ((*i)->active ()) {
- l_in += (*i)->signal_latency ();
- }
(*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)->signal_latency ();
+ }
}
-
lm.release ();
if (apply_to_delayline) {
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 */
}
}
+ /* 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()) {
+ new_processors.insert (writer_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()) {
#endif
}
+boost::shared_ptr<AutomationControl>
+Route::tape_drive_controllable () const
+{
+#ifdef MIXBUS
+
+ if ( _ch_pre && (is_master() || mixbus()) ) {
+ return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (_ch_pre->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 4)));
+ }
+#endif
+
+ return boost::shared_ptr<AutomationControl>();
+}
+
string
Route::eq_band_name (uint32_t band) const
{
#endif
}
+boost::shared_ptr<AutomationControl>
+Route::send_pan_azi_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) {
+# ifdef MIXBUS32C
+ case 0: port_id = port_channel_post_aux0_pan; break; //32c mb "pan" controls use zero-based names, unlike levels. ugh
+ case 1: port_id = port_channel_post_aux1_pan; break;
+ case 2: port_id = port_channel_post_aux2_pan; break;
+ case 3: port_id = port_channel_post_aux3_pan; break;
+ case 4: port_id = port_channel_post_aux4_pan; break;
+ case 5: port_id = port_channel_post_aux5_pan; break;
+ case 6: port_id = port_channel_post_aux6_pan; break;
+ case 7: port_id = port_channel_post_aux7_pan; break;
+ case 8: port_id = port_channel_post_aux8_pan; break;
+ case 9: port_id = port_channel_post_aux9_pan; break;
+ case 10: port_id = port_channel_post_aux10_pan; break;
+ case 11: port_id = port_channel_post_aux11_pan; break;
+# endif
+ default:
+ break;
+ }
+
+ if (port_id > 0) {
+ return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_id)));
+ }
+ }
+#endif
+
+ return boost::shared_ptr<AutomationControl>();
+}
+
boost::shared_ptr<AutomationControl>
Route::send_level_controllable (uint32_t n) const
{
* 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
+ * rg: sept 30 2017: Above is not the case: punch-in/out location is
+ * global session playhead position.
+ * When this method is called from process_output_buffers() we need
+ * to use delay-compensated route's process-position.
+ *
+ * NB. Disk reader/writer may also be offset by a same amount of time.
+ *
+ * Also keep in mind that _session.transport_rolling() is false during
+ * pre-roll but the disk already produces output.
+ *
+ * TODO: FIXME
*/
- if (_session.config.get_punch_in() || _session.config.get_punch_out() || _session.preroll_record_punch_enabled ()) {
+ if (_session.config.get_punch_in() || _session.config.get_punch_out()) {
session_rec = _session.actively_recording ();
} else {
session_rec = _session.get_record_enabled();
projects / ardour.git / blobdiff