X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=libs%2Fardour%2Froute.cc;h=2d24ac4ac654eb180747841178403802b2afc589;hb=5a2ea4d0e2b9afb23da25e43e1f6b7a3cbe4df11;hp=d405dd8f082ee527837b3055f07832eed0a44c7e;hpb=dc4f730ac95837590e8305f69778d1049e4a545e;p=ardour.git diff --git a/libs/ardour/route.cc b/libs/ardour/route.cc index d405dd8f08..2d24ac4ac6 100644 --- a/libs/ardour/route.cc +++ b/libs/ardour/route.cc @@ -47,6 +47,8 @@ #include "ardour/capturing_processor.h" #include "ardour/debug.h" #include "ardour/delivery.h" +#include "ardour/disk_reader.h" +#include "ardour/disk_writer.h" #include "ardour/event_type_map.h" #include "ardour/gain_control.h" #include "ardour/internal_return.h" @@ -55,6 +57,7 @@ #include "ardour/delayline.h" #include "ardour/midi_buffer.h" #include "ardour/midi_port.h" +#include "ardour/monitor_control.h" #include "ardour/monitor_processor.h" #include "ardour/pannable.h" #include "ardour/panner.h" @@ -92,10 +95,7 @@ Route::Route (Session& sess, string name, PresentationInfo::Flag flag, DataType , Muteable (sess, name) , _active (true) , _signal_latency (0) - , _signal_latency_at_amp_position (0) - , _signal_latency_at_trim_position (0) - , _initial_delay (0) - , _roll_delay (0) + , _disk_io_point (DiskIOPreFader) , _pending_process_reorder (0) , _pending_signals (0) , _pending_declick (true) @@ -109,10 +109,10 @@ Route::Route (Session& sess, string name, PresentationInfo::Flag flag, DataType , _have_internal_generator (false) , _default_type (default_type) , _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) @@ -192,12 +192,9 @@ Route::init () _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 */ @@ -290,7 +287,7 @@ Route::set_trim (gain_t val, Controllable::GroupControlDisposition /* group over } void -Route::maybe_declick (BufferSet&, framecnt_t, int) +Route::maybe_declick (BufferSet&, samplecnt_t, int) { /* this is the "bus" implementation and they never declick. */ @@ -300,56 +297,101 @@ Route::maybe_declick (BufferSet&, framecnt_t, int) /** Process this route for one (sub) cycle (process thread) * * @param bufs Scratch buffers to use for the signal path - * @param start_frame Initial transport frame - * @param end_frame Final transport frame - * @param nframes Number of frames to output (to ports) + * @param start_sample Initial transport sample + * @param end_sample Final transport sample + * @param nframes Number of samples to output (to ports) * - * Note that (end_frame - start_frame) may not be equal to nframes when the + * Note that (end_sample - start_sample) may not be equal to nframes when the * transport speed isn't 1.0 (eg varispeed). */ void Route::process_output_buffers (BufferSet& bufs, - framepos_t start_frame, framepos_t end_frame, pframes_t nframes, - int declick, bool gain_automation_ok) + samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes, + int declick, 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; } - automation_run (start_frame, nframes); + /* 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); /* figure out if we're going to use gain automation */ if (gain_automation_ok) { _amp->set_gain_automation_buffer (_session.gain_automation_buffer ()); _amp->setup_gain_automation ( - start_frame + _signal_latency_at_amp_position, - end_frame + _signal_latency_at_amp_position, + start_sample + _amp->output_latency (), + end_sample + _amp->output_latency (), nframes); _trim->set_gain_automation_buffer (_session.trim_automation_buffer ()); _trim->setup_gain_automation ( - start_frame + _signal_latency_at_trim_position, - end_frame + _signal_latency_at_trim_position, + start_sample + _trim->output_latency (), + end_sample + _trim->output_latency (), nframes); - } else { - _amp->apply_gain_automation (false); - _trim->apply_gain_automation (false); } - /* Tell main outs what to do about monitoring. We do this so that - 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 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. + */ - We override this in the case where we have an internal generator. - */ + start_sample += _signal_latency; + end_sample += _signal_latency; + + start_sample += _output->latency (); + end_sample += _output->latency (); + + /* 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); + + /* 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) { + samplecnt_t latency_preroll = _session.remaining_latency_preroll (); + run_disk_writer = latency_preroll < nframes + (_signal_latency + _output->latency ()); + } + + /* 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); @@ -358,6 +400,8 @@ Route::process_output_buffers (BufferSet& bufs, GLOBAL DECLICK (for transport changes etc.) ----------------------------------------------------------------------------------------- */ + // XXX not latency compensated. calls Amp::declick, but there may be + // plugins between disk and Fader. maybe_declick (bufs, nframes, declick); _pending_declick = 0; @@ -365,6 +409,14 @@ Route::process_output_buffers (BufferSet& bufs, DENORMAL CONTROL/PHASE INVERT ----------------------------------------------------------------------------------------- */ + /* TODO phase-control should become a processor, or rather a Stub-processor: + * a point in the chain which calls a special-cased private Route method. + * _phase_control is route-owned and dynamic.) + * and we should rename it to polarity. + * + * denormals: we'll need to protect silent inputs as well as silent disk + * (when not monitoring input). Or simply drop that feature. + */ if (!_phase_control->none()) { int chn = 0; @@ -409,8 +461,8 @@ Route::process_output_buffers (BufferSet& bufs, sp[nx] += 1.0e-27f; } } - } + } /* ------------------------------------------------------------------------------------------- @@ -420,11 +472,17 @@ Route::process_output_buffers (BufferSet& bufs, /* set this to be true if the meter will already have been ::run() earlier */ bool const meter_already_run = metering_state() == MeteringInput; - framecnt_t latency = 0; - const double speed = _session.transport_speed (); + samplecnt_t latency = 0; + const double speed = (is_auditioner() ? 1.0 : _session.transport_speed ()); for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) { + /* TODO check for split cycles here. + * + * start_frame, end_frame is adjusted by latency and may + * cross loop points. + */ + if (meter_already_run && boost::dynamic_pointer_cast (*i)) { /* don't ::run() the meter, otherwise it will have its previous peak corrupted */ continue; @@ -444,31 +502,60 @@ Route::process_output_buffers (BufferSet& bufs, } #endif - /* should we NOT run plugins here if the route is inactive? - do we catch route != active somewhere higher? - */ - if (boost::dynamic_pointer_cast(*i) != 0) { - boost::dynamic_pointer_cast(*i)->set_delay_in(_signal_latency - latency); + // inform the reader that we're sending a late signal, + // relative to original (output aligned) start_sample + boost::dynamic_pointer_cast(*i)->set_delay_in (latency); } if (boost::dynamic_pointer_cast(*i) != 0) { - const framecnt_t longest_session_latency = _initial_delay + _signal_latency; + /* set potential sidechain ports, capture and playback latency. + * This effectively sets jack port latency which should include + * up/downstream latencies. + * + * However, the value is not used by Ardour (2017-09-20) and calling + * IO::latency() is expensive, so we punt. + * + * capture should be + * input()->latenct + latency, + * playback should be + * output->latency() + _signal_latency - latency + * + * Also see note below, _signal_latency may be smaller than latency + * if a plugin's latency increases while it's running. + */ + const samplecnt_t playback_latency = std::max ((samplecnt_t)0, _signal_latency - latency); boost::dynamic_pointer_cast(*i)->set_sidechain_latency ( - _initial_delay + latency, longest_session_latency - latency); + /* input->latency() + */ latency, /* output->latency() + */ playback_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; } - //cerr << name() << " run " << (*i)->name() << endl; - (*i)->run (bufs, start_frame - latency, end_frame - latency, speed, nframes, *i != _processors.back()); + (*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 + * 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 (); } +#if 0 + if ((*i) == _delayline) { + latency += _delayline->get_delay (); + } +#endif } } void -Route::bounce_process (BufferSet& buffers, framepos_t start, framecnt_t nframes, +Route::bounce_process (BufferSet& buffers, samplepos_t start, samplecnt_t nframes, boost::shared_ptr endpoint, bool include_endpoint, bool for_export, bool for_freeze) { @@ -477,7 +564,7 @@ Route::bounce_process (BufferSet& buffers, framepos_t start, framecnt_t nframes, return; } - framecnt_t latency = bounce_get_latency(_amp, false, for_export, for_freeze); + samplecnt_t latency = bounce_get_latency(_amp, false, for_export, for_freeze); _amp->set_gain_automation_buffer (_session.gain_automation_buffer ()); _amp->setup_gain_automation (start - latency, start - latency + nframes, nframes); @@ -528,11 +615,11 @@ Route::bounce_process (BufferSet& buffers, framepos_t start, framecnt_t nframes, } } -framecnt_t +samplecnt_t Route::bounce_get_latency (boost::shared_ptr endpoint, bool include_endpoint, bool for_export, bool for_freeze) const { - framecnt_t latency = 0; + samplecnt_t latency = 0; if (!endpoint && !include_endpoint) { return latency; } @@ -592,16 +679,16 @@ Route::n_process_buffers () } void -Route::monitor_run (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick) +Route::monitor_run (samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes, int declick) { assert (is_monitor()); BufferSet& bufs (_session.get_route_buffers (n_process_buffers())); fill_buffers_with_input (bufs, _input, nframes); - passthru (bufs, start_frame, end_frame, nframes, declick); + passthru (bufs, start_sample, end_sample, nframes, declick, true, false); } void -Route::passthru (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick) +Route::passthru (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes, int declick, bool gain_automation_ok, bool run_disk_reader) { _silent = false; @@ -615,18 +702,23 @@ Route::passthru (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, bufs.silence (nframes, 0); } - write_out_of_band_data (bufs, start_frame, end_frame, nframes); - process_output_buffers (bufs, start_frame, end_frame, nframes, declick, true); + /* append immediate messages to the first MIDI buffer (thus sending it to the first output port) */ + + write_out_of_band_data (bufs, start_sample, end_sample, nframes); + + /* run processor chain */ + + process_output_buffers (bufs, start_sample, end_sample, nframes, declick, gain_automation_ok, run_disk_reader); } void -Route::passthru_silence (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick) +Route::passthru_silence (samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes, int declick) { BufferSet& bufs (_session.get_route_buffers (n_process_buffers(), true)); bufs.set_count (_input->n_ports()); - write_out_of_band_data (bufs, start_frame, end_frame, nframes); - process_output_buffers (bufs, start_frame, end_frame, nframes, declick, false); + write_out_of_band_data (bufs, start_sample, end_sample, nframes); + process_output_buffers (bufs, start_sample, end_sample, nframes, declick, false, false); } void @@ -1248,7 +1340,7 @@ Route::clear_processors (Placement p) 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 */ @@ -1298,6 +1390,15 @@ Route::clear_processors (Placement p) } } +bool +Route::is_internal_processor (boost::shared_ptr p) const +{ + if (p == _amp || p == _meter || p == _main_outs || p == _delayline || p == _trim) { + return true; + } + return false; +} + int Route::remove_processor (boost::shared_ptr processor, ProcessorStreams* err, bool need_process_lock) { @@ -1317,7 +1418,7 @@ Route::remove_processor (boost::shared_ptr processor, ProcessorStream /* these can never be removed */ - if (processor == _amp || processor == _meter || processor == _main_outs || processor == _delayline || processor == _trim) { + if (is_internal_processor (processor)) { return 0; } @@ -1419,11 +1520,11 @@ int Route::replace_processor (boost::shared_ptr old, boost::shared_ptr 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; } @@ -1538,7 +1639,7 @@ Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* /* these can never be removed */ - if (processor == _amp || processor == _meter || processor == _main_outs || processor == _delayline || processor == _trim) { + if (is_internal_processor (processor)) { ++i; continue; } @@ -1806,8 +1907,6 @@ Route::configure_processors_unlocked (ProcessorStreams* err, Glib::Threads::RWLo // TODO check for a potential ReaderLock after ReaderLock ?? Glib::Threads::RWLock::ReaderLock lr (_processor_lock); - framecnt_t chain_latency = _input->latency (); - list< pair >::iterator c = configuration.begin(); for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) { @@ -1819,9 +1918,6 @@ Route::configure_processors_unlocked (ProcessorStreams* err, Glib::Threads::RWLo return -1; } - (*p)->set_input_latency (chain_latency); - chain_latency += (*p)->signal_latency (); - processor_max_streams = ChanCount::max(processor_max_streams, c->first); processor_max_streams = ChanCount::max(processor_max_streams, c->second); @@ -2101,6 +2197,11 @@ Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err g_atomic_int_set (&_pending_process_reorder, 1); } + /* update processor input/output latency + * (total signal_latency does not change) + */ + update_signal_latency (true); + return 0; } @@ -2326,21 +2427,22 @@ Route::state(bool full_state) XMLNode *node = new XMLNode("Route"); ProcessorList::iterator i; - node->set_property ("id", id ()); - node->set_property ("name", name()); - node->set_property ("default-type", _default_type); - node->set_property ("strict-io", _strict_io); + node->set_property (X_("id"), id ()); + node->set_property (X_("name"), name()); + node->set_property (X_("default-type"), _default_type); + node->set_property (X_("strict-io"), _strict_io); node->add_child_nocopy (_presentation_info.get_state()); - node->set_property ("active", _active); - node->set_property ("denormal-protection", _denormal_protection); - node->set_property ("meter-point", _meter_point); + node->set_property (X_("active"), _active); + node->set_property (X_("denormal-protection"), _denormal_protection); + node->set_property (X_("meter-point"), _meter_point); + node->set_property (X_("disk-io-point"), _disk_io_point); - node->set_property ("meter-type", _meter_type); + node->set_property (X_("meter-type"), _meter_type); if (_route_group) { - node->set_property ("route-group", _route_group->name()); + node->set_property (X_("route-group"), _route_group->name()); } node->add_child_nocopy (_solo_control->get_state ()); @@ -2370,6 +2472,9 @@ Route::state(bool full_state) { Glib::Threads::RWLock::ReaderLock lm (_processor_lock); for (i = _processors.begin(); i != _processors.end(); ++i) { + if (*i == _delayline) { + continue; + } if (!full_state) { /* template save: do not include internal sends functioning as aux sends because the chance of the target ID @@ -2492,6 +2597,17 @@ Route::set_state (const XMLNode& node, int version) } } + DiskIOPoint diop; + if (node.get_property (X_("disk-io-point"), diop)) { + if (_disk_writer) { + _disk_writer->set_display_to_user (diop == DiskIOCustom); + } + if (_disk_reader) { + _disk_reader->set_display_to_user (diop == DiskIOCustom); + } + set_disk_io_point (diop); + } + node.get_property (X_("meter-type"), _meter_type); _initial_io_setup = false; @@ -2575,6 +2691,10 @@ Route::set_state (const XMLNode& node, int version) } } + if (_delayline) { + _delayline->set_name (name ()); + } + return 0; } @@ -2810,10 +2930,7 @@ Route::set_processor_state (const XMLNode& node) _meter->set_state (**niter, Stateful::current_state_version); new_order.push_back (_meter); } 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") { @@ -2831,6 +2948,12 @@ Route::set_processor_state (const XMLNode& node) } else if (prop->value() == "capture") { /* CapturingProcessor should never be restored, it's always added explicitly when needed */ + } else if (prop->value() == "diskreader" && _disk_reader) { + _disk_reader->set_state (**niter, Stateful::current_state_version); + new_order.push_back (_disk_reader); + } else if (prop->value() == "diskwriter" && _disk_writer) { + _disk_writer->set_state (**niter, Stateful::current_state_version); + new_order.push_back (_disk_writer); } else { set_processor_state (**niter, prop, new_order, must_configure); } @@ -2969,7 +3092,7 @@ Route::curve_reallocate () } void -Route::silence (framecnt_t nframes) +Route::silence (samplecnt_t nframes) { Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK); if (!lm.locked()) { @@ -2980,11 +3103,11 @@ Route::silence (framecnt_t nframes) } void -Route::silence_unlocked (framecnt_t nframes) +Route::silence_unlocked (samplecnt_t nframes) { /* Must be called with the processor lock held */ - const framepos_t now = _session.transport_frame (); + const samplepos_t now = _session.transport_sample (); if (!_silent) { @@ -3314,24 +3437,20 @@ Route::feeds_according_to_graph (boost::shared_ptr other) /** Called from the (non-realtime) butler thread when the transport is stopped */ void -Route::non_realtime_transport_stop (framepos_t now, bool flush) +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 (); } - } - _roll_delay = _initial_delay; + (*i)->non_realtime_transport_stop (now, flush); + } } void @@ -3508,7 +3627,7 @@ Route::pans_required () const } void -Route::flush_processor_buffers_locked (framecnt_t nframes) +Route::flush_processor_buffers_locked (samplecnt_t nframes) { for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { boost::shared_ptr d = boost::dynamic_pointer_cast (*i); @@ -3524,7 +3643,7 @@ Route::flush_processor_buffers_locked (framecnt_t nframes) } int -Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing) +Route::no_roll (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, bool session_state_changing) { Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK); @@ -3552,53 +3671,136 @@ Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, */ } + 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) +{ 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 (_meter_point == MeterInput) { - _meter->run (bufs, start_frame, end_frame, 0.0, nframes, true); + _meter->run (bufs, start_sample, end_sample, 0.0, nframes, true); } - _amp->apply_gain_automation (false); - _trim->apply_gain_automation (false); - passthru (bufs, start_frame, end_frame, nframes, 0); + passthru (bufs, start_sample, end_sample, nframes, 0, true, false); flush_processor_buffers_locked (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 (incl_downstream) { + rv += _output->connected_latency (true); + } else { + rv += _output->latency (); + } + return rv; +} + +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; + } + + samplecnt_t route_offset = playback_latency (); + + if (latency_preroll > route_offset + nframes) { + no_roll_unlocked (nframes, start_sample - latency_preroll, end_sample - latency_preroll); + 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 iop = boost::dynamic_pointer_cast (*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; } int -Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& /* need_butler */) +Route::roll (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, int declick, bool& need_butler) { Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK); + if (!lm.locked()) { return 0; } if (!_active) { silence_unlocked (nframes); + if (_meter_point == MeterInput && ((_monitoring_control->monitoring_choice() & MonitorInput) || (!_disk_writer || _disk_writer->record_enabled()))) { + _meter->reset(); + } return 0; } - - framepos_t unused = 0; - - if ((nframes = check_initial_delay (nframes, unused)) == 0) { + if ((nframes = latency_preroll (nframes, start_sample, end_sample)) == 0) { return 0; } _silent = false; - BufferSet& bufs = _session.get_route_buffers (n_process_buffers()); + BufferSet& bufs = _session.get_route_buffers (n_process_buffers ()); fill_buffers_with_input (bufs, _input, nframes); - if (_meter_point == MeterInput) { - _meter->run (bufs, start_frame, end_frame, 1.0, nframes, true); + /* filter captured data before meter sees it */ + filter_input (bufs); + + if (_meter_point == MeterInput && + ((_monitoring_control->monitoring_choice() & MonitorInput) || (_disk_writer && _disk_writer->record_enabled()))) { + _meter->run (bufs, start_sample, end_sample, 1.0 /*speed()*/, nframes, true); } - passthru (bufs, start_frame, end_frame, nframes, declick); + passthru (bufs, start_sample, end_sample, nframes, declick, (!_disk_writer || !_disk_writer->record_enabled()) && _session.transport_rolling(), true); + + if ((_disk_reader && _disk_reader->need_butler()) || (_disk_writer && _disk_writer->need_butler())) { + need_butler = true; + } flush_processor_buffers_locked (nframes); @@ -3606,7 +3808,7 @@ Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, in } int -Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& /* need_butler */) +Route::silent_roll (pframes_t nframes, samplepos_t /*start_sample*/, samplepos_t /*end_sample*/, bool& /* need_butler */) { silence (nframes); flush_processor_buffers_locked (nframes); @@ -3658,6 +3860,10 @@ Route::apply_processor_changes_rt () } if (changed) { set_processor_positions (); + /* update processor input/output latency + * (total signal_latency does not change) + */ + update_signal_latency (true); } if (emissions != 0) { g_atomic_int_set (&_pending_signals, emissions); @@ -3829,53 +4035,54 @@ Route::add_export_point() Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ()); Glib::Threads::RWLock::WriterLock lw (_processor_lock); - // this aligns all tracks; but not tracks + busses - assert (_session.worst_track_latency () >= _initial_delay); - _capturing_processor.reset (new CapturingProcessor (_session, _session.worst_track_latency () - _initial_delay)); - _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; } -framecnt_t -Route::update_signal_latency () +samplecnt_t +Route::update_signal_latency (bool apply_to_delayline) { - framecnt_t l = _output->user_latency(); - framecnt_t lamp = 0; - bool before_amp = true; - framecnt_t ltrim = 0; - bool before_trim = true; + Glib::Threads::RWLock::ReaderLock lm (_processor_lock); - for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { + samplecnt_t l_in = 0; // _input->latency (); + samplecnt_t l_out = _output->user_latency(); + for (ProcessorList::reverse_iterator i = _processors.rbegin(); i != _processors.rend(); ++i) { + (*i)->set_output_latency (l_out); if ((*i)->active ()) { - l += (*i)->signal_latency (); - } - if ((*i) == _amp) { - before_amp = false; - } - if ((*i) == _trim) { - before_amp = false; - } - if (before_amp) { - lamp = l; + l_out += (*i)->signal_latency (); } - if (before_trim) { - lamp = l; + } + + 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) { + 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 ()); } - DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l)); - // TODO: (lamp - _signal_latency) to sync to output (read-ahed), currently _roll_delay shifts this around - _signal_latency_at_amp_position = lamp; - _signal_latency_at_trim_position = ltrim; + lm.release (); + + if (apply_to_delayline) { + /* see also Session::post_playback_latency() */ + apply_latency_compensation (); + } - if (_signal_latency != l) { - _signal_latency = l; + if (_signal_latency != l_out) { signal_latency_changed (); /* EMIT SIGNAL */ } @@ -3883,34 +4090,35 @@ Route::update_signal_latency () } void -Route::set_user_latency (framecnt_t nframes) +Route::set_user_latency (samplecnt_t nframes) { _output->set_user_latency (nframes); _session.update_latency_compensation (); } void -Route::set_latency_compensation (framecnt_t longest_session_latency) +Route::apply_latency_compensation () { - framecnt_t old = _initial_delay; + if (_delayline) { + samplecnt_t old = _delayline->get_delay (); - if (_signal_latency < longest_session_latency) { - _initial_delay = longest_session_latency - _signal_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->get_delay ()) { + signal_latency_updated (); /* EMIT SIGNAL */ + } } } @@ -3951,18 +4159,18 @@ Route::set_pending_declick (int declick) * Adds undo commands for any shifts that are performed. * * @param pos Position to start shifting from. - * @param frames Amount to shift forwards by. + * @param samples Amount to shift forwards by. */ void -Route::shift (framepos_t pos, framecnt_t frames) +Route::shift (samplepos_t pos, samplecnt_t samples) { /* gain automation */ { boost::shared_ptr gc = _amp->gain_control(); XMLNode &before = gc->alist()->get_state (); - gc->alist()->shift (pos, frames); + gc->alist()->shift (pos, samples); XMLNode &after = gc->alist()->get_state (); _session.add_command (new MementoCommand (*gc->alist().get(), &before, &after)); } @@ -3972,7 +4180,7 @@ Route::shift (framepos_t pos, framecnt_t frames) boost::shared_ptr gc = _trim->gain_control(); XMLNode &before = gc->alist()->get_state (); - gc->alist()->shift (pos, frames); + gc->alist()->shift (pos, samples); XMLNode &after = gc->alist()->get_state (); _session.add_command (new MementoCommand (*gc->alist().get(), &before, &after)); } @@ -3988,7 +4196,7 @@ Route::shift (framepos_t pos, framecnt_t frames) if (pc) { boost::shared_ptr al = pc->alist(); XMLNode& before = al->get_state (); - al->shift (pos, frames); + al->shift (pos, samples); XMLNode& after = al->get_state (); _session.add_command (new MementoCommand (*al.get(), &before, &after)); } @@ -4007,7 +4215,7 @@ Route::shift (framepos_t pos, framecnt_t frames) if (ac) { boost::shared_ptr al = ac->alist(); XMLNode &before = al->get_state (); - al->shift (pos, frames); + al->shift (pos, samples); XMLNode &after = al->get_state (); _session.add_command (new MementoCommand (*al.get(), &before, &after)); } @@ -4375,8 +4583,8 @@ Route::unknown_processors () const } -framecnt_t -Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecnt_t our_latency) const +samplecnt_t +Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, samplecnt_t our_latency) const { /* we assume that all our input ports feed all our output ports. its not universally true, but the alternative is way too corner-case to worry about. @@ -4424,10 +4632,10 @@ Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecn return all_connections.max; } -framecnt_t +samplecnt_t Route::set_private_port_latencies (bool playback) const { - framecnt_t own_latency = 0; + samplecnt_t own_latency = 0; /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD OR LATENCY CALLBACK. @@ -4456,7 +4664,7 @@ Route::set_private_port_latencies (bool playback) const } void -Route::set_public_port_latencies (framecnt_t value, bool playback) const +Route::set_public_port_latencies (samplecnt_t value, bool playback) const { /* this is called to set the JACK-visible port latencies, which take latency compensation into account. @@ -4507,6 +4715,8 @@ Route::setup_invisible_processors () */ ProcessorList new_processors; + ProcessorList::iterator dr; + ProcessorList::iterator dw; /* find visible processors */ @@ -4611,12 +4821,6 @@ Route::setup_invisible_processors () } } -#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 ()) { @@ -4626,9 +4830,12 @@ Route::setup_invisible_processors () /* TRIM CONTROL */ - if (_trim && _trim->active()) { + ProcessorList::iterator trim = new_processors.end(); + + if (_trim->active()) { assert (!_trim->display_to_user ()); new_processors.push_front (_trim); + trim = new_processors.begin(); } /* INTERNAL RETURN */ @@ -4642,14 +4849,80 @@ Route::setup_invisible_processors () new_processors.push_front (_intreturn); } - /* EXPORT PROCESSOR */ + /* DISK READER & WRITER (for Track objects) */ + + if (_disk_reader || _disk_writer) { + switch (_disk_io_point) { + case DiskIOPreFader: + if (trim != new_processors.end()) { + /* insert BEFORE TRIM */ + if (_disk_writer) { + new_processors.insert (trim, _disk_writer); + } + if (_disk_reader) { + new_processors.insert (trim, _disk_reader); + } + } else { + if (_disk_writer) { + new_processors.push_front (_disk_writer); + } + if (_disk_reader) { + new_processors.push_front (_disk_reader); + } + } + break; + case DiskIOPostFader: + /* insert BEFORE main outs */ + if (_disk_writer) { + new_processors.insert (main, _disk_writer); + } + if (_disk_reader) { + new_processors.insert (main, _disk_reader); + } + break; + case DiskIOCustom: + /* reader and writer are visible under this condition, so they + * are not invisible and thus not handled here. + */ + break; + } + } + + /* 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 ()); - new_processors.push_front (_capturing_processor); + ProcessorList::iterator reader_pos = find (new_processors.begin(), new_processors.end(), _disk_reader); + if (reader_pos != new_processors.end()) { + /* insert after disk-reader */ + new_processors.insert (++reader_pos, _capturing_processor); + } else { + new_processors.push_front (_capturing_processor); + } } - setup_invisible_processors_oh_children_of_mine (new_processors); + 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; @@ -4737,15 +5010,6 @@ Route::processor_by_id (PBD::ID id) const return boost::shared_ptr (); } -/** @return the monitoring state, or in other words what data we are pushing - * into the route (data from the inputs, data from disk or silence) - */ -MonitorState -Route::monitoring_state () const -{ - return MonitoringInput; -} - /** @return what we should be metering; either the data coming from the input * IO or the data that is flowing through the route. */ @@ -4794,7 +5058,7 @@ Route::the_instrument_unlocked () const void -Route::non_realtime_locate (framepos_t pos) +Route::non_realtime_locate (samplepos_t pos) { Automatable::non_realtime_locate (pos); @@ -4802,9 +5066,11 @@ Route::non_realtime_locate (framepos_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 ()); @@ -4814,7 +5080,6 @@ Route::non_realtime_locate (framepos_t pos) (*i)->non_realtime_locate (pos); } } - _roll_delay = _initial_delay; } void @@ -5561,3 +5826,189 @@ Route::slavables () const rv.push_back (_solo_control); return rv; } + +void +Route::set_disk_io_point (DiskIOPoint diop) +{ + bool display = false; + + cerr << "set disk io to " << enum_2_string (diop) << endl; + + switch (diop) { + case DiskIOCustom: + display = true; + break; + default: + display = false; + } + + if (_disk_writer) { + _disk_writer->set_display_to_user (display); + } + + if (_disk_reader) { + _disk_reader->set_display_to_user (display); + } + + const bool changed = (diop != _disk_io_point); + + _disk_io_point = diop; + + if (changed) { + Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ()); + configure_processors (0); + } + + processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */ +} + +#ifdef USE_TRACKS_CODE_FEATURES + +/* This is the Tracks version of Track::monitoring_state(). + * + * Ardour developers: try to flag or fix issues if parts of the libardour API + * change in ways that invalidate this + */ + +MonitorState +Route::monitoring_state () const +{ + /* Explicit requests */ + + if (_monitoring != MonitorInput) { + return MonitoringInput; + } + + if (_monitoring & MonitorDisk) { + return MonitoringDisk; + } + + /* This is an implementation of the truth table in doc/monitor_modes.pdf; + I don't think it's ever going to be too pretty too look at. + */ + + // GZ: NOT USED IN TRACKS + //bool const auto_input = _session.config.get_auto_input (); + //bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring; + //bool const tape_machine_mode = Config->get_tape_machine_mode (); + + bool const roll = _session.transport_rolling (); + bool const track_rec = _diskstream->record_enabled (); + bool session_rec = _session.actively_recording (); + + if (track_rec) { + + if (!session_rec && roll) { + return MonitoringDisk; + } else { + return MonitoringInput; + } + + } else { + + if (roll) { + return MonitoringDisk; + } + } + + return MonitoringSilence; +} + +#else + +/* This is the Ardour/Mixbus version of Track::monitoring_state(). + * + * Tracks developers: do NOT modify this method under any circumstances. + */ + +MonitorState +Route::monitoring_state () const +{ + if (!_disk_reader) { + return MonitoringInput; + } + + /* Explicit requests */ + MonitorChoice m (_monitoring_control->monitoring_choice()); + + if (m != MonitorAuto) { + + MonitorState ms ((MonitorState) 0); + + if (m & MonitorInput) { + ms = MonitoringInput; + } + + if (m & MonitorDisk) { + ms = MonitorState (ms | MonitoringDisk); + } + + return ms; + } + + switch (_session.config.get_session_monitoring ()) { + case MonitorDisk: + return MonitoringDisk; + break; + case MonitorInput: + return MonitoringInput; + break; + default: + break; + } + + /* This is an implementation of the truth table in doc/monitor_modes.pdf; + I don't think it's ever going to be too pretty too look at. + */ + + bool const roll = _session.transport_rolling (); + bool const track_rec = _disk_writer->record_enabled (); + bool const auto_input = _session.config.get_auto_input (); + bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring; + bool const tape_machine_mode = Config->get_tape_machine_mode (); + bool session_rec; + + /* I suspect that just use actively_recording() is good enough all the + * time, but just to keep the semantics the same as they were before + * sept 26th 2012, we differentiate between the cases where punch is + * enabled and those where it is not. + * + * rg: I suspect this is not the case: monitoring may differ + */ + + if (_session.config.get_punch_in() || _session.config.get_punch_out() || _session.preroll_record_punch_enabled ()) { + session_rec = _session.actively_recording (); + } else { + session_rec = _session.get_record_enabled(); + } + + if (track_rec) { + + if (!session_rec && roll && auto_input) { + return MonitoringDisk; + } else { + return software_monitor ? MonitoringInput : MonitoringSilence; + } + + } else { + + if (tape_machine_mode) { + + return MonitoringDisk; + + } else { + + if (!roll && auto_input) { + return software_monitor ? MonitoringInput : MonitoringSilence; + } else { + return MonitoringDisk; + } + + } + } + + abort(); /* NOTREACHED */ + return MonitoringSilence; +} + +#endif