X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Froute.cc;h=f39b094ccd97ffc4143e6db906d1b01b1a51a36c;hb=10933e200369ecceb2c8b3a52be41b930955d269;hp=1ea43e4a64c99cc4c61d613dc52b44771dea2292;hpb=1cc5a1829bd2b2fcee956b76d8065bfb68c1adc3;p=ardour.git diff --git a/libs/ardour/route.cc b/libs/ardour/route.cc index 1ea43e4a64..046bf7998e 100644 --- a/libs/ardour/route.cc +++ b/libs/ardour/route.cc @@ -26,6 +26,8 @@ #include #include +#include + #include "pbd/xml++.h" #include "pbd/enumwriter.h" #include "pbd/memento_command.h" @@ -33,23 +35,20 @@ #include "pbd/convert.h" #include "pbd/boost_debug.h" -#include "evoral/Curve.hpp" - #include "ardour/amp.h" +#include "ardour/audio_buffer.h" #include "ardour/audio_port.h" #include "ardour/audioengine.h" #include "ardour/buffer.h" #include "ardour/buffer_set.h" -#include "ardour/configuration.h" -#include "ardour/cycle_timer.h" +#include "ardour/capturing_processor.h" #include "ardour/debug.h" #include "ardour/delivery.h" -#include "ardour/dB.h" -#include "ardour/internal_send.h" #include "ardour/internal_return.h" -#include "ardour/ladspa_plugin.h" +#include "ardour/internal_send.h" #include "ardour/meter.h" -#include "ardour/mix.h" +#include "ardour/midi_buffer.h" +#include "ardour/midi_port.h" #include "ardour/monitor_processor.h" #include "ardour/pannable.h" #include "ardour/panner.h" @@ -58,16 +57,12 @@ #include "ardour/port.h" #include "ardour/port_insert.h" #include "ardour/processor.h" -#include "ardour/profile.h" #include "ardour/route.h" #include "ardour/route_group.h" #include "ardour/send.h" #include "ardour/session.h" -#include "ardour/timestamps.h" -#include "ardour/utils.h" -#include "ardour/graph.h" #include "ardour/unknown_processor.h" -#include "ardour/capturing_processor.h" +#include "ardour/utils.h" #include "i18n.h" @@ -75,14 +70,13 @@ using namespace std; using namespace ARDOUR; using namespace PBD; -uint32_t Route::order_key_cnt = 0; -PBD::Signal1 Route::SyncOrderKeys; +PBD::Signal0 Route::SyncOrderKeys; PBD::Signal0 Route::RemoteControlIDChange; Route::Route (Session& sess, string name, Flag flg, DataType default_type) : SessionObject (sess, name) , Automatable (sess) - , GraphNode( sess.route_graph ) + , GraphNode (sess._process_graph) , _active (true) , _signal_latency (0) , _initial_delay (0) @@ -90,6 +84,7 @@ Route::Route (Session& sess, string name, Flag flg, DataType default_type) , _flags (flg) , _pending_declick (true) , _meter_point (MeterPostFader) + , _meter_type (MeterPeak) , _self_solo (false) , _soloed_by_others_upstream (0) , _soloed_by_others_downstream (0) @@ -102,11 +97,18 @@ Route::Route (Session& sess, string name, Flag flg, DataType default_type) , _have_internal_generator (false) , _solo_safe (false) , _default_type (default_type) + , _order_key (0) + , _has_order_key (false) , _remote_control_id (0) , _in_configure_processors (false) + , _initial_io_setup (false) + , _custom_meter_position_noted (false) + , _last_custom_meter_was_at_end (false) { + if (is_master()) { + _meter_type = MeterK20; + } processor_max_streams.reset(); - order_keys[N_("signal")] = order_key_cnt++; } int @@ -125,11 +127,9 @@ Route::init () /* panning */ - Pannable* p = new Pannable (_session); -#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS - boost_debug_shared_ptr_mark_interesting (p, "Pannable"); -#endif - _pannable.reset (p); + if (!(_flags & Route::MonitorOut)) { + _pannable.reset (new Pannable (_session)); + } /* input and output objects */ @@ -139,6 +139,9 @@ Route::init () _input->changed.connect_same_thread (*this, boost::bind (&Route::input_change_handler, this, _1, _2)); _input->PortCountChanging.connect_same_thread (*this, boost::bind (&Route::input_port_count_changing, this, _1)); + _output->changed.connect_same_thread (*this, boost::bind (&Route::output_change_handler, this, _1, _2)); + _output->PortCountChanging.connect_same_thread (*this, boost::bind (&Route::output_port_count_changing, this, _1)); + /* add amp processor */ _amp.reset (new Amp (_session)); @@ -148,7 +151,8 @@ Route::init () they will be added to _processors by setup_invisible_processors () */ - _meter.reset (new PeakMeter (_session)); + _meter.reset (new PeakMeter (_session, _name)); + _meter->set_owner (this); _meter->set_display_to_user (false); _meter->activate (); @@ -160,14 +164,14 @@ Route::init () _intreturn.reset (new InternalReturn (_session)); _intreturn->activate (); - /* the thing that provides proper control over a control/monitor/listen bus + /* the thing that provides proper control over a control/monitor/listen bus (such as per-channel cut, dim, solo, invert, etc). */ _monitor_control.reset (new MonitorProcessor (_session)); _monitor_control->activate (); } - if (is_master() || is_monitor() || is_hidden()) { + if (is_master() || is_monitor() || is_auditioner()) { _mute_master->set_solo_ignore (true); } @@ -176,8 +180,7 @@ Route::init () Metering::Meter.connect_same_thread (*this, (boost::bind (&Route::meter, this))); { - /* run a configure so that the invisible processors get set up */ - Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ()); + Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ()); configure_processors (0); } @@ -188,16 +191,16 @@ Route::~Route () { DEBUG_TRACE (DEBUG::Destruction, string_compose ("route %1 destructor\n", _name)); - /* do this early so that we don't get incoming signals as we are going through destruction + /* do this early so that we don't get incoming signals as we are going through destruction */ drop_connections (); /* don't use clear_processors here, as it depends on the session which may - be half-destroyed by now + be half-destroyed by now */ - Glib::RWLock::WriterLock lm (_processor_lock); + Glib::Threads::RWLock::WriterLock lm (_processor_lock); for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { (*i)->drop_references (); } @@ -208,9 +211,44 @@ Route::~Route () void Route::set_remote_control_id (uint32_t id, bool notify_class_listeners) { - if (id != _remote_control_id) { + if (Config->get_remote_model() != UserOrdered) { + return; + } + + set_remote_control_id_internal (id, notify_class_listeners); +} + +void +Route::set_remote_control_id_internal (uint32_t id, bool notify_class_listeners) +{ + /* force IDs for master/monitor busses and prevent + any other route from accidentally getting these IDs + (i.e. legacy sessions) + */ + + if (is_master() && id != MasterBusRemoteControlID) { + id = MasterBusRemoteControlID; + } + + if (is_monitor() && id != MonitorBusRemoteControlID) { + id = MonitorBusRemoteControlID; + } + + if (id < 1) { + return; + } + + /* don't allow it to collide */ + + if (!is_master () && !is_monitor() && + (id == MasterBusRemoteControlID || id == MonitorBusRemoteControlID)) { + id += MonitorBusRemoteControlID; + } + + if (id != remote_control_id()) { _remote_control_id = id; RemoteControlIDChanged (); + if (notify_class_listeners) { RemoteControlIDChange (); } @@ -220,88 +258,68 @@ Route::set_remote_control_id (uint32_t id, bool notify_class_listeners) uint32_t Route::remote_control_id() const { + if (is_master()) { + return MasterBusRemoteControlID; + } + + if (is_monitor()) { + return MonitorBusRemoteControlID; + } + return _remote_control_id; } -int32_t -Route::order_key (std::string const & name) const +bool +Route::has_order_key () const { - OrderKeys::const_iterator i = order_keys.find (name); - if (i == order_keys.end()) { - return -1; - } + return _has_order_key; +} - return i->second; +uint32_t +Route::order_key () const +{ + return _order_key; } void -Route::set_order_key (std::string const & name, int32_t n) +Route::set_remote_control_id_explicit (uint32_t rid) { - bool changed = false; - - /* This method looks more complicated than it should, but - it's important that we don't emit order_key_changed unless - it actually has, as expensive things happen on receipt of that - signal. - */ - - if (order_keys.find(name) == order_keys.end() || order_keys[name] != n) { - order_keys[name] = n; - changed = true; + if (is_master() || is_monitor() || is_auditioner()) { + /* hard-coded remote IDs, or no remote ID */ + return; } - if (Config->get_sync_all_route_ordering()) { - for (OrderKeys::iterator x = order_keys.begin(); x != order_keys.end(); ++x) { - if (x->second != n) { - x->second = n; - changed = true; - } - } + if (_remote_control_id != rid) { + DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("%1: set edit-based RID to %2\n", name(), rid)); + _remote_control_id = rid; + RemoteControlIDChanged (); /* EMIT SIGNAL (per-route) */ } - if (changed) { - order_key_changed (); /* EMIT SIGNAL */ - _session.set_dirty (); - } + /* don't emit the class-level RID signal RemoteControlIDChange here, + leave that to the entity that changed the order key, so that we + don't get lots of emissions for no good reasons (e.g. when changing + all route order keys). + + See Session::sync_remote_id_from_order_keys() for the (primary|only) + spot where that is emitted. + */ } -/** Set all order keys to be the same as that for `base', if such a key - * exists in this route. - * @param base Base key. - */ void -Route::sync_order_keys (std::string const & base) +Route::set_order_key (uint32_t n) { - if (order_keys.empty()) { + _has_order_key = true; + + if (_order_key == n) { return; } - OrderKeys::iterator i; - int32_t key; - - if ((i = order_keys.find (base)) == order_keys.end()) { - /* key doesn't exist, use the first existing key (during session initialization) */ - i = order_keys.begin(); - key = i->second; - ++i; - } else { - /* key exists - use it and reset all others (actually, itself included) */ - key = i->second; - i = order_keys.begin(); - } + _order_key = n; - bool changed = false; - - for (; i != order_keys.end(); ++i) { - if (i->second != key) { - i->second = key; - changed = true; - } - } + DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("%1 order key set to %2\n", + name(), order_key ())); - if (changed) { - order_key_changed (); /* EMIT SIGNAL */ - } + _session.set_dirty (); } string @@ -399,23 +417,25 @@ Route::maybe_declick (BufferSet&, framecnt_t, int) void Route::process_output_buffers (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, - bool /*with_processors*/, int declick, - bool gain_automation_ok) + int declick, bool gain_automation_ok) { - bool monitor = should_monitor (); - - bufs.is_silent (false); + Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK); + assert(lm.locked()); /* 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, end_frame, nframes); } else { _amp->apply_gain_automation (false); } - /* tell main outs what to do about monitoring */ - _main_outs->no_outs_cuz_we_no_monitor (!monitor); + /* 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. + */ + _main_outs->no_outs_cuz_we_no_monitor (monitoring_state () == MonitoringSilence); /* ------------------------------------------------------------------------------------------- GLOBAL DECLICK (for transport changes etc.) @@ -480,23 +500,30 @@ Route::process_output_buffers (BufferSet& bufs, and go .... ----------------------------------------------------------------------------------------- */ + /* set this to be true if the meter will already have been ::run() earlier */ + bool const meter_already_run = metering_state() == MeteringInput; + for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { - if (boost::dynamic_pointer_cast (*i)) { - break; + 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 ((*i)->input_streams() != ChanCount::ZERO) { + if (boost::dynamic_pointer_cast (*i) == 0 && (*i)->input_streams() != ChanCount::ZERO) { if (bufs.count() != (*i)->input_streams()) { - cerr << _name << " bufs = " << bufs.count() - << " input for " << (*i)->name() << " = " << (*i)->input_streams() - << endl; - abort (); + DEBUG_TRACE ( + DEBUG::Processors, string_compose ( + "input port mismatch %1 bufs = %2 input for %3 = %4\n", + _name, bufs.count(), (*i)->name(), (*i)->input_streams() + ) + ); } } -#endif +#endif + /* should we NOT run plugins here if the route is inactive? do we catch route != active somewhere higher? */ @@ -513,52 +540,41 @@ Route::n_process_buffers () } void -Route::passthru (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick) +Route::monitor_run (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick) { - BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers()); + 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); +} +void +Route::passthru (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick) +{ _silent = false; - assert (bufs.available() >= input_streams()); - - if (_input->n_ports() == ChanCount::ZERO) { - silence_unlocked (nframes); - } - - bufs.set_count (input_streams()); - if (is_monitor() && _session.listening() && !_session.is_auditioning()) { /* control/monitor bus ignores input ports when something is feeding the listen "stream". data will "arrive" into the route from the intreturn processor element. */ - bufs.silence (nframes, 0); - - } else { - for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) { - - BufferSet::iterator o = bufs.begin(*t); - PortSet& ports (_input->ports()); - - for (PortSet::iterator i = ports.begin(*t); i != ports.end(*t); ++i, ++o) { - o->read_from (i->get_buffer(nframes), nframes); - } - } + bufs.silence (nframes, 0); } write_out_of_band_data (bufs, start_frame, end_frame, nframes); - process_output_buffers (bufs, start_frame, end_frame, nframes, true, declick, true); + process_output_buffers (bufs, start_frame, end_frame, nframes, declick, true); } void Route::passthru_silence (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick) { - BufferSet& bufs (_session.get_silent_buffers (n_process_buffers())); + 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, true, declick, false); + process_output_buffers (bufs, start_frame, end_frame, nframes, declick, false); } void @@ -568,6 +584,11 @@ Route::set_listen (bool yn, void* src) return; } + if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) { + _route_group->foreach_route (boost::bind (&Route::set_listen, _1, yn, _route_group)); + return; + } + if (_monitor_send) { if (yn != _monitor_send->active()) { if (yn) { @@ -599,7 +620,7 @@ Route::set_solo_safe (bool yn, void *src) if (_solo_safe != yn) { _solo_safe = yn; solo_safe_changed (src); - } + } } bool @@ -612,6 +633,7 @@ void Route::set_solo (bool yn, void *src) { if (_solo_safe) { + DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 ignore solo change due to solo-safe\n", name())); return; } @@ -620,6 +642,9 @@ Route::set_solo (bool yn, void *src) return; } + DEBUG_TRACE (DEBUG::Solo, string_compose ("%1: set solo => %2, src: %3 grp ? %4 currently self-soloed ? %5\n", + name(), yn, src, (src == _route_group), self_soloed())); + if (self_soloed() != yn) { set_self_solo (yn); set_mute_master_solo (); @@ -631,6 +656,7 @@ Route::set_solo (bool yn, void *src) void Route::set_self_solo (bool yn) { + DEBUG_TRACE (DEBUG::Solo, string_compose ("%1: set SELF solo => %2\n", name(), yn)); _self_solo = yn; } @@ -638,9 +664,13 @@ void Route::mod_solo_by_others_upstream (int32_t delta) { if (_solo_safe) { + DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 ignore solo-by-upstream due to solo-safe\n", name())); return; } + DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 mod solo-by-upstream by %2, current up = %3 down = %4\n", + name(), delta, _soloed_by_others_upstream, _soloed_by_others_downstream)); + uint32_t old_sbu = _soloed_by_others_upstream; if (delta < 0) { @@ -655,16 +685,16 @@ Route::mod_solo_by_others_upstream (int32_t delta) DEBUG_TRACE (DEBUG::Solo, string_compose ( "%1 SbU delta %2 = %3 old = %4 sbd %5 ss %6 exclusive %7\n", - name(), delta, _soloed_by_others_upstream, old_sbu, + name(), delta, _soloed_by_others_upstream, old_sbu, _soloed_by_others_downstream, _self_solo, Config->get_exclusive_solo())); - /* push the inverse solo change to everything that feeds us. + /* push the inverse solo change to everything that feeds us. This is important for solo-within-group. When we solo 1 track out of N that feed a bus, that track will cause mod_solo_by_upstream (+1) to be called on the bus. The bus then needs to call mod_solo_by_downstream (-1) on all tracks that feed it. This will silence them if they were audible because - of a bus solo, but the newly soloed track will still be audible (because + of a bus solo, but the newly soloed track will still be audible (because it is self-soloed). but .. do this only when we are being told to solo-by-upstream (i.e delta = +1), @@ -672,7 +702,7 @@ Route::mod_solo_by_others_upstream (int32_t delta) */ if ((_self_solo || _soloed_by_others_downstream) && - ((old_sbu == 0 && _soloed_by_others_upstream > 0) || + ((old_sbu == 0 && _soloed_by_others_upstream > 0) || (old_sbu > 0 && _soloed_by_others_upstream == 0))) { if (delta > 0 || !Config->get_exclusive_solo()) { @@ -683,7 +713,7 @@ Route::mod_solo_by_others_upstream (int32_t delta) sr->mod_solo_by_others_downstream (-delta); } } - } + } } set_mute_master_solo (); @@ -694,9 +724,13 @@ void Route::mod_solo_by_others_downstream (int32_t delta) { if (_solo_safe) { + DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 ignore solo-by-downstream due to solo safe\n", name())); return; } + DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 mod solo-by-downstream by %2, current up = %3 down = %4\n", + name(), delta, _soloed_by_others_upstream, _soloed_by_others_downstream)); + if (delta < 0) { if (_soloed_by_others_downstream >= (uint32_t) abs (delta)) { _soloed_by_others_downstream += delta; @@ -722,7 +756,7 @@ Route::set_mute_master_solo () void Route::set_solo_isolated (bool yn, void *src) { - if (is_master() || is_monitor() || is_hidden()) { + if (is_master() || is_monitor() || is_auditioner()) { return; } @@ -730,19 +764,19 @@ Route::set_solo_isolated (bool yn, void *src) _route_group->foreach_route (boost::bind (&Route::set_solo_isolated, _1, yn, _route_group)); return; } - + /* forward propagate solo-isolate status to everything fed by this route, but not those via sends only */ boost::shared_ptr routes = _session.get_routes (); for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) { - if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) { + if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) { continue; } bool sends_only; - bool does_feed = direct_feeds (*i, &sends_only); // we will recurse anyway, so don't use ::feeds() - + bool does_feed = direct_feeds_according_to_graph (*i, &sends_only); // we will recurse anyway, so don't use ::feeds() + if (does_feed && !sends_only) { (*i)->set_solo_isolated (yn, (*i)->route_group()); } @@ -801,6 +835,11 @@ Route::set_mute (bool yn, void *src) if (muted() != yn) { _mute_master->set_muted_by_self (yn); + /* allow any derived classes to respond to the mute change + before anybody else knows about it. + */ + act_on_mute (); + /* tell everyone else */ mute_changed (src); /* EMIT SIGNAL */ _mute_control->Changed (); /* EMIT SIGNAL */ } @@ -819,22 +858,23 @@ dump_processors(const string& name, const list >& p cerr << name << " {" << endl; for (list >::const_iterator p = procs.begin(); p != procs.end(); ++p) { - cerr << "\t" << (*p)->name() << " ID = " << (*p)->id() << endl; + cerr << "\t" << (*p)->name() << " ID = " << (*p)->id() << " @ " << (*p) << endl; } cerr << "}" << endl; } #endif -int -Route::add_processor (boost::shared_ptr processor, Placement placement, ProcessorStreams* err, bool activation_allowed) +/** Supposing that we want to insert a Processor at a given Placement, return + * the processor to add the new one before (or 0 to add at the end). + */ +boost::shared_ptr +Route::before_processor_for_placement (Placement p) { - ProcessorList::iterator loc; - - /* XXX this is not thread safe - we don't hold the lock across determining the iter - to add before and actually doing the insertion. dammit. - */ + Glib::Threads::RWLock::ReaderLock lm (_processor_lock); - if (placement == PreFader) { + ProcessorList::iterator loc; + + if (p == PreFader) { /* generic pre-fader: insert immediately before the amp */ loc = find (_processors.begin(), _processors.end(), _amp); } else { @@ -842,64 +882,114 @@ Route::add_processor (boost::shared_ptr processor, Placement placemen loc = find (_processors.begin(), _processors.end(), _main_outs); } - return add_processor (processor, loc, err, activation_allowed); + return loc != _processors.end() ? *loc : boost::shared_ptr (); +} + +/** Supposing that we want to insert a Processor at a given index, return + * the processor to add the new one before (or 0 to add at the end). + */ +boost::shared_ptr +Route::before_processor_for_index (int index) +{ + if (index == -1) { + return boost::shared_ptr (); + } + + Glib::Threads::RWLock::ReaderLock lm (_processor_lock); + + ProcessorList::iterator i = _processors.begin (); + int j = 0; + while (i != _processors.end() && j < index) { + if ((*i)->display_to_user()) { + ++j; + } + + ++i; + } + + return (i != _processors.end() ? *i : boost::shared_ptr ()); +} + +/** Add a processor either pre- or post-fader + * @return 0 on success, non-0 on failure. + */ +int +Route::add_processor (boost::shared_ptr processor, Placement placement, ProcessorStreams* err, bool activation_allowed) +{ + return add_processor (processor, before_processor_for_placement (placement), err, activation_allowed); } +/** Add a processor to a route such that it ends up with a given index into the visible processors. + * @param index Index to add the processor at, or -1 to add at the end of the list. + * @return 0 on success, non-0 on failure. + */ +int +Route::add_processor_by_index (boost::shared_ptr processor, int index, ProcessorStreams* err, bool activation_allowed) +{ + return add_processor (processor, before_processor_for_index (index), err, activation_allowed); +} + /** Add a processor to the route. - * @param iter an iterator in _processors; the new processor will be inserted immediately before this location. + * @param before An existing processor in the list, or 0; the new processor will be inserted immediately before it (or at the end). + * @return 0 on success, non-0 on failure. */ int -Route::add_processor (boost::shared_ptr processor, ProcessorList::iterator iter, ProcessorStreams* err, bool activation_allowed) +Route::add_processor (boost::shared_ptr processor, boost::shared_ptr before, ProcessorStreams* err, bool activation_allowed) { assert (processor != _meter); assert (processor != _main_outs); DEBUG_TRACE (DEBUG::Processors, string_compose ( "%1 adding processor %2\n", name(), processor->name())); - - ChanCount old_pms = processor_max_streams; - if (!_session.engine().connected() || !processor) { + if (!AudioEngine::instance()->connected() || !processor) { return 1; } { - Glib::RWLock::WriterLock lm (_processor_lock); + Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ()); + Glib::Threads::RWLock::WriterLock lm (_processor_lock); ProcessorState pstate (this); boost::shared_ptr pi; boost::shared_ptr porti; - ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), processor); - if (processor == _amp) { - // Ensure only one amp is in the list at any time - if (loc != _processors.end()) { - if (iter == loc) { // Already in place, do nothing + /* Ensure that only one amp is in the list at any time */ + ProcessorList::iterator check = find (_processors.begin(), _processors.end(), processor); + if (check != _processors.end()) { + if (before == _amp) { + /* Already in position; all is well */ return 0; - } else { // New position given, relocate - _processors.erase (loc); + } else { + _processors.erase (check); } } + } - } else { - if (loc != _processors.end()) { - cerr << "ERROR: Processor added to route twice!" << endl; + assert (find (_processors.begin(), _processors.end(), processor) == _processors.end ()); + + ProcessorList::iterator loc; + if (before) { + /* inserting before a processor; find it */ + loc = find (_processors.begin(), _processors.end(), before); + if (loc == _processors.end ()) { + /* Not found */ return 1; } - - loc = iter; + } else { + /* inserting at end */ + loc = _processors.end (); } _processors.insert (loc, processor); + processor->set_owner (this); // Set up processor list channels. This will set processor->[input|output]_streams(), // configure redirect ports properly, etc. { - Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ()); - if (configure_processors_unlocked (err)) { pstate.restore (); configure_processors_unlocked (0); // it worked before we tried to add it ... @@ -909,14 +999,14 @@ Route::add_processor (boost::shared_ptr processor, ProcessorList::ite if ((pi = boost::dynamic_pointer_cast(processor)) != 0) { - if (pi->natural_input_streams() == ChanCount::ZERO) { + if (pi->has_no_inputs ()) { /* generator plugin */ _have_internal_generator = true; } } - if (activation_allowed) { + if (activation_allowed && !_session.get_disable_all_loaded_plugins()) { processor->activate (); } @@ -925,6 +1015,7 @@ Route::add_processor (boost::shared_ptr processor, ProcessorList::ite _output->set_user_latency (0); } + reset_instrument_info (); processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */ set_processor_positions (); @@ -945,7 +1036,7 @@ Route::add_processor_from_xml_2X (const XMLNode& node, int version) XMLNodeList const & children = node.children (); XMLNodeList::const_iterator i = children.begin (); - + while (i != children.end() && (*i)->name() != X_("Redirect")) { ++i; } @@ -962,9 +1053,10 @@ Route::add_processor_from_xml_2X (const XMLNode& node, int version) if ((prop = node.property ("type")) != 0) { - if (prop->value() == "ladspa" || prop->value() == "Ladspa" || + if (prop->value() == "ladspa" || prop->value() == "Ladspa" || prop->value() == "lv2" || - prop->value() == "vst" || + prop->value() == "windows-vst" || + prop->value() == "lxvst" || prop->value() == "audiounit") { processor.reset (new PluginInsert (_session)); @@ -1016,8 +1108,6 @@ Route::add_processors (const ProcessorList& others, boost::shared_ptr loc = _processors.end (); } - ChanCount old_pms = processor_max_streams; - if (!_session.engine().connected()) { return 1; } @@ -1027,7 +1117,8 @@ Route::add_processors (const ProcessorList& others, boost::shared_ptr } { - Glib::RWLock::WriterLock lm (_processor_lock); + Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ()); + Glib::Threads::RWLock::WriterLock lm (_processor_lock); ProcessorState pstate (this); for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) { @@ -1042,14 +1133,15 @@ Route::add_processors (const ProcessorList& others, boost::shared_ptr pi->set_count (1); } - ProcessorList::iterator inserted = _processors.insert (loc, *i); + _processors.insert (loc, *i); + (*i)->set_owner (this); if ((*i)->active()) { (*i)->activate (); } + /* Think: does this really need to be called for every processor in the loop? */ { - Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ()); if (configure_processors_unlocked (err)) { pstate.restore (); configure_processors_unlocked (0); // it worked before we tried to add it ... @@ -1064,7 +1156,7 @@ Route::add_processors (const ProcessorList& others, boost::shared_ptr boost::shared_ptr pi; if ((pi = boost::dynamic_pointer_cast(*i)) != 0) { - if (pi->is_generator()) { + if (pi->has_no_inputs ()) { _have_internal_generator = true; break; } @@ -1074,6 +1166,7 @@ Route::add_processors (const ProcessorList& others, boost::shared_ptr _output->set_user_latency (0); } + reset_instrument_info (); processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */ set_processor_positions (); @@ -1099,7 +1192,7 @@ Route::placement_range(Placement p, ProcessorList::iterator& start, ProcessorLis void Route::disable_processors (Placement p) { - Glib::RWLock::ReaderLock lm (_processor_lock); + Glib::Threads::RWLock::ReaderLock lm (_processor_lock); ProcessorList::iterator start, end; placement_range(p, start, end); @@ -1116,7 +1209,7 @@ Route::disable_processors (Placement p) void Route::disable_processors () { - Glib::RWLock::ReaderLock lm (_processor_lock); + Glib::Threads::RWLock::ReaderLock lm (_processor_lock); for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { (*i)->deactivate (); @@ -1131,7 +1224,7 @@ Route::disable_processors () void Route::disable_plugins (Placement p) { - Glib::RWLock::ReaderLock lm (_processor_lock); + Glib::Threads::RWLock::ReaderLock lm (_processor_lock); ProcessorList::iterator start, end; placement_range(p, start, end); @@ -1150,7 +1243,7 @@ Route::disable_plugins (Placement p) void Route::disable_plugins () { - Glib::RWLock::ReaderLock lm (_processor_lock); + Glib::Threads::RWLock::ReaderLock lm (_processor_lock); for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { if (boost::dynamic_pointer_cast (*i)) { @@ -1165,7 +1258,7 @@ Route::disable_plugins () void Route::ab_plugins (bool forward) { - Glib::RWLock::ReaderLock lm (_processor_lock); + Glib::Threads::RWLock::ReaderLock lm (_processor_lock); if (forward) { @@ -1214,8 +1307,6 @@ Route::ab_plugins (bool forward) void Route::clear_processors (Placement p) { - const ChanCount old_pms = processor_max_streams; - if (!_session.engine().connected()) { return; } @@ -1226,7 +1317,8 @@ Route::clear_processors (Placement p) } { - Glib::RWLock::WriterLock lm (_processor_lock); + Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ()); + Glib::Threads::RWLock::WriterLock lm (_processor_lock); ProcessorList new_list; ProcessorStreams err; bool seen_amp = false; @@ -1270,11 +1362,7 @@ Route::clear_processors (Placement p) } _processors = new_list; - - { - Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ()); - configure_processors_unlocked (&err); // this can't fail - } + configure_processors_unlocked (&err); // this can't fail } processor_max_streams.reset(); @@ -1282,22 +1370,27 @@ Route::clear_processors (Placement p) processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */ set_processor_positions (); + reset_instrument_info (); + if (!already_deleting) { _session.clear_deletion_in_progress(); } } int -Route::remove_processor (boost::shared_ptr processor, ProcessorStreams* err) +Route::remove_processor (boost::shared_ptr processor, ProcessorStreams* err, bool need_process_lock) { + // TODO once the export point can be configured properly, do something smarter here + if (processor == _capturing_processor) { + _capturing_processor.reset(); + } + /* these can never be removed */ if (processor == _amp || processor == _meter || processor == _main_outs) { return 0; } - ChanCount old_pms = processor_max_streams; - if (!_session.engine().connected()) { return 1; } @@ -1305,9 +1398,13 @@ Route::remove_processor (boost::shared_ptr processor, ProcessorStream processor_max_streams.reset(); { - Glib::RWLock::WriterLock lm (_processor_lock); + Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK); + if (need_process_lock) { + lx.acquire(); + } + Glib::Threads::RWLock::WriterLock lm (_processor_lock); ProcessorState pstate (this); - + ProcessorList::iterator i; bool removed = false; @@ -1326,12 +1423,7 @@ Route::remove_processor (boost::shared_ptr processor, ProcessorStream boost::shared_ptr iop; if ((iop = boost::dynamic_pointer_cast (*i)) != 0) { - if (iop->input()) { - iop->input()->disconnect (this); - } - if (iop->output()) { - iop->output()->disconnect (this); - } + iop->disconnect (); } i = _processors.erase (i); @@ -1348,17 +1440,13 @@ Route::remove_processor (boost::shared_ptr processor, ProcessorStream if (!removed) { /* what? */ return 1; - } + } - { - Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ()); - - if (configure_processors_unlocked (err)) { - pstate.restore (); - /* we know this will work, because it worked before :) */ - configure_processors_unlocked (0); - return -1; - } + if (configure_processors_unlocked (err)) { + pstate.restore (); + /* we know this will work, because it worked before :) */ + configure_processors_unlocked (0); + return -1; } _have_internal_generator = false; @@ -1367,14 +1455,18 @@ Route::remove_processor (boost::shared_ptr processor, ProcessorStream boost::shared_ptr pi; if ((pi = boost::dynamic_pointer_cast(*i)) != 0) { - if (pi->is_generator()) { + if (pi->has_no_inputs ()) { _have_internal_generator = true; break; } } } + if (need_process_lock) { + lx.release(); + } } + reset_instrument_info (); processor->drop_references (); processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */ set_processor_positions (); @@ -1394,9 +1486,10 @@ Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* processor_max_streams.reset(); { - Glib::RWLock::WriterLock lm (_processor_lock); + Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ()); + Glib::Threads::RWLock::WriterLock lm (_processor_lock); ProcessorState pstate (this); - + ProcessorList::iterator i; boost::shared_ptr processor; @@ -1440,16 +1533,13 @@ Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* _output->set_user_latency (0); - { - Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ()); - - if (configure_processors_unlocked (err)) { - pstate.restore (); - /* we know this will work, because it worked before :) */ - configure_processors_unlocked (0); - return -1; - } + if (configure_processors_unlocked (err)) { + pstate.restore (); + /* we know this will work, because it worked before :) */ + configure_processors_unlocked (0); + return -1; } + //lx.unlock(); _have_internal_generator = false; @@ -1457,7 +1547,7 @@ Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* boost::shared_ptr pi; if ((pi = boost::dynamic_pointer_cast(*i)) != 0) { - if (pi->is_generator()) { + if (pi->has_no_inputs ()) { _have_internal_generator = true; break; } @@ -1471,23 +1561,89 @@ Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* (*i)->drop_references (); } + reset_instrument_info (); processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */ set_processor_positions (); return 0; } +#if 0 +/* currently unused (again) -- but will come in handy soon (again) + * once there is an option to link route + delivery panner settings + */ +void +Route::set_custom_panner_uri (std::string const panner_uri) +{ + if (_in_configure_processors) { + DEBUG_TRACE (DEBUG::Panning, string_compose (_("Route::set_custom_panner_uri '%1' -- called while in_configure_processors\n"), name())); + return; + } + + if (!_main_outs->panner_shell()->set_user_selected_panner_uri(panner_uri)) { + DEBUG_TRACE (DEBUG::Panning, string_compose (_("Route::set_custom_panner_uri '%1 '%2' -- no change needed\n"), name(), panner_uri)); + /* no change needed */ + return; + } + + DEBUG_TRACE (DEBUG::Panning, string_compose (_("Route::set_custom_panner_uri '%1 '%2' -- reconfigure I/O\n"), name(), panner_uri)); + + /* reconfigure I/O -- re-initialize panner modules */ + { + Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ()); + Glib::Threads::RWLock::WriterLock lm (_processor_lock); + + for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p) { + boost::shared_ptr dl; + boost::shared_ptr panner; + if ((dl = boost::dynamic_pointer_cast (*p)) == 0) { + continue; + } + if (!dl->panner_shell()) { + continue; + } + if (!(panner = dl->panner_shell()->panner())) { + continue; + } + /* _main_outs has already been set before the loop. + * Ignore the return status here. It need reconfiguration */ + if (dl->panner_shell() != _main_outs->panner_shell()) { + if (!dl->panner_shell()->set_user_selected_panner_uri(panner_uri)) { + continue; + } + } + + ChanCount in = panner->in(); + ChanCount out = panner->out(); + dl->panner_shell()->configure_io(in, out); + dl->panner_shell()->pannable()->set_panner(dl->panner_shell()->panner()); + } + } + + processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */ + _session.set_dirty (); +} +#endif + +void +Route::reset_instrument_info () +{ + boost::shared_ptr instr = the_instrument(); + if (instr) { + _instrument_info.set_internal_instrument (instr); + } +} + /** Caller must hold process lock */ int Route::configure_processors (ProcessorStreams* err) { assert (!AudioEngine::instance()->process_lock().trylock()); - if (!_in_configure_processors) { - Glib::RWLock::WriterLock lm (_processor_lock); + Glib::Threads::RWLock::WriterLock lm (_processor_lock); return configure_processors_unlocked (err); } - + return 0; } @@ -1500,7 +1656,7 @@ Route::input_streams () const list > Route::try_configure_processors (ChanCount in, ProcessorStreams* err) { - Glib::RWLock::ReaderLock lm (_processor_lock); + Glib::Threads::RWLock::ReaderLock lm (_processor_lock); return try_configure_processors_unlocked (in, err); } @@ -1520,9 +1676,10 @@ Route::try_configure_processors_unlocked (ChanCount in, ProcessorStreams* err) if (boost::dynamic_pointer_cast (*p)) { DEBUG_TRACE (DEBUG::Processors, "--- CONFIGURE ABORTED due to unknown processor.\n"); - break; + DEBUG_TRACE (DEBUG::Processors, "}\n"); + return list > (); } - + if ((*p)->can_support_io_configuration(in, out)) { DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID=%2 in=%3 out=%4\n",(*p)->name(), (*p)->id(), in, out)); configuration.push_back(make_pair(in, out)); @@ -1540,7 +1697,7 @@ Route::try_configure_processors_unlocked (ChanCount in, ProcessorStreams* err) } DEBUG_TRACE (DEBUG::Processors, "}\n"); - + return configuration; } @@ -1570,6 +1727,9 @@ Route::configure_processors_unlocked (ProcessorStreams* err) } ChanCount out; + bool seen_mains_out = false; + processor_out_streams = _input->n_ports(); + processor_max_streams.reset(); list< pair >::iterator c = configuration.begin(); for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) { @@ -1577,19 +1737,33 @@ Route::configure_processors_unlocked (ProcessorStreams* err) if (boost::dynamic_pointer_cast (*p)) { break; } - + (*p)->configure_io(c->first, c->second); processor_max_streams = ChanCount::max(processor_max_streams, c->first); processor_max_streams = ChanCount::max(processor_max_streams, c->second); out = c->second; + + if (boost::dynamic_pointer_cast (*p) + && boost::dynamic_pointer_cast (*p)->role() == Delivery::Main) { + /* main delivery will increase port count to match input. + * the Delivery::Main is usually the last processor - followed only by + * 'MeterOutput'. + */ + seen_mains_out = true; + } + if (!seen_mains_out) { + processor_out_streams = out; + } } + if (_meter) { _meter->reset_max_channels (processor_max_streams); } /* make sure we have sufficient scratch buffers to cope with the new processor - configuration */ + configuration + */ _session.ensure_buffers (n_process_buffers ()); DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name)); @@ -1598,86 +1772,33 @@ Route::configure_processors_unlocked (ProcessorStreams* err) return 0; } +/** Set all visible processors to a given active state (except Fader, whose state is not changed) + * @param state New active state for those processors. + */ void -Route::all_processors_flip () +Route::all_visible_processors_active (bool state) { - Glib::RWLock::ReaderLock lm (_processor_lock); + Glib::Threads::RWLock::ReaderLock lm (_processor_lock); if (_processors.empty()) { return; } - - bool first_is_on = _processors.front()->active(); - + for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { - if (first_is_on) { - (*i)->deactivate (); - } else { + if (!(*i)->display_to_user() || boost::dynamic_pointer_cast (*i)) { + continue; + } + + if (state) { (*i)->activate (); + } else { + (*i)->deactivate (); } } _session.set_dirty (); } -/** Set all processors with a given placement to a given active state. - * @param p Placement of processors to change. - * @param state New active state for those processors. - */ -void -Route::all_processors_active (Placement p, bool state) -{ - Glib::RWLock::ReaderLock lm (_processor_lock); - - if (_processors.empty()) { - return; - } - ProcessorList::iterator start, end; - placement_range(p, start, end); - - bool before_amp = true; - for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { - if ((*i) == _amp) { - before_amp = false; - continue; - } - if (p == PreFader && before_amp) { - if (state) { - (*i)->activate (); - } else { - (*i)->deactivate (); - } - } - } - - _session.set_dirty (); -} - -bool -Route::processor_is_prefader (boost::shared_ptr p) -{ - bool pre_fader = true; - Glib::RWLock::ReaderLock lm (_processor_lock); - - for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { - - /* semantic note: if p == amp, we want to return true, so test - for equality before checking if this is the amp - */ - - if ((*i) == p) { - break; - } - - if ((*i) == _amp) { - pre_fader = false; - break; - } - } - - return pre_fader; -} - int Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err) { @@ -1688,9 +1809,10 @@ Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err */ { - Glib::RWLock::WriterLock lm (_processor_lock); + Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ()); + Glib::Threads::RWLock::WriterLock lm (_processor_lock); ProcessorState pstate (this); - + ProcessorList::iterator oiter; ProcessorList::const_iterator niter; ProcessorList as_it_will_be; @@ -1746,13 +1868,12 @@ Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end()); - { - Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ()); - - if (configure_processors_unlocked (err)) { - pstate.restore (); - return -1; - } + /* If the meter is in a custom position, find it and make a rough note of its position */ + maybe_note_meter_position (); + + if (configure_processors_unlocked (err)) { + pstate.restore (); + return -1; } } @@ -1797,28 +1918,14 @@ Route::state(bool full_state) node->add_property("denormal-protection", _denormal_protection?"yes":"no"); node->add_property("meter-point", enum_2_string (_meter_point)); + node->add_property("meter-type", enum_2_string (_meter_type)); + if (_route_group) { node->add_property("route-group", _route_group->name()); } - string order_string; - OrderKeys::iterator x = order_keys.begin(); - - while (x != order_keys.end()) { - order_string += string ((*x).first); - order_string += '='; - snprintf (buf, sizeof(buf), "%ld", (*x).second); - order_string += buf; - - ++x; - - if (x == order_keys.end()) { - break; - } - - order_string += ':'; - } - node->add_property ("order-keys", order_string); + snprintf (buf, sizeof (buf), "%d", _order_key); + node->add_property ("order-key", buf); node->add_property ("self-solo", (_self_solo ? "yes" : "no")); snprintf (buf, sizeof (buf), "%d", _soloed_by_others_upstream); node->add_property ("soloed-by-upstream", buf); @@ -1843,30 +1950,54 @@ Route::state(bool full_state) cmt->add_content (_comment); } - node->add_child_nocopy (_pannable->state (full_state)); + if (_pannable) { + node->add_child_nocopy (_pannable->state (full_state)); + } for (i = _processors.begin(); i != _processors.end(); ++i) { + if (!full_state) { + /* 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 + is not very likely. + + similarly, do not save listen sends which connect to + the monitor section, because these will always be + added if necessary. + */ + boost::shared_ptr is; + + if ((is = boost::dynamic_pointer_cast (*i)) != 0) { + if (is->role() == Delivery::Listen) { + continue; + } + } + } node->add_child_nocopy((*i)->state (full_state)); } - if (_extra_xml){ + if (_extra_xml) { node->add_child_copy (*_extra_xml); } + if (_custom_meter_position_noted) { + boost::shared_ptr after = _processor_after_last_custom_meter.lock (); + if (after) { + after->id().print (buf, sizeof (buf)); + node->add_property (X_("processor-after-last-custom-meter"), buf); + } + + node->add_property (X_("last-custom-meter-was-at-end"), _last_custom_meter_was_at_end ? "yes" : "no"); + } + return *node; } int Route::set_state (const XMLNode& node, int version) -{ - return _set_state (node, version, true); -} - -int -Route::_set_state (const XMLNode& node, int version, bool /*call_base*/) { if (version < 3000) { - return _set_state_2X (node, version); + return set_state_2X (node, version); } XMLNodeList nlist; @@ -1883,9 +2014,8 @@ Route::_set_state (const XMLNode& node, int version, bool /*call_base*/) Route::set_name (prop->value()); } - if ((prop = node.property ("id")) != 0) { - _id = prop->value (); - } + set_id (node); + _initial_io_setup = true; if ((prop = node.property (X_("flags"))) != 0) { _flags = Flag (string_2_enum (prop->value(), _flags)); @@ -1893,15 +2023,25 @@ Route::_set_state (const XMLNode& node, int version, bool /*call_base*/) _flags = Flag (0); } - if (is_master() || is_monitor() || is_hidden()) { + if (is_master() || is_monitor() || is_auditioner()) { _mute_master->set_solo_ignore (true); } + if (is_monitor()) { + /* monitor bus does not get a panner, but if (re)created + via XML, it will already have one by the time we + call ::set_state(). so ... remove it. + */ + unpan (); + } + /* add all processors (except amp, which is always present) */ nlist = node.children(); XMLNode processor_state (X_("processor_state")); + Stateful::save_extra_xml (node); + for (niter = nlist.begin(); niter != nlist.end(); ++niter){ child = *niter; @@ -1922,14 +2062,34 @@ Route::_set_state (const XMLNode& node, int version, bool /*call_base*/) processor_state.add_child_copy (*child); } - if (child->name() == X_("Pannable")) { - _pannable->set_state (*child, version); + if (_pannable) { + _pannable->set_state (*child, version); + } else { + warning << string_compose (_("Pannable state found for route (%1) without a panner!"), name()) << endmsg; + } + } + } + + if ((prop = node.property (X_("meter-point"))) != 0) { + MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point)); + set_meter_point (mp, true); + if (_meter) { + _meter->set_display_to_user (_meter_point == MeterCustom); } } + if ((prop = node.property (X_("meter-type"))) != 0) { + _meter_type = MeterType (string_2_enum (prop->value (), _meter_type)); + } + + _initial_io_setup = false; + set_processor_state (processor_state); + // this looks up the internal instrument in processors + reset_instrument_info(); + if ((prop = node.property ("self-solo")) != 0) { set_self_solo (string_is_affirmative (prop->value())); } @@ -1966,15 +2126,11 @@ Route::_set_state (const XMLNode& node, int version, bool /*call_base*/) set_active (yn, this); } - if ((prop = node.property (X_("meter-point"))) != 0) { - MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point)); - set_meter_point (mp, true); - if (_meter) { - _meter->set_display_to_user (_meter_point == MeterCustom); - } + if ((prop = node.property (X_("order-key"))) != 0) { // New order key (no separate mixer/editor ordering) + set_order_key (atoi(prop->value())); } - if ((prop = node.property (X_("order-keys"))) != 0) { + if ((prop = node.property (X_("order-keys"))) != 0) { // Deprecated order keys int32_t n; @@ -1991,7 +2147,12 @@ Route::_set_state (const XMLNode& node, int version, bool /*call_base*/) error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining) << endmsg; } else { - set_order_key (remaining.substr (0, equal), n); + string keyname = remaining.substr (0, equal); + + if ((keyname == "EditorSort") || (keyname == "editor")) { + cerr << "Setting " << name() << " order key to " << n << " using saved Editor order." << endl; + set_order_key (n); + } } } @@ -2005,6 +2166,24 @@ Route::_set_state (const XMLNode& node, int version, bool /*call_base*/) } } + if ((prop = node.property (X_("processor-after-last-custom-meter"))) != 0) { + PBD::ID id (prop->value ()); + Glib::Threads::RWLock::ReaderLock lm (_processor_lock); + ProcessorList::const_iterator i = _processors.begin (); + while (i != _processors.end() && (*i)->id() != id) { + ++i; + } + + if (i != _processors.end ()) { + _processor_after_last_custom_meter = *i; + _custom_meter_position_noted = true; + } + } + + if ((prop = node.property (X_("last-custom-meter-was-at-end"))) != 0) { + _last_custom_meter_was_at_end = string_is_affirmative (prop->value ()); + } + for (niter = nlist.begin(); niter != nlist.end(); ++niter){ child = *niter; @@ -2015,20 +2194,18 @@ Route::_set_state (const XMLNode& node, int version, bool /*call_base*/) XMLNode *cmt = *(child->children().begin()); _comment = cmt->content(); - } else if (child->name() == X_("Extra")) { - - _extra_xml = new XMLNode (*child); - } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) { if (prop->value() == "solo") { _solo_control->set_state (*child, version); + } else if (prop->value() == "mute") { + _mute_control->set_state (*child, version); } } else if (child->name() == X_("RemoteControl")) { if ((prop = child->property (X_("id"))) != 0) { int32_t x; sscanf (prop->value().c_str(), "%d", &x); - set_remote_control_id (x); + set_remote_control_id_internal (x); } } else if (child->name() == X_("MuteMaster")) { @@ -2040,7 +2217,7 @@ Route::_set_state (const XMLNode& node, int version, bool /*call_base*/) } int -Route::_set_state_2X (const XMLNode& node, int version) +Route::set_state_2X (const XMLNode& node, int version) { XMLNodeList nlist; XMLNodeConstIterator niter; @@ -2059,16 +2236,22 @@ Route::_set_state_2X (const XMLNode& node, int version) } if ((prop = node.property (X_("flags"))) != 0) { - _flags = Flag (string_2_enum (prop->value(), _flags)); + string f = prop->value (); + boost::replace_all (f, "ControlOut", "MonitorOut"); + _flags = Flag (string_2_enum (f, _flags)); } else { _flags = Flag (0); } - + + if (is_master() || is_monitor() || is_auditioner()) { + _mute_master->set_solo_ignore (true); + } + if ((prop = node.property (X_("phase-invert"))) != 0) { boost::dynamic_bitset<> p (_input->n_ports().n_audio ()); if (string_is_affirmative (prop->value ())) { p.set (); - } + } set_phase_invert (p); } @@ -2085,60 +2268,60 @@ Route::_set_state_2X (const XMLNode& node, int version) } if ((prop = node.property (X_("muted"))) != 0) { - + bool first = true; bool muted = string_is_affirmative (prop->value()); - + if (muted) { string mute_point; - + if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) { - + if (string_is_affirmative (prop->value())){ mute_point = mute_point + "PreFader"; first = false; } } - + if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) { - + if (string_is_affirmative (prop->value())){ - + if (!first) { mute_point = mute_point + ","; } - + mute_point = mute_point + "PostFader"; first = false; } } if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) { - + if (string_is_affirmative (prop->value())){ - + if (!first) { mute_point = mute_point + ","; } - + mute_point = mute_point + "Listen"; first = false; } } if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) { - + if (string_is_affirmative (prop->value())){ - + if (!first) { mute_point = mute_point + ","; } - + mute_point = mute_point + "Main"; } } - + _mute_master->set_mute_points (mute_point); _mute_master->set_muted_by_self (true); } @@ -2169,7 +2352,12 @@ Route::_set_state_2X (const XMLNode& node, int version) error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining) << endmsg; } else { - set_order_key (remaining.substr (0, equal), n); + string keyname = remaining.substr (0, equal); + + if (keyname == "EditorSort" || keyname == "editor") { + info << string_compose(_("Converting deprecated order key for %1 using Editor order %2"), name (), n) << endmsg; + set_order_key (n); + } } } @@ -2203,16 +2391,14 @@ Route::_set_state_2X (const XMLNode& node, int version) Route::set_name (prop->value ()); } - if ((prop = child->property (X_("id"))) != 0) { - _id = prop->value (); - } + set_id (*child); if ((prop = child->property (X_("active"))) != 0) { bool yn = string_is_affirmative (prop->value()); _active = !yn; // force switch set_active (yn, this); } - + if ((prop = child->property (X_("gain"))) != 0) { gain_t val; @@ -2220,17 +2406,17 @@ Route::_set_state_2X (const XMLNode& node, int version) _amp->gain_control()->set_value (val); } } - + /* Set up Panners in the IO */ XMLNodeList io_nlist = child->children (); - + XMLNodeConstIterator io_niter; XMLNode *io_child; - + for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) { io_child = *io_niter; - + if (io_child->name() == X_("Panner")) { _main_outs->panner_shell()->set_state(*io_child, version); } else if (io_child->name() == X_("Automation")) { @@ -2255,6 +2441,8 @@ Route::_set_state_2X (const XMLNode& node, int version) set_processor_state_2X (redirect_nodes, version); + Stateful::save_extra_xml (node); + for (niter = nlist.begin(); niter != nlist.end(); ++niter){ child = *niter; @@ -2265,10 +2453,6 @@ Route::_set_state_2X (const XMLNode& node, int version) XMLNode *cmt = *(child->children().begin()); _comment = cmt->content(); - } else if (child->name() == X_("extra")) { - - _extra_xml = new XMLNode (*child); - } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) { if (prop->value() == X_("solo")) { _solo_control->set_state (*child, version); @@ -2280,10 +2464,10 @@ Route::_set_state_2X (const XMLNode& node, int version) if ((prop = child->property (X_("id"))) != 0) { int32_t x; sscanf (prop->value().c_str(), "%d", &x); - set_remote_control_id (x); + set_remote_control_id_internal (x); } - } + } } return 0; @@ -2331,6 +2515,7 @@ Route::set_processor_state (const XMLNode& node) new_order.push_back (_amp); } else if (prop->value() == "meter") { _meter->set_state (**niter, Stateful::current_state_version); + new_order.push_back (_meter); } else if (prop->value() == "main-outs") { _main_outs->set_state (**niter, Stateful::current_state_version); } else if (prop->value() == "intreturn") { @@ -2346,7 +2531,8 @@ Route::set_processor_state (const XMLNode& node) } _monitor_control->set_state (**niter, Stateful::current_state_version); } else if (prop->value() == "capture") { - _capturing_processor.reset (new CapturingProcessor (_session)); + /* CapturingProcessor should never be restored, it's always + added explicitly when needed */ } else { ProcessorList::iterator o; @@ -2359,7 +2545,7 @@ Route::set_processor_state (const XMLNode& node) } } - // If the processor (*niter) is not on the route then create it + // If the processor (*niter) is not on the route then create it if (o == _processors.end()) { @@ -2367,10 +2553,12 @@ Route::set_processor_state (const XMLNode& node) if (prop->value() == "intsend") { - processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::shared_ptr(), Delivery::Role (0))); + processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::shared_ptr(), Delivery::Aux)); + } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" || prop->value() == "lv2" || - prop->value() == "vst" || + prop->value() == "windows-vst" || + prop->value() == "lxvst" || prop->value() == "audiounit") { processor.reset (new PluginInsert(_session)); @@ -2412,22 +2600,23 @@ Route::set_processor_state (const XMLNode& node) } { - Glib::RWLock::WriterLock lm (_processor_lock); + Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ()); + Glib::Threads::RWLock::WriterLock lm (_processor_lock); _processors = new_order; if (must_configure) { - Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ()); configure_processors_unlocked (0); } for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) { + (*i)->set_owner (this); (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false)); boost::shared_ptr pi; if ((pi = boost::dynamic_pointer_cast(*i)) != 0) { - if (pi->is_generator()) { + if (pi->has_no_inputs ()) { _have_internal_generator = true; break; } @@ -2435,6 +2624,7 @@ Route::set_processor_state (const XMLNode& node) } } + reset_instrument_info (); processors_changed (RouteProcessorChange ()); set_processor_positions (); } @@ -2449,7 +2639,7 @@ Route::curve_reallocate () void Route::silence (framecnt_t nframes) { - Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK); + Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK); if (!lm.locked()) { return; } @@ -2461,22 +2651,22 @@ void Route::silence_unlocked (framecnt_t nframes) { /* Must be called with the processor lock held */ - + if (!_silent) { _output->silence (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 continue; } - + (*i)->silence (nframes); } - + if (nframes == _session.get_block_size()) { // _silent = true; } @@ -2495,7 +2685,7 @@ Route::add_internal_return () void Route::add_send_to_internal_return (InternalSend* send) { - Glib::RWLock::ReaderLock rm (_processor_lock); + Glib::Threads::RWLock::ReaderLock rm (_processor_lock); for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) { boost::shared_ptr d = boost::dynamic_pointer_cast(*x); @@ -2509,7 +2699,7 @@ Route::add_send_to_internal_return (InternalSend* send) void Route::remove_send_from_internal_return (InternalSend* send) { - Glib::RWLock::ReaderLock rm (_processor_lock); + Glib::Threads::RWLock::ReaderLock rm (_processor_lock); for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) { boost::shared_ptr d = boost::dynamic_pointer_cast(*x); @@ -2520,37 +2710,37 @@ Route::remove_send_from_internal_return (InternalSend* send) } } -/** Add a monitor send (if we don't already have one) but don't activate it */ -int -Route::listen_via_monitor () +void +Route::enable_monitor_send () { - /* master never sends to control outs */ + /* Caller must hold process lock */ + assert (!AudioEngine::instance()->process_lock().trylock()); + + /* master never sends to monitor section via the normal mechanism */ assert (!is_master ()); - + assert (!is_monitor ()); + /* make sure we have one */ if (!_monitor_send) { _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, _session.monitor_out(), Delivery::Listen)); _monitor_send->set_display_to_user (false); } - + /* set it up */ - Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ()); configure_processors (0); - - return 0; } -/** Add an internal send to a route. +/** Add an aux send to a route. * @param route route to send to. - * @param placement placement for the send. + * @param before Processor to insert before, or 0 to insert at the end. */ int -Route::listen_via (boost::shared_ptr route, Placement placement) +Route::add_aux_send (boost::shared_ptr route, boost::shared_ptr before) { assert (route != _session.monitor_out ()); - + { - Glib::RWLock::ReaderLock rm (_processor_lock); + Glib::Threads::RWLock::ReaderLock rm (_processor_lock); for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) { @@ -2564,8 +2754,15 @@ Route::listen_via (boost::shared_ptr route, Placement placement) } try { - boost::shared_ptr listener (new InternalSend (_session, _pannable, _mute_master, route, Delivery::Aux)); - add_processor (listener, placement); + + boost::shared_ptr listener; + + { + Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ()); + listener.reset (new InternalSend (_session, _pannable, _mute_master, route, Delivery::Aux)); + } + + add_processor (listener, before); } catch (failed_constructor& err) { return -1; @@ -2575,36 +2772,39 @@ Route::listen_via (boost::shared_ptr route, Placement placement) } void -Route::drop_listen (boost::shared_ptr route) +Route::remove_aux_or_listen (boost::shared_ptr route) { ProcessorStreams err; ProcessorList::iterator tmp; - Glib::RWLock::ReaderLock rl(_processor_lock); - rl.acquire (); - - again: - for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ) { - - boost::shared_ptr d = boost::dynamic_pointer_cast(*x); - - if (d && d->target_route() == route) { - rl.release (); - remove_processor (*x, &err); - rl.acquire (); + { + Glib::Threads::RWLock::ReaderLock rl(_processor_lock); - /* list could have been demolished while we dropped the lock - so start over. - */ + /* have to do this early because otherwise processor reconfig + * will put _monitor_send back in the list + */ - goto again; + if (route == _session.monitor_out()) { + _monitor_send.reset (); } - } - rl.release (); + again: + for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) { + + boost::shared_ptr d = boost::dynamic_pointer_cast(*x); + + if (d && d->target_route() == route) { + rl.release (); + remove_processor (*x, &err, false); + rl.acquire (); - if (route == _session.monitor_out()) { - _monitor_send.reset (); + /* list could have been demolished while we dropped the lock + so start over. + */ + + goto again; + } + } } } @@ -2663,20 +2863,20 @@ Route::feeds (boost::shared_ptr other, bool* via_sends_only) } bool -Route::direct_feeds (boost::shared_ptr other, bool* only_send) +Route::direct_feeds_according_to_reality (boost::shared_ptr other, bool* via_send_only) { DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name)); if (_output->connected_to (other->input())) { DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name())); - if (only_send) { - *only_send = false; + if (via_send_only) { + *via_send_only = false; } return true; } - + for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) { boost::shared_ptr iop; @@ -2684,8 +2884,8 @@ Route::direct_feeds (boost::shared_ptr other, bool* only_send) if ((iop = boost::dynamic_pointer_cast(*r)) != 0) { if (iop->feeds (other)) { DEBUG_TRACE (DEBUG::Graph, string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name())); - if (only_send) { - *only_send = true; + if (via_send_only) { + *via_send_only = true; } return true; } else { @@ -2694,25 +2894,27 @@ Route::direct_feeds (boost::shared_ptr other, bool* only_send) } else { DEBUG_TRACE (DEBUG::Graph, string_compose ("\tPROC %1 is not an IOP\n", (*r)->name())); } - + } DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdoes NOT feed %1\n", other->name())); return false; } +bool +Route::direct_feeds_according_to_graph (boost::shared_ptr other, bool* via_send_only) +{ + return _session._current_route_graph.has (shared_from_this (), other, via_send_only); +} + /** 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::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool /*did_locate*/, bool can_flush_processors) { framepos_t now = _session.transport_frame(); { - Glib::RWLock::ReaderLock lm (_processor_lock); - - if (!did_locate) { - automation_snapshot (now, true); - } + Glib::Threads::RWLock::ReaderLock lm (_processor_lock); Automatable::transport_stopped (now); @@ -2729,15 +2931,66 @@ Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool did_lo _roll_delay = _initial_delay; } -/** Called with the process lock held if change contains ConfigurationChanged */ void Route::input_change_handler (IOChange change, void * /*src*/) { + bool need_to_queue_solo_change = true; + if ((change.type & IOChange::ConfigurationChanged)) { + /* This is called with the process lock held if change + contains ConfigurationChanged + */ + need_to_queue_solo_change = false; configure_processors (0); _phase_invert.resize (_input->n_ports().n_audio ()); io_changed (); /* EMIT SIGNAL */ } + + if (!_input->connected() && _soloed_by_others_upstream) { + if (need_to_queue_solo_change) { + _session.cancel_solo_after_disconnect (shared_from_this(), true); + } else { + cancel_solo_after_disconnect (true); + } + } +} + +void +Route::output_change_handler (IOChange change, void * /*src*/) +{ + bool need_to_queue_solo_change = true; + if (_initial_io_setup) { + return; + } + + if ((change.type & IOChange::ConfigurationChanged)) { + /* This is called with the process lock held if change + contains ConfigurationChanged + */ + need_to_queue_solo_change = false; + configure_processors (0); + io_changed (); /* EMIT SIGNAL */ + } + + if (!_output->connected() && _soloed_by_others_downstream) { + if (need_to_queue_solo_change) { + _session.cancel_solo_after_disconnect (shared_from_this(), false); + } else { + cancel_solo_after_disconnect (false); + } + } +} + +void +Route::cancel_solo_after_disconnect (bool upstream) +{ + if (upstream) { + _soloed_by_others_upstream = 0; + } else { + _soloed_by_others_downstream = 0; + } + set_mute_master_solo (); + solo_changed (false, this); } uint32_t @@ -2751,10 +3004,10 @@ Route::pans_required () const } int -Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, - bool session_state_changing, bool /*can_record*/, bool /*rec_monitors_input*/) +Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing) { - Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK); + Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK); + if (!lm.locked()) { return 0; } @@ -2767,11 +3020,12 @@ Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, 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); @@ -2782,125 +3036,65 @@ Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, */ } + 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, nframes, true); + } + _amp->apply_gain_automation (false); - passthru (start_frame, end_frame, nframes, 0); + passthru (bufs, start_frame, end_frame, nframes, 0); return 0; } -framecnt_t -Route::check_initial_delay (framecnt_t nframes, framecnt_t& transport_frame) +int +Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& /* need_butler */) { - if (_roll_delay > nframes) { + Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK); + if (!lm.locked()) { + return 0; + } - _roll_delay -= nframes; - silence_unlocked (nframes); - /* transport frame is not legal for caller to use */ + if (n_outputs().n_total() == 0) { return 0; + } - } else if (_roll_delay > 0) { + if (!_active || n_inputs().n_total() == 0) { + silence_unlocked (nframes); + return 0; + } - nframes -= _roll_delay; - silence_unlocked (_roll_delay); - transport_frame += _roll_delay; + framepos_t unused = 0; - /* shuffle all the port buffers for things that lead "out" of this Route - to reflect that we just wrote _roll_delay frames of silence. - */ - - Glib::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 (_roll_delay); - } - } - _output->increment_port_buffer_offset (_roll_delay); - - _roll_delay = 0; - - } - - return nframes; -} - -int -Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, - bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */) -{ - Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK); - if (!lm.locked()) { + if ((nframes = check_initial_delay (nframes, unused)) == 0) { return 0; } - - automation_snapshot (_session.transport_frame(), false); - if (n_outputs().n_total() == 0) { - return 0; - } + _silent = false; - if (!_active || n_inputs().n_total() == 0) { - silence_unlocked (nframes); - return 0; - } + BufferSet& bufs = _session.get_route_buffers (n_process_buffers()); - framecnt_t unused = 0; + fill_buffers_with_input (bufs, _input, nframes); - if ((nframes = check_initial_delay (nframes, unused)) == 0) { - return 0; + if (_meter_point == MeterInput) { + _meter->run (bufs, start_frame, end_frame, nframes, true); } - _silent = false; - - passthru (start_frame, end_frame, nframes, declick); + passthru (bufs, start_frame, end_frame, nframes, declick); return 0; } int -Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, - bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */) +Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& /* need_butler */) { silence (nframes); return 0; } -void -Route::toggle_monitor_input () -{ - for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) { - i->ensure_monitor_input( ! i->monitoring_input()); - } -} - -bool -Route::has_external_redirects () const -{ - // FIXME: what about sends? - they don't return a signal back to ardour? - - boost::shared_ptr pi; - - for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) { - - if ((pi = boost::dynamic_pointer_cast(*i)) != 0) { - - for (PortSet::const_iterator port = pi->output()->ports().begin(); port != pi->output()->ports().end(); ++port) { - - string port_name = port->name(); - string client_name = port_name.substr (0, port_name.find(':')); - - /* only say "yes" if the redirect is actually in use */ - - if (client_name != "ardour" && pi->active()) { - return true; - } - } - } - } - - return false; -} - void Route::flush_processors () { @@ -2908,7 +3102,7 @@ Route::flush_processors () this is called from the RT audio thread. */ - Glib::RWLock::ReaderLock lm (_processor_lock); + Glib::Threads::RWLock::ReaderLock lm (_processor_lock); for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { (*i)->flush (); @@ -2918,57 +3112,73 @@ Route::flush_processors () void Route::set_meter_point (MeterPoint p, bool force) { - /* CAN BE CALLED FROM PROCESS CONTEXT */ - if (_meter_point == p && !force) { return; } - _meter_point = p; - bool meter_was_visible_to_user = _meter->display_to_user (); { - Glib::RWLock::WriterLock lm (_processor_lock); - + Glib::Threads::RWLock::WriterLock lm (_processor_lock); + + maybe_note_meter_position (); + + _meter_point = p; + if (_meter_point != MeterCustom) { _meter->set_display_to_user (false); - + setup_invisible_processors (); - - ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter); - ChanCount m_in; - - if (loc == _processors.begin()) { - m_in = _input->n_ports(); - } else { - ProcessorList::iterator before = loc; - --before; - m_in = (*before)->output_streams (); - } - - _meter->reflect_inputs (m_in); - - /* we do not need to reconfigure the processors, because the meter - (a) is always ready to handle processor_max_streams - (b) is always an N-in/N-out processor, and thus moving - it doesn't require any changes to the other processors. - */ - } else { - - // just make it visible and let the user move it - + _meter->set_display_to_user (true); + + /* If we have a previous position for the custom meter, try to put it there */ + if (_custom_meter_position_noted) { + boost::shared_ptr after = _processor_after_last_custom_meter.lock (); + + if (after) { + ProcessorList::iterator i = find (_processors.begin(), _processors.end(), after); + if (i != _processors.end ()) { + _processors.remove (_meter); + _processors.insert (i, _meter); + } + } else if (_last_custom_meter_was_at_end) { + _processors.remove (_meter); + _processors.push_back (_meter); + } + } + } + + /* Set up the meter for its new position */ + + ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter); + + ChanCount m_in; + + if (loc == _processors.begin()) { + m_in = _input->n_ports(); + } else { + ProcessorList::iterator before = loc; + --before; + m_in = (*before)->output_streams (); } + + _meter->reflect_inputs (m_in); + + /* we do not need to reconfigure the processors, because the meter + (a) is always ready to handle processor_max_streams + (b) is always an N-in/N-out processor, and thus moving + it doesn't require any changes to the other processors. + */ } meter_change (); /* EMIT SIGNAL */ bool const meter_visibly_changed = (_meter->display_to_user() != meter_was_visible_to_user); - + processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */ } @@ -2976,17 +3186,14 @@ void Route::listen_position_changed () { { - Glib::RWLock::WriterLock lm (_processor_lock); + Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ()); + Glib::Threads::RWLock::WriterLock lm (_processor_lock); ProcessorState pstate (this); - { - Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ()); - - if (configure_processors_unlocked (0)) { - pstate.restore (); - configure_processors_unlocked (0); // it worked before we tried to add it ... - return; - } + if (configure_processors_unlocked (0)) { + pstate.restore (); + configure_processors_unlocked (0); // it worked before we tried to add it ... + return; } } @@ -2998,17 +3205,14 @@ boost::shared_ptr Route::add_export_point() { if (!_capturing_processor) { - + _capturing_processor.reset (new CapturingProcessor (_session)); _capturing_processor->activate (); - { - Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ()); - configure_processors (0); - } + configure_processors (0); } - + return _capturing_processor; } @@ -3065,15 +3269,6 @@ Route::set_latency_compensation (framecnt_t longest_session_latency) } } -void -Route::automation_snapshot (framepos_t now, bool force) -{ - _pannable->automation_snapshot (now, force); - for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { - (*i)->automation_snapshot (now, force); - } -} - Route::SoloControllable::SoloControllable (std::string name, boost::shared_ptr r) : AutomationControl (r->session(), Evoral::Parameter (SoloAutomation), boost::shared_ptr(), name) @@ -3094,7 +3289,7 @@ Route::SoloControllable::set_value (double val) if (!r) { return; } - + rl->push_back (r); if (Config->get_solo_control_is_listen_control()) { @@ -3111,7 +3306,7 @@ Route::SoloControllable::get_value () const if (!r) { return 0; } - + if (Config->get_solo_control_is_listen_control()) { return r->listening_via_monitor() ? 1.0f : 0.0f; } else { @@ -3139,7 +3334,7 @@ Route::MuteControllable::set_value (double val) if (!r) { return; } - + rl->push_back (r); _session.set_mute (rl, bval); } @@ -3151,7 +3346,7 @@ Route::MuteControllable::get_value () const if (!r) { return 0; } - + return r->muted() ? 1.0f : 0.0f; } @@ -3161,7 +3356,7 @@ Route::set_block_size (pframes_t nframes) for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { (*i)->set_block_size (nframes); } - + _session.ensure_buffers (n_process_buffers ()); } @@ -3172,19 +3367,20 @@ Route::protect_automation () (*i)->protect_automation(); } +/** @param declick 1 to set a pending declick fade-in, + * -1 to set a pending declick fade-out + */ void Route::set_pending_declick (int declick) { if (_declickable) { - /* this call is not allowed to turn off a pending declick unless "force" is true */ + /* this call is not allowed to turn off a pending declick */ if (declick) { _pending_declick = declick; } - // cerr << _name << ": after setting to " << declick << " pending declick = " << _pending_declick << endl; } else { _pending_declick = 0; } - } /** Shift automation forwards from a particular place, thereby inserting time. @@ -3208,7 +3404,7 @@ Route::shift (framepos_t pos, framecnt_t frames) } /* pan automation */ - { + if (_pannable) { ControlSet::Controls& c (_pannable->controls()); for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) { @@ -3225,7 +3421,7 @@ Route::shift (framepos_t pos, framecnt_t frames) /* redirect automation */ { - Glib::RWLock::ReaderLock lm (_processor_lock); + Glib::Threads::RWLock::ReaderLock lm (_processor_lock); for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) { set parameters = (*i)->what_can_be_automated(); @@ -3276,7 +3472,7 @@ Route::set_name (const string& str) * just fine as it is (it will not contain the route * name if its a port insert, port send or port return). */ - + if (_main_outs) { if (_main_outs->set_name (name)) { /* XXX returning false here is stupid because @@ -3290,10 +3486,42 @@ Route::set_name (const string& str) return ret; } +/** Set the name of a route in an XML description. + * @param node XML node to set the name in. + * @param name New name. + */ +void +Route::set_name_in_state (XMLNode& node, string const & name) +{ + node.add_property (X_("name"), name); + + XMLNodeList children = node.children(); + for (XMLNodeIterator i = children.begin(); i != children.end(); ++i) { + + if ((*i)->name() == X_("IO")) { + + IO::set_name_in_state (**i, name); + + } else if ((*i)->name() == X_("Processor")) { + + XMLProperty* role = (*i)->property (X_("role")); + if (role && role->value() == X_("Main")) { + (*i)->add_property (X_("name"), name); + } + + } else if ((*i)->name() == X_("Diskstream")) { + + (*i)->add_property (X_("playlist"), string_compose ("%1.1", name).c_str()); + (*i)->add_property (X_("name"), name); + + } + } +} + boost::shared_ptr Route::internal_send_for (boost::shared_ptr target) const { - Glib::RWLock::ReaderLock lm (_processor_lock); + Glib::Threads::RWLock::ReaderLock lm (_processor_lock); for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) { boost::shared_ptr send; @@ -3365,19 +3593,20 @@ Route::set_active (bool yn, void* src) _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group)); return; } - + if (_active != yn) { _active = yn; _input->set_active (yn); _output->set_active (yn); active_changed (); // EMIT SIGNAL + _session.set_dirty (); } } void Route::meter () { - Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK); + Glib::Threads::RWLock::ReaderLock rm (_processor_lock, Glib::Threads::TRY_LOCK); assert (_meter); @@ -3432,7 +3661,7 @@ Route::get_control (const Evoral::Parameter& param) /* maybe one of our processors does or ... */ - Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK); + Glib::Threads::RWLock::ReaderLock rm (_processor_lock, Glib::Threads::TRY_LOCK); for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { if ((c = boost::dynamic_pointer_cast((*i)->control (param))) != 0) { break; @@ -3454,7 +3683,7 @@ Route::get_control (const Evoral::Parameter& param) boost::shared_ptr Route::nth_plugin (uint32_t n) { - Glib::RWLock::ReaderLock lm (_processor_lock); + Glib::Threads::RWLock::ReaderLock lm (_processor_lock); ProcessorList::iterator i; for (i = _processors.begin(); i != _processors.end(); ++i) { @@ -3471,7 +3700,7 @@ Route::nth_plugin (uint32_t n) boost::shared_ptr Route::nth_send (uint32_t n) { - Glib::RWLock::ReaderLock lm (_processor_lock); + Glib::Threads::RWLock::ReaderLock lm (_processor_lock); ProcessorList::iterator i; for (i = _processors.begin(); i != _processors.end(); ++i) { @@ -3479,7 +3708,7 @@ Route::nth_send (uint32_t n) if (n-- == 0) { return *i; } - } + } } return boost::shared_ptr (); @@ -3488,7 +3717,7 @@ Route::nth_send (uint32_t n) bool Route::has_io_processor_named (const string& name) { - Glib::RWLock::ReaderLock lm (_processor_lock); + Glib::Threads::RWLock::ReaderLock lm (_processor_lock); ProcessorList::iterator i; for (i = _processors.begin(); i != _processors.end(); ++i) { @@ -3512,7 +3741,7 @@ Route::mute_points () const void Route::set_processor_positions () { - Glib::RWLock::ReaderLock lm (_processor_lock); + Glib::Threads::RWLock::ReaderLock lm (_processor_lock); bool had_amp = false; for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { @@ -3539,12 +3768,25 @@ Route::input_port_count_changing (ChanCount to) return false; } +/** Called when there is a proposed change to the output port count */ +bool +Route::output_port_count_changing (ChanCount to) +{ + for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) { + if (processor_out_streams.get(*t) > to.get(*t)) { + return true; + } + } + /* The change is ok */ + return false; +} + list Route::unknown_processors () const { list p; - - Glib::RWLock::ReaderLock lm (_processor_lock); + + Glib::Threads::RWLock::ReaderLock lm (_processor_lock); for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) { if (boost::dynamic_pointer_cast (*i)) { p.push_back ((*i)->name ()); @@ -3562,23 +3804,28 @@ Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecn universally true, but the alternative is way too corner-case to worry about. */ - jack_latency_range_t all_connections; - - all_connections.min = ~((jack_nframes_t) 0); - all_connections.max = 0; - - /* iterate over all "from" ports and determine the latency range for all of their - connections to the "outside" (outside of this Route). - */ + LatencyRange all_connections; - for (PortSet::iterator p = from.begin(); p != from.end(); ++p) { - - jack_latency_range_t range; - - p->get_connected_latency_range (range, playback); - - all_connections.min = min (all_connections.min, range.min); - all_connections.max = max (all_connections.max, range.max); + if (from.empty()) { + all_connections.min = 0; + all_connections.max = 0; + } else { + all_connections.min = ~((pframes_t) 0); + all_connections.max = 0; + + /* iterate over all "from" ports and determine the latency range for all of their + connections to the "outside" (outside of this Route). + */ + + for (PortSet::iterator p = from.begin(); p != from.end(); ++p) { + + LatencyRange range; + + p->get_connected_latency_range (range, playback); + + all_connections.min = min (all_connections.min, range.min); + all_connections.max = max (all_connections.max, range.max); + } } /* set the "from" port latencies to the max/min range of all their connections */ @@ -3637,7 +3884,7 @@ Route::set_public_port_latencies (framecnt_t value, bool playback) const latency compensation into account. */ - jack_latency_range_t range; + LatencyRange range; range.min = value; range.max = value; @@ -3664,7 +3911,7 @@ void Route::setup_invisible_processors () { #ifndef NDEBUG - Glib::RWLock::WriterLock lm (_processor_lock, Glib::TRY_LOCK); + Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK); assert (!lm.locked ()); #endif @@ -3674,11 +3921,11 @@ Route::setup_invisible_processors () } /* we'll build this new list here and then use it */ - + ProcessorList new_processors; /* find visible processors */ - + for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { if ((*i)->display_to_user ()) { new_processors.push_back (*i); @@ -3764,6 +4011,7 @@ Route::setup_invisible_processors () new_processors.insert (amp, _monitor_send); break; } + _monitor_send->set_can_pan (false); break; case AfterFaderListen: switch (Config->get_afl_position ()) { @@ -3774,10 +4022,12 @@ Route::setup_invisible_processors () new_processors.insert (new_processors.end(), _monitor_send); break; } + _monitor_send->set_can_pan (true); break; } } else { new_processors.insert (new_processors.end(), _monitor_send); + _monitor_send->set_can_pan (false); } } @@ -3787,7 +4037,7 @@ Route::setup_invisible_processors () assert (!_monitor_control->display_to_user ()); new_processors.push_front (_monitor_control); } - + /* INTERNAL RETURN */ /* doing this here means that any monitor control will come just after @@ -3800,7 +4050,7 @@ Route::setup_invisible_processors () } /* EXPORT PROCESSOR */ - + if (_capturing_processor) { assert (!_capturing_processor->display_to_user ()); new_processors.push_front (_capturing_processor); @@ -3814,18 +4064,225 @@ Route::setup_invisible_processors () } } +void +Route::unpan () +{ + Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ()); + Glib::Threads::RWLock::ReaderLock lp (_processor_lock); + + _pannable.reset (); + + for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { + boost::shared_ptr d = boost::dynamic_pointer_cast(*i); + if (d) { + d->unpan (); + } + } +} + +/** If the meter point is `Custom', make a note of where the meter is. + * This is so that if the meter point is subsequently set to something else, + * and then back to custom, we can put the meter back where it was last time + * custom was enabled. + * + * Must be called with the _processor_lock held. + */ +void +Route::maybe_note_meter_position () +{ + if (_meter_point != MeterCustom) { + return; + } + + _custom_meter_position_noted = true; + for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { + if (boost::dynamic_pointer_cast (*i)) { + ProcessorList::iterator j = i; + ++j; + if (j != _processors.end ()) { + _processor_after_last_custom_meter = *j; + _last_custom_meter_was_at_end = false; + } else { + _last_custom_meter_was_at_end = true; + } + } + } +} + +boost::shared_ptr +Route::processor_by_id (PBD::ID id) const +{ + Glib::Threads::RWLock::ReaderLock lm (_processor_lock); + for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) { + if ((*i)->id() == id) { + return *i; + } + } + + 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. + */ +MeterState +Route::metering_state () const +{ + return MeteringRoute; +} + bool -Route::should_monitor () const +Route::has_external_redirects () const { - switch (Config->get_monitoring_model()) { - case HardwareMonitoring: - case ExternalMonitoring: - return !record_enabled() || (_session.config.get_auto_input() && !_session.actively_recording()); - break; - default: - break; + for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) { + + /* ignore inactive processors and obviously ignore the main + * outs since everything has them and we don't care. + */ + + if ((*i)->active() && (*i) != _main_outs && (*i)->does_routing()) { + return true;; + } + } + + return false; +} + +boost::shared_ptr +Route::the_instrument () const +{ + Glib::Threads::RWLock::ReaderLock lm (_processor_lock); + return the_instrument_unlocked (); +} + +boost::shared_ptr +Route::the_instrument_unlocked () const +{ + for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) { + if (boost::dynamic_pointer_cast(*i)) { + if ((*i)->input_streams().n_midi() > 0 && + (*i)->output_streams().n_audio() > 0) { + return (*i); + } + } + } + return boost::shared_ptr(); +} + + + +void +Route::non_realtime_locate (framepos_t pos) +{ + if (_pannable) { + _pannable->transport_located (pos); } - return true; + { + //Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ()); + Glib::Threads::RWLock::WriterLock lm (_processor_lock); + + for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { + (*i)->transport_located (pos); + } + } } +void +Route::fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr io, pframes_t nframes) +{ + size_t n_buffers; + size_t i; + + /* MIDI + * + * We don't currently mix MIDI input together, so we don't need the + * complex logic of the audio case. + */ + + n_buffers = bufs.count().n_midi (); + + for (i = 0; i < n_buffers; ++i) { + + boost::shared_ptr source_port = io->midi (i); + MidiBuffer& buf (bufs.get_midi (i)); + + if (source_port) { + buf.copy (source_port->get_midi_buffer(nframes)); + } else { + buf.silence (nframes); + } + } + + /* AUDIO */ + + n_buffers = bufs.count().n_audio(); + + size_t n_ports = io->n_ports().n_audio(); + float scaling = 1.0f; + + if (n_ports > n_buffers) { + scaling = ((float) n_buffers) / n_ports; + } + + for (i = 0; i < n_ports; ++i) { + + /* if there are more ports than buffers, map them onto buffers + * in a round-robin fashion + */ + + 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 + the output buffer. + */ + + buf.read_from (source_port->get_audio_buffer (nframes), nframes); + + if (scaling != 1.0f) { + buf.apply_gain (scaling, nframes); + } + + } else { + + /* on subsequent times around, merge data from + * the port with what is already there + */ + + if (scaling != 1.0f) { + buf.accumulate_with_gain_from (source_port->get_audio_buffer (nframes), nframes, 0, scaling); + } else { + buf.accumulate_from (source_port->get_audio_buffer (nframes), nframes); + } + } + } + + /* silence any remaining buffers */ + + for (; i < n_buffers; ++i) { + AudioBuffer& buf (bufs.get_audio (i)); + buf.silence (nframes); + } + + /* establish the initial setup of the buffer set, reflecting what was + copied into it. unless, of course, we are the auditioner, in which + case nothing was fed into it from the inputs at all. + */ + + if (!is_auditioner()) { + bufs.set_count (io->n_ports()); + } +}