move disk_{writer,reader} into Route to allow for simple, sensible implementation of DiskIOPoint

8 files changed, 133 insertions, 106 deletions

diff --git a/libs/ardour/ardour/disk_reader.h b/libs/ardour/ardour/disk_reader.h
index cc98a1174b..88657d56f1 100644
--- a/libs/ardour/ardour/disk_reader.h
+++ b/libs/ardour/ardour/disk_reader.h
@@ -40,7 +40,7 @@ class LIBARDOUR_API DiskReader : public DiskIOProcessor
 	~DiskReader ();
 
 	bool set_name (std::string const & str);
-	std::string display_name() const { return std::string (_("reader")); }
+	std::string display_name() const { return std::string (_("player")); }
 
 	static framecnt_t chunk_frames() { return _chunk_frames; }
 	static framecnt_t default_chunk_frames ();
diff --git a/libs/ardour/ardour/disk_writer.h b/libs/ardour/ardour/disk_writer.h
index 218d1fc1fa..45fc37bdcf 100644
--- a/libs/ardour/ardour/disk_writer.h
+++ b/libs/ardour/ardour/disk_writer.h
@@ -42,7 +42,7 @@ class LIBARDOUR_API DiskWriter : public DiskIOProcessor
 	~DiskWriter ();
 
 	bool set_name (std::string const & str);
-	std::string display_name() const { return std::string (_("writer")); }
+	std::string display_name() const { return std::string (_("recorder")); }
 
 	virtual bool set_write_source_name (const std::string& str);
 
diff --git a/libs/ardour/ardour/route.h b/libs/ardour/ardour/route.h
index 2590be291b..dc693d3a7e 100644
--- a/libs/ardour/ardour/route.h
+++ b/libs/ardour/ardour/route.h
@@ -66,6 +66,8 @@ namespace ARDOUR {
 class Amp;
 class DelayLine;
 class Delivery;
+class DiskReader;
+class DiskWriter;
 class IOProcessor;
 class Panner;
 class PannerShell;
@@ -186,6 +188,9 @@ public:
 	void         set_meter_type (MeterType t) { _meter_type = t; }
 	MeterType    meter_type() const { return _meter_type; }
 
+	void set_disk_io_point (DiskIOPoint);
+	DiskIOPoint disk_io_point() const { return _disk_io_point; }
+
 	/* Processors */
 
 	boost::shared_ptr<Amp> amp() const  { return _amp; }
@@ -635,6 +640,10 @@ public:
 	boost::shared_ptr<InternalReturn> _intreturn;
 	boost::shared_ptr<MonitorProcessor> _monitor_control;
 	boost::shared_ptr<Pannable> _pannable;
+	boost::shared_ptr<DiskReader> _disk_reader;
+	boost::shared_ptr<DiskWriter> _disk_writer;
+
+	DiskIOPoint    _disk_io_point;
 
 	enum {
 		EmitNone = 0x00,
@@ -740,8 +749,6 @@ private:
 	framecnt_t update_port_latencies (PortSet& ports, PortSet& feeders, bool playback, framecnt_t) const;
 
 	void setup_invisible_processors ();
-	virtual void setup_invisible_processors_oh_children_of_mine (ProcessorList&) {}
-	virtual void add_processors_oh_children_of_mine () {}
 
 	void unpan ();
 
diff --git a/libs/ardour/ardour/track.h b/libs/ardour/ardour/track.h
index 65513e46a1..b1d3ec75e7 100644
--- a/libs/ardour/ardour/track.h
+++ b/libs/ardour/ardour/track.h
@@ -187,9 +187,6 @@ class LIBARDOUR_API Track : public Route, public Recordable
 	void adjust_playback_buffering ();
 	void adjust_capture_buffering ();
 
-	void set_disk_io_position (DiskIOPoint);
-	DiskIOPoint disk_io_point() const { return _disk_io_point; }
-
 	PBD::Signal0<void> FreezeChange;
 	PBD::Signal0<void> PlaylistChanged;
 	PBD::Signal0<void> SpeedChanged;
@@ -198,12 +195,9 @@ class LIBARDOUR_API Track : public Route, public Recordable
   protected:
 	XMLNode& state (bool full);
 
-	boost::shared_ptr<DiskReader> _disk_reader;
-	boost::shared_ptr<DiskWriter> _disk_writer;
 	boost::shared_ptr<Playlist>   _playlists[DataType::num_types];
 
 	MeterPoint    _saved_meter_point;
-	DiskIOPoint   _disk_io_point;
 	TrackMode     _mode;
 	bool          _needs_butler;
 	boost::shared_ptr<MonitorControl> _monitoring_control;
@@ -257,8 +251,6 @@ class LIBARDOUR_API Track : public Route, public Recordable
 
 private:
 	void parameter_changed (std::string const & p);
-	void setup_invisible_processors_oh_children_of_mine (ProcessorList&);
-	void add_processors_oh_children_of_mine ();
 
 	std::string _diskstream_name;
 };
diff --git a/libs/ardour/disk_reader.cc b/libs/ardour/disk_reader.cc
index 69eb2e43ae..4250cd5991 100644
--- a/libs/ardour/disk_reader.cc
+++ b/libs/ardour/disk_reader.cc
@@ -116,7 +116,7 @@ DiskReader::default_chunk_frames()
 bool
 DiskReader::set_name (string const & str)
 {
-	string my_name = X_("playback:");
+	string my_name = X_("player:");
 	my_name += str;
 
 	if (_name != my_name) {
diff --git a/libs/ardour/enums.cc b/libs/ardour/enums.cc
index 103e42402b..5c792f1b6d 100644
--- a/libs/ardour/enums.cc
+++ b/libs/ardour/enums.cc
@@ -137,7 +137,7 @@ setup_enum_writer ()
 	PresentationInfo::Flag _PresentationInfo_Flag;
 	MusicalMode::Type mode;
 	MidiPortFlags _MidiPortFlags;
-		
+
 #define REGISTER(e) enum_writer.register_distinct (typeid(e).name(), i, s); i.clear(); s.clear()
 #define REGISTER_BITS(e) enum_writer.register_bits (typeid(e).name(), i, s); i.clear(); s.clear()
 #define REGISTER_ENUM(e) i.push_back (e); s.push_back (#e)
diff --git a/libs/ardour/route.cc b/libs/ardour/route.cc
index f83a9d4d13..c447f26875 100644
--- a/libs/ardour/route.cc
+++ b/libs/ardour/route.cc
@@ -47,6 +47,8 @@
 #include "ardour/capturing_processor.h"
 #include "ardour/debug.h"
 #include "ardour/delivery.h"
+#include "ardour/disk_reader.h"
+#include "ardour/disk_writer.h"
 #include "ardour/event_type_map.h"
 #include "ardour/gain_control.h"
 #include "ardour/internal_return.h"
@@ -96,6 +98,7 @@ Route::Route (Session& sess, string name, PresentationInfo::Flag flag, DataType
 	, _signal_latency_at_trim_position (0)
 	, _initial_delay (0)
 	, _roll_delay (0)
+	, _disk_io_point (DiskIOPreFader)
 	, _pending_process_reorder (0)
 	, _pending_signals (0)
 	, _pending_declick (true)
@@ -239,10 +242,6 @@ Route::init ()
 		_monitor_control->activate ();
 	}
 
-	/* give derived classes a chance to add processors before we configure */
-
-	add_processors_oh_children_of_mine ();
-
 	/* now that we have _meter, its safe to connect to this */
 
 	{
@@ -2340,6 +2339,7 @@ Route::state(bool full_state)
 	node->set_property ("active", _active);
 	node->set_property ("denormal-protection", _denormal_protection);
 	node->set_property ("meter-point", _meter_point);
+	node->set_property ("disk-io-point", _disk_io_point);
 
 	node->set_property ("meter-type", _meter_type);
 
@@ -2496,6 +2496,17 @@ Route::set_state (const XMLNode& node, int version)
 		}
 	}
 
+	DiskIOPoint diop;
+	if (node.get_property (X_("disk-io-point"), diop)) {
+		if (_disk_writer) {
+			_disk_writer->set_display_to_user (diop == DiskIOCustom);
+		}
+		if (_disk_reader) {
+			_disk_reader->set_display_to_user (diop == DiskIOCustom);
+		}
+		set_disk_io_point (diop);
+	}
+
 	node.get_property (X_("meter-type"), _meter_type);
 
 	_initial_io_setup = false;
@@ -2835,6 +2846,12 @@ Route::set_processor_state (const XMLNode& node)
 		} else if (prop->value() == "capture") {
 			/* CapturingProcessor should never be restored, it's always
 			   added explicitly when needed */
+		} else if (prop->value() == "diskreader" && _disk_reader) {
+			_disk_reader->set_state (**niter, Stateful::current_state_version);
+			new_order.push_back (_disk_reader);
+		} else if (prop->value() == "diskwriter" && _disk_writer) {
+			_disk_writer->set_state (**niter, Stateful::current_state_version);
+			new_order.push_back (_disk_writer);
 		} else {
 			set_processor_state (**niter, prop, new_order, must_configure);
 		}
@@ -4511,6 +4528,8 @@ Route::setup_invisible_processors ()
 	 */
 
 	ProcessorList new_processors;
+	ProcessorList::iterator dr;
+	ProcessorList::iterator dw;
 
 	/* find visible processors */
 
@@ -4630,9 +4649,12 @@ Route::setup_invisible_processors ()
 
 	/* TRIM CONTROL */
 
+	ProcessorList::iterator trim = new_processors.end();
+
 	if (_trim && _trim->active()) {
 		assert (!_trim->display_to_user ());
 		new_processors.push_front (_trim);
+		trim = new_processors.begin();
 	}
 
 	/* INTERNAL RETURN */
@@ -4653,7 +4675,46 @@ Route::setup_invisible_processors ()
 		new_processors.push_front (_capturing_processor);
 	}
 
-	setup_invisible_processors_oh_children_of_mine (new_processors);
+	/* DISK READER & WRITER (for Track objects) */
+
+	if (_disk_reader || _disk_writer) {
+		switch (_disk_io_point) {
+		case DiskIOPreFader:
+			if (trim != new_processors.end()) {
+				/* insert AFTER TRIM */
+				ProcessorList::iterator insert_pos = trim;
+				++insert_pos;
+				if (_disk_writer) {
+					new_processors.insert (insert_pos, _disk_writer);
+				}
+				if (_disk_reader) {
+					new_processors.insert (insert_pos, _disk_reader);
+				}
+			} else {
+				if (_disk_writer) {
+					new_processors.push_front (_disk_writer);
+				}
+				if (_disk_reader) {
+					new_processors.push_front (_disk_reader);
+				}
+			}
+			break;
+		case DiskIOPostFader:
+			/* insert BEFORE main outs */
+			if (_disk_writer) {
+				new_processors.insert (main, _disk_writer);
+			}
+			if (_disk_reader) {
+				new_processors.insert (main, _disk_reader);
+			}
+			break;
+		case DiskIOCustom:
+			/* reader and writer are visible under this condition, so they
+			 * are not invisible and thus not handled here.
+			 */
+			break;
+		}
+	}
 
 	_processors = new_processors;
 
@@ -5565,3 +5626,38 @@ Route::slavables () const
 	rv.push_back (_solo_control);
 	return rv;
 }
+
+void
+Route::set_disk_io_point (DiskIOPoint diop)
+{
+	bool display = false;
+
+	cerr << "set disk io to " << enum_2_string (diop) << endl;
+
+	switch (diop) {
+	case DiskIOCustom:
+		display = true;
+		break;
+	default:
+		display = false;
+	}
+
+	if (_disk_writer) {
+		_disk_writer->set_display_to_user (display);
+	}
+
+	if (_disk_reader) {
+		_disk_reader->set_display_to_user (display);
+	}
+
+	const bool changed = (diop != _disk_io_point);
+
+	_disk_io_point = diop;
+
+	if (changed) {
+		Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
+		configure_processors (0);
+	}
+
+	processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
+}
diff --git a/libs/ardour/track.cc b/libs/ardour/track.cc
index 448ac02ec7..669a30190e 100644
--- a/libs/ardour/track.cc
+++ b/libs/ardour/track.cc
@@ -55,12 +55,12 @@ using namespace PBD;
 Track::Track (Session& sess, string name, PresentationInfo::Flag flag, TrackMode mode, DataType default_type)
 	: Route (sess, name, flag, default_type)
         , _saved_meter_point (_meter_point)
-	, _disk_io_point (DiskIOPreFader)
         , _mode (mode)
 	, _alignment_choice (Automatic)
 {
 	_freeze_record.state = NoFreeze;
         _declickable = true;
+
 }
 
 Track::~Track ()
@@ -85,11 +85,23 @@ Track::init ()
                 return -1;
         }
 
-        use_new_playlist (data_type());
+        DiskIOProcessor::Flag dflags = DiskIOProcessor::Recordable;
 
-        /* disk writer and reader processors will be added when Route calls
-         * add_processors_oh_children_of_mine ().
-         */
+        if (_mode == Destructive && !Profile->get_trx()) {
+	        dflags = DiskIOProcessor::Flag (dflags | DiskIOProcessor::Destructive);
+        } else if (_mode == NonLayered){
+	        dflags = DiskIOProcessor::Flag(dflags | DiskIOProcessor::NonLayered);
+        }
+
+        _disk_reader.reset (new DiskReader (_session, name(), dflags));
+        _disk_reader->set_block_size (_session.get_block_size ());
+        _disk_reader->set_route (boost::dynamic_pointer_cast<Route> (shared_from_this()));
+
+        _disk_writer.reset (new DiskWriter (_session, name(), dflags));
+        _disk_writer->set_block_size (_session.get_block_size ());
+        _disk_writer->set_route (boost::dynamic_pointer_cast<Route> (shared_from_this()));
+
+        use_new_playlist (data_type());
 
         boost::shared_ptr<Route> rp (boost::dynamic_pointer_cast<Route> (shared_from_this()));
 	boost::shared_ptr<Track> rt = boost::dynamic_pointer_cast<Track> (rp);
@@ -115,31 +127,6 @@ Track::init ()
 }
 
 void
-Track::add_processors_oh_children_of_mine ()
-{
-        cerr << name() << " ::apocom(), create DW + DR\n";
-
-        DiskIOProcessor::Flag dflags = DiskIOProcessor::Recordable;
-
-        if (_mode == Destructive && !Profile->get_trx()) {
-	        dflags = DiskIOProcessor::Flag (dflags | DiskIOProcessor::Destructive);
-        } else if (_mode == NonLayered){
-	        dflags = DiskIOProcessor::Flag(dflags | DiskIOProcessor::NonLayered);
-        }
-        if (!_disk_reader) {
-	        _disk_reader.reset (new DiskReader (_session, name(), dflags));
-	        _disk_reader->set_block_size (_session.get_block_size ());
-	        _disk_reader->set_route (boost::dynamic_pointer_cast<Route> (shared_from_this()));
-        }
-
-        if (!_disk_writer) {
-	        _disk_writer.reset (new DiskWriter (_session, name(), dflags));
-	        _disk_writer->set_block_size (_session.get_block_size ());
-	        _disk_writer->set_route (boost::dynamic_pointer_cast<Route> (shared_from_this()));
-        }
-}
-
-void
 Track::input_changed ()
 {
 	if (_disk_writer && _alignment_choice == Automatic) {
@@ -171,7 +158,6 @@ Track::state (bool full)
 	root.add_child_nocopy (_record_enable_control->get_state ());
 
 	root.set_property (X_("saved-meter-point"), _saved_meter_point);
-	root.set_property (X_("disk-io-point"), _disk_io_point);
 	root.set_property (X_("alignment-choice"), _alignment_choice);
 
 	return root;
@@ -234,9 +220,6 @@ Track::set_state (const XMLNode& node, int version)
 		_saved_meter_point = _meter_point;
 	}
 
-	if (!node.get_property (X_("saved-meter-point"), _disk_io_point)) {
-		_disk_io_point = DiskIOPreFader;
-	}
 
 	AlignChoice ac;
 
@@ -1264,6 +1247,8 @@ Track::set_processor_state (XMLNode const & node, XMLProperty const* prop, Proce
 		return true;
 	}
 
+	cerr << name() << " looking for state for track procs, DR = " << _disk_reader << endl;
+
 	if (prop->value() == "diskreader") {
 		if (_disk_reader) {
 			_disk_reader->set_state (node, Stateful::current_state_version);
@@ -1521,57 +1506,4 @@ Track::use_captured_audio_sources (SourceList& srcs, CaptureInfos const & captur
 	_session.add_command (new StatefulDiffCommand (pl));
 }
 
-#ifdef __clang__
-__attribute__((annotate("realtime")))
-#endif
-void
-Track::setup_invisible_processors_oh_children_of_mine (ProcessorList& processors)
-{
-	ProcessorList::iterator insert_pos;
-
-	switch (_disk_io_point) {
-	case DiskIOPreFader:
-		insert_pos = find (processors.begin(), processors.end(), _trim);
-		if (insert_pos != processors.end()) {
-			insert_pos = processors.insert (insert_pos, _disk_writer);
-			processors.insert (insert_pos, _disk_reader);
-		}
-		break;
-	case DiskIOPostFader:
-		insert_pos = find (processors.begin(), processors.end(), _main_outs);
-		if (insert_pos != processors.end()) {
-			insert_pos = processors.insert (insert_pos, _disk_writer);
-			processors.insert (insert_pos, _disk_reader);
-		}
-	case DiskIOCustom:
-		break;
-	}
-}
-
-void
-Track::set_disk_io_position (DiskIOPoint diop)
-{
-	bool display = false;
-
-	switch (diop) {
-	case DiskIOCustom:
-		display = true;
-		break;
-	default:
-		display = false;
-	}
 
-	_disk_writer->set_display_to_user (display);
-	_disk_reader->set_display_to_user (display);
-
-	const bool changed = (diop != _disk_io_point);
-
-	_disk_io_point = diop;
-
-	if (changed) {
-		Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
-		configure_processors (0);
-	}
-
-	processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
-}