mega-commit to save state of first "it compilesand links" state for separated disk i/o changes.

THIS WILL NOT RUN. THIS REQUIRES MANY CHANGES

gtk2_ardour/mixer_strip.cc

@@ -692,10 +692,6 @@ MixerStrip::set_route (boost::shared_ptr<Route> rt)
 		_route->panner_shell()->Changed.connect (route_connections, invalidator (*this), boost::bind (&MixerStrip::connect_to_pan, this), gui_context());
 	}
 
-	if (is_audio_track()) {
-		audio_track()->DiskstreamChanged.connect (route_connections, invalidator (*this), boost::bind (&MixerStrip::diskstream_changed, this), gui_context());
-	}
-
 	_route->comment_changed.connect (route_connections, invalidator (*this), boost::bind (&MixerStrip::setup_comment_button, this), gui_context());
 
 	set_stuff_from_route ();

gtk2_ardour/playlist_selector.cc

@@ -272,7 +272,7 @@ PlaylistSelector::selection_changed ()
 			return;
 		}
 
-		at->use_playlist (apl);
+		at->use_playlist (DataType::AUDIO, apl);
 
 		hide ();
 	}

gtk2_ardour/route_time_axis.cc

@@ -1643,7 +1643,7 @@ RouteTimeAxisView::use_playlist (RadioMenuItem *item, boost::weak_ptr<Playlist>
 		return;
 	}
 
-	track()->use_playlist (pl);
+	track()->use_playlist (track()->data_type(), pl);
 
 	RouteGroup* rg = route_group();
 
@@ -1683,7 +1683,7 @@ RouteTimeAxisView::use_playlist (RadioMenuItem *item, boost::weak_ptr<Playlist>
 				track->use_new_playlist();
 				track->playlist()->set_name(playlist_name);
 			} else {
-				track->use_playlist(ipl);
+				track->use_playlist(track->data_type(), ipl);
 			}
 		}
 	}

gtk2_ardour/streamview.cc

@@ -77,7 +77,6 @@ StreamView::StreamView (RouteTimeAxisView& tv, ArdourCanvas::Container* canvas_g
 	canvas_rect->Event.connect (sigc::bind (sigc::mem_fun (_trackview.editor(), &PublicEditor::canvas_stream_view_event), canvas_rect, &_trackview));
 
 	if (_trackview.is_track()) {
-		_trackview.track()->DiskstreamChanged.connect (*this, invalidator (*this), boost::bind (&StreamView::diskstream_changed, this), gui_context());
 		_trackview.track()->rec_enable_control()->Changed.connect (*this, invalidator (*this), boost::bind (&StreamView::rec_enable_changed, this), gui_context());
 
 		_trackview.session()->TransportStateChange.connect (*this, invalidator (*this), boost::bind (&StreamView::transport_changed, this), gui_context());

libs/ardour/ardour/audio_track.h

@@ -40,13 +40,6 @@ class LIBARDOUR_API AudioTrack : public Track
 	int roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
 	          int declick, bool& need_butler);
 
-	boost::shared_ptr<Diskstream> create_diskstream ();
-	void set_diskstream (boost::shared_ptr<Diskstream>);
-
-	DataType data_type () const {
-		return DataType::AUDIO;
-	}
-
 	void freeze_me (InterThreadInfo&);
 	void unfreeze ();
 
@@ -62,13 +55,9 @@ class LIBARDOUR_API AudioTrack : public Track
 	boost::shared_ptr<AudioFileSource> write_source (uint32_t n = 0);
 
   protected:
-	boost::shared_ptr<AudioDiskstream> audio_diskstream () const;
 	XMLNode& state (bool full);
 
   private:
-
-	boost::shared_ptr<Diskstream> diskstream_factory (XMLNode const &);
-
 	int  deprecated_use_diskstream_connections ();
 	void set_state_part_two ();
 	void set_state_part_three ();

libs/ardour/ardour/auditioner.h

@@ -80,9 +80,6 @@ class LIBARDOUR_API Auditioner : public Track
 	int roll_audio (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& need_butler);
 	int roll_midi (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& need_butler);
 
-	boost::shared_ptr<Diskstream> create_diskstream ();
-	void set_diskstream (boost::shared_ptr<Diskstream> ds);
-
 	/* fake track */
 	void set_state_part_two () {}
 	int set_state (const XMLNode&, int) { return 0; }
@@ -102,9 +99,6 @@ class LIBARDOUR_API Auditioner : public Track
 	boost::shared_ptr<Diskstream> diskstream_factory (XMLNode const &)
 		{ return boost::shared_ptr<Diskstream> (); }
 
-	boost::shared_ptr<AudioDiskstream> audio_diskstream() const;
-	boost::shared_ptr<MidiDiskstream> midi_diskstream() const;
-
   private:
 	boost::shared_ptr<AudioRegion> the_region;
 	boost::shared_ptr<MidiRegion> midi_region;

libs/ardour/ardour/disk_io.h

@@ -65,12 +65,11 @@ class LIBARDOUR_API DiskIOProcessor : public Processor
 	bool configure_io (ChanCount in, ChanCount out);
 	bool can_support_io_configuration (const ChanCount& in, ChanCount& out);
 
-	/** @return A number between 0 and 1, where 0 indicates that the playback buffer
+	/** @return A number between 0 and 1, where 0 indicates that the playback/capture buffer
 	 *  is dry (ie the disk subsystem could not keep up) and 1 indicates that the
 	 *  buffer is full.
 	 */
-	virtual float playback_buffer_load() const = 0;
+	virtual float buffer_load() const = 0;
-	virtual float capture_buffer_load() const = 0;
 
 	void set_flag (Flag f)   { _flags = Flag (_flags | f); }
 	void unset_flag (Flag f) { _flags = Flag (_flags & ~f); }
@@ -89,8 +88,6 @@ class LIBARDOUR_API DiskIOProcessor : public Processor
 	virtual void punch_in()  {}
 	virtual void punch_out() {}
 
-	virtual float buffer_load() const = 0;
-
 	bool slaved() const      { return _slaved; }
 	void set_slaved(bool yn) { _slaved = yn; }
 
@@ -113,8 +110,6 @@ class LIBARDOUR_API DiskIOProcessor : public Processor
 
 	virtual void playlist_modified () {}
 	virtual int use_playlist (DataType, boost::shared_ptr<Playlist>);
-	virtual int use_new_playlist (DataType);
-	virtual int use_copy_playlist (DataType);
 
 	PBD::Signal1<void,DataType>   PlaylistChanged;
 
@@ -135,6 +130,8 @@ class LIBARDOUR_API DiskIOProcessor : public Processor
 	bool         _slaved;
 	Location*     loop_location;
 	bool          in_set_state;
+	framepos_t     file_frame;
+	framepos_t     playback_sample;
 	framecnt_t    wrap_buffer_size;
 	framecnt_t    speed_buffer_size;
 	bool         _need_butler;
@@ -202,7 +199,6 @@ class LIBARDOUR_API DiskIOProcessor : public Processor
 	virtual void playlist_changed (const PBD::PropertyChange&) {}
 	virtual void playlist_deleted (boost::weak_ptr<Playlist>);
 	virtual void playlist_ranges_moved (std::list< Evoral::RangeMove<framepos_t> > const &, bool) {}
-	int find_and_use_playlist (DataType, std::string const &);
 
 	/* The MIDI stuff */
 
@@ -210,6 +206,8 @@ class LIBARDOUR_API DiskIOProcessor : public Processor
 	gint                         _frames_written_to_ringbuffer;
 	gint                         _frames_read_from_ringbuffer;
 	CubicMidiInterpolation        midi_interpolation;
+
+	static void get_location_times (const Location* location, framepos_t* start, framepos_t* end, framepos_t* length);
 };
 
 } // namespace ARDOUR

libs/ardour/ardour/disk_reader.h

@@ -86,14 +86,18 @@ class LIBARDOUR_API DiskReader : public DiskIOProcessor
 	void adjust_buffering ();
 
 	int can_internal_playback_seek (framecnt_t distance);
+	int internal_playback_seek (framecnt_t distance);
 	int seek (framepos_t frame, bool complete_refill = false);
 
 	static PBD::Signal0<void> Underrun;
 
 	void playlist_modified ();
+	void reset_tracker ();
 
   protected:
-	void reset_tracker ();
+	friend class Track;
+	friend class MidiTrack;
+
 	void resolve_tracker (Evoral::EventSink<framepos_t>& buffer, framepos_t time);
 	boost::shared_ptr<MidiBuffer> get_gui_feed_buffer () const;
 
@@ -113,8 +117,6 @@ class LIBARDOUR_API DiskReader : public DiskIOProcessor
 	IOChange      input_change_pending;
 	framecnt_t    wrap_buffer_size;
 	framecnt_t    speed_buffer_size;
-	framepos_t     file_frame;
-	framepos_t     playback_sample;
 	MonitorChoice   _monitoring_choice;
 
 	int _do_refill_with_alloc (bool partial_fill);
@@ -142,7 +144,6 @@ class LIBARDOUR_API DiskReader : public DiskIOProcessor
 	int refill_audio (Sample *mixdown_buffer, float *gain_buffer, framecnt_t fill_level);
 	int refill_midi ();
 
-	int internal_playback_seek (framecnt_t distance);
 	frameoffset_t calculate_playback_distance (pframes_t);
 
 	void get_playback (MidiBuffer& dst, framecnt_t nframes);

libs/ardour/ardour/disk_writer.h

@@ -24,12 +24,14 @@
 #include <vector>
 
 #include "ardour/disk_io.h"
+#include "ardour/midi_buffer.h"
 
 namespace ARDOUR
 {
 
 class AudioFileSource;
 class SMFSource;
+class MidiSource;
 
 class LIBARDOUR_API DiskWriter : public DiskIOProcessor
 {
@@ -50,8 +52,6 @@ class LIBARDOUR_API DiskWriter : public DiskIOProcessor
 	virtual XMLNode& state (bool full);
 	int set_state (const XMLNode&, int version);
 
-	virtual int use_new_write_source (uint32_t n=0) = 0;
-
 	std::string write_source_name () const {
 		if (_write_source_name.empty()) {
 			return name();
@@ -72,6 +72,8 @@ class LIBARDOUR_API DiskWriter : public DiskIOProcessor
 	boost::shared_ptr<SMFSource> midi_write_source () { return _midi_write_source; }
 
 	virtual std::string steal_write_source_name () { return std::string(); }
+	int use_new_write_source (DataType, uint32_t n = 0);
+	void reset_write_sources (bool, bool force = false);
 
 	AlignStyle  alignment_style() const { return _alignment_style; }
 	AlignChoice alignment_choice() const { return _alignment_choice; }
@@ -87,8 +89,8 @@ class LIBARDOUR_API DiskWriter : public DiskIOProcessor
 
 	bool         record_enabled() const { return g_atomic_int_get (const_cast<gint*>(&_record_enabled)); }
 	bool         record_safe () const { return g_atomic_int_get (const_cast<gint*>(&_record_safe)); }
-	virtual void set_record_enabled (bool yn) = 0;
+	virtual void set_record_enabled (bool yn);
-	virtual void set_record_safe (bool yn) = 0;
+	virtual void set_record_safe (bool yn);
 
 	bool destructive() const { return _flags & Destructive; }
 	int set_destructive (bool yn);
@@ -109,16 +111,31 @@ class LIBARDOUR_API DiskWriter : public DiskIOProcessor
 	framecnt_t   capture_offset() const { return _capture_offset; }
 	virtual void set_capture_offset ();
 
+	int seek (framepos_t frame, bool complete_refill);
+
 	static PBD::Signal0<void> Overrun;
 
+	void set_note_mode (NoteMode m);
+
+	/** Emitted when some MIDI data has been received for recording.
+	 *  Parameter is the source that it is destined for.
+	 *  A caller can get a copy of the data with get_gui_feed_buffer ()
+	 */
+	PBD::Signal1<void, boost::weak_ptr<MidiSource> > DataRecorded;
+
 	PBD::Signal0<void> RecordEnableChanged;
 	PBD::Signal0<void> RecordSafeChanged;
 
+	void check_record_status (framepos_t transport_frame, bool can_record);
+
+	void transport_looped (framepos_t transport_frame);
+	void transport_stopped_wallclock (struct tm&, time_t, bool abort);
+
   protected:
-	virtual int do_flush (RunContext context, bool force = false) = 0;
+	friend class Track;
+	int do_flush (RunContext context, bool force = false);
 
 	void get_input_sources ();
-	void check_record_status (framepos_t transport_frame, bool can_record);
 	void prepare_record_status (framepos_t /*capture_start_frame*/);
 	void set_align_style_from_io();
 	void setup_destructive_playlist ();
@@ -138,9 +155,6 @@ class LIBARDOUR_API DiskWriter : public DiskIOProcessor
 		framecnt_t& rec_nframes, framecnt_t& rec_offset
 		);
 
-	static framecnt_t disk_read_chunk_frames;
-	static framecnt_t disk_write_chunk_frames;
-
 	struct CaptureInfo {
 		framepos_t start;
 		framecnt_t frames;
@@ -168,7 +182,7 @@ class LIBARDOUR_API DiskWriter : public DiskIOProcessor
 
 	std::list<boost::shared_ptr<Source> > _last_capture_sources;
 	std::vector<boost::shared_ptr<AudioFileSource> > capturing_sources;
-	
+
 	static framecnt_t _chunk_frames;
 
 	NoteMode                     _note_mode;
@@ -176,6 +190,12 @@ class LIBARDOUR_API DiskWriter : public DiskIOProcessor
 	volatile gint                _num_captured_loops;
 	framepos_t                   _accumulated_capture_offset;
 
+	/** A buffer that we use to put newly-arrived MIDI data in for
+	    the GUI to read (so that it can update itself).
+	*/
+	MidiBuffer                   _gui_feed_buffer;
+	mutable Glib::Threads::Mutex _gui_feed_buffer_mutex;
+
 	void finish_capture (boost::shared_ptr<ChannelList> c);
 };
 

libs/ardour/ardour/midi_track.h

@@ -54,10 +54,6 @@ public:
 	bool can_be_record_enabled ();
 	bool can_be_record_safe ();
 
-	DataType data_type () const {
-		return DataType::MIDI;
-	}
-
 	void freeze_me (InterThreadInfo&);
 	void unfreeze ();
 
@@ -156,8 +152,6 @@ private:
 
 	virtual boost::shared_ptr<Diskstream> diskstream_factory (XMLNode const &);
 
-	boost::shared_ptr<MidiDiskstream> midi_diskstream () const;
-
 	void write_out_of_band_data (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, framecnt_t nframes);
 
 	void set_state_part_two ();

libs/ardour/ardour/public_diskstream.h

@@ -68,7 +68,7 @@ public:
 	virtual framepos_t current_capture_start () const = 0;
 	virtual framepos_t current_capture_end () const = 0;
 	virtual void playlist_modified () = 0;
-	virtual int use_playlist (boost::shared_ptr<Playlist>) = 0;
+	// XXX DISK removed virtual int use_playlist (boost::shared_ptr<Playlist>) = 0;
 	virtual void set_align_style (AlignStyle, bool force=false) = 0;
 	virtual void set_align_choice (AlignChoice, bool force=false) = 0;
 	virtual int use_copy_playlist () = 0;

libs/ardour/ardour/route.h

@@ -100,6 +100,13 @@ public:
 
 	virtual int init ();
 
+	DataType data_type () const {
+		/* XXX ultimately nice to do away with this concept, but it is
+		   quite useful for coders and for users too.
+		*/
+		return _default_type;
+	}
+
 	boost::shared_ptr<IO> input() const { return _input; }
 	boost::shared_ptr<IO> output() const { return _output; }
 	IOVector all_inputs () const;

libs/ardour/ardour/track.h

@@ -36,15 +36,19 @@ class RouteGroup;
 class Source;
 class Region;
 class Diskstream;
+class DiskReader;
+class DiskWriter;
 class IO;
 class MonitorControl;
 class RecordEnableControl;
 class RecordSafeControl;
 
 /** A track is an route (bus) with a recordable diskstream and
- * related objects relevant to tracking, playback and editing.
+ * related objects relevant to recording, playback and editing.
  *
- * Specifically a track has regions and playlist objects.
+ * Specifically a track has a playlist object that describes material
+ * to be played from disk, and modifies that object during recording and
+ * editing.
  */
 class LIBARDOUR_API Track : public Route, public Recordable, public PublicDiskstream
 {
@@ -75,14 +79,8 @@ class LIBARDOUR_API Track : public Route, public Recordable, public PublicDiskst
 
 	bool needs_butler() const { return _needs_butler; }
 
-	virtual DataType data_type () const = 0;
-
 	bool can_record();
 
-	void use_new_diskstream ();
-	virtual boost::shared_ptr<Diskstream> create_diskstream() = 0;
-	virtual void set_diskstream (boost::shared_ptr<Diskstream>);
-
 	void set_latency_compensation (framecnt_t);
 
 	enum FreezeState {
@@ -179,18 +177,17 @@ class LIBARDOUR_API Track : public Route, public Recordable, public PublicDiskst
 	AlignChoice alignment_choice () const;
 	framepos_t current_capture_start () const;
 	framepos_t current_capture_end () const;
-	void playlist_modified ();
-	int use_playlist (boost::shared_ptr<Playlist>);
 	void set_align_style (AlignStyle, bool force=false);
 	void set_align_choice (AlignChoice, bool force=false);
+	void playlist_modified ();
+	int use_playlist (DataType, boost::shared_ptr<Playlist>);
+	int find_and_use_playlist (DataType, std::string const & name);
 	int use_copy_playlist ();
 	int use_new_playlist ();
 	void adjust_playback_buffering ();
 	void adjust_capture_buffering ();
 
-	PBD::Signal0<void> DiskstreamChanged;
 	PBD::Signal0<void> FreezeChange;
-	/* Emitted when our diskstream is set to use a different playlist */
 	PBD::Signal0<void> PlaylistChanged;
 	PBD::Signal0<void> SpeedChanged;
 	PBD::Signal0<void> AlignmentStyleChanged;
@@ -199,6 +196,11 @@ class LIBARDOUR_API Track : public Route, public Recordable, public PublicDiskst
 	XMLNode& state (bool full);
 
 	boost::shared_ptr<Diskstream> _diskstream;
+
+	boost::shared_ptr<DiskReader> _disk_reader;
+	boost::shared_ptr<DiskWriter> _disk_writer;
+	boost::shared_ptr<Playlist>   _playlists[DataType::num_types];
+
 	MeterPoint    _saved_meter_point;
 	TrackMode     _mode;
 	bool          _needs_butler;
@@ -245,12 +247,6 @@ class LIBARDOUR_API Track : public Route, public Recordable, public PublicDiskst
 	virtual void monitoring_changed (bool, PBD::Controllable::GroupControlDisposition);
 
 private:
-
-	virtual boost::shared_ptr<Diskstream> diskstream_factory (XMLNode const &) = 0;
-
-	void diskstream_playlist_changed ();
-	void diskstream_speed_changed ();
-	void diskstream_alignment_style_changed ();
 	void parameter_changed (std::string const & p);
 
 	std::string _diskstream_name;

libs/ardour/audio_track.cc

@@ -32,6 +32,8 @@
 #include "ardour/boost_debug.h"
 #include "ardour/buffer_set.h"
 #include "ardour/delivery.h"
+#include "ardour/disk_reader.h"
+#include "ardour/disk_writer.h"
 #include "ardour/meter.h"
 #include "ardour/monitor_control.h"
 #include "ardour/playlist_factory.h"
@@ -63,97 +65,48 @@ AudioTrack::~AudioTrack ()
 	}
 }
 
-boost::shared_ptr<Diskstream>
+#ifdef XXX_OLD_DESTRUCTIVE_API_XXX
-AudioTrack::create_diskstream ()
-{
-	AudioDiskstream::Flag dflags = AudioDiskstream::Flag (AudioDiskstream::Recordable);
-
-	if (_mode == Destructive && !Profile->get_trx()) {
-		dflags = AudioDiskstream::Flag (dflags | AudioDiskstream::Destructive);
-	} else if (_mode == NonLayered){
-		dflags = AudioDiskstream::Flag(dflags | AudioDiskstream::NonLayered);
-	}
-
-	return boost::shared_ptr<AudioDiskstream> (new AudioDiskstream (_session, name(), dflags));
-}
-
-void
-AudioTrack::set_diskstream (boost::shared_ptr<Diskstream> ds)
-{
-	Track::set_diskstream (ds);
-
-	_diskstream->set_track (this);
-
-	if (audio_diskstream()->deprecated_io_node) {
-
-		if (!IO::connecting_legal) {
-			IO::ConnectingLegal.connect_same_thread (*this, boost::bind (&AudioTrack::deprecated_use_diskstream_connections, this));
-		} else {
-			deprecated_use_diskstream_connections ();
-		}
-	}
-
-	_diskstream->set_record_enabled (false);
-	_diskstream->request_input_monitoring (false);
-
-	DiskstreamChanged (); /* EMIT SIGNAL */
-}
-
-boost::shared_ptr<AudioDiskstream>
-AudioTrack::audio_diskstream() const
-{
-	return boost::dynamic_pointer_cast<AudioDiskstream>(_diskstream);
-}
-
 int
-AudioTrack::deprecated_use_diskstream_connections ()
+AudioTrack::set_mode (TrackMode m)
 {
-	boost::shared_ptr<AudioDiskstream> diskstream = audio_diskstream();
+	if (m != _mode) {
 
-	if (diskstream->deprecated_io_node == 0) {
+		if (!Profile->get_trx() && _diskstream->set_destructive (m == Destructive)) {
-		return 0;
-	}
-
-	XMLNode& node (*diskstream->deprecated_io_node);
-
-	/* don't do this more than once. */
-
-	diskstream->deprecated_io_node = 0;
-
-	float val;
-	if (node.get_property ("gain", val)) {
-		_amp->gain_control()->set_value (val, PBD::Controllable::NoGroup);
-	}
-
-	std::string str;
-	if (node.get_property ("input-connection", str)) {
-		boost::shared_ptr<Bundle> c = _session.bundle_by_name (str);
-
-		if (c == 0) {
-			error << string_compose(_("Unknown bundle \"%1\" listed for input of %2"), str, _name) << endmsg;
-
-			if ((c = _session.bundle_by_name (_("in 1"))) == 0) {
-				error << _("No input bundles available as a replacement")
-			        << endmsg;
-				return -1;
-			} else {
-				info << string_compose (_("Bundle %1 was not available - \"in 1\" used instead"), str)
-			       << endmsg;
-			}
-		}
-
-		_input->connect_ports_to_bundle (c, true, this);
-
-	} else if (node.get_property ("inputs", str)) {
-		if (_input->set_ports (str)) {
-			error << string_compose(_("improper input channel list in XML node (%1)"), str) << endmsg;
 			return -1;
 		}
+
+		_diskstream->set_non_layered (m == NonLayered);
+		_mode = m;
+
+		TrackModeChanged (); /* EMIT SIGNAL */
 	}
 
 	return 0;
 }
 
+bool
+AudioTrack::can_use_mode (TrackMode m, bool& bounce_required)
+{
+	switch (m) {
+	case NonLayered:
+	case Normal:
+		bounce_required = false;
+		return true;
+
+	case Destructive:
+		if (Profile->get_trx()) {
+			return false;
+		} else {
+			return _diskstream->can_become_destructive (bounce_required);
+		}
+		break;
+
+	default:
+		return false;
+	}
+}
+#endif
+
 int
 AudioTrack::set_state (const XMLNode& node, int version)
 {
@@ -279,49 +232,21 @@ AudioTrack::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_fram
 	Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
 
 	if (!lm.locked()) {
-		boost::shared_ptr<AudioDiskstream> diskstream = audio_diskstream();
-		framecnt_t playback_distance = diskstream->calculate_playback_distance(nframes);
-		if (can_internal_playback_seek(::llabs(playback_distance))) {
-			/* TODO should declick */
-			internal_playback_seek(playback_distance);
-		}
 		return 0;
 	}
 
-	framepos_t transport_frame;
-	boost::shared_ptr<AudioDiskstream> diskstream = audio_diskstream();
-
 	if (n_outputs().n_total() == 0 && _processors.empty()) {
 		return 0;
 	}
 
 	if (!_active) {
 		silence (nframes);
-		if (_meter_point == MeterInput && ((_monitoring_control->monitoring_choice() & MonitorInput) || _diskstream->record_enabled())) {
+		if (_meter_point == MeterInput && ((_monitoring_control->monitoring_choice() & MonitorInput) || _disk_writer->record_enabled())) {
 			_meter->reset();
 		}
 		return 0;
 	}
 
-	transport_frame = _session.transport_frame();
-
-	int dret;
-	framecnt_t playback_distance;
-
-	if ((nframes = check_initial_delay (nframes, transport_frame)) == 0) {
-
-		/* need to do this so that the diskstream sets its
-		   playback distance to zero, thus causing diskstream::commit
-		   to do nothing.
-		*/
-
-		BufferSet bufs; /* empty set, no matter - nothing will happen */
-
-		dret = diskstream->process (bufs, transport_frame, 0, playback_distance, false);
-		need_butler = diskstream->commit (playback_distance);
-		return dret;
-	}
-
 	_silent = false;
 	_amp->apply_gain_automation(false);
 
@@ -333,18 +258,10 @@ AudioTrack::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_fram
 		_meter->run (bufs, start_frame, end_frame, 1.0 /*speed()*/, nframes, true);
 	}
 
-	if ((dret = diskstream->process (bufs, transport_frame, nframes, playback_distance, (monitoring_state() == MonitoringDisk))) != 0) {
+	process_output_buffers (bufs, start_frame, end_frame, nframes, declick, (!_disk_writer->record_enabled() && _session.transport_rolling()));
-		need_butler = diskstream->commit (playback_distance);
-		silence (nframes);
-		return dret;
-	}
-
-	process_output_buffers (bufs, start_frame, end_frame, nframes, declick, (!diskstream->record_enabled() && _session.transport_rolling()));
 
 	flush_processor_buffers_locked (nframes);
 
-	need_butler = diskstream->commit (playback_distance);
-
 	return 0;
 }
 
@@ -354,11 +271,10 @@ AudioTrack::export_stuff (BufferSet& buffers, framepos_t start, framecnt_t nfram
 {
 	boost::scoped_array<gain_t> gain_buffer (new gain_t[nframes]);
 	boost::scoped_array<Sample> mix_buffer (new Sample[nframes]);
-	boost::shared_ptr<AudioDiskstream> diskstream = audio_diskstream();
 
 	Glib::Threads::RWLock::ReaderLock rlock (_processor_lock);
 
-	boost::shared_ptr<AudioPlaylist> apl = boost::dynamic_pointer_cast<AudioPlaylist>(diskstream->playlist());
+	boost::shared_ptr<AudioPlaylist> apl = boost::dynamic_pointer_cast<AudioPlaylist>(playlist());
 
 	assert(apl);
 	assert(buffers.count().n_audio() >= 1);
@@ -373,7 +289,7 @@ AudioTrack::export_stuff (BufferSet& buffers, framepos_t start, framecnt_t nfram
 	BufferSet::audio_iterator bi = buffers.audio_begin();
 	++bi;
 	for ( ; bi != buffers.audio_end(); ++bi, ++n) {
-		if (n < diskstream->n_channels().n_audio()) {
+		if (n < _disk_reader->output_streams().n_audio()) {
 			if (apl->read (bi->data(), mix_buffer.get(), gain_buffer.get(), start, nframes, n) != nframes) {
 				return -1;
 			}
@@ -468,9 +384,8 @@ AudioTrack::freeze_me (InterThreadInfo& itt)
 	boost::shared_ptr<Playlist> new_playlist;
 	string dir;
 	string region_name;
-	boost::shared_ptr<AudioDiskstream> diskstream = audio_diskstream();
 
-	if ((_freeze_record.playlist = boost::dynamic_pointer_cast<AudioPlaylist>(diskstream->playlist())) == 0) {
+	if ((_freeze_record.playlist = boost::dynamic_pointer_cast<AudioPlaylist>(playlist())) == 0) {
 		return;
 	}
 
@@ -555,8 +470,8 @@ AudioTrack::freeze_me (InterThreadInfo& itt)
 	new_playlist->set_frozen (true);
 	region->set_locked (true);
 
-	diskstream->use_playlist (boost::dynamic_pointer_cast<AudioPlaylist>(new_playlist));
+	use_playlist (DataType::AUDIO, boost::dynamic_pointer_cast<AudioPlaylist>(new_playlist));
-	diskstream->set_record_enabled (false);
+	_disk_writer->set_record_enabled (false);
 
 	_freeze_record.playlist->use(); // prevent deletion
 
@@ -576,7 +491,7 @@ AudioTrack::unfreeze ()
 {
 	if (_freeze_record.playlist) {
 		_freeze_record.playlist->release();
-		audio_diskstream()->use_playlist (_freeze_record.playlist);
+		use_playlist (DataType::AUDIO, _freeze_record.playlist);
 
 		{
 			Glib::Threads::RWLock::ReaderLock lm (_processor_lock); // should this be a write lock? jlc
@@ -601,13 +516,6 @@ AudioTrack::unfreeze ()
 boost::shared_ptr<AudioFileSource>
 AudioTrack::write_source (uint32_t n)
 {
-	boost::shared_ptr<AudioDiskstream> ds = boost::dynamic_pointer_cast<AudioDiskstream> (_diskstream);
+	assert (_disk_writer);
-	assert (ds);
+	return _disk_writer->audio_write_source (n);
-	return ds->write_source (n);
-}
-
-boost::shared_ptr<Diskstream>
-AudioTrack::diskstream_factory (XMLNode const & node)
-{
-	return boost::shared_ptr<Diskstream> (new AudioDiskstream (_session, node));
 }

libs/ardour/auditioner.cc

@@ -22,7 +22,6 @@
 #include "pbd/error.h"
 
 #include "ardour/amp.h"
-#include "ardour/audio_diskstream.h"
 #include "ardour/audio_port.h"
 #include "ardour/audioengine.h"
 #include "ardour/audioplaylist.h"
@@ -30,7 +29,8 @@
 #include "ardour/auditioner.h"
 #include "ardour/data_type.h"
 #include "ardour/delivery.h"
-#include "ardour/midi_diskstream.h"
+#include "ardour/disk_reader.h"
+#include "ardour/midi_playlist.h"
 #include "ardour/midi_region.h"
 #include "ardour/plugin.h"
 #include "ardour/plugin_insert.h"
@@ -215,37 +215,8 @@ Auditioner::data_type () const {
 	}
 }
 
-boost::shared_ptr<Diskstream>
-Auditioner::create_diskstream () {
-
-	{
-		AudioDiskstream::Flag dflags = AudioDiskstream::Flag (0);
-		dflags = AudioDiskstream::Flag (dflags | AudioDiskstream::Hidden);
-		_diskstream_audio = boost::shared_ptr<AudioDiskstream> (new AudioDiskstream (_session, name(), dflags));
-	}
-
-	{
-		MidiDiskstream::Flag dflags = MidiDiskstream::Flag (0);
-		dflags = MidiDiskstream::Flag (dflags | MidiDiskstream::Hidden);
-		_diskstream_midi = boost::shared_ptr<Diskstream> (new MidiDiskstream (_session, name(), dflags));
-		_diskstream_midi->do_refill_with_alloc ();
-		_diskstream_midi->playlist()->set_orig_track_id (id());
-	}
-
-	return _diskstream_audio;
-}
-
 int
-Auditioner::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& need_butler) {
+Auditioner::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& need_butler)
-	if (_midi_audition) {
-		return roll_midi(nframes, start_frame, end_frame, declick, need_butler);
-	} else {
-		return roll_audio(nframes, start_frame, end_frame, declick, need_butler);
-	}
-}
-
-int
-Auditioner::roll_midi (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& need_butler)
 {
 	Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
 	if (!lm.locked()) {
@@ -254,17 +225,13 @@ Auditioner::roll_midi (pframes_t nframes, framepos_t start_frame, framepos_t end
 
 	assert(_active);
 
-	framecnt_t playback_distance = nframes;
-	boost::shared_ptr<MidiDiskstream> diskstream = midi_diskstream();
 	BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
-	MidiBuffer& mbuf (bufs.get_midi (0));
-	_silent = false;
 
-	ChanCount cnt (DataType::MIDI, 1);
+	_silent = false;
-	cnt.set (DataType::AUDIO, bufs.count().n_audio());
+	_amp->apply_gain_automation(false);
-	bufs.set_count (cnt);
 
 	if (_queue_panic) {
+		MidiBuffer& mbuf (bufs.get_midi (0));
 		_queue_panic = false;
 		for (uint8_t chn = 0; chn < 0xf; ++chn) {
 			uint8_t buf[3] = { ((uint8_t) (MIDI_CMD_CONTROL | chn)), ((uint8_t) MIDI_CTL_SUSTAIN), 0 };
@@ -274,20 +241,9 @@ Auditioner::roll_midi (pframes_t nframes, framepos_t start_frame, framepos_t end
 			buf[1] = MIDI_CTL_RESET_CONTROLLERS;
 			mbuf.push_back(0, 3, buf);
 		}
-		process_output_buffers (bufs, start_frame, start_frame+1, 1, false, false);
-
-		for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
-			boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery> (*i);
-			if (d) {
-				d->flush_buffers (nframes);
-			}
-		}
 	}
 
-	diskstream->get_playback (mbuf, nframes);
+	process_output_buffers (bufs, start_frame, end_frame, nframes, declick, !_session.transport_stopped());
-
-	process_output_buffers (bufs, start_frame, end_frame, nframes,
-				declick, (!diskstream->record_enabled() && !_session.transport_stopped()));
 
 	for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 		boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery> (*i);
@@ -296,67 +252,23 @@ Auditioner::roll_midi (pframes_t nframes, framepos_t start_frame, framepos_t end
 		}
 	}
 
-	need_butler = diskstream->commit (playback_distance);
 	return 0;
 }
 
-
-int
-Auditioner::roll_audio (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& need_butler) {
-	Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
-	if (!lm.locked()) {
-		return 0;
-	}
-
-	assert(n_outputs().n_total() > 0);
-	assert(_active);
-
-	int dret;
-	framecnt_t playback_distance;
-	framepos_t transport_frame = _session.transport_frame();
-	boost::shared_ptr<AudioDiskstream> diskstream = audio_diskstream();
-	BufferSet& bufs = _session.get_route_buffers (n_process_buffers ());
-
-	_silent = false;
-	_amp->apply_gain_automation(false);
-
-	if ((dret = diskstream->process (bufs, transport_frame, nframes, playback_distance, (monitoring_state() == MonitoringDisk))) != 0) {
-		need_butler = diskstream->commit (playback_distance);
-		silence (nframes);
-		return dret;
-	}
-
-	process_output_buffers (bufs, start_frame, end_frame, nframes, declick, (!diskstream->record_enabled() && _session.transport_rolling()));
-	need_butler = diskstream->commit (playback_distance);
-	return 0;
-}
-
-void
-Auditioner::set_diskstream (boost::shared_ptr<Diskstream> ds)
-{
-	Track::set_diskstream (ds);
-
-	_diskstream->set_track (this);
-	_diskstream->set_record_enabled (false);
-	_diskstream->request_input_monitoring (false);
-
-	DiskstreamChanged (); /* EMIT SIGNAL */
-}
-
 AudioPlaylist&
 Auditioner::prepare_playlist ()
 {
 	// used by CrossfadeEditor::audition()
 
 	_midi_audition = false;
-	set_diskstream(_diskstream_audio);
+
 	if (_synth_added) {
 		remove_processor(asynth);
 		_synth_added = false;
 	}
 
 	// FIXME auditioner is still audio-only
-	boost::shared_ptr<AudioPlaylist> apl = boost::dynamic_pointer_cast<AudioPlaylist>(_diskstream->playlist());
+	boost::shared_ptr<AudioPlaylist> apl = boost::dynamic_pointer_cast<AudioPlaylist>(playlist());
 	assert(apl);
 
 	apl->clear ();
@@ -378,7 +290,7 @@ Auditioner::audition_region (boost::shared_ptr<Region> region)
 	if (boost::dynamic_pointer_cast<AudioRegion>(region) != 0) {
 
 		_midi_audition = false;
-		set_diskstream(_diskstream_audio);
+
 		if (_synth_added) {
 			remove_processor(asynth);
 			_synth_added = false;
@@ -390,14 +302,8 @@ Auditioner::audition_region (boost::shared_ptr<Region> region)
 		the_region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (region));
 		the_region->set_position (0);
 
-		_diskstream->playlist()->drop_regions ();
+		_disk_reader->audio_playlist()->drop_regions ();
-		_diskstream->playlist()->add_region (the_region, 0, 1);
+		_disk_reader->audio_playlist()->add_region (the_region, 0, 1);
-
-		if (_diskstream->n_channels().n_audio() < the_region->n_channels()) {
-			audio_diskstream()->add_channel (the_region->n_channels() - _diskstream->n_channels().n_audio());
-		} else if (_diskstream->n_channels().n_audio() > the_region->n_channels()) {
-			audio_diskstream()->remove_channel (_diskstream->n_channels().n_audio() - the_region->n_channels());
-		}
 
 		ProcessorStreams ps;
 		{
@@ -405,14 +311,14 @@ Auditioner::audition_region (boost::shared_ptr<Region> region)
 
 			if (configure_processors (&ps)) {
 				error << string_compose (_("Cannot setup auditioner processing flow for %1 channels"),
-							 _diskstream->n_channels()) << endmsg;
+				                         region->n_channels()) << endmsg;
 				return;
 			}
 		}
 
 	} else if (boost::dynamic_pointer_cast<MidiRegion>(region)) {
 		_midi_audition = true;
-		set_diskstream(_diskstream_midi);
+
 		the_region.reset();
 		_import_position = region->position();
 
@@ -420,9 +326,9 @@ Auditioner::audition_region (boost::shared_ptr<Region> region)
 		midi_region = (boost::dynamic_pointer_cast<MidiRegion> (RegionFactory::create (region)));
 		midi_region->set_position (_import_position);
 
-		_diskstream->playlist()->drop_regions ();
+		_disk_reader->midi_playlist()->drop_regions ();
-		_diskstream->playlist()->add_region (midi_region, _import_position, 1);
+		_disk_reader->midi_playlist()->add_region (midi_region, _import_position, 1);
-		midi_diskstream()->reset_tracker();
+		_disk_reader->reset_tracker();
 
 		ProcessorStreams ps;
 
@@ -435,7 +341,6 @@ Auditioner::audition_region (boost::shared_ptr<Region> region)
 			lookup_synth();
 		}
 
-
 		if (!_synth_added && asynth) {
 			int rv = add_processor (asynth, PreFader, &ps, true);
 			if (rv) {
@@ -452,7 +357,7 @@ Auditioner::audition_region (boost::shared_ptr<Region> region)
 
 			if (configure_processors (&ps)) {
 				error << string_compose (_("Cannot setup auditioner processing flow for %1 channels"),
-							 _diskstream->n_channels()) << endmsg;
+							 region->n_channels()) << endmsg;
 				return;
 			}
 		}
@@ -485,7 +390,7 @@ Auditioner::audition_region (boost::shared_ptr<Region> region)
 		offset = 0;
 	}
 
-	_diskstream->seek (offset, true);
+	_disk_reader->seek (offset, true);
 	current_frame = offset;
 
 	g_atomic_int_set (&_auditioning, 1);
@@ -515,9 +420,7 @@ Auditioner::play_audition (framecnt_t nframes)
 		_seek_complete = false;
 		_seeking = false;
 		_seek_frame = -1;
-		if (_midi_audition && midi_diskstream()) {
+		_disk_reader->reset_tracker();
-			midi_diskstream()->reset_tracker();
-		}
 	}
 
 	if(!_seeking) {
@@ -604,18 +507,10 @@ ChanCount
 Auditioner::input_streams () const
 {
 	/* auditioner never has any inputs - its channel configuration
-		 depends solely on the region we are auditioning.
+	   depends solely on the region we are auditioning.
-		 */
+	*/
 
-	if (!_midi_audition && audio_diskstream()) {
+	return _disk_reader->input_streams ();
-		return audio_diskstream()->n_channels();
-	}
-	if (_midi_audition && midi_diskstream()) {
-		ChanCount cnt (DataType::MIDI, 1);
-		return cnt;
-	}
-
-	return ChanCount ();
 }
 
 MonitorState
@@ -624,14 +519,3 @@ Auditioner::monitoring_state () const
 	return MonitoringDisk;
 }
 
-boost::shared_ptr<AudioDiskstream>
-Auditioner::audio_diskstream() const
-{
-	return boost::dynamic_pointer_cast<AudioDiskstream> (_diskstream);
-}
-
-boost::shared_ptr<MidiDiskstream>
-Auditioner::midi_diskstream() const
-{
-	return boost::dynamic_pointer_cast<MidiDiskstream> (_diskstream);
-}

libs/ardour/disk_io.cc

@@ -56,6 +56,8 @@ DiskIOProcessor::DiskIOProcessor (Session& s, string const & str, Flag f)
 	, _slaved (false)
 	, loop_location (0)
 	, in_set_state (false)
+        , file_frame (0)
+        , playback_sample (0)
         , wrap_buffer_size (0)
         , speed_buffer_size (0)
 	, _need_butler (false)
@@ -394,68 +396,6 @@ DiskIOProcessor::use_playlist (DataType dt, boost::shared_ptr<Playlist> playlist
 	return 0;
 }
 
-int
-DiskIOProcessor::find_and_use_playlist (DataType dt, const string& name)
-{
-	boost::shared_ptr<Playlist> playlist;
-
-	if ((playlist = _session.playlists->by_name (name)) == 0) {
-		playlist = PlaylistFactory::create (dt, _session, name);
-	}
-
-	if (!playlist) {
-		error << string_compose(_("DiskIOProcessor: \"%1\" isn't an playlist"), name) << endmsg;
-		return -1;
-	}
-
-	return use_playlist (dt, playlist);
-}
-
-int
-DiskIOProcessor::use_new_playlist (DataType dt)
-{
-	string newname;
-	boost::shared_ptr<Playlist> playlist = _playlists[dt];
-
-	if (playlist) {
-		newname = Playlist::bump_name (playlist->name(), _session);
-	} else {
-		newname = Playlist::bump_name (_name, _session);
-	}
-
-	playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (dt, _session, newname, hidden()));
-
-	if (!playlist) {
-		return -1;
-	}
-
-	return use_playlist (dt, playlist);
-}
-
-int
-DiskIOProcessor::use_copy_playlist (DataType dt)
-{
-	assert (_playlists[dt]);
-
-	if (_playlists[dt] == 0) {
-		error << string_compose(_("DiskIOProcessor %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
-		return -1;
-	}
-
-	string newname;
-	boost::shared_ptr<Playlist> playlist;
-
-	newname = Playlist::bump_name (_playlists[dt]->name(), _session);
-
-	if ((playlist = PlaylistFactory::create (_playlists[dt], newname)) == 0) {
-		return -1;
-	}
-
-	playlist->reset_shares();
-
-	return use_playlist (dt, playlist);
-}
-
 DiskIOProcessor::ChannelInfo::ChannelInfo (framecnt_t bufsize)
 {
 	buf = new RingBufferNPT<Sample> (bufsize);
@@ -492,3 +432,24 @@ DiskIOProcessor::set_route (boost::shared_ptr<Route> r)
 {
 	_route = r;
 }
+
+/** Get the start, end, and length of a location "atomically".
+ *
+ * Note: Locations don't get deleted, so all we care about when I say "atomic"
+ * is that we are always pointing to the same one and using start/length values
+ * obtained just once.  Use this function to achieve this since location being
+ * a parameter achieves this.
+ */
+void
+DiskIOProcessor::get_location_times(const Location* location,
+                   framepos_t*     start,
+                   framepos_t*     end,
+                   framepos_t*     length)
+{
+	if (location) {
+		*start  = location->start();
+		*end    = location->end();
+		*length = *end - *start;
+	}
+}
+

libs/ardour/disk_reader.cc

@@ -51,8 +51,6 @@ DiskReader::DiskReader (Session& s, string const & str, DiskIOProcessor::Flag f)
         , overwrite_offset (0)
         , _pending_overwrite (false)
         , overwrite_queued (false)
-        , file_frame (0)
-        , playback_sample (0)
 	, _monitoring_choice (MonitorDisk)
 	, _gui_feed_buffer (AudioEngine::instance()->raw_buffer_size (DataType::MIDI))
 {
@@ -143,28 +141,10 @@ DiskReader::state (bool full)
 int
 DiskReader::set_state (const XMLNode& node, int version)
 {
-	XMLProperty const * prop;
-
 	if (DiskIOProcessor::set_state (node, version)) {
 		return -1;
 	}
 
-	if ((prop = node.property ("audio-playlist")) == 0) {
-		return -1;
-	}
-
-	if (find_and_use_playlist (DataType::AUDIO, prop->value())) {
-		return -1;
-	}
-
-	if ((prop = node.property ("midi-playlist")) == 0) {
-		return -1;
-	}
-
-	if (find_and_use_playlist (DataType::MIDI, prop->value())) {
-		return -1;
-	}
-
 	return 0;
 }
 
@@ -1310,26 +1290,6 @@ DiskReader::get_playback (MidiBuffer& dst, framecnt_t nframes)
 	//cerr << "----------------\n";
 }
 
-/** Get the start, end, and length of a location "atomically".
- *
- * Note: Locations don't get deleted, so all we care about when I say "atomic"
- * is that we are always pointing to the same one and using start/length values
- * obtained just once.  Use this function to achieve this since location being
- * a parameter achieves this.
- */
-static void
-get_location_times(const Location* location,
-                   framepos_t*     start,
-                   framepos_t*     end,
-                   framepos_t*     length)
-{
-	if (location) {
-		*start  = location->start();
-		*end    = location->end();
-		*length = *end - *start;
-	}
-}
-
 /** @a start is set to the new frame position (TIME) read up to */
 int
 DiskReader::midi_read (framepos_t& start, framecnt_t dur, bool reversed)

libs/ardour/midi_track.cc

@@ -33,10 +33,13 @@
 #include "pbd/types_convert.h"
 #include "evoral/midi_util.h"
 
+#include "ardour/amp.h"
 #include "ardour/beats_frames_converter.h"
 #include "ardour/buffer_set.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/meter.h"
 #include "ardour/midi_diskstream.h"
@@ -72,11 +75,15 @@ MidiTrack::MidiTrack (Session& sess, string name, TrackMode mode)
 	: Track (sess, name, PresentationInfo::MidiTrack, mode, DataType::MIDI)
 	, _immediate_events(6096) // FIXME: size?
 	, _step_edit_ring_buffer(64) // FIXME: size?
-	, _note_mode(Sustained)
+	, _note_mode (Sustained)
 	, _step_editing (false)
 	, _input_active (true)
 {
 	_session.SessionLoaded.connect_same_thread (*this, boost::bind (&MidiTrack::restore_controls, this));
+
+	_disk_writer->set_note_mode (_note_mode);
+	_disk_reader->reset_tracker ();
+
 }
 
 MidiTrack::~MidiTrack ()
@@ -126,36 +133,6 @@ MidiTrack::can_be_record_enabled ()
 	return Track::can_be_record_enabled ();
 }
 
-void
-MidiTrack::set_diskstream (boost::shared_ptr<Diskstream> ds)
-{
-	/* We have to do this here, as Track::set_diskstream will cause a buffer refill,
-	   and the diskstream must be set up to fill its buffers using the correct _note_mode.
-	*/
-	boost::shared_ptr<MidiDiskstream> mds = boost::dynamic_pointer_cast<MidiDiskstream> (ds);
-	mds->set_note_mode (_note_mode);
-
-	Track::set_diskstream (ds);
-
-	mds->reset_tracker ();
-
-	_diskstream->set_track (this);
-	_diskstream->set_record_enabled (false);
-
-	_diskstream_data_recorded_connection.disconnect ();
-	mds->DataRecorded.connect_same_thread (
-		_diskstream_data_recorded_connection,
-		boost::bind (&MidiTrack::diskstream_data_recorded, this, _1));
-
-	DiskstreamChanged (); /* EMIT SIGNAL */
-}
-
-boost::shared_ptr<MidiDiskstream>
-MidiTrack::midi_diskstream() const
-{
-	return boost::dynamic_pointer_cast<MidiDiskstream>(_diskstream);
-}
-
 int
 MidiTrack::set_state (const XMLNode& node, int version)
 {
@@ -323,10 +300,6 @@ MidiTrack::set_state_part_two ()
 		}
 	}
 
-	if (midi_diskstream ()) {
-		midi_diskstream()->set_block_size (_session.get_block_size ());
-	}
-
 	return;
 }
 
@@ -364,18 +337,11 @@ int
 MidiTrack::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& need_butler)
 {
 	Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
+
 	if (!lm.locked()) {
-		boost::shared_ptr<MidiDiskstream> diskstream = midi_diskstream();
-		framecnt_t playback_distance = diskstream->calculate_playback_distance(nframes);
-		if (can_internal_playback_seek(::llabs(playback_distance))) {
-			/* TODO should declick, and/or note-off */
-			internal_playback_seek(playback_distance);
-		}
 		return 0;
 	}
 
-	boost::shared_ptr<MidiDiskstream> diskstream = midi_diskstream();
-
 	if (n_outputs().n_total() == 0 && _processors.empty()) {
 		return 0;
 	}
@@ -388,22 +354,8 @@ MidiTrack::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame
 		return 0;
 	}
 
-	framepos_t transport_frame = _session.transport_frame();
+	_silent = false;
-
+	_amp->apply_gain_automation (false);
-	int dret;
-	framecnt_t playback_distance;
-
-	if ((nframes = check_initial_delay (nframes, transport_frame)) == 0) {
-		/* need to do this so that the diskstream sets its
-		   playback distance to zero, thus causing diskstream::commit
-		   to do nothing.
-		   */
-		BufferSet bufs; /* empty set - is OK, since nothing will happen */
-
-		dret = diskstream->process (bufs, transport_frame, 0, playback_distance, false);
-		need_butler = diskstream->commit (playback_distance);
-		return dret;
-	}
 
 	BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
 
@@ -416,47 +368,16 @@ MidiTrack::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame
 		_meter->run (bufs, start_frame, end_frame, 1.0 /*speed()*/, nframes, true);
 	}
 
-
-	_silent = false;
-
-	if ((dret = diskstream->process (bufs, transport_frame, nframes, playback_distance, (monitoring_state() == MonitoringDisk))) != 0) {
-		need_butler = diskstream->commit (playback_distance);
-		silence (nframes);
-		return dret;
-	}
-
-	/* note diskstream uses our filter to filter/map playback channels appropriately. */
-
-	if (monitoring_state() == MonitoringInput) {
-
-		/* not actually recording, but we want to hear the input material anyway,
-		   at least potentially (depending on monitoring options)
-		*/
-
-		/* because the playback buffer is event based and not a
-		 * continuous stream, we need to make sure that we empty
-		 * it of events every cycle to avoid it filling up with events
-		 * read from disk, while we are actually monitoring input
-		 */
-
-		diskstream->flush_playback (start_frame, end_frame);
-
-	}
-
-
 	/* append immediate messages to the first MIDI buffer (thus sending it to the first output port) */
 
 	write_out_of_band_data (bufs, start_frame, end_frame, nframes);
 
 	/* final argument: don't waste time with automation if we're not recording or rolling */
 
-	process_output_buffers (bufs, start_frame, end_frame, nframes,
+	process_output_buffers (bufs, start_frame, end_frame, nframes, declick, (!_disk_writer->record_enabled() && !_session.transport_stopped()));
-				declick, (!diskstream->record_enabled() && !_session.transport_stopped()));
 
 	flush_processor_buffers_locked (nframes);
 
-	need_butler = diskstream->commit (playback_distance);
-
 	return 0;
 }
 
@@ -485,7 +406,7 @@ MidiTrack::realtime_locate ()
 		(*i)->realtime_locate ();
 	}
 
-	midi_diskstream()->reset_tracker ();
+	_disk_reader->reset_tracker ();
 }
 
 void
@@ -507,7 +428,7 @@ MidiTrack::non_realtime_locate (framepos_t pos)
 {
 	Track::non_realtime_locate(pos);
 
-	boost::shared_ptr<MidiPlaylist> playlist = midi_diskstream()->midi_playlist();
+	boost::shared_ptr<MidiPlaylist> playlist = _disk_writer->midi_playlist();
 	if (!playlist) {
 		return;
 	}
@@ -612,11 +533,9 @@ MidiTrack::export_stuff (BufferSet&                   buffers,
 		return -1;
 	}
 
-	boost::shared_ptr<MidiDiskstream> diskstream = midi_diskstream();
-
 	Glib::Threads::RWLock::ReaderLock rlock (_processor_lock);
 
-	boost::shared_ptr<MidiPlaylist> mpl = boost::dynamic_pointer_cast<MidiPlaylist>(diskstream->playlist());
+	boost::shared_ptr<MidiPlaylist> mpl = _disk_writer->midi_playlist();
 	if (!mpl) {
 		return -2;
 	}
@@ -665,7 +584,7 @@ void
 MidiTrack::set_note_mode (NoteMode m)
 {
 	_note_mode = m;
-	midi_diskstream()->set_note_mode(m);
+	_disk_writer->set_note_mode(m);
 }
 
 std::string
@@ -809,7 +728,7 @@ MidiTrack::set_step_editing (bool yn)
 boost::shared_ptr<SMFSource>
 MidiTrack::write_source (uint32_t)
 {
-	return midi_diskstream()->write_source ();
+	return _disk_writer->midi_write_source ();
 }
 
 void
@@ -847,7 +766,7 @@ MidiTrack::set_capture_channel_mask (uint16_t mask)
 boost::shared_ptr<MidiPlaylist>
 MidiTrack::midi_playlist ()
 {
-	return midi_diskstream()->midi_playlist ();
+	return boost::dynamic_pointer_cast<MidiPlaylist> (_playlists[DataType::MIDI]);
 }
 
 void
@@ -906,7 +825,7 @@ MidiTrack::diskstream_factory (XMLNode const & node)
 boost::shared_ptr<MidiBuffer>
 MidiTrack::get_gui_feed_buffer () const
 {
-	return midi_diskstream()->get_gui_feed_buffer ();
+	return _disk_reader->get_gui_feed_buffer ();
 }
 
 void
@@ -922,7 +841,7 @@ MidiTrack::act_on_mute ()
 	/* If we haven't got a diskstream yet, there's nothing to worry about,
 	   and we can't call get_channel_mask() anyway.
 	*/
-	if (!midi_diskstream()) {
+	if (!_disk_writer) {
 		return;
 	}
 
@@ -945,7 +864,7 @@ MidiTrack::act_on_mute ()
 		}
 
 		/* Resolve active notes. */
-		midi_diskstream()->resolve_tracker(_immediate_events, Port::port_offset());
+		_disk_reader->resolve_tracker(_immediate_events, Port::port_offset());
 	}
 }
 
@@ -967,11 +886,7 @@ MidiTrack::monitoring_changed (bool self, Controllable::GroupControlDisposition
 		}
 	}
 
-	boost::shared_ptr<MidiDiskstream> md (midi_diskstream());
+	_disk_reader->reset_tracker ();
-
-	if (md) {
-		md->reset_tracker ();
-	}
 }
 
 MonitorState

libs/ardour/session.cc

@@ -1546,7 +1546,6 @@ Session::hookup_io ()
 			if (a->init()) {
 				throw failed_constructor ();
 			}
-			a->use_new_diskstream ();
 			auditioner = a;
 		}
 
@@ -2625,8 +2624,6 @@ Session::new_midi_track (const ChanCount& input, const ChanCount& output, bool s
 				track->set_strict_io (true);
 			}
 
-			track->use_new_diskstream();
-
 			BOOST_MARK_TRACK (track);
 
 			{
@@ -2648,8 +2645,6 @@ Session::new_midi_track (const ChanCount& input, const ChanCount& output, bool s
 				route_group->add (track);
 			}
 
-			track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
-
 			new_routes.push_back (track);
 			ret.push_back (track);
 		}
@@ -3223,8 +3218,6 @@ Session::new_audio_track (int input_channels, int output_channels, RouteGroup* r
 				}
 			}
 
-			track->use_new_diskstream();
-
 			BOOST_MARK_TRACK (track);
 
 			{
@@ -3253,8 +3246,6 @@ Session::new_audio_track (int input_channels, int output_channels, RouteGroup* r
 
 			track->non_realtime_input_change();
 
-			track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
-
 			new_routes.push_back (track);
 			ret.push_back (track);
 		}

libs/ardour/session_state.cc

@@ -1845,7 +1845,7 @@ Session::XMLRouteFactory_2X (const XMLNode& node, int version)
 			return ret;
 		}
 
-		track->set_diskstream (*i);
+                // XXX DISK NEED TO SET UP DISKSTREAM ???
 
 		BOOST_MARK_TRACK (track);
 		ret = track;

libs/ardour/track.cc

@@ -21,11 +21,14 @@
 #include "ardour/debug.h"
 #include "ardour/delivery.h"
 #include "ardour/diskstream.h"
+#include "ardour/disk_reader.h"
+#include "ardour/disk_writer.h"
 #include "ardour/event_type_map.h"
 #include "ardour/io_processor.h"
 #include "ardour/meter.h"
 #include "ardour/monitor_control.h"
 #include "ardour/playlist.h"
+#include "ardour/playlist_factory.h"
 #include "ardour/port.h"
 #include "ardour/processor.h"
 #include "ardour/profile.h"
@@ -51,6 +54,25 @@ Track::Track (Session& sess, string name, PresentationInfo::Flag flag, TrackMode
 {
 	_freeze_record.state = NoFreeze;
         _declickable = true;
+
+        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);
+        }
+
+        _disk_reader.reset (new DiskReader (sess, name, dflags));
+
+        _disk_reader->set_block_size (_session.get_block_size ());
+        _disk_reader->set_route (shared_from_this());
+        _disk_reader->do_refill_with_alloc ();
+
+        _disk_writer.reset (new DiskWriter (sess, name, dflags));
+        _disk_writer->set_block_size (_session.get_block_size ());
+        _disk_writer->set_route (shared_from_this());
+
 }
 
 Track::~Track ()
@@ -86,18 +108,6 @@ Track::init ()
         return 0;
 }
 
-void
-Track::use_new_diskstream ()
-{
-	boost::shared_ptr<Diskstream> ds = create_diskstream ();
-
-	ds->do_refill_with_alloc ();
-	ds->set_block_size (_session.get_block_size ());
-	ds->playlist()->set_orig_track_id (id());
-
-	set_diskstream (ds);
-}
-
 XMLNode&
 Track::get_state ()
 {
@@ -128,18 +138,12 @@ Track::set_state (const XMLNode& node, int version)
 
 	XMLNode* child;
 
-	if (version >= 3000) {
+	if (version >= 3000 && version < 4000) {
 		if ((child = find_named_node (node, X_("Diskstream"))) != 0) {
-			boost::shared_ptr<Diskstream> ds = diskstream_factory (*child);
+			/* XXX DISK ... setup reader/writer from XML */
-			ds->do_refill_with_alloc ();
-			set_diskstream (ds);
 		}
 	}
 
-	if (_diskstream) {
-		_diskstream->playlist()->set_orig_track_id (id());
-	}
-
 	/* set rec-enable control *AFTER* setting up diskstream, because it may
 	   want to operate on the diskstream as it sets its own state
 	*/
@@ -406,7 +410,7 @@ Track::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
 		*/
 	}
 
-	_diskstream->check_record_status (start_frame, can_record);
+	_disk_writer->check_record_status (start_frame, can_record);
 
 	bool be_silent;
 
@@ -443,7 +447,7 @@ Track::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
 		if (_meter_point == MeterInput) {
 			/* still need input monitoring and metering */
 
-			bool const track_rec = _diskstream->record_enabled ();
+			bool const track_rec = _disk_writer->record_enabled ();
 			bool const auto_input = _session.config.get_auto_input ();
 			bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
 			bool const tape_machine_mode = Config->get_tape_machine_mode ();
@@ -502,10 +506,11 @@ Track::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*
 {
 	Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
 	if (!lm.locked()) {
-		framecnt_t playback_distance = _diskstream->calculate_playback_distance(nframes);
+		// XXX DISK reader needs to seek ahead the correct distance ?? OR DOES IT ?
-		if (can_internal_playback_seek(playback_distance)) {
+		//framecnt_t playback_distance = _disk_reader->calculate_playback_distance(nframes);
-			internal_playback_seek(playback_distance);
+		//if (can_internal_playback_seek(playback_distance)) {
-		}
+		// internal_playback_seek(playback_distance);
+		//}
 		return 0;
 	}
 
@@ -524,42 +529,9 @@ Track::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*
 	silence (nframes);
 	flush_processor_buffers_locked (nframes);
 
-	framecnt_t playback_distance;
+	//BufferSet& bufs (_session.get_route_buffers (n_process_buffers(), true));
-
+	// XXXX DISKWRITER/READER ADVANCE, SET need_butler
-	BufferSet& bufs (_session.get_route_buffers (n_process_buffers(), true));
+	return 0;
-
-	int const dret = _diskstream->process (bufs, _session.transport_frame(), nframes, playback_distance, false);
-	need_butler = _diskstream->commit (playback_distance);
-	return dret;
-}
-
-void
-Track::set_diskstream (boost::shared_ptr<Diskstream> ds)
-{
-	_diskstream = ds;
-
-	ds->PlaylistChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_playlist_changed, this));
-	diskstream_playlist_changed ();
-	ds->SpeedChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_speed_changed, this));
-	ds->AlignmentStyleChanged.connect_same_thread (*this, boost::bind (&Track::diskstream_alignment_style_changed, this));
-}
-
-void
-Track::diskstream_playlist_changed ()
-{
-	PlaylistChanged (); /* EMIT SIGNAL */
-}
-
-void
-Track::diskstream_speed_changed ()
-{
-	SpeedChanged (); /* EMIT SIGNAL */
-}
-
-void
-Track::diskstream_alignment_style_changed ()
-{
-	AlignmentStyleChanged (); /* EMIT SIGNAL */
 }
 
 boost::shared_ptr<Playlist>
@@ -571,103 +543,100 @@ Track::playlist ()
 void
 Track::request_input_monitoring (bool m)
 {
-	_diskstream->request_input_monitoring (m);
+	// XXX DISK
 }
 
 void
 Track::ensure_input_monitoring (bool m)
 {
-	_diskstream->ensure_input_monitoring (m);
+	// XXX DISK
 }
 
 bool
 Track::destructive () const
 {
-	return _diskstream->destructive ();
+	return _disk_writer->destructive ();
 }
 
 list<boost::shared_ptr<Source> > &
 Track::last_capture_sources ()
 {
-	return _diskstream->last_capture_sources ();
+	return _disk_writer->last_capture_sources ();
 }
 
 void
 Track::set_capture_offset ()
 {
-	_diskstream->set_capture_offset ();
+	_disk_writer->set_capture_offset ();
 }
 
 std::string
 Track::steal_write_source_name()
 {
-        return _diskstream->steal_write_source_name ();
+        return _disk_writer->steal_write_source_name ();
 }
 
 void
 Track::reset_write_sources (bool r, bool force)
 {
-	_diskstream->reset_write_sources (r, force);
+	_disk_writer->reset_write_sources (r, force);
 }
 
 float
 Track::playback_buffer_load () const
 {
-	return _diskstream->playback_buffer_load ();
+	return _disk_reader->buffer_load ();
 }
 
 float
 Track::capture_buffer_load () const
 {
-	return _diskstream->capture_buffer_load ();
+	return _disk_writer->buffer_load ();
 }
 
 int
 Track::do_refill ()
 {
-	return _diskstream->do_refill ();
+	return _disk_reader->do_refill ();
 }
 
 int
 Track::do_flush (RunContext c, bool force)
 {
-	return _diskstream->do_flush (c, force);
+	return _disk_writer->do_flush (c, force);
 }
 
 void
 Track::set_pending_overwrite (bool o)
 {
-	_diskstream->set_pending_overwrite (o);
+	_disk_reader->set_pending_overwrite (o);
 }
 
 int
 Track::seek (framepos_t p, bool complete_refill)
 {
-	return _diskstream->seek (p, complete_refill);
+	if (_disk_reader->seek (p, complete_refill)) {
+		return -1;
+	}
+	return _disk_writer->seek (p, complete_refill);
 }
 
 bool
 Track::hidden () const
 {
-	return _diskstream->hidden ();
+	return _disk_writer->hidden () || _disk_reader->hidden();
 }
 
 int
 Track::can_internal_playback_seek (framecnt_t p)
 {
-	return _diskstream->can_internal_playback_seek (p);
+	return _disk_reader->can_internal_playback_seek (p);
 }
 
 int
 Track::internal_playback_seek (framecnt_t p)
 {
-	return _diskstream->internal_playback_seek (p);
+	return _disk_reader->internal_playback_seek (p);
-}
-
-void
-Track::non_realtime_input_change ()
-{
-	_diskstream->non_realtime_input_change ();
 }
 
 void
@@ -679,74 +648,82 @@ Track::non_realtime_locate (framepos_t p)
 		/* don't waste i/o cycles and butler calls
 		   for hidden (secret) tracks
 		*/
-		_diskstream->non_realtime_locate (p);
+		_disk_reader->non_realtime_locate (p);
+		_disk_writer->non_realtime_locate (p);
 	}
 }
 
 void
 Track::non_realtime_set_speed ()
 {
-	_diskstream->non_realtime_set_speed ();
+	_disk_reader->non_realtime_set_speed ();
 }
 
 int
 Track::overwrite_existing_buffers ()
 {
-	return _diskstream->overwrite_existing_buffers ();
+	return _disk_reader->overwrite_existing_buffers ();
 }
 
 framecnt_t
 Track::get_captured_frames (uint32_t n) const
 {
-	return _diskstream->get_captured_frames (n);
+	return _disk_writer->get_captured_frames (n);
 }
 
 int
 Track::set_loop (Location* l)
 {
-	return _diskstream->set_loop (l);
+	if (_disk_reader->set_loop (l)) {
+		return -1;
+	}
+	return _disk_writer->set_loop (l);
 }
 
 void
 Track::transport_looped (framepos_t p)
 {
-	_diskstream->transport_looped (p);
+	return _disk_writer->transport_looped (p);
 }
 
 bool
 Track::realtime_set_speed (double s, bool g)
 {
-	return _diskstream->realtime_set_speed (s, g);
+	if (_disk_reader->realtime_set_speed (s, g)) {
+		return -1;
+	}
+	return _disk_writer->realtime_set_speed (s, g);
 }
 
 void
 Track::transport_stopped_wallclock (struct tm & n, time_t t, bool g)
 {
-	_diskstream->transport_stopped_wallclock (n, t, g);
+	_disk_writer->transport_stopped_wallclock (n, t, g);
 }
 
 bool
 Track::pending_overwrite () const
 {
-	return _diskstream->pending_overwrite ();
+	return _disk_reader->pending_overwrite ();
 }
 
 double
 Track::speed () const
 {
-	return _diskstream->speed ();
+	return _disk_reader->speed ();
 }
 
 void
 Track::prepare_to_stop (framepos_t t, framepos_t a)
 {
-	_diskstream->prepare_to_stop (t, a);
+	_disk_writer->prepare_to_stop (t, a);
 }
 
 void
 Track::set_slaved (bool s)
 {
-	_diskstream->set_slaved (s);
+	_disk_reader->set_slaved (s);
+	_disk_writer->set_slaved (s);
 }
 
 ChanCount
@@ -758,71 +735,113 @@ Track::n_channels ()
 framepos_t
 Track::get_capture_start_frame (uint32_t n) const
 {
-	return _diskstream->get_capture_start_frame (n);
+	return _disk_writer->get_capture_start_frame (n);
 }
 
 AlignStyle
 Track::alignment_style () const
 {
-	return _diskstream->alignment_style ();
+	return _disk_writer->alignment_style ();
 }
 
 AlignChoice
 Track::alignment_choice () const
 {
-	return _diskstream->alignment_choice ();
+	return _disk_writer->alignment_choice ();
 }
 
 framepos_t
 Track::current_capture_start () const
 {
-	return _diskstream->current_capture_start ();
+	return _disk_writer->current_capture_start ();
 }
 
 framepos_t
 Track::current_capture_end () const
 {
-	return _diskstream->current_capture_end ();
+	return _disk_writer->current_capture_end ();
 }
 
 void
 Track::playlist_modified ()
 {
-	_diskstream->playlist_modified ();
+	_disk_reader->playlist_modified ();
 }
 
 int
-Track::use_playlist (boost::shared_ptr<Playlist> p)
+Track::find_and_use_playlist (DataType dt, const string& name)
 {
-	int ret = _diskstream->use_playlist (p);
+	boost::shared_ptr<Playlist> playlist;
-	if (ret == 0) {
+
-		p->set_orig_track_id (id());
+	if ((playlist = _session.playlists->by_name (name)) == 0) {
+		playlist = PlaylistFactory::create (dt, _session, name);
 	}
+
+	if (!playlist) {
+		error << string_compose(_("DiskIOProcessor: \"%1\" isn't an playlist"), name) << endmsg;
+		return -1;
+	}
+
+	return use_playlist (dt, playlist);
+}
+
+int
+Track::use_playlist (DataType dt, boost::shared_ptr<Playlist> p)
+{
+	int ret;
+
+	if ((ret = _disk_reader->use_playlist (dt, p)) == 0) {
+		if ((ret = _disk_writer->use_playlist (dt, p)) == 0) {
+			p->set_orig_track_id (id());
+		}
+	}
+
 	return ret;
 }
 
 int
 Track::use_copy_playlist ()
 {
-	int ret =  _diskstream->use_copy_playlist ();
+	assert (_playlists[data_type()]);
 
-	if (ret == 0) {
+	if (_playlists[data_type()] == 0) {
-		_diskstream->playlist()->set_orig_track_id (id());
+		error << string_compose(_("DiskIOProcessor %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
+		return -1;
 	}
 
-	return ret;
+	string newname;
+	boost::shared_ptr<Playlist> playlist;
+
+	newname = Playlist::bump_name (_playlists[data_type()]->name(), _session);
+
+	if ((playlist = PlaylistFactory::create (_playlists[data_type()], newname)) == 0) {
+		return -1;
+	}
+
+	playlist->reset_shares();
+
+	return use_playlist (data_type(), playlist);
 }
 
 int
 Track::use_new_playlist ()
 {
-	int ret = _diskstream->use_new_playlist ();
+	string newname;
+	boost::shared_ptr<Playlist> playlist = _playlists[data_type()];
 
-	if (ret == 0) {
+	if (playlist) {
-		_diskstream->playlist()->set_orig_track_id (id());
+		newname = Playlist::bump_name (playlist->name(), _session);
+	} else {
+		newname = Playlist::bump_name (_name, _session);
 	}
 
-	return ret;
+	playlist = PlaylistFactory::create (data_type(), _session, newname, hidden());
+
+	if (!playlist) {
+		return -1;
+	}
+
+	return use_playlist (data_type(), playlist);
 }
 
 void
@@ -955,7 +974,7 @@ Track::monitoring_state () const
 	*/
 
 	bool const roll = _session.transport_rolling ();
-	bool const track_rec = _diskstream->record_enabled ();
+	bool const track_rec = _disk_writer->record_enabled ();
 	bool const auto_input = _session.config.get_auto_input ();
 	bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
 	bool const tape_machine_mode = Config->get_tape_machine_mode ();
@@ -1078,10 +1097,16 @@ Track::metering_state () const
 	bool rv;
 	if (_session.transport_rolling ()) {
 		// audio_track.cc || midi_track.cc roll() runs meter IFF:
-		rv = _meter_point == MeterInput && ((_monitoring_control->monitoring_choice() & MonitorInput) || _diskstream->record_enabled());
+		rv = _meter_point == MeterInput && ((_monitoring_control->monitoring_choice() & MonitorInput) || _disk_writer->record_enabled());
 	} else {
 		// track no_roll() always metering if
 		rv = _meter_point == MeterInput;
 	}
 	return rv ? MeteringInput : MeteringRoute;
 }
+
+void
+Track::non_realtime_input_change ()
+{
+	// XXX DISK do we need to do anything here anymore ?
+}