X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Faudiosource.cc;h=0c820eed4d29b9c923fb0a14150b2c978b52b305;hb=7d96960b162d25da87c388a3083775e8770bba56;hp=8e68b315877e0b87e0499db9f6bcc5e8113a947e;hpb=68e943265edf04e63a8e8b8f62bab20f99d9c637;p=ardour.git

diff --git a/libs/ardour/audiosource.cc b/libs/ardour/audiosource.cc
index 8e68b31587..0c820eed4d 100644
--- a/libs/ardour/audiosource.cc
+++ b/libs/ardour/audiosource.cc
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2000 Paul Davis 
+    Copyright (C) 2000 Paul Davis
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -34,13 +34,14 @@
 #include <glibmm/fileutils.h>
 #include <glibmm/miscutils.h>
 
-#include <pbd/xml++.h>
-#include <pbd/pthread_utils.h>
+#include "pbd/xml++.h"
+#include "pbd/pthread_utils.h"
 
-#include <ardour/audiosource.h>
-#include <ardour/cycle_timer.h>
-#include <ardour/session.h>
-#include <ardour/transient_detector.h>
+#include "ardour/audiosource.h"
+#include "ardour/cycle_timer.h"
+#include "ardour/session.h"
+#include "ardour/transient_detector.h"
+#include "ardour/runtime_functions.h"
 
 #include "i18n.h"
 
@@ -50,12 +51,15 @@ using namespace PBD;
 using Glib::ustring;
 
 bool AudioSource::_build_missing_peakfiles = false;
+
+/** true if we want peakfiles (e.g. if we are displaying a GUI) */
 bool AudioSource::_build_peakfiles = false;
 
 #define _FPP 256
 
 AudioSource::AudioSource (Session& s, ustring name)
-	: Source (s, name, DataType::AUDIO)
+	: Source (s, DataType::AUDIO, name)
+	, _length (0)
 {
 	_peaks_built = false;
 	_peak_byte_max = 0;
@@ -67,10 +71,11 @@ AudioSource::AudioSource (Session& s, ustring name)
 	peak_leftovers = 0;
 }
 
-AudioSource::AudioSource (Session& s, const XMLNode& node) 
+AudioSource::AudioSource (Session& s, const XMLNode& node)
 	: Source (s, node)
+	, _length (0)
 {
-	
+
 	_peaks_built = false;
 	_peak_byte_max = 0;
 	peakfile = -1;
@@ -80,7 +85,7 @@ AudioSource::AudioSource (Session& s, const XMLNode& node)
 	peak_leftover_size = 0;
 	peak_leftovers = 0;
 
-	if (set_state (node)) {
+	if (set_state (node, Stateful::loading_state_version)) {
 		throw failed_constructor();
 	}
 }
@@ -88,7 +93,7 @@ AudioSource::AudioSource (Session& s, const XMLNode& node)
 AudioSource::~AudioSource ()
 {
 	/* shouldn't happen but make sure we don't leak file descriptors anyway */
-	
+
 	if (peak_leftover_cnt) {
 		cerr << "AudioSource destroyed with leftover peak data pending" << endl;
 	}
@@ -97,9 +102,7 @@ AudioSource::~AudioSource ()
 		::close (peakfile);
 	}
 
-	if (peak_leftovers) {
-		delete [] peak_leftovers;
-	}
+	delete [] peak_leftovers;
 }
 
 XMLNode&
@@ -115,12 +118,10 @@ AudioSource::get_state ()
 }
 
 int
-AudioSource::set_state (const XMLNode& node)
+AudioSource::set_state (const XMLNode& node, int /*version*/)
 {
 	const XMLProperty* prop;
 
-	Source::set_state (node);
-
 	if ((prop = node.property ("captured-for")) != 0) {
 		_captured_for = prop->value();
 	}
@@ -128,12 +129,27 @@ AudioSource::set_state (const XMLNode& node)
 	return 0;
 }
 
+sframes_t
+AudioSource::length (sframes_t /*pos*/) const
+{
+	return _length;
+}
+
+void
+AudioSource::update_length (sframes_t pos, sframes_t cnt)
+{
+	if (pos + cnt > _length) {
+		_length = pos + cnt;
+	}
+}
+
+
 /***********************************************************************
   PEAK FILE STUFF
  ***********************************************************************/
 
 bool
-AudioSource::peaks_ready (sigc::slot<void> the_slot, sigc::connection& conn) const
+AudioSource::peaks_ready (boost::function<void()> doThisWhenReady, Connection& connect_here_if_not, EventLoop* event_loop) const
 {
 	bool ret;
 	Glib::Mutex::Lock lm (_peaks_ready_lock);
@@ -143,7 +159,7 @@ AudioSource::peaks_ready (sigc::slot<void> the_slot, sigc::connection& conn) con
 	*/
 
 	if (!(ret = _peaks_built)) {
-		conn = PeaksReady.connect (the_slot);
+		PeaksReady.connect (connect_here_if_not, doThisWhenReady, event_loop);
 	}
 
 	return ret;
@@ -157,12 +173,12 @@ AudioSource::touch_peakfile ()
 	if (stat (peakpath.c_str(), &statbuf) != 0 || statbuf.st_size == 0) {
 		return;
 	}
-	
+
 	struct utimbuf tbuf;
-	
+
 	tbuf.actime = statbuf.st_atime;
 	tbuf.modtime = time ((time_t) 0);
-	
+
 	utime (peakpath.c_str(), &tbuf);
 }
 
@@ -193,7 +209,7 @@ AudioSource::initialize_peakfile (bool newfile, ustring audio_path)
 	peakpath = peak_path (audio_path);
 
 	/* if the peak file should be there, but isn't .... */
-	
+
 	if (!newfile && !Glib::file_test (peakpath.c_str(), Glib::FILE_TEST_EXISTS)) {
 		peakpath = find_broken_peakfile (peakpath, audio_path);
 	}
@@ -201,27 +217,27 @@ AudioSource::initialize_peakfile (bool newfile, ustring audio_path)
 	if (stat (peakpath.c_str(), &statbuf)) {
 		if (errno != ENOENT) {
 			/* it exists in the peaks dir, but there is some kind of error */
-			
+
 			error << string_compose(_("AudioSource: cannot stat peakfile \"%1\""), peakpath) << endmsg;
 			return -1;
 		}
 
 		/* peakfile does not exist */
-		
+
 		_peaks_built = false;
-		
+
 	} else {
-		
+
 		/* we found it in the peaks dir, so check it out */
-		
-		if (statbuf.st_size == 0 || ((nframes_t) statbuf.st_size < ((length() / _FPP) * sizeof (PeakData)))) {
+
+		if (statbuf.st_size == 0 || ((nframes_t) statbuf.st_size < ((length(_timeline_position) / _FPP) * sizeof (PeakData)))) {
 			// empty
 			_peaks_built = false;
 		} else {
 			// Check if the audio file has changed since the peakfile was built.
 			struct stat stat_file;
 			int err = stat (audio_path.c_str(), &stat_file);
-			
+
 			if (err) {
 				_peaks_built = false;
 				_peak_byte_max = 0;
@@ -244,13 +260,13 @@ AudioSource::initialize_peakfile (bool newfile, ustring audio_path)
 
 	if (!newfile && !_peaks_built && _build_missing_peakfiles && _build_peakfiles) {
 		build_peaks_from_scratch ();
-	} 
-	
+	}
+
 	return 0;
 }
 
 nframes_t
-AudioSource::read (Sample *dst, nframes_t start, nframes_t cnt) const
+AudioSource::read (Sample *dst, sframes_t start, nframes_t cnt, int /*channel*/) const
 {
 	Glib::Mutex::Lock lm (_lock);
 	return read_unlocked (dst, start, cnt);
@@ -260,17 +276,23 @@ nframes_t
 AudioSource::write (Sample *dst, nframes_t cnt)
 {
 	Glib::Mutex::Lock lm (_lock);
+	/* any write makes the fill not removable */
+	_flags = Flag (_flags & ~Removable);
 	return write_unlocked (dst, cnt);
 }
 
 int
-AudioSource::read_peaks (PeakData *peaks, nframes_t npeaks, nframes_t start, nframes_t cnt, double samples_per_visual_peak) const
+AudioSource::read_peaks (PeakData *peaks, nframes_t npeaks, sframes_t start, nframes_t cnt, double samples_per_visual_peak) const
 {
 	return read_peaks_with_fpp (peaks, npeaks, start, cnt, samples_per_visual_peak, _FPP);
 }
 
-int 
-AudioSource::read_peaks_with_fpp (PeakData *peaks, nframes_t npeaks, nframes_t start, nframes_t cnt, 
+/** @param peaks Buffer to write peak data.
+ *  @param npeaks Number of peaks to write.
+ */
+
+int
+AudioSource::read_peaks_with_fpp (PeakData *peaks, nframes_t npeaks, sframes_t start, nframes_t cnt,
 				  double samples_per_visual_peak, nframes_t samples_per_file_peak) const
 {
 	Glib::Mutex::Lock lm (_lock);
@@ -291,15 +313,15 @@ AudioSource::read_peaks_with_fpp (PeakData *peaks, nframes_t npeaks, nframes_t s
 
 #undef DEBUG_READ_PEAKS
 #ifdef DEBUG_READ_PEAKS
-	cerr << "======>RP: npeaks = " << npeaks 
-	     << " start = " << start 
-	     << " cnt = " << cnt 
-	     << " len = " << _length 
-	     << "   samples_per_visual_peak =" << samples_per_visual_peak 
+	cerr << "======>RP: npeaks = " << npeaks
+	     << " start = " << start
+	     << " cnt = " << cnt
+	     << " len = " << _length
+	     << "   samples_per_visual_peak =" << samples_per_visual_peak
 	     << " expected was " << expected_peaks << " ... scale = " << scale
 	     << " PD ptr = " << peaks
 	     <<endl;
-	
+
 #endif
 
 	/* fix for near-end-of-file conditions */
@@ -313,18 +335,18 @@ AudioSource::read_peaks_with_fpp (PeakData *peaks, nframes_t npeaks, nframes_t s
 	}
 
 	// cerr << "actual npeaks = " << npeaks << " zf = " << zero_fill << endl;
-	
+
 	if (npeaks == cnt) {
 
 #ifdef DEBUG_READ_PEAKS
 		cerr << "RAW DATA\n";
-#endif		
+#endif
 		/* no scaling at all, just get the sample data and duplicate it for
 		   both max and min peak values.
 		*/
 
 		Sample* raw_staging = new Sample[cnt];
-		
+
 		if (read_unlocked (raw_staging, start, cnt) != cnt) {
 			error << _("cannot read sample data for unscaled peak computation") << endmsg;
 			return -1;
@@ -353,18 +375,18 @@ AudioSource::read_peaks_with_fpp (PeakData *peaks, nframes_t npeaks, nframes_t s
 #ifdef DEBUG_READ_PEAKS
 		cerr << "DIRECT PEAKS\n";
 #endif
-		
+
 		nread = ::pread (_peakfile, peaks, sizeof (PeakData)* npeaks, first_peak_byte);
 		close (_peakfile);
 
 		if (nread != sizeof (PeakData) * npeaks) {
 			cerr << "AudioSource["
 			     << _name
-			     << "]: cannot read peaks from peakfile! (read only " 
+			     << "]: cannot read peaks from peakfile! (read only "
 			     << nread
-			     << " not " 
+			     << " not "
 			     << npeaks
-			      << "at sample " 
+			      << "at sample "
 			     << start
 			     << " = byte "
 			     << first_peak_byte
@@ -387,7 +409,7 @@ AudioSource::read_peaks_with_fpp (PeakData *peaks, nframes_t npeaks, nframes_t s
 
 #ifdef DEBUG_READ_PEAKS
 		cerr << "DOWNSAMPLE\n";
-#endif		
+#endif
 		/* the caller wants:
 
 		    - more frames-per-peak (lower resolution) than the peakfile, or to put it another way,
@@ -395,15 +417,15 @@ AudioSource::read_peaks_with_fpp (PeakData *peaks, nframes_t npeaks, nframes_t s
 
 		    So, read a block into a staging area, and then downsample from there.
 
-		    to avoid confusion, I'll refer to the requested peaks as visual_peaks and the peakfile peaks as stored_peaks  
+		    to avoid confusion, I'll refer to the requested peaks as visual_peaks and the peakfile peaks as stored_peaks
 		*/
 
 		const uint32_t chunksize = (uint32_t) min (expected_peaks, 65536.0);
-		
+
 		staging = new PeakData[chunksize];
-		
+
 		/* compute the rounded up frame position  */
-	
+
 		nframes_t current_frame = start;
 		nframes_t current_stored_peak = (nframes_t) ceil (current_frame / (double) samples_per_file_peak);
 		uint32_t       next_visual_peak  = (uint32_t) ceil (current_frame / samples_per_visual_peak);
@@ -429,18 +451,18 @@ AudioSource::read_peaks_with_fpp (PeakData *peaks, nframes_t npeaks, nframes_t s
 			if (i == stored_peaks_read) {
 
 				uint32_t       start_byte = current_stored_peak * sizeof(PeakData);
-				tnp = min ((_length/samples_per_file_peak - current_stored_peak), (nframes_t) expected_peaks);
+				tnp = min ((nframes_t)(_length/samples_per_file_peak - current_stored_peak), (nframes_t) expected_peaks);
 				to_read = min (chunksize, tnp);
-				
+
 #ifdef DEBUG_READ_PEAKS
 				cerr << "read " << sizeof (PeakData) * to_read << " from peakfile @ " << start_byte << endl;
 #endif
-				
+
 				if ((nread = ::pread (_peakfile, staging, sizeof (PeakData) * to_read, start_byte))
 				    != sizeof (PeakData) * to_read) {
 
 					off_t fend = lseek (_peakfile, 0, SEEK_END);
-					
+
 					cerr << "AudioSource["
 					     << _name
 					     << "]: cannot read peak data from peakfile ("
@@ -450,18 +472,18 @@ AudioSource::read_peaks_with_fpp (PeakData *peaks, nframes_t npeaks, nframes_t s
 					     << ") ("
 					     << strerror (errno)
 					     << ')'
-					     << " at start_byte = " << start_byte 
+					     << " at start_byte = " << start_byte
 					     << " _length = " << _length << " versus len = " << fend
 					     << " expected maxpeaks = " << (_length - current_frame)/samples_per_file_peak
 					     << " npeaks was " << npeaks
 					     << endl;
 					goto out;
 				}
-				
+
 				i = 0;
 				stored_peaks_read = nread / sizeof(PeakData);
 			}
-			
+
 			xmax = -1.0;
 			xmin = 1.0;
 
@@ -481,21 +503,21 @@ AudioSource::read_peaks_with_fpp (PeakData *peaks, nframes_t npeaks, nframes_t s
 
 			//next_visual_peak_frame = min ((next_visual_peak * samples_per_visual_peak), (next_visual_peak_frame+samples_per_visual_peak) );
 			next_visual_peak_frame =  min ((double) start+cnt, (next_visual_peak_frame+samples_per_visual_peak) );
-			stored_peak_before_next_visual_peak = (uint32_t) next_visual_peak_frame / samples_per_file_peak; 
+			stored_peak_before_next_visual_peak = (uint32_t) next_visual_peak_frame / samples_per_file_peak;
 		}
 
 		if (zero_fill) {
- 			memset (&peaks[npeaks], 0, sizeof (PeakData) * zero_fill);
- 		}
-		
+			memset (&peaks[npeaks], 0, sizeof (PeakData) * zero_fill);
+		}
+
 		ret = 0;
 
 	} else {
-		
+
 #ifdef DEBUG_READ_PEAKS
 		cerr << "UPSAMPLE\n";
 #endif
-		/* the caller wants 
+		/* the caller wants
 
 		     - less frames-per-peak (more resolution)
 		     - more peaks than stored in the Peakfile
@@ -510,7 +532,7 @@ AudioSource::read_peaks_with_fpp (PeakData *peaks, nframes_t npeaks, nframes_t s
 		nframes_t nvisual_peaks = 0;
 		nframes_t chunksize = (nframes_t) min (cnt, (nframes_t) 4096);
 		raw_staging = new Sample[chunksize];
-		
+
 		nframes_t frame_pos = start;
 		double pixel_pos = floor (frame_pos / samples_per_visual_peak);
 		double next_pixel_pos = ceil (frame_pos / samples_per_visual_peak);
@@ -522,27 +544,28 @@ AudioSource::read_peaks_with_fpp (PeakData *peaks, nframes_t npeaks, nframes_t s
 		while (nvisual_peaks < npeaks) {
 
 			if (i == frames_read) {
-				
-				to_read = min (chunksize, (_length - current_frame));
+
+				to_read = min (chunksize, nframes_t(_length - current_frame));
 
 				if (to_read == 0) {
 					/* XXX ARGH .. out by one error ... need to figure out why this happens
 					   and fix it rather than do this band-aid move.
 					*/
 					zero_fill = npeaks - nvisual_peaks;
+					npeaks -= zero_fill;
 					break;
 				}
 
 				if ((frames_read = read_unlocked (raw_staging, current_frame, to_read)) == 0) {
 					error << string_compose(_("AudioSource[%1]: peak read - cannot read %2 samples at offset %3 of %4 (%5)"),
-								_name, to_read, current_frame, _length, strerror (errno)) 
+								_name, to_read, current_frame, _length, strerror (errno))
 					      << endmsg;
 					goto out;
 				}
-					
+
 				i = 0;
 			}
-			
+
 			xmax = max (xmax, raw_staging[i]);
 			xmin = min (xmin, raw_staging[i]);
 			++i;
@@ -560,7 +583,7 @@ AudioSource::read_peaks_with_fpp (PeakData *peaks, nframes_t npeaks, nframes_t s
 				next_pixel_pos = ceil (pixel_pos + 0.5);
 			}
 		}
-		
+
 		if (zero_fill) {
 			memset (&peaks[npeaks], 0, sizeof (PeakData) * zero_fill);
 		}
@@ -573,13 +596,8 @@ AudioSource::read_peaks_with_fpp (PeakData *peaks, nframes_t npeaks, nframes_t s
 		close (_peakfile);
 	}
 
-	if (staging) {
-		delete [] staging;
-	} 
-
-	if (raw_staging) {
-		delete [] raw_staging;
-	}
+	delete [] staging;
+	delete [] raw_staging;
 
 #ifdef DEBUG_READ_PEAKS
 	cerr << "RP DONE\n";
@@ -606,18 +624,18 @@ AudioSource::build_peaks_from_scratch ()
 		/* hold lock while building peaks */
 
 		Glib::Mutex::Lock lp (_lock);
-		
+
 		if (prepare_for_peakfile_writes ()) {
 			goto out;
 		}
-		
+
 		current_frame = 0;
 		cnt = _length;
 		_peaks_built = false;
 		buf = new Sample[bufsize];
-		
+
 		while (cnt) {
-			
+
 			frames_to_read = min (bufsize, cnt);
 
 			if ((frames_read = read_unlocked (buf, current_frame, frames_to_read)) != frames_to_read) {
@@ -629,7 +647,7 @@ AudioSource::build_peaks_from_scratch ()
 			if (compute_and_write_peaks (buf, current_frame, frames_read, true, false, _FPP)) {
 				break;
 			}
-			
+
 			current_frame += frames_read;
 			cnt -= frames_read;
 		}
@@ -637,14 +655,14 @@ AudioSource::build_peaks_from_scratch ()
 		if (cnt == 0) {
 			/* success */
 			truncate_peakfile();
-		} 
+		}
 
 		done_with_peakfile_writes ((cnt == 0));
 	}
-	
+
 	{
 		Glib::Mutex::Lock lm (_peaks_ready_lock);
-		
+
 		if (_peaks_built) {
 			PeaksReady (); /* EMIT SIGNAL */
 			ret = 0;
@@ -656,9 +674,7 @@ AudioSource::build_peaks_from_scratch ()
 		unlink (peakpath.c_str());
 	}
 
-	if (buf) {
-		delete [] buf;
-	}
+	delete [] buf;
 
 	return ret;
 }
@@ -679,7 +695,7 @@ AudioSource::done_with_peakfile_writes (bool done)
 	if (peak_leftover_cnt) {
 		compute_and_write_peaks (0, 0, 0, true, false, _FPP);
 	}
-	
+
 	if (done) {
 		_peaks_built = true;
 	}
@@ -691,14 +707,15 @@ AudioSource::done_with_peakfile_writes (bool done)
 }
 
 int
-AudioSource::compute_and_write_peaks (Sample* buf, nframes_t first_frame, nframes_t cnt, bool force, bool intermediate_peaks_ready)
+AudioSource::compute_and_write_peaks (Sample* buf, sframes_t first_frame, nframes_t cnt,
+		bool force, bool intermediate_peaks_ready)
 {
 	return compute_and_write_peaks (buf, first_frame, cnt, force, intermediate_peaks_ready, _FPP);
 }
 
 int
-AudioSource::compute_and_write_peaks (Sample* buf, nframes_t first_frame, nframes_t cnt, bool force, 
-				      bool intermediate_peaks_ready, nframes_t fpp)
+AudioSource::compute_and_write_peaks (Sample* buf, sframes_t first_frame, nframes_t cnt,
+		bool force, bool intermediate_peaks_ready, nframes_t fpp)
 {
 	Sample* buf2 = 0;
 	nframes_t to_do;
@@ -719,13 +736,13 @@ AudioSource::compute_and_write_peaks (Sample* buf, nframes_t first_frame, nframe
 
 		if (first_frame != peak_leftover_frame + peak_leftover_cnt) {
 
-			/* uh-oh, ::seek() since the last ::compute_and_write_peaks(), 
+			/* uh-oh, ::seek() since the last ::compute_and_write_peaks(),
 			   and we have leftovers. flush a single peak (since the leftovers
 			   never represent more than that, and restart.
 			*/
-			
+
 			PeakData x;
-			
+
 			x.min = peak_leftovers[0];
 			x.max = peak_leftovers[0];
 
@@ -738,12 +755,12 @@ AudioSource::compute_and_write_peaks (Sample* buf, nframes_t first_frame, nframe
 
 			_peak_byte_max = max (_peak_byte_max, (off_t) (byte + sizeof(PeakData)));
 
-			{ 
+			{
 				Glib::Mutex::Lock lm (_peaks_ready_lock);
 				PeakRangeReady (peak_leftover_frame, peak_leftover_cnt); /* EMIT SIGNAL */
 				if (intermediate_peaks_ready) {
 					PeaksReady (); /* EMIT SIGNAL */
-				} 
+				}
 			}
 
 			/* left overs are done */
@@ -776,7 +793,7 @@ AudioSource::compute_and_write_peaks (Sample* buf, nframes_t first_frame, nframe
 		/* make sure that when we write into the peakfile, we startup where we left off */
 
 		first_frame = peak_leftover_frame;
-		
+
 	} else {
 		to_do = cnt;
 	}
@@ -809,7 +826,7 @@ AudioSource::compute_and_write_peaks (Sample* buf, nframes_t first_frame, nframe
 
 			break;
 		}
-			
+
 		nframes_t this_time = min (fpp, to_do);
 
 		peakbuf[peaks_computed].max = buf[0];
@@ -823,20 +840,20 @@ AudioSource::compute_and_write_peaks (Sample* buf, nframes_t first_frame, nframe
 		frames_done += this_time;
 		current_frame += this_time;
 	}
-		
+
 	first_peak_byte = (first_frame / fpp) * sizeof (PeakData);
 
 	if (can_truncate_peaks()) {
 
 		/* on some filesystems (ext3, at least) this helps to reduce fragmentation of
 		   the peakfiles. its not guaranteed to do so, and even on ext3 (as of december 2006)
-		   it does not cause single-extent allocation even for peakfiles of 
+		   it does not cause single-extent allocation even for peakfiles of
 		   less than BLOCKSIZE bytes.  only call ftruncate if we'll make the file larger.
 		*/
-		
+
 		off_t endpos = lseek (peakfile, 0, SEEK_END);
 		off_t target_length = blocksize * ((first_peak_byte + blocksize + 1) / blocksize);
-		
+
 		if (endpos < target_length) {
 			ftruncate (peakfile, target_length);
 			/* error doesn't actually matter though, so continue on without testing */
@@ -848,7 +865,7 @@ AudioSource::compute_and_write_peaks (Sample* buf, nframes_t first_frame, nframe
 		goto out;
 	}
 
-	_peak_byte_max = max (_peak_byte_max, (off_t) (first_peak_byte + sizeof(PeakData)*peaks_computed));	
+	_peak_byte_max = max (_peak_byte_max, (off_t) (first_peak_byte + sizeof(PeakData)*peaks_computed));
 
 	if (frames_done) {
 		Glib::Mutex::Lock lm (_peaks_ready_lock);
@@ -862,9 +879,8 @@ AudioSource::compute_and_write_peaks (Sample* buf, nframes_t first_frame, nframe
 
   out:
 	delete [] peakbuf;
-	if (buf2) {
-		delete [] buf2;
-	}
+	delete [] buf2;
+
 	return ret;
 }
 
@@ -880,53 +896,27 @@ AudioSource::truncate_peakfile ()
 	/* truncate the peakfile down to its natural length if necessary */
 
 	off_t end = lseek (peakfile, 0, SEEK_END);
-	
+
 	if (end > _peak_byte_max) {
 		ftruncate (peakfile, _peak_byte_max);
 	}
 }
 
-bool
-AudioSource::file_changed (ustring path)
-{
-	struct stat stat_file;
-	struct stat stat_peak;
-
-	int e1 = stat (path.c_str(), &stat_file);
-	int e2 = stat (peak_path(path).c_str(), &stat_peak);
-	
-	if (!e1 && !e2 && stat_file.st_mtime > stat_peak.st_mtime){
-		return true;
-	} else {
-		return false;
-	}
-}
-
 nframes_t
 AudioSource::available_peaks (double zoom_factor) const
 {
-	off_t end;
-
 	if (zoom_factor < _FPP) {
-		return length(); // peak data will come from the audio file
-	} 
-	
+		return length(_timeline_position); // peak data will come from the audio file
+	}
+
 	/* peak data comes from peakfile, but the filesize might not represent
 	   the valid data due to ftruncate optimizations, so use _peak_byte_max state.
 	   XXX - there might be some atomicity issues here, we should probably add a lock,
 	   but _peak_byte_max only monotonically increases after initialization.
 	*/
 
-	end = _peak_byte_max;
+	off_t end = _peak_byte_max;
 
 	return (end/sizeof(PeakData)) * _FPP;
 }
 
-void
-AudioSource::update_length (nframes_t pos, nframes_t cnt)
-{
-	if (pos + cnt > _length) {
-		_length = pos+cnt;
-	}
-}
-