X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Froute.cc;h=3b615c517b1a00c12e6d31e65db259b0e0fa69ce;hb=11b02e90ac9b084cd25741b7a6bdc91c59749c16;hp=ee4068dda16a079aeaf979ac6029e1c759cafde2;hpb=8139becb1898187729b0ea57f145302d4975bf3a;p=ardour.git diff --git a/libs/ardour/route.cc b/libs/ardour/route.cc index ee4068dda1..3b615c517b 100644 --- a/libs/ardour/route.cc +++ b/libs/ardour/route.cc @@ -57,6 +57,7 @@ #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" @@ -65,6 +66,7 @@ #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" @@ -104,10 +106,10 @@ Route::Route (Session& sess, string name, PresentationInfo::Flag flag, DataType , _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) @@ -188,12 +190,16 @@ Route::init () _amp.reset (new Amp (_session, X_("Fader"), _gain_control, true)); add_processor (_amp, PostFader); + _polarity.reset (new PolarityProcessor (_session, _phase_control)); + _polarity->activate(); + _polarity->set_owner (this); + if (is_monitor ()) { _amp->set_display_name (_("Monitor")); } if (!is_master() && !is_monitor() && !is_auditioner()) { - _delayline.reset (new DelayLine (_session, name () + ":in")); + _delayline.reset (new DelayLine (_session, name ())); } /* and input trim */ @@ -330,6 +336,10 @@ Route::process_output_buffers (BufferSet& bufs, */ 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 ()); @@ -356,11 +366,17 @@ Route::process_output_buffers (BufferSet& bufs, * By the Time T=0 is reached (dt=15 later) that sample is audible. */ - start_sample += _signal_latency; - end_sample += _signal_latency; + const double speed = (is_auditioner() ? 1.0 : _session.transport_speed ()); - start_sample += _output->latency (); - end_sample += _output->latency (); + 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; + } /* Note: during intial pre-roll 'start_sample' as passed as argument can be negative. * Functions calling process_output_buffers() will set "run_disk_reader" @@ -368,7 +384,7 @@ Route::process_output_buffers (BufferSet& bufs, * * playback_latency() is guarnteed to be <= _signal_latency + _output->latency () */ - assert (!_disk_reader || !run_disk_reader || start_sample >= 0); + assert (!_disk_reader || !run_disk_reader || start_sample >= 0 || speed < 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). @@ -380,9 +396,12 @@ Route::process_output_buffers (BufferSet& bufs, * 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 @@ -391,8 +410,15 @@ Route::process_output_buffers (BufferSet& bufs, * 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); @@ -406,74 +432,30 @@ Route::process_output_buffers (BufferSet& bufs, _pending_declick = 0; /* ------------------------------------------------------------------------------------------- - DENORMAL CONTROL/PHASE INVERT + DENORMAL CONTROL ----------------------------------------------------------------------------------------- */ - - /* 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. + /* 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). * - * denormals: we'll need to protect silent inputs as well as silent disk - * (when not monitoring input). Or simply drop that feature. + * ...or simply drop that feature. */ - 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(); - - 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; - } - } - } + if (_denormal_protection || Config->get_denormal_protection()) { - } else { - - for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) { - Sample* const sp = i->data(); - - if (_phase_control->inverted (chn)) { - for (pframes_t nx = 0; nx < nframes; ++nx) { - sp[nx] = -sp[nx]; - } - } + 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; } } - - } else { - - if (_denormal_protection || Config->get_denormal_protection()) { - - for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) { - Sample* const sp = i->data(); - for (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) { @@ -483,11 +465,6 @@ Route::process_output_buffers (BufferSet& bufs, * 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; - } - #ifndef NDEBUG /* if it has any inputs, make sure they match */ if (boost::dynamic_pointer_cast (*i) == 0 && (*i)->input_streams() != ChanCount::ZERO) { @@ -502,30 +479,22 @@ Route::process_output_buffers (BufferSet& bufs, } #endif - if (boost::dynamic_pointer_cast(*i) != 0) { - // 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) { - /* 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. + 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. * - * capture should be - * input()->latenct + latency, - * playback should be - * output->latency() + _signal_latency - latency + * Even when not doing MonitoringDisk, we need to run the processors, + * so that it advances its internal buffers (IFF run_disk_reader is true). * - * 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 ( - /* input->latency() + */ latency, /* output->latency() + */ playback_latency); + 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; @@ -534,7 +503,12 @@ Route::process_output_buffers (BufferSet& bufs, pspeed = 0; } - (*i)->run (bufs, start_sample - latency, end_sample - latency, pspeed, nframes, *i != _processors.back()); + 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()); + } + bufs.set_count ((*i)->output_streams()); /* Note: plugin latency may change. While the plugin does inform the session via @@ -546,9 +520,14 @@ Route::process_output_buffers (BufferSet& bufs, 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 (); + latency += _delayline->delay (); } #endif } @@ -682,15 +661,19 @@ void 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()) { @@ -702,23 +685,19 @@ Route::passthru (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_samp 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 @@ -1393,7 +1372,7 @@ 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) { + if (p == _amp || p == _meter || p == _main_outs || p == _delayline || p == _trim || p == _polarity) { return true; } return false; @@ -2408,17 +2387,17 @@ Route::set_strict_io (const bool enable) 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)); @@ -2449,14 +2428,14 @@ Route::state(bool full_state) 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 ()); } @@ -2466,13 +2445,16 @@ Route::state(bool full_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 @@ -2490,7 +2472,7 @@ Route::state(bool full_state) } } } - node->add_child_nocopy((*i)->state (full_state)); + node->add_child_nocopy((*i)->get_state ()); } } @@ -2688,6 +2670,10 @@ Route::set_state (const XMLNode& node, int version) } } + if (_delayline) { + _delayline->set_name (name ()); + } + return 0; } @@ -2881,7 +2867,7 @@ Route::get_processor_state () { XMLNode* root = new XMLNode (X_("redirects")); for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { - root->add_child_nocopy ((*i)->state (true)); + root->add_child_nocopy ((*i)->get_state ()); } return *root; @@ -2922,6 +2908,9 @@ Route::set_processor_state (const XMLNode& node) } 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") { // skip -- internal } else if (prop->value() == "main-outs") { @@ -3102,29 +3091,25 @@ Route::silence_unlocked (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 pi; + // update owned automated controllables + automation_run (now, nframes); + if (_pannable) { + _pannable->automation_run (now, nframes); + } - if (!_active && (pi = boost::dynamic_pointer_cast (*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 pi; - (*i)->silence (nframes, now); + if (!_active && (pi = boost::dynamic_pointer_cast (*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); } } @@ -3454,7 +3439,6 @@ Route::input_change_handler (IOChange change, void * /*src*/) contains ConfigurationChanged */ configure_processors (0); - _phase_control->resize (_input->n_ports().n_audio ()); io_changed (); /* EMIT SIGNAL */ } @@ -3635,57 +3619,14 @@ Route::flush_processor_buffers_locked (samplecnt_t nframes) } } -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 @@ -3718,38 +3659,11 @@ Route::latency_preroll (pframes_t nframes, samplepos_t& start_sample, samplepos_ 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 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; @@ -3766,37 +3680,62 @@ Route::roll (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample 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; + run_route (start_sample, end_sample, nframes, declick, (!_disk_writer || !_disk_writer->record_enabled()) && _session.transport_rolling(), true); - BufferSet& bufs = _session.get_route_buffers (n_process_buffers ()); - - 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; } @@ -3808,16 +3747,6 @@ Route::silent_roll (pframes_t nframes, samplepos_t /*start_sample*/, samplepos_t 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 @@ -4043,11 +3972,29 @@ Route::add_export_point() 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... + + 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 = 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 snd = boost::dynamic_pointer_cast (*i)) { + snd->set_delay_in (l_out + _output->latency()); + } + + if (boost::shared_ptr pi = boost::dynamic_pointer_cast (*i)) { + if (boost::shared_ptr 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_output_latency (l_out); if ((*i)->active ()) { l_out += (*i)->signal_latency (); @@ -4059,15 +4006,35 @@ Route::update_signal_latency (bool apply_to_delayline) _signal_latency = l_out; for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { - if ((*i)->active ()) { - l_in += (*i)->signal_latency (); + + /* set sidechain, send and insert port latencies */ + if (boost::shared_ptr pi = boost::dynamic_pointer_cast (*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); + } + + } else if (boost::shared_ptr snd = boost::dynamic_pointer_cast (*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)); + } } + (*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) { @@ -4093,7 +4060,7 @@ void Route::apply_latency_compensation () { if (_delayline) { - samplecnt_t old = _delayline->get_delay (); + samplecnt_t old = _delayline->delay (); samplecnt_t play_lat_in = _input->connected_latency (true); samplecnt_t play_lat_out = _output->connected_latency (true); @@ -4109,7 +4076,7 @@ Route::apply_latency_compensation () _delayline->set_delay (latcomp > 0 ? latcomp : 0); - if (old != _delayline->get_delay ()) { + if (old != _delayline->delay ()) { signal_latency_updated (); /* EMIT SIGNAL */ } } @@ -4642,6 +4609,7 @@ Route::set_private_port_latencies (bool playback) const */ for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) { + if ((*i)->active ()) { own_latency += (*i)->signal_latency (); } @@ -4659,28 +4627,26 @@ Route::set_private_port_latencies (bool playback) const 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 iop = boost::dynamic_pointer_cast(*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. @@ -4734,28 +4700,12 @@ Route::setup_invisible_processors () 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 */ @@ -4894,7 +4844,6 @@ Route::setup_invisible_processors () } } - /* EXPORT PROCESSOR */ if (_capturing_processor) { assert (!_capturing_processor->display_to_user ()); @@ -4903,7 +4852,52 @@ Route::setup_invisible_processors () /* 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); + } } } @@ -5048,7 +5042,11 @@ Route::the_instrument_unlocked () const return boost::shared_ptr(); } - +bool +Route::is_track() +{ + return dynamic_cast(this) != 0; +} void Route::non_realtime_locate (samplepos_t pos) @@ -5449,6 +5447,19 @@ Route::filter_enable_controllable (bool) const #endif } +boost::shared_ptr +Route::tape_drive_controllable () const +{ +#ifdef MIXBUS + + if ( _ch_pre && (is_master() || mixbus()) ) { + return boost::dynamic_pointer_cast (_ch_pre->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 4))); + } +#endif + + return boost::shared_ptr(); +} + string Route::eq_band_name (uint32_t band) const { @@ -5614,6 +5625,43 @@ Route::comp_speed_name (uint32_t mode) const #endif } +boost::shared_ptr +Route::send_pan_azi_controllable (uint32_t n) const +{ +#ifdef MIXBUS +# undef MIXBUS_PORTS_H +# include "../../gtk2_ardour/mixbus_ports.h" + boost::shared_ptr 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 (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_id))); + } + } +#endif + + return boost::shared_ptr(); +} + boost::shared_ptr Route::send_level_controllable (uint32_t n) const { @@ -5855,6 +5903,16 @@ Route::set_disk_io_point (DiskIOPoint diop) processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */ } +void +Route::set_loop (Location* l) +{ + _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); + } +} + #ifdef USE_TRACKS_CODE_FEATURES /* This is the Tracks version of Track::monitoring_state(). @@ -5950,58 +6008,6 @@ 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