X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=libs%2Fardour%2Froute.cc;h=57793098d803151ffa291ef0aaa3a348ac53fe41;hb=58dbe9ed13cede08f9e11f428fa6c188325db009;hp=d0dca37e0a7837fac9c23129a91e0e81a30708fa;hpb=cfe9ae636e0ee61cafdff43b3bd6967d835ef629;p=ardour.git diff --git a/libs/ardour/route.cc b/libs/ardour/route.cc index d0dca37e0a..57793098d8 100644 --- a/libs/ardour/route.cc +++ b/libs/ardour/route.cc @@ -65,7 +65,6 @@ #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" @@ -82,7 +81,7 @@ 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) @@ -104,6 +103,8 @@ Route::Route (Session& sess, string name, Flag flg, DataType default_type) , _default_type (default_type) , _remote_control_id (0) , _in_configure_processors (false) + , _custom_meter_position_noted (false) + , _last_custom_meter_was_at_end (false) { processor_max_streams.reset(); order_keys[N_("signal")] = order_key_cnt++; @@ -404,15 +405,6 @@ Route::process_output_buffers (BufferSet& bufs, bufs.is_silent (false); -#if 0 - cerr << name() << " POB, buffers: count: " << bufs.count() << " avail " << bufs.available() << endl; - int na = bufs.count().n_audio(); - for (int nn = 0; nn < na; ++nn) { - AudioBuffer& ab (bufs.get_audio (nn)); - cerr << "\tAudio buffer " << nn << " @ " << &ab << " data @ " << ab.data() << endl; - } -#endif - /* figure out if we're going to use gain automation */ if (gain_automation_ok) { _amp->setup_gain_automation (start_frame, end_frame, nframes); @@ -563,6 +555,7 @@ 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())); + 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); @@ -753,7 +746,7 @@ Route::set_solo_isolated (bool yn, void *src) } 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()); @@ -1632,12 +1625,11 @@ Route::configure_processors_unlocked (ProcessorStreams* err) return 0; } -/** 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. +/** 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_active (Placement p, bool state) +Route::all_visible_processors_active (bool state) { Glib::RWLock::ReaderLock lm (_processor_lock); @@ -1645,10 +1637,11 @@ Route::all_processors_active (Placement p, bool state) return; } - ProcessorList::iterator start, end; - placement_range(p, start, end); - - for (ProcessorList::iterator i = start; i != end; ++i) { + for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { + if (!(*i)->display_to_user() || boost::dynamic_pointer_cast (*i)) { + continue; + } + if (state) { (*i)->activate (); } else { @@ -1727,6 +1720,9 @@ Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end()); + /* If the meter is in a custom position, find it and make a rough note of its position */ + maybe_note_meter_position (); + { Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ()); @@ -1832,24 +1828,28 @@ Route::state(bool full_state) 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); -} - -int -Route::_set_state (const XMLNode& node, int version) { if (version < 3000) { - return _set_state_2X (node, version); + return set_state_2X (node, version); } XMLNodeList nlist; @@ -2000,6 +2000,24 @@ Route::_set_state (const XMLNode& node, int version) } } + if ((prop = node.property (X_("processor-after-last-custom-meter"))) != 0) { + PBD::ID id (prop->value ()); + Glib::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; @@ -2031,7 +2049,7 @@ Route::_set_state (const XMLNode& node, int version) } int -Route::_set_state_2X (const XMLNode& node, int version) +Route::set_state_2X (const XMLNode& node, int version) { XMLNodeList nlist; XMLNodeConstIterator niter; @@ -2653,14 +2671,14 @@ 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; @@ -2674,8 +2692,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 { @@ -2691,6 +2709,12 @@ Route::direct_feeds (boost::shared_ptr other, bool* only_send) 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) @@ -2875,45 +2899,63 @@ Route::set_meter_point (MeterPoint p, bool force) return; } - _meter_point = p; - bool meter_was_visible_to_user = _meter->display_to_user (); { Glib::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); + } else { - ChanCount m_in; + _meter->set_display_to_user (true); - if (loc == _processors.begin()) { - m_in = _input->n_ports(); - } else { - ProcessorList::iterator before = loc; - --before; - m_in = (*before)->output_streams (); + /* 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); + } } + } - _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. - */ + /* 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 { - - // just make it visible and let the user move it - - _meter->set_display_to_user (true); + 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 */ @@ -3806,3 +3848,32 @@ Route::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; + } + } + } +}