X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Froute.cc;h=4d473eb7406d2a945c981a830e69f2a4bc49744c;hb=4e5423b3487771220cdca4c2b1a79c4d74b6afa5;hp=c6e3f157b34b7e55734396623b9a527e96d4b02f;hpb=bcbdd858faff38b9b22573284f07bdb35b76140b;p=ardour.git diff --git a/libs/ardour/route.cc b/libs/ardour/route.cc index c6e3f157b3..4d473eb740 100644 --- a/libs/ardour/route.cc +++ b/libs/ardour/route.cc @@ -30,6 +30,7 @@ #include "pbd/xml++.h" #include "pbd/enumwriter.h" +#include "pbd/locale_guard.h" #include "pbd/memento_command.h" #include "pbd/stacktrace.h" #include "pbd/types_convert.h" @@ -46,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" @@ -54,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" @@ -91,10 +95,8 @@ 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) @@ -114,6 +116,7 @@ Route::Route (Session& sess, string name, PresentationInfo::Flag flag, DataType , _strict_io (false) , _custom_meter_position_noted (false) , _pinmgr_proxy (0) + , _patch_selector_dialog (0) { processor_max_streams.reset(); } @@ -139,10 +142,12 @@ Route::init () /* add standard controls */ _gain_control.reset (new GainControl (_session, GainAutomation)); - add_control (_gain_control); - _trim_control.reset (new GainControl (_session, TrimAutomation)); - add_control (_trim_control); + /* While the route has-a gain-control for consistency with Stripable and VCA + * ownership is handed over to the Amp Processor which manages the + * state of the Control and AutomationList as part of its + * Automatable API. -- Don't call add_control () here. + */ _solo_control.reset (new SoloControl (_session, X_("solo"), *this, *this)); add_control (_solo_control); @@ -286,7 +291,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. */ @@ -296,16 +301,16 @@ 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, + samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes, int declick, bool gain_automation_ok) { /* Caller must hold process lock */ @@ -319,24 +324,21 @@ Route::process_output_buffers (BufferSet& bufs, return; } - _mute_control->automation_run (start_frame, nframes); + automation_run (start_sample, nframes); /* figure out if we're going to use gain automation */ if (gain_automation_ok) { _amp->set_gain_automation_buffer (_session.gain_automation_buffer ()); _amp->setup_gain_automation ( - start_frame + _signal_latency_at_amp_position, - end_frame + _signal_latency_at_amp_position, + start_sample + _amp->output_latency (), + end_sample + _amp->output_latency (), nframes); _trim->set_gain_automation_buffer (_session.trim_automation_buffer ()); _trim->setup_gain_automation ( - start_frame + _signal_latency_at_trim_position, - end_frame + _signal_latency_at_trim_position, + start_sample + _trim->output_latency (), + end_sample + _trim->output_latency (), nframes); - } else { - _amp->apply_gain_automation (false); - _trim->apply_gain_automation (false); } /* Tell main outs what to do about monitoring. We do this so that @@ -416,8 +418,8 @@ 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) { @@ -448,12 +450,13 @@ Route::process_output_buffers (BufferSet& bufs, boost::dynamic_pointer_cast(*i)->set_delay_in(_signal_latency - latency); } if (boost::dynamic_pointer_cast(*i) != 0) { - const framecnt_t longest_session_latency = _initial_delay + _signal_latency; + const samplecnt_t longest_session_latency = _initial_delay + _signal_latency; boost::dynamic_pointer_cast(*i)->set_sidechain_latency ( _initial_delay + latency, longest_session_latency - latency); } - (*i)->run (bufs, start_frame - latency, end_frame - latency, speed, nframes, *i != _processors.back()); + //cerr << name() << " run " << (*i)->name() << endl; + (*i)->run (bufs, start_sample - latency, end_sample - latency, speed, nframes, *i != _processors.back()); bufs.set_count ((*i)->output_streams()); if ((*i)->active ()) { @@ -463,7 +466,7 @@ Route::process_output_buffers (BufferSet& bufs, } 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) { @@ -472,7 +475,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); @@ -523,11 +526,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; } @@ -587,16 +590,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); } void -Route::passthru (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick) +Route::passthru (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes, int declick, bool gain_automation_ok) { _silent = false; @@ -610,18 +613,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); } void -Route::passthru_silence (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick) +Route::passthru_silence (samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes, int declick) { BufferSet& bufs (_session.get_route_buffers (n_process_buffers(), true)); bufs.set_count (_input->n_ports()); - write_out_of_band_data (bufs, start_frame, end_frame, nframes); - process_output_buffers (bufs, start_frame, end_frame, nframes, declick, false); + write_out_of_band_data (bufs, start_sample, end_sample, nframes); + process_output_buffers (bufs, start_sample, end_sample, nframes, declick, false); } void @@ -923,10 +931,6 @@ Route::add_processors (const ProcessorList& others, boost::shared_ptr loc = _processors.end (); } - if (!AudioEngine::instance()->connected()) { - return 1; - } - if (others.empty()) { return 0; } @@ -1233,6 +1237,7 @@ Route::clear_processors (Placement p) _session.set_deletion_in_progress(); } + ProcessorList old_list = _processors; { Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ()); Glib::Threads::RWLock::WriterLock lm (_processor_lock); @@ -1281,13 +1286,15 @@ Route::clear_processors (Placement p) _processors = new_list; configure_processors_unlocked (&err, &lm); // this can't fail } + /* drop references w/o process-lock (I/O procs may re-take it in ~IO() */ + old_list.clear (); processor_max_streams.reset(); _have_internal_generator = false; - processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */ + reset_instrument_info (); set_processor_positions (); - reset_instrument_info (); + processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */ if (!already_deleting) { _session.clear_deletion_in_progress(); @@ -1812,6 +1819,7 @@ Route::configure_processors_unlocked (ProcessorStreams* err, Glib::Threads::RWLo lm->acquire (); return -1; } + processor_max_streams = ChanCount::max(processor_max_streams, c->first); processor_max_streams = ChanCount::max(processor_max_streams, c->second); @@ -2091,6 +2099,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; } @@ -2309,7 +2322,6 @@ Route::get_template() XMLNode& Route::state(bool full_state) { - LocaleGuard lg; if (!_session._template_state_dir.empty()) { foreach_processor (sigc::bind (sigc::mem_fun (*this, &Route::set_plugin_state_dir), _session._template_state_dir)); } @@ -2317,21 +2329,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 ()); @@ -2483,6 +2496,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; @@ -2539,9 +2563,7 @@ Route::set_state (const XMLNode& node, int version) continue; } - if (control_name == _gain_control->name()) { - _gain_control->set_state (*child, version); - } else if (control_name == _solo_control->name()) { + if (control_name == _solo_control->name()) { _solo_control->set_state (*child, version); } else if (control_name == _solo_safe_control->name()) { _solo_safe_control->set_state (*child, version); @@ -2824,92 +2846,18 @@ 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 { - ProcessorList::iterator o; - - for (o = _processors.begin(); o != _processors.end(); ++o) { - XMLProperty const * id_prop = (*niter)->property(X_("id")); - if (id_prop && (*o)->id() == id_prop->value()) { - (*o)->set_state (**niter, Stateful::current_state_version); - new_order.push_back (*o); - break; - } - } - - // If the processor (*niter) is not on the route then create it - - if (o == _processors.end()) { - - boost::shared_ptr processor; - - if (prop->value() == "intsend") { - - processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast(shared_from_this()), boost::shared_ptr(), Delivery::Aux, true)); - - } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" || - prop->value() == "lv2" || - prop->value() == "windows-vst" || - prop->value() == "mac-vst" || - prop->value() == "lxvst" || - prop->value() == "luaproc" || - prop->value() == "audiounit") { - - if (_session.get_disable_all_loaded_plugins ()) { - processor.reset (new UnknownProcessor (_session, **niter)); - } else { - processor.reset (new PluginInsert (_session)); - processor->set_owner (this); - if (_strict_io) { - boost::shared_ptr pi = boost::dynamic_pointer_cast(processor); - pi->set_strict_io (true); - } - - } - } else if (prop->value() == "port") { - - processor.reset (new PortInsert (_session, _pannable, _mute_master)); - - } else if (prop->value() == "send") { - - processor.reset (new Send (_session, _pannable, _mute_master, Delivery::Send, true)); - boost::shared_ptr send = boost::dynamic_pointer_cast (processor); - send->SelfDestruct.connect_same_thread (*this, - boost::bind (&Route::processor_selfdestruct, this, boost::weak_ptr (processor))); - - } else { - error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg; - continue; - } - - if (processor->set_state (**niter, Stateful::current_state_version) != 0) { - /* This processor could not be configured. Turn it into a UnknownProcessor */ - processor.reset (new UnknownProcessor (_session, **niter)); - } - - /* subscribe to Sidechain IO changes */ - boost::shared_ptr pi = boost::dynamic_pointer_cast (processor); - if (pi && pi->has_sidechain ()) { - pi->sidechain_input ()->changed.connect_same_thread (*this, boost::bind (&Route::sidechain_change_handler, this, _1, _2)); - } - - /* we have to note the monitor send here, otherwise a new one will be created - and the state of this one will be lost. - */ - boost::shared_ptr isend = boost::dynamic_pointer_cast (processor); - if (isend && isend->role() == Delivery::Listen) { - _monitor_send = isend; - } - - /* it doesn't matter if invisible processors are added here, as they - will be sorted out by setup_invisible_processors () shortly. - */ - - new_order.push_back (processor); - must_configure = true; - } + set_processor_state (**niter, prop, new_order, must_configure); } } + ProcessorList old_list = _processors; // keep a copy { Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ()); Glib::Threads::RWLock::WriterLock lm (_processor_lock); @@ -2939,12 +2887,101 @@ Route::set_processor_state (const XMLNode& node) } } } + /* drop references w/o process-lock (I/O procs may re-take it in ~IO() */ + old_list.clear (); reset_instrument_info (); processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */ set_processor_positions (); } +bool +Route::set_processor_state (XMLNode const & node, XMLProperty const* prop, ProcessorList& new_order, bool& must_configure) +{ + ProcessorList::iterator o; + + for (o = _processors.begin(); o != _processors.end(); ++o) { + XMLProperty const * id_prop = node.property(X_("id")); + if (id_prop && (*o)->id() == id_prop->value()) { + (*o)->set_state (node, Stateful::current_state_version); + new_order.push_back (*o); + break; + } + } + + // If the processor (node) is not on the route then create it + + if (o == _processors.end()) { + + boost::shared_ptr processor; + + if (prop->value() == "intsend") { + + processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast(shared_from_this()), boost::shared_ptr(), Delivery::Aux, true)); + + } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" || + prop->value() == "lv2" || + prop->value() == "windows-vst" || + prop->value() == "mac-vst" || + prop->value() == "lxvst" || + prop->value() == "luaproc" || + prop->value() == "audiounit") { + + if (_session.get_disable_all_loaded_plugins ()) { + processor.reset (new UnknownProcessor (_session, node)); + } else { + processor.reset (new PluginInsert (_session)); + processor->set_owner (this); + if (_strict_io) { + boost::shared_ptr pi = boost::dynamic_pointer_cast(processor); + pi->set_strict_io (true); + } + + } + } else if (prop->value() == "port") { + + processor.reset (new PortInsert (_session, _pannable, _mute_master)); + + } else if (prop->value() == "send") { + + processor.reset (new Send (_session, _pannable, _mute_master, Delivery::Send, true)); + boost::shared_ptr send = boost::dynamic_pointer_cast (processor); + send->SelfDestruct.connect_same_thread (*this, + boost::bind (&Route::processor_selfdestruct, this, boost::weak_ptr (processor))); + + } else { + return false; + } + + if (processor->set_state (node, Stateful::current_state_version) != 0) { + /* This processor could not be configured. Turn it into a UnknownProcessor */ + processor.reset (new UnknownProcessor (_session, node)); + } + + /* subscribe to Sidechain IO changes */ + boost::shared_ptr pi = boost::dynamic_pointer_cast (processor); + if (pi && pi->has_sidechain ()) { + pi->sidechain_input ()->changed.connect_same_thread (*this, boost::bind (&Route::sidechain_change_handler, this, _1, _2)); + } + + /* we have to note the monitor send here, otherwise a new one will be created + and the state of this one will be lost. + */ + boost::shared_ptr isend = boost::dynamic_pointer_cast (processor); + if (isend && isend->role() == Delivery::Listen) { + _monitor_send = isend; + } + + /* it doesn't matter if invisible processors are added here, as they + will be sorted out by setup_invisible_processors () shortly. + */ + + new_order.push_back (processor); + must_configure = true; + } + return true; +} + void Route::curve_reallocate () { @@ -2953,7 +2990,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()) { @@ -2964,21 +3001,26 @@ 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) { _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; if (!_active && (pi = boost::dynamic_pointer_cast (*i)) != 0) { - // skip plugins, they don't need anything when we're not active + /* evaluate automated automation controls */ + pi->automation_run (now, nframes); + /* skip plugins, they don't need anything when we're not active */ continue; } @@ -3293,26 +3335,26 @@ Route::feeds_according_to_graph (boost::shared_ptr other) /** Called from the (non-realtime) butler thread when the transport is stopped */ void -Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool /*did_locate*/, bool can_flush_processors) +Route::non_realtime_transport_stop (samplepos_t now, bool flush) { - framepos_t now = _session.transport_frame(); - { Glib::Threads::RWLock::ReaderLock lm (_processor_lock); - Automatable::transport_stopped (now); + Automatable::non_realtime_transport_stop (now, flush); for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { - if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && can_flush_processors)) { + if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && flush)) { (*i)->flush (); } - (*i)->transport_stopped (now); + (*i)->non_realtime_transport_stop (now, flush); } } - _roll_delay = _initial_delay; + if (_disk_reader) { + _disk_reader->set_roll_delay (_initial_delay); + } } void @@ -3489,7 +3531,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); @@ -3505,7 +3547,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); @@ -3538,12 +3580,10 @@ Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, fill_buffers_with_input (bufs, _input, nframes); if (_meter_point == MeterInput) { - _meter->run (bufs, start_frame, end_frame, 0.0, nframes, true); + _meter->run (bufs, start_sample, end_sample, 0.0, nframes, true); } - _amp->apply_gain_automation (false); - _trim->apply_gain_automation (false); - passthru (bufs, start_frame, end_frame, nframes, 0); + passthru (bufs, start_sample, end_sample, nframes, 0, true); flush_processor_buffers_locked (nframes); @@ -3551,35 +3591,41 @@ Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, } int -Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& /* need_butler */) +Route::roll (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, int declick, bool& need_butler) { Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK); + if (!lm.locked()) { return 0; } if (!_active) { silence_unlocked (nframes); - return 0; - } - - framepos_t unused = 0; - - if ((nframes = check_initial_delay (nframes, unused)) == 0) { + if (_meter_point == MeterInput && ((_monitoring_control->monitoring_choice() & MonitorInput) || (!_disk_writer || _disk_writer->record_enabled()))) { + _meter->reset(); + } return 0; } _silent = false; - BufferSet& bufs = _session.get_route_buffers (n_process_buffers()); + BufferSet& bufs = _session.get_route_buffers (n_process_buffers ()); fill_buffers_with_input (bufs, _input, nframes); - if (_meter_point == MeterInput) { - _meter->run (bufs, start_frame, end_frame, 1.0, nframes, true); + /* filter captured data before meter sees it */ + filter_input (bufs); + + if (_meter_point == MeterInput && + ((_monitoring_control->monitoring_choice() & MonitorInput) || (_disk_writer && _disk_writer->record_enabled()))) { + _meter->run (bufs, start_sample, end_sample, 1.0 /*speed()*/, nframes, true); } - passthru (bufs, start_frame, end_frame, nframes, declick); + passthru (bufs, start_sample, end_sample, nframes, declick, (!_disk_writer || !_disk_writer->record_enabled()) && _session.transport_rolling()); + + if ((_disk_reader && _disk_reader->need_butler()) || (_disk_writer && _disk_writer->need_butler())) { + need_butler = true; + } flush_processor_buffers_locked (nframes); @@ -3587,7 +3633,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); @@ -3639,6 +3685,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); @@ -3811,8 +3861,9 @@ Route::add_export_point() Glib::Threads::RWLock::WriterLock lw (_processor_lock); // this aligns all tracks; but not tracks + busses - assert (_session.worst_track_latency () >= _initial_delay); - _capturing_processor.reset (new CapturingProcessor (_session, _session.worst_track_latency () - _initial_delay)); + samplecnt_t latency = _session.worst_track_roll_delay (); + assert (latency >= _initial_delay); + _capturing_processor.reset (new CapturingProcessor (_session, latency - _initial_delay)); _capturing_processor->activate (); configure_processors_unlocked (0, &lw); @@ -3822,41 +3873,40 @@ Route::add_export_point() return _capturing_processor; } -framecnt_t -Route::update_signal_latency () +samplecnt_t +Route::update_signal_latency (bool set_initial_delay) { - framecnt_t l = _output->user_latency(); - framecnt_t lamp = 0; - bool before_amp = true; - framecnt_t ltrim = 0; - bool before_trim = true; + Glib::Threads::RWLock::ReaderLock lm (_processor_lock); + + samplecnt_t l_in = _input->latency (); + samplecnt_t l_out = _output->user_latency(); for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { if ((*i)->active ()) { - l += (*i)->signal_latency (); - } - if ((*i) == _amp) { - before_amp = false; + l_in += (*i)->signal_latency (); } - if ((*i) == _trim) { - before_amp = false; - } - if (before_amp) { - lamp = l; - } - if (before_trim) { - lamp = l; + (*i)->set_input_latency (l_in); + } + + for (ProcessorList::reverse_iterator i = _processors.rbegin(); i != _processors.rend(); ++i) { + (*i)->set_output_latency (l_out); + if ((*i)->active ()) { + l_out += (*i)->signal_latency (); } } - DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l)); + DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l_out)); + + _signal_latency = l_out; - // 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 (set_initial_delay) { + /* see also Session::post_playback_latency() */ + set_latency_compensation (_session.worst_track_latency () + _session.worst_track_out_latency () - output ()->latency ()); + } - if (_signal_latency != l) { - _signal_latency = l; + if (_signal_latency != l_out) { signal_latency_changed (); /* EMIT SIGNAL */ } @@ -3864,19 +3914,20 @@ 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::set_latency_compensation (samplecnt_t longest_session_latency) { - framecnt_t old = _initial_delay; + samplecnt_t old = _initial_delay; + assert (!_disk_reader || _disk_reader->output_latency () <= _signal_latency); - if (_signal_latency < longest_session_latency) { - _initial_delay = longest_session_latency - _signal_latency; + if (_disk_reader && _disk_reader->output_latency () < longest_session_latency) { + _initial_delay = longest_session_latency - _disk_reader->output_latency (); } else { _initial_delay = 0; } @@ -3891,7 +3942,9 @@ Route::set_latency_compensation (framecnt_t longest_session_latency) } if (_session.transport_stopped()) { - _roll_delay = _initial_delay; + if (_disk_reader) { + _disk_reader->set_roll_delay (_initial_delay); + } } } @@ -3932,18 +3985,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)); } @@ -3953,7 +4006,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)); } @@ -3969,7 +4022,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)); } @@ -3988,7 +4041,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)); } @@ -4009,12 +4062,22 @@ Route::set_plugin_state_dir (boost::weak_ptr p, const std::string& d) } int -Route::save_as_template (const string& path, const string& name) +Route::save_as_template (const string& path, const string& name, const string& description) { std::string state_dir = path.substr (0, path.find_last_of ('.')); // strip template_suffix PBD::Unwinder uw (_session._template_state_dir, state_dir); XMLNode& node (state (false)); + node.set_property (X_("name"), name); + + node.remove_nodes (X_("description")); + if (!description.empty()) { + XMLNode* desc = new XMLNode(X_("description")); + XMLNode* desc_cont = new XMLNode(X_("content"), description); + desc->add_child_nocopy (*desc_cont); + + node.add_child_nocopy (*desc); + } XMLTree tree; @@ -4346,8 +4409,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. @@ -4395,10 +4458,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. @@ -4427,7 +4490,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. @@ -4478,6 +4541,8 @@ Route::setup_invisible_processors () */ ProcessorList new_processors; + ProcessorList::iterator dr; + ProcessorList::iterator dw; /* find visible processors */ @@ -4597,9 +4662,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 */ @@ -4615,11 +4683,57 @@ Route::setup_invisible_processors () /* EXPORT PROCESSOR */ + /* DISK READER & WRITER (for Track objects) */ + + if (_disk_reader || _disk_writer) { + switch (_disk_io_point) { + case DiskIOPreFader: + if (trim != new_processors.end()) { + /* insert BEFORE TRIM */ + if (_disk_writer) { + new_processors.insert (trim, _disk_writer); + } + if (_disk_reader) { + new_processors.insert (trim, _disk_reader); + } + } else { + if (_disk_writer) { + new_processors.push_front (_disk_writer); + } + if (_disk_reader) { + new_processors.push_front (_disk_reader); + } + } + break; + case DiskIOPostFader: + /* insert BEFORE main outs */ + if (_disk_writer) { + new_processors.insert (main, _disk_writer); + } + if (_disk_reader) { + new_processors.insert (main, _disk_reader); + } + break; + case DiskIOCustom: + /* reader and writer are visible under this condition, so they + * are not invisible and thus not handled here. + */ + break; + } + } + if (_capturing_processor) { assert (!_capturing_processor->display_to_user ()); - new_processors.push_front (_capturing_processor); + ProcessorList::iterator reader_pos = find (new_processors.begin(), new_processors.end(), _disk_reader); + if (reader_pos != new_processors.end()) { + /* insert after disk-reader */ + new_processors.insert (++reader_pos, _capturing_processor); + } else { + new_processors.push_front (_capturing_processor); + } } + _processors = new_processors; for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { @@ -4706,15 +4820,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. */ @@ -4763,10 +4868,12 @@ 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); + if (_pannable) { - _pannable->transport_located (pos); + _pannable->non_realtime_locate (pos); } if (_delayline.get()) { @@ -4778,10 +4885,13 @@ Route::non_realtime_locate (framepos_t pos) Glib::Threads::RWLock::ReaderLock lm (_processor_lock); for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { - (*i)->transport_located (pos); + (*i)->non_realtime_locate (pos); } } - _roll_delay = _initial_delay; + + if (_disk_reader) { + _disk_reader->set_roll_delay (_initial_delay); + } } void @@ -4830,7 +4940,6 @@ Route::fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr io, pfram boost::shared_ptr source_port = io->audio (i); AudioBuffer& buf (bufs.get_audio (i%n_buffers)); - if (i < n_buffers) { /* first time through just copy a channel into @@ -5042,10 +5151,10 @@ Route::eq_freq_controllable (uint32_t band) const uint32_t port_number; #ifdef MIXBUS32C switch (band) { - case 0: port_number = 13; break; - case 1: port_number = 11; break; - case 2: port_number = 9; break; - case 3: port_number = 7; break; + case 0: port_number = 13; break; // lo + case 1: port_number = 11; break; // lo mid + case 2: port_number = 9; break; // hi mid + case 3: port_number = 7; break; // hi default: return boost::shared_ptr(); } @@ -5074,6 +5183,22 @@ Route::eq_q_controllable (uint32_t band) const boost::shared_ptr Route::eq_shape_controllable (uint32_t band) const { +#ifdef MIXBUS32C + boost::shared_ptr eq = ch_eq(); + if (is_master() || mixbus() || !eq) { + return boost::shared_ptr(); + } + switch (band) { + case 0: + return boost::dynamic_pointer_cast (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 4))); // lo bell + break; + case 3: + return boost::dynamic_pointer_cast (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 3))); // hi bell + break; + default: + break; + } +#endif return boost::shared_ptr(); } @@ -5094,7 +5219,7 @@ Route::eq_enable_controllable () const } boost::shared_ptr -Route::eq_hpf_controllable () const +Route::filter_freq_controllable (bool hpf) const { #ifdef MIXBUS boost::shared_ptr eq = ch_eq(); @@ -5102,12 +5227,42 @@ Route::eq_hpf_controllable () const if (is_master() || mixbus() || !eq) { return boost::shared_ptr(); } + if (hpf) { #ifdef MIXBUS32C - return boost::dynamic_pointer_cast (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 3))); + return boost::dynamic_pointer_cast (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 5))); // HPF freq #else - return boost::dynamic_pointer_cast (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2))); + return boost::dynamic_pointer_cast (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2))); #endif + } else { +#ifdef MIXBUS32C + return boost::dynamic_pointer_cast (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 6))); // LPF freq +#else + return boost::shared_ptr(); +#endif + } + +#else + return boost::shared_ptr(); +#endif +} + +boost::shared_ptr +Route::filter_slope_controllable (bool) const +{ + return boost::shared_ptr(); +} + +boost::shared_ptr +Route::filter_enable_controllable (bool) const +{ +#ifdef MIXBUS32C + boost::shared_ptr eq = ch_eq(); + + if (is_master() || mixbus() || !eq) { + return boost::shared_ptr(); + } + return boost::dynamic_pointer_cast (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2))); #else return boost::shared_ptr(); #endif @@ -5285,7 +5440,7 @@ Route::send_level_controllable (uint32_t n) const # undef MIXBUS_PORTS_H # include "../../gtk2_ardour/mixbus_ports.h" boost::shared_ptr plug = ch_post(); - if (plug) { + if (plug && !mixbus()) { uint32_t port_id = 0; switch (n) { case 0: port_id = port_channel_post_aux1_level; break; @@ -5332,7 +5487,7 @@ Route::send_enable_controllable (uint32_t n) const # undef MIXBUS_PORTS_H # include "../../gtk2_ardour/mixbus_ports.h" boost::shared_ptr plug = ch_post(); - if (plug) { + if (plug && !mixbus()) { uint32_t port_id = 0; switch (n) { case 0: port_id = port_channel_post_aux1_asgn; break; @@ -5377,17 +5532,20 @@ string Route::send_name (uint32_t n) const { #ifdef MIXBUS + boost::shared_ptr plug = ch_post(); + if (plug && !mixbus()) { # ifdef MIXBUS32C - if (n < 12) { - return _session.get_mixbus (n)->name(); - } - n -= 12; + if (n < 12) { + return _session.get_mixbus (n)->name(); + } + n -= 12; #else - if (n < 8) { - return _session.get_mixbus (n)->name(); - } - n -= 8; + if (n < 8) { + return _session.get_mixbus (n)->name(); + } + n -= 8; # endif + } #endif boost::shared_ptr p = nth_send (n); if (p) { @@ -5470,3 +5628,199 @@ Route::automation_control_recurse (PBD::ID const & id) const return boost::shared_ptr (); } + +SlavableControlList +Route::slavables () const +{ + SlavableControlList rv; + rv.push_back (_gain_control); + rv.push_back (_mute_control); + rv.push_back (_solo_control); + return rv; +} + +void +Route::set_disk_io_point (DiskIOPoint diop) +{ + bool display = false; + + cerr << "set disk io to " << enum_2_string (diop) << endl; + + switch (diop) { + case DiskIOCustom: + display = true; + break; + default: + display = false; + } + + if (_disk_writer) { + _disk_writer->set_display_to_user (display); + } + + if (_disk_reader) { + _disk_reader->set_display_to_user (display); + } + + const bool changed = (diop != _disk_io_point); + + _disk_io_point = diop; + + if (changed) { + Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ()); + configure_processors (0); + } + + processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */ +} + +#ifdef USE_TRACKS_CODE_FEATURES + +/* This is the Tracks version of Track::monitoring_state(). + * + * Ardour developers: try to flag or fix issues if parts of the libardour API + * change in ways that invalidate this + */ + +MonitorState +Route::monitoring_state () const +{ + /* Explicit requests */ + + if (_monitoring != MonitorInput) { + return MonitoringInput; + } + + if (_monitoring & MonitorDisk) { + return MonitoringDisk; + } + + /* This is an implementation of the truth table in doc/monitor_modes.pdf; + I don't think it's ever going to be too pretty too look at. + */ + + // GZ: NOT USED IN TRACKS + //bool const auto_input = _session.config.get_auto_input (); + //bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring; + //bool const tape_machine_mode = Config->get_tape_machine_mode (); + + bool const roll = _session.transport_rolling (); + bool const track_rec = _diskstream->record_enabled (); + bool session_rec = _session.actively_recording (); + + if (track_rec) { + + if (!session_rec && roll) { + return MonitoringDisk; + } else { + return MonitoringInput; + } + + } else { + + if (roll) { + return MonitoringDisk; + } + } + + return MonitoringSilence; +} + +#else + +/* This is the Ardour/Mixbus version of Track::monitoring_state(). + * + * Tracks developers: do NOT modify this method under any circumstances. + */ + +MonitorState +Route::monitoring_state () const +{ + if (!_disk_reader) { + return MonitoringInput; + } + + /* Explicit requests */ + MonitorChoice m (_monitoring_control->monitoring_choice()); + + if (m != MonitorAuto) { + + MonitorState ms ((MonitorState) 0); + + if (m & MonitorInput) { + ms = MonitoringInput; + } + + if (m & MonitorDisk) { + ms = MonitorState (ms | MonitoringDisk); + } + + return ms; + } + + switch (_session.config.get_session_monitoring ()) { + case MonitorDisk: + return MonitoringDisk; + break; + case MonitorInput: + return MonitoringInput; + break; + default: + break; + } + + /* This is an implementation of the truth table in doc/monitor_modes.pdf; + I don't think it's ever going to be too pretty too look at. + */ + + bool const roll = _session.transport_rolling (); + bool const track_rec = _disk_writer->record_enabled (); + bool const auto_input = _session.config.get_auto_input (); + bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring; + bool const tape_machine_mode = Config->get_tape_machine_mode (); + bool session_rec; + + /* I suspect that just use actively_recording() is good enough all the + * time, but just to keep the semantics the same as they were before + * sept 26th 2012, we differentiate between the cases where punch is + * enabled and those where it is not. + * + * rg: I suspect this is not the case: monitoring may differ + */ + + if (_session.config.get_punch_in() || _session.config.get_punch_out() || _session.preroll_record_punch_enabled ()) { + session_rec = _session.actively_recording (); + } else { + session_rec = _session.get_record_enabled(); + } + + if (track_rec) { + + if (!session_rec && roll && auto_input) { + return MonitoringDisk; + } else { + return software_monitor ? MonitoringInput : MonitoringSilence; + } + + } else { + + if (tape_machine_mode) { + + return MonitoringDisk; + + } else { + + if (!roll && auto_input) { + return software_monitor ? MonitoringInput : MonitoringSilence; + } else { + return MonitoringDisk; + } + + } + } + + abort(); /* NOTREACHED */ + return MonitoringSilence; +} + +#endif