#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"
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)
, _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++;
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);
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);
}
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());
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);
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<Amp> (*i)) {
+ continue;
+ }
+
if (state) {
(*i)->activate ();
} else {
_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 ());
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<Processor> 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;
}
}
+ 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;
}
int
-Route::_set_state_2X (const XMLNode& node, int version)
+Route::set_state_2X (const XMLNode& node, int version)
{
XMLNodeList nlist;
XMLNodeConstIterator niter;
}
bool
-Route::direct_feeds (boost::shared_ptr<Route> other, bool* only_send)
+Route::direct_feeds_according_to_reality (boost::shared_ptr<Route> 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;
if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*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 {
return false;
}
+bool
+Route::direct_feeds_according_to_graph (boost::shared_ptr<Route> 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)
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<Processor> 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 */
}
}
}
+
+/** 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<PeakMeter> (*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;
+ }
+ }
+ }
+}