use libsndfile for all audio file i/o, and rename DiskStream AudioDiskStream

git-svn-id: svn://localhost/ardour2/trunk@589 d708f5d6-7413-0410-9779-e7cbd77b26cf

12 files changed, 124 insertions, 201 deletions

diff --git a/libs/ardour/ardour/audio_track.h b/libs/ardour/ardour/audio_track.h
index c7af9fc5d8..1c17cbc859 100644
--- a/libs/ardour/ardour/audio_track.h
+++ b/libs/ardour/ardour/audio_track.h
@@ -26,7 +26,7 @@
 namespace ARDOUR {
 
 class Session;
-class DiskStream;
+class AudioDiskstream;
 class AudioPlaylist;
 class RouteGroup;
 
@@ -52,8 +52,8 @@ class AudioTrack : public Route
 	bool can_record() const { return true; }
 	void set_record_enable (bool yn, void *src);
 
-	DiskStream& disk_stream() const { return *diskstream; }
-	int set_diskstream (DiskStream&, void *);
+	AudioDiskstream& disk_stream() const { return *diskstream; }
+	int set_diskstream (AudioDiskstream&, void *);
 	int use_diskstream (string name);
 	int use_diskstream (id_t id);
 
@@ -99,7 +99,7 @@ class AudioTrack : public Route
 	void set_meter_point (MeterPoint, void* src);
 
   protected:
-	DiskStream *diskstream;
+	AudioDiskstream *diskstream;
 	MeterPoint _saved_meter_point;
 	TrackMode _mode;
 
diff --git a/libs/ardour/ardour/audiofilter.h b/libs/ardour/ardour/audiofilter.h
index d0fc275cf6..02e5e6f061 100644
--- a/libs/ardour/ardour/audiofilter.h
+++ b/libs/ardour/ardour/audiofilter.h
@@ -28,7 +28,6 @@ namespace ARDOUR {
 
 class AudioRegion;
 class Session;
-class FileSource;
 
 class AudioFilter {
 
@@ -37,7 +36,6 @@ class AudioFilter {
 		: session (s){}
 	virtual ~AudioFilter() {}
 
-
 	virtual int run (ARDOUR::AudioRegion&) = 0;
 	std::vector<ARDOUR::AudioRegion*> results;
 
diff --git a/libs/ardour/ardour/audioregion.h b/libs/ardour/ardour/audioregion.h
index f210fa595b..009aa4b5b0 100644
--- a/libs/ardour/ardour/audioregion.h
+++ b/libs/ardour/ardour/audioregion.h
@@ -27,7 +27,6 @@
 #include <pbd/undo.h>
 
 #include <ardour/ardour.h>
-#include <ardour/source.h>
 #include <ardour/gain.h>
 #include <ardour/region.h>
 #include <ardour/export.h>
@@ -40,6 +39,7 @@ class Route;
 class Playlist;
 class Session;
 class AudioFilter;
+class AudioSource;
 
 struct AudioRegionState : public RegionState 
 {
@@ -56,7 +56,7 @@ struct AudioRegionState : public RegionState
 class AudioRegion : public Region
 {
   public:
-	typedef vector<Source *> SourceList;
+	typedef vector<AudioSource *> SourceList;
 
 	static Change FadeInChanged;
 	static Change FadeOutChanged;
@@ -66,12 +66,12 @@ class AudioRegion : public Region
 	static Change ScaleAmplitudeChanged;
 	static Change EnvelopeChanged;
 
-	AudioRegion (Source&, jack_nframes_t start, jack_nframes_t length, bool announce = true);
-	AudioRegion (Source&, jack_nframes_t start, jack_nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags, bool announce = true);
+	AudioRegion (AudioSource&, jack_nframes_t start, jack_nframes_t length, bool announce = true);
+	AudioRegion (AudioSource&, jack_nframes_t start, jack_nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags, bool announce = true);
 	AudioRegion (SourceList &, jack_nframes_t start, jack_nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags, bool announce = true);
 	AudioRegion (const AudioRegion&, jack_nframes_t start, jack_nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags, bool announce = true);
 	AudioRegion (const AudioRegion&);
-	AudioRegion (Source&, const XMLNode&);
+	AudioRegion (AudioSource&, const XMLNode&);
 	AudioRegion (SourceList &, const XMLNode&);
 	~AudioRegion();
 
@@ -85,7 +85,7 @@ class AudioRegion : public Region
 
 	void lock_sources ();
 	void unlock_sources ();
-	Source& source (uint32_t n=0) const { if (n < sources.size()) return *sources[n]; else return *sources[0]; } 
+	AudioSource& source (uint32_t n=0) const { if (n < sources.size()) return *sources[n]; else return *sources[0]; } 
 
 	void set_scale_amplitude (gain_t);
 	gain_t scale_amplitude() const { return _scale_amplitude; }
diff --git a/libs/ardour/ardour/coreaudio_source.h b/libs/ardour/ardour/coreaudio_source.h
index 736ea32df7..82533de950 100644
--- a/libs/ardour/ardour/coreaudio_source.h
+++ b/libs/ardour/ardour/coreaudio_source.h
@@ -31,8 +31,11 @@ class CoreAudioSource : public ExternalSource {
 	CoreAudioSource (const XMLNode&);
 	~CoreAudioSource ();
 
-	jack_nframes_t read (Sample *dst, jack_nframes_t start, jack_nframes_t cnt, char * workbuf) const;
 	float sample_rate() const;
+	int update_header (jack_nframes_t when, struct tm&, time_t);
+
+  protected:
+	jack_nframes_t read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt, char * workbuf) const;
 
   private:
 	ExtAudioFileRef af;
diff --git a/libs/ardour/ardour/cycle_timer.h b/libs/ardour/ardour/cycle_timer.h
index 1ec7c74903..b9cbbbf0a8 100644
--- a/libs/ardour/ardour/cycle_timer.h
+++ b/libs/ardour/ardour/cycle_timer.h
@@ -22,29 +22,27 @@
 #define __ardour_cycle_timer_h__
 
 #include <string>
-#include <cstdio>
+#include <iostream>
 
 #include <ardour/cycles.h>
 
-using std::string;
-
 class CycleTimer {
   private:
 	static float cycles_per_usec;
-	uint32_t long entry;
-	uint32_t long exit;
-	string _name;
+	cycles_t _entry;
+	cycles_t _exit;
+	std::string _name;
 	
   public:
-	CycleTimer(string name) : _name (name){
+	CycleTimer(std::string name) : _name (name){
 		if (cycles_per_usec == 0) {
 			cycles_per_usec = get_mhz ();
 		}
-		entry = get_cycles();
+		_entry = get_cycles();
 	}
 	~CycleTimer() {
-		exit = get_cycles();
-		printf ("%s: %.9f usecs (%lu-%lu)\n", _name.c_str(), (float) (exit - entry) / cycles_per_usec, entry, exit);
+		_exit = get_cycles();
+		std::cerr << _name << ": " << (float) (_exit - _entry) / cycles_per_usec << " (" <<  _entry << ", " << _exit << ')' << endl;
 	}
 
 	static float get_mhz ();
diff --git a/libs/ardour/ardour/destructive_filesource.h b/libs/ardour/ardour/destructive_filesource.h
index dbaf379257..49a1e3b48a 100644
--- a/libs/ardour/ardour/destructive_filesource.h
+++ b/libs/ardour/ardour/destructive_filesource.h
@@ -23,30 +23,33 @@
 
 #include <string>
 
-#include <ardour/filesource.h>
+#include <ardour/sndfilesource.h>
 
 struct tm;
 
 namespace ARDOUR {
 
-class DestructiveFileSource : public FileSource {
+class DestructiveFileSource : public SndFileSource {
   public:
-	DestructiveFileSource (std::string path, jack_nframes_t rate, bool repair_first = false, SampleFormat samp_format=FormatInt24);
-	DestructiveFileSource (const XMLNode&, jack_nframes_t rate);
+	DestructiveFileSource (std::string path, SampleFormat samp_format, HeaderFormat hdr_format, jack_nframes_t rate,
+			       Flag flags = AudioFileSource::Flag (AudioFileSource::Writable|
+								   AudioFileSource::BuildPeaks));
+
+	DestructiveFileSource (const XMLNode&);
 	~DestructiveFileSource ();
 
-	int  seek (jack_nframes_t frame);
 	jack_nframes_t last_capture_start_frame() const;
 	void mark_capture_start (jack_nframes_t);
 	void mark_capture_end ();
 	void clear_capture_marks();
 
-	jack_nframes_t write (Sample *src, jack_nframes_t cnt, char * workbuf);
-
 	XMLNode& get_state ();
 
 	static void setup_standard_crossfades (jack_nframes_t sample_rate);
 
+  protected:
+	jack_nframes_t write_unlocked (Sample *src, jack_nframes_t start, jack_nframes_t cnt, char * workbuf);
+
   private:
 	static jack_nframes_t xfade_frames;
 	static gain_t* out_coefficient;
@@ -59,7 +62,7 @@ class DestructiveFileSource : public FileSource {
 	Sample*        xfade_buf;
 
 	jack_nframes_t crossfade (Sample* data, jack_nframes_t cnt, int dir, char * workbuf);
-
+	void set_timeline_position (jack_nframes_t);
 };
 
 }
diff --git a/libs/ardour/ardour/playlist.h b/libs/ardour/ardour/playlist.h
index d322f564ee..c653c8502e 100644
--- a/libs/ardour/ardour/playlist.h
+++ b/libs/ardour/ardour/playlist.h
@@ -37,7 +37,6 @@
 #include <ardour/crossfade_compare.h>
 #include <ardour/location.h>
 #include <ardour/stateful.h>
-#include <ardour/source.h>
 #include <ardour/state_manager.h>
 
 namespace ARDOUR  {
diff --git a/libs/ardour/ardour/session.h b/libs/ardour/ardour/session.h
index 83acb3f82a..902510436a 100644
--- a/libs/ardour/ardour/session.h
+++ b/libs/ardour/ardour/session.h
@@ -60,11 +60,12 @@ namespace ARDOUR {
 class Port;
 class AudioEngine;
 class Slave;
-class DiskStream;	
+class AudioDiskstream;	
 class Route;
 class AuxInput;
 class Source;
-class FileSource;
+class AudioSource;
+class AudioFileSource;
 class Auditioner;
 class Insert;
 class Send;
@@ -261,25 +262,30 @@ class Session : public sigc::trackable, public Stateful
 	vector<Sample*>& get_silent_buffers (uint32_t howmany);
 	vector<Sample*>& get_send_buffers () { return _send_buffers; }
 
-	DiskStream    *diskstream_by_id (id_t id);
-	DiskStream    *diskstream_by_name (string name);
+	AudioDiskstream    *diskstream_by_id (id_t id);
+	AudioDiskstream    *diskstream_by_name (string name);
 
 	bool have_captured() const { return _have_captured; }
 
 	void refill_all_diskstream_buffers ();
 	uint32_t diskstream_buffer_size() const { return dstream_buffer_size; }
-	uint32_t get_next_diskstream_id() const { return n_diskstreams(); }
-	uint32_t n_diskstreams() const;
 	
-	typedef list<DiskStream *> DiskStreamList;
+	/* XXX fix required here when we get new diskstream types *, but
+	   not sure of the direction to take this in until then.
+	*/
+
+	uint32_t get_next_diskstream_id() const { return n_audio_diskstreams(); }
+	uint32_t n_audio_diskstreams() const;
+	
+	typedef list<AudioDiskstream *> AudioDiskstreamList;
 
-	Session::DiskStreamList disk_streams() const {
+	Session::AudioDiskstreamList audio_disk_streams() const {
 		Glib::RWLock::ReaderLock lm (diskstream_lock);
-		return diskstreams; /* XXX yes, force a copy */
+		return audio_diskstreams; /* XXX yes, force a copy */
 	}
 
-	void foreach_diskstream (void (DiskStream::*func)(void));
-	template<class T> void foreach_diskstream (T *obj, void (T::*func)(DiskStream&));
+	void foreach_audio_diskstream (void (AudioDiskstream::*func)(void));
+	template<class T> void foreach_audio_diskstream (T *obj, void (T::*func)(AudioDiskstream&));
 
 	typedef list<Route *> RouteList;
 
@@ -344,7 +350,7 @@ class Session : public sigc::trackable, public Stateful
 	sigc::signal<void> HaltOnXrun;
 
 	sigc::signal<void,Route*> RouteAdded;
-	sigc::signal<void,DiskStream*> DiskStreamAdded;
+	sigc::signal<void,AudioDiskstream*> AudioDiskstreamAdded;
 
 	void request_roll ();
 	void request_bounded_roll (jack_nframes_t start, jack_nframes_t end);
@@ -356,15 +362,15 @@ class Session : public sigc::trackable, public Stateful
 	void goto_start () { request_locate (start_location->start(), false); }
 	void use_rf_shuttle_speed ();
 	void request_transport_speed (float speed);
-	void request_overwrite_buffer (DiskStream*);
-	void request_diskstream_speed (DiskStream&, float speed);
+	void request_overwrite_buffer (AudioDiskstream*);
+	void request_diskstream_speed (AudioDiskstream&, float speed);
 	void request_input_change_handling ();
 
 	bool locate_pending() const { return static_cast<bool>(post_transport_work&PostTransportLocate); }
 	bool transport_locked () const;
 
 	int wipe ();
-	int wipe_diskstream (DiskStream *);
+	int wipe_diskstream (AudioDiskstream *);
 
 	int remove_region_from_region_list (Region&);
 
@@ -612,7 +618,7 @@ class Session : public sigc::trackable, public Stateful
 
 	jack_nframes_t convert_to_frames_at (jack_nframes_t position, AnyTime&);
 
-	sigc::signal<void> SMPTEOffsetChanged;
+	static sigc::signal<void> SMPTEOffsetChanged;
 	sigc::signal<void> SMPTETypeChanged;
 
 	void        request_slave_source (SlaveSource, jack_nframes_t pos = 0);
@@ -668,8 +674,9 @@ class Session : public sigc::trackable, public Stateful
 	int start_audio_export (ARDOUR::AudioExportSpecification&);
 	int stop_audio_export (ARDOUR::AudioExportSpecification&);
 	
-	void add_source (Source *);
-	int  remove_file_source (FileSource&);
+	void add_audio_source (AudioSource *);
+	void remove_source (Source *);
+	int  cleanup_audio_file_source (AudioFileSource&);
 
 	struct cleanup_report {
 	    vector<string> paths;
@@ -701,7 +708,8 @@ class Session : public sigc::trackable, public Stateful
 	sigc::signal<void,Source *> SourceAdded;
 	sigc::signal<void,Source *> SourceRemoved;
 
-	FileSource *create_file_source (ARDOUR::DiskStream&, int32_t chan, bool destructive);
+	AudioFileSource *create_audio_source_for_session (ARDOUR::AudioDiskstream&, uint32_t which_channel, bool destructive);
+
 	Source *get_source (ARDOUR::id_t);
 
 	/* playlist management */
@@ -745,8 +753,8 @@ class Session : public sigc::trackable, public Stateful
 
 	/* flattening stuff */
 
-	int write_one_track (AudioTrack&, jack_nframes_t start, jack_nframes_t cnt, bool overwrite, vector<Source*>&,
-			     InterThreadInfo& wot);
+	int write_one_audio_track (AudioTrack&, jack_nframes_t start, jack_nframes_t cnt, bool overwrite, vector<AudioSource*>&,
+				   InterThreadInfo& wot);
 	int freeze (InterThreadInfo&);
 
 	/* session-wide solo/mute/rec-enable */
@@ -972,7 +980,7 @@ class Session : public sigc::trackable, public Stateful
 	void set_frame_rate (jack_nframes_t nframes);
 
   protected:
-	friend class DiskStream;
+	friend class AudioDiskstream;
 	void stop_butler ();
 	void wait_till_butler_finished();
 
@@ -1434,12 +1442,12 @@ class Session : public sigc::trackable, public Stateful
 	bool waiting_to_start;
 
 	void set_auto_loop (bool yn);
-	void overwrite_some_buffers (DiskStream*);
+	void overwrite_some_buffers (AudioDiskstream*);
 	void flush_all_redirects ();
 	void locate (jack_nframes_t, bool with_roll, bool with_flush, bool with_loop=false);
 	void start_locate (jack_nframes_t, bool with_roll, bool with_flush, bool with_loop=false);
 	void force_locate (jack_nframes_t frame, bool with_roll = false);
-	void set_diskstream_speed (DiskStream*, float speed);
+	void set_diskstream_speed (AudioDiskstream*, float speed);
 	void set_transport_speed (float speed, bool abort = false);
 	void stop_transport (bool abort = false);
 	void start_transport ();
@@ -1470,10 +1478,10 @@ class Session : public sigc::trackable, public Stateful
 
 	/* disk-streams */
 
-	DiskStreamList  diskstreams; 
+	AudioDiskstreamList  audio_diskstreams; 
 	mutable Glib::RWLock diskstream_lock;
 	uint32_t dstream_buffer_size;
-	void add_diskstream (DiskStream*);
+	void add_diskstream (AudioDiskstream*);
 	int  load_diskstreams (const XMLNode&);
 
 	/* routes stuff */
@@ -1515,16 +1523,14 @@ class Session : public sigc::trackable, public Stateful
 
 	/* SOURCES */
 	
-	mutable Glib::Mutex source_lock;
-	typedef std::map<id_t, Source *>    SourceList;
+	mutable Glib::Mutex audio_source_lock;
+	typedef std::map<id_t, AudioSource *>    AudioSourceList;
 
-	SourceList sources;
+	AudioSourceList audio_sources;
 
 	int load_sources (const XMLNode& node);
 	XMLNode& get_sources_as_xml ();
 
-	void remove_source (Source *);
-
 	Source *XMLSourceFactory (const XMLNode&);
 
 	/* PLAYLISTS */
@@ -1543,7 +1549,7 @@ class Session : public sigc::trackable, public Stateful
 	Playlist *XMLPlaylistFactory (const XMLNode&);
 
 	void playlist_length_changed (Playlist *);
-	void diskstream_playlist_changed (DiskStream *);
+	void diskstream_playlist_changed (AudioDiskstream *);
 
 	/* NAMED SELECTIONS */
 
diff --git a/libs/ardour/ardour/session_diskstream.h b/libs/ardour/ardour/session_diskstream.h
index 3c888c92c3..33fc5419ba 100644
--- a/libs/ardour/ardour/session_diskstream.h
+++ b/libs/ardour/ardour/session_diskstream.h
@@ -22,15 +22,15 @@
 #define __ardour_session_diskstream_h__
 
 #include <ardour/session.h>
-#include <ardour/diskstream.h>
+#include <ardour/audio_diskstream.h>
 
 namespace ARDOUR {
 
 template<class T> void 
-Session::foreach_diskstream (T *obj, void (T::*func)(DiskStream&)) 
+Session::foreach_audio_diskstream (T *obj, void (T::*func)(AudioDiskstream&)) 
 {
 	Glib::RWLock::ReaderLock lm (diskstream_lock);
-	for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); i++) {
+	for (AudioDiskstreamList::iterator i = audio_diskstreams.begin(); i != audio_diskstreams.end(); i++) {
 		if (!(*i)->hidden()) {
 			(obj->*func) (**i);
 		}
diff --git a/libs/ardour/ardour/sndfilesource.h b/libs/ardour/ardour/sndfilesource.h
index 5d11c9ef09..b9ea308b34 100644
--- a/libs/ardour/ardour/sndfilesource.h
+++ b/libs/ardour/ardour/sndfilesource.h
@@ -23,29 +23,57 @@
 
 #include <sndfile.h>
 
-#include <ardour/externalsource.h>
+#include <ardour/audiofilesource.h>
 
 namespace ARDOUR {
 
-class SndFileSource : public ExternalSource {
+class SndFileSource : public AudioFileSource {
   public:
-	SndFileSource (const string& path_plus_channel, bool build_peak = true);
+	/* constructor to be called for existing external-to-session files */
+
+	SndFileSource (std::string path, Flag flags);
+
+	/* constructor to be called for new in-session files */
+
+	SndFileSource (std::string path, SampleFormat samp_format, HeaderFormat hdr_format, jack_nframes_t rate, 
+		       Flag flags = AudioFileSource::Flag (AudioFileSource::Writable|
+							   AudioFileSource::Removable|
+							   AudioFileSource::RemovableIfEmpty|
+							   AudioFileSource::CanRename|
+							   AudioFileSource::BuildPeaks));
+		       
+	/* constructor to be called for existing in-session files */
+	
 	SndFileSource (const XMLNode&);
+
 	~SndFileSource ();
 
-	jack_nframes_t length() const { return _info.frames; } 
-	jack_nframes_t read (Sample *dst, jack_nframes_t start, jack_nframes_t cnt, char * workbuf) const;
 	float sample_rate () const;
+	int update_header (jack_nframes_t when, struct tm&, time_t);
+	int flush_header ();
+
+	static Flag default_in_session_flags();
+
+  protected:
+	void set_header_timeline_position ();
+
+	jack_nframes_t read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt, char * workbuf) const;
+	jack_nframes_t write_unlocked (Sample *dst, jack_nframes_t cnt, char * workbuf);
+
+	jack_nframes_t write_float (Sample* data, jack_nframes_t pos, jack_nframes_t cnt);
 
   private:
 	SNDFILE *sf;
 	SF_INFO _info;
+	SF_BROADCAST_INFO* _broadcast_info;
 
-	mutable float *tmpbuf;
-	mutable jack_nframes_t tmpbufsize;
-	mutable Glib::Mutex _tmpbuf_lock;
+	mutable float *interleave_buf;
+	mutable jack_nframes_t interleave_bufsize;
 
-	void init (const string &str, bool build_peak);
+	void init (const string &str);
+	int open();
+	void close();
+	int setup_broadcast_info (jack_nframes_t when, struct tm&, time_t);
 };
 
 }; /* namespace ARDOUR */
diff --git a/libs/ardour/ardour/source.h b/libs/ardour/ardour/source.h
index 3781950fbf..f3133c71cd 100644
--- a/libs/ardour/ardour/source.h
+++ b/libs/ardour/ardour/source.h
@@ -21,166 +21,46 @@
 #ifndef __ardour_source_h__
 #define __ardour_source_h__
 
-#include <list>
-#include <vector>
 #include <string>
 
-#include <ctime>
-
 #include <sigc++/signal.h>
 
-#include <glibmm/thread.h>
-
 #include <ardour/ardour.h>
 #include <ardour/stateful.h>
-#include <pbd/xml++.h>
-
-using std::list;
-using std::vector;
-using std::string;
 
 namespace ARDOUR {
 
-struct PeakData {
-    typedef Sample PeakDatum;
-
-    PeakDatum min;
-    PeakDatum max;
-};
-
-const jack_nframes_t frames_per_peak = 256;
-
 class Source : public Stateful, public sigc::trackable
 {
   public:
-	Source (bool announce=true);
+	Source (std::string name);
 	Source (const XMLNode&);
 	virtual ~Source ();
 
-	const string& name() const { return _name; }
+	std::string name() const { return _name; }
+	int set_name (std::string str, bool destructive);
 
 	ARDOUR::id_t  id() const   { return _id; }
 
-	/* returns the number of items in this `source' */
-
-	virtual jack_nframes_t length() const {
-		return _length;
-	}
-
-	virtual jack_nframes_t available_peaks (double zoom) const;
-
-	virtual jack_nframes_t read (Sample *dst, jack_nframes_t start, jack_nframes_t cnt, char * workbuf) const {
-		return 0;
-	}
-
-	virtual jack_nframes_t write (Sample *src, jack_nframes_t cnt, char * workbuf) {
-		return 0;
-	}
-
-	virtual float sample_rate () const { return 0; }
-
 	uint32_t use_cnt() const { return _use_cnt; }
 	void use ();
 	void release ();
 
-	virtual void mark_for_remove() = 0;
-	virtual void mark_streaming_write_completed () {}
-
 	time_t timestamp() const { return _timestamp; }
 	void stamp (time_t when) { _timestamp = when; }
 
-	void set_captured_for (string str) { _captured_for = str; }
-	string captured_for() const { return _captured_for; }
-
-	uint32_t read_data_count() const { return _read_data_count; }
-	uint32_t write_data_count() const { return _write_data_count; }
-
- 	int  read_peaks (PeakData *peaks, jack_nframes_t npeaks, jack_nframes_t start, jack_nframes_t cnt, double samples_per_unit) const;
- 	int  build_peaks ();
-	bool peaks_ready (sigc::slot<void>, sigc::connection&) const;
-
-	static sigc::signal<void,Source*> SourceCreated;
-	       
-	sigc::signal<void,Source *> GoingAway;
-	mutable sigc::signal<void>  PeaksReady;
-	mutable sigc::signal<void,jack_nframes_t,jack_nframes_t>  PeakRangeReady;
-	
 	XMLNode& get_state ();
 	int set_state (const XMLNode&);
 
-	static int  start_peak_thread ();
-	static void stop_peak_thread ();
-
-	int rename_peakfile (std::string newpath);
-
-	static void set_build_missing_peakfiles (bool yn) {
-		_build_missing_peakfiles = yn;
-	}
-	static void set_build_peakfiles (bool yn) {
-		_build_peakfiles = yn;
-	}
+	sigc::signal<void,Source *> GoingAway;
 
   protected:
-	static bool _build_missing_peakfiles;
-	static bool _build_peakfiles;
-
 	string            _name;
-	uint32_t     _use_cnt;
-	bool              _peaks_built;
-	mutable Glib::Mutex _lock;
-	jack_nframes_t    _length;
-	bool               next_peak_clear_should_notify;
-	string             peakpath;
+	uint32_t          _use_cnt;
 	time_t            _timestamp;
-	string            _captured_for;
-
-	mutable uint32_t _read_data_count;  // modified in read()
-	mutable uint32_t _write_data_count; // modified in write()
-
-	int initialize_peakfile (bool newfile, string path);
-	void build_peaks_from_scratch ();
-
-	int  do_build_peak (jack_nframes_t, jack_nframes_t);
-	virtual jack_nframes_t read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt, char * workbuf) const = 0;
-	virtual string peak_path(string audio_path) = 0;
-
-	static pthread_t peak_thread;
-	static bool      have_peak_thread;
-	static void*     peak_thread_work(void*);
-
-	static int peak_request_pipe[2];
-
-	struct PeakRequest {
-	    enum Type {
-		    Build,
-		    Quit
-	    };
-	};
-
-	static vector<Source*> pending_peak_sources;
-	static Glib::StaticMutex pending_peak_sources_lock;
-
-	static void queue_for_peaks (Source&);
-	static void clear_queue_for_peaks ();
-	
-	struct PeakBuildRecord {
-	    jack_nframes_t frame;
-	    jack_nframes_t cnt;
-
-	    PeakBuildRecord (jack_nframes_t f, jack_nframes_t c) 
-		    : frame (f), cnt (c) {}
-	    PeakBuildRecord (const PeakBuildRecord& other) {
-		    frame = other.frame;
-		    cnt = other.cnt;
-	    }
-	};
-
-	list<Source::PeakBuildRecord *> pending_peak_builds;
 
   private:
 	ARDOUR::id_t _id;
-	
-	bool file_changed (string path);
 };
 
 }
diff --git a/libs/ardour/ardour/types.h b/libs/ardour/ardour/types.h
index 3d7ab4b59a..cdf71b8cc6 100644
--- a/libs/ardour/ardour/types.h
+++ b/libs/ardour/ardour/types.h
@@ -255,10 +255,18 @@ namespace ARDOUR {
 		BWF,
 		WAVE,
 		WAVE64,
+		CAF,
+		AIFF,
 		iXML,
 		RF64
 	};
 
+	struct PeakData {
+	    typedef Sample PeakDatum;
+	    
+	    PeakDatum min;
+	    PeakDatum max;
+	};
 };
 
 std::istream& operator>>(std::istream& o, ARDOUR::SampleFormat& sf);