X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Faudiosource.cc;h=93e201b8c2843171a86208fd77338b0d0de793a1;hb=8713667ec1a6cc9ba56c07f763e5a422cc47fbef;hp=a2ce7209f6f634e0802b71f69b4dd2d0e6cd8071;hpb=f7f9d6fdc40248b190ec9c6e1a886261d55777ae;p=ardour.git

diff --git a/libs/ardour/audiosource.cc b/libs/ardour/audiosource.cc
index a2ce7209f6..93e201b8c2 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
@@ -27,17 +27,21 @@
 #include <ctime>
 #include <cmath>
 #include <iomanip>
+#include <fstream>
 #include <algorithm>
 #include <vector>
 
 #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/audiosource.h"
+#include "ardour/cycle_timer.h"
+#include "ardour/session.h"
+#include "ardour/transient_detector.h"
+#include "ardour/runtime_functions.h"
 
 #include "i18n.h"
 
@@ -47,10 +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;
@@ -62,9 +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;
@@ -74,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();
 	}
 }
@@ -82,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;
 	}
@@ -91,9 +102,7 @@ AudioSource::~AudioSource ()
 		::close (peakfile);
 	}
 
-	if (peak_leftovers) {
-		delete [] peak_leftovers;
-	}
+	delete [] peak_leftovers;
 }
 
 XMLNode&
@@ -109,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();
 	}
@@ -122,6 +129,21 @@ 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
  ***********************************************************************/
@@ -135,7 +157,7 @@ AudioSource::peaks_ready (sigc::slot<void> the_slot, sigc::connection& conn) con
 	/* check to see if the peak data is ready. if not
 	   connect the slot while still holding the lock.
 	*/
-	
+
 	if (!(ret = _peaks_built)) {
 		conn = PeaksReady.connect (the_slot);
 	}
@@ -151,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);
 }
 
@@ -187,43 +209,45 @@ 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);
 	}
 
-	if (newfile) {
+	if (stat (peakpath.c_str(), &statbuf)) {
+		if (errno != ENOENT) {
+			/* it exists in the peaks dir, but there is some kind of error */
 
-		if (!_build_peakfiles) {
-			return 0;
+			error << string_compose(_("AudioSource: cannot stat peakfile \"%1\""), peakpath) << endmsg;
+			return -1;
 		}
 
+		/* peakfile does not exist */
+
 		_peaks_built = false;
 
 	} else {
 
-		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;
-			}
-			
-			_peaks_built = false;
+		/* we found it in the peaks dir, so check it out */
 
+		if (statbuf.st_size == 0 || ((nframes_t) statbuf.st_size < ((length(_timeline_position) / _FPP) * sizeof (PeakData)))) {
+			// empty
+			_peaks_built = false;
 		} else {
-			
-			/* we found it in the peaks dir, so check it out */
+			// 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 (statbuf.st_size == 0) {
+			if (err) {
 				_peaks_built = false;
+				_peak_byte_max = 0;
 			} 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 && stat_file.st_mtime > statbuf.st_mtime){
+
+				/* allow 6 seconds slop on checking peak vs. file times because of various
+				   disk action "races"
+				*/
+
+				if (stat_file.st_mtime > statbuf.st_mtime && (stat_file.st_mtime - statbuf.st_mtime > 6)) {
 					_peaks_built = false;
 					_peak_byte_max = 0;
 				} else {
@@ -236,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);
@@ -255,8 +279,19 @@ AudioSource::write (Sample *dst, nframes_t cnt)
 	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
+int
+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);
+}
+
+/** @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);
 	double scale;
@@ -271,20 +306,20 @@ AudioSource::read_peaks (PeakData *peaks, nframes_t npeaks, nframes_t start, nfr
 	Sample* raw_staging = 0;
 	int _peakfile = -1;
 
-	expected_peaks = (cnt / (double) frames_per_peak);
+	expected_peaks = (cnt / (double) samples_per_file_peak);
 	scale = npeaks/expected_peaks;
 
 #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 */
@@ -298,18 +333,18 @@ AudioSource::read_peaks (PeakData *peaks, nframes_t npeaks, nframes_t start, nfr
 	}
 
 	// 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;
@@ -326,7 +361,7 @@ AudioSource::read_peaks (PeakData *peaks, nframes_t npeaks, nframes_t start, nfr
 
 	if (scale == 1.0) {
 
-		off_t first_peak_byte = (start / frames_per_peak) * sizeof (PeakData);
+		off_t first_peak_byte = (start / samples_per_file_peak) * sizeof (PeakData);
 
 		/* open, read, close */
 
@@ -338,18 +373,18 @@ AudioSource::read_peaks (PeakData *peaks, nframes_t npeaks, nframes_t start, nfr
 #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
@@ -372,7 +407,7 @@ AudioSource::read_peaks (PeakData *peaks, nframes_t npeaks, nframes_t start, nfr
 
 #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,
@@ -380,20 +415,20 @@ AudioSource::read_peaks (PeakData *peaks, nframes_t npeaks, nframes_t start, nfr
 
 		    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) frames_per_peak);
+		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);
 		double         next_visual_peak_frame = next_visual_peak * samples_per_visual_peak;
-		uint32_t       stored_peak_before_next_visual_peak = (nframes_t) next_visual_peak_frame / frames_per_peak;
+		uint32_t       stored_peak_before_next_visual_peak = (nframes_t) next_visual_peak_frame / samples_per_file_peak;
 		uint32_t       nvisual_peaks = 0;
 		uint32_t       stored_peaks_read = 0;
 		uint32_t       i = 0;
@@ -414,18 +449,18 @@ AudioSource::read_peaks (PeakData *peaks, nframes_t npeaks, nframes_t start, nfr
 			if (i == stored_peaks_read) {
 
 				uint32_t       start_byte = current_stored_peak * sizeof(PeakData);
-				tnp = min ((_length/frames_per_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 ("
@@ -435,18 +470,18 @@ AudioSource::read_peaks (PeakData *peaks, nframes_t npeaks, nframes_t start, nfr
 					     << ") ("
 					     << strerror (errno)
 					     << ')'
-					     << " at start_byte = " << start_byte 
+					     << " at start_byte = " << start_byte
 					     << " _length = " << _length << " versus len = " << fend
-					     << " expected maxpeaks = " << (_length - current_frame)/frames_per_peak
+					     << " 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;
 
@@ -466,21 +501,21 @@ AudioSource::read_peaks (PeakData *peaks, nframes_t npeaks, nframes_t start, nfr
 
 			//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 / frames_per_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
@@ -495,7 +530,7 @@ AudioSource::read_peaks (PeakData *peaks, nframes_t npeaks, nframes_t start, nfr
 		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);
@@ -507,27 +542,28 @@ AudioSource::read_peaks (PeakData *peaks, nframes_t npeaks, nframes_t start, nfr
 		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;
@@ -545,7 +581,7 @@ AudioSource::read_peaks (PeakData *peaks, nframes_t npeaks, nframes_t start, nfr
 				next_pixel_pos = ceil (pixel_pos + 0.5);
 			}
 		}
-		
+
 		if (zero_fill) {
 			memset (&peaks[npeaks], 0, sizeof (PeakData) * zero_fill);
 		}
@@ -558,13 +594,8 @@ AudioSource::read_peaks (PeakData *peaks, nframes_t npeaks, nframes_t start, nfr
 		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";
@@ -591,18 +622,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) {
@@ -611,10 +642,10 @@ AudioSource::build_peaks_from_scratch ()
 				goto out;
 			}
 
-			if (compute_and_write_peaks (buf, current_frame, frames_read, true, false)) {
+			if (compute_and_write_peaks (buf, current_frame, frames_read, true, false, _FPP)) {
 				break;
 			}
-			
+
 			current_frame += frames_read;
 			cnt -= frames_read;
 		}
@@ -622,14 +653,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;
@@ -641,9 +672,7 @@ AudioSource::build_peaks_from_scratch ()
 		unlink (peakpath.c_str());
 	}
 
-	if (buf) {
-		delete [] buf;
-	}
+	delete [] buf;
 
 	return ret;
 }
@@ -662,9 +691,9 @@ void
 AudioSource::done_with_peakfile_writes (bool done)
 {
 	if (peak_leftover_cnt) {
-		compute_and_write_peaks (0, 0, 0, true, false);
+		compute_and_write_peaks (0, 0, 0, true, false, _FPP);
 	}
-	
+
 	if (done) {
 		_peaks_built = true;
 	}
@@ -676,7 +705,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, sframes_t first_frame, nframes_t cnt,
+		bool force, bool intermediate_peaks_ready, nframes_t fpp)
 {
 	Sample* buf2 = 0;
 	nframes_t to_do;
@@ -697,19 +734,17 @@ 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];
 
-			ARDOUR::find_peaks (peak_leftovers + 1, peak_leftover_cnt - 1, &x.min, &x.max);
-
-			off_t byte = (peak_leftover_frame / frames_per_peak) * sizeof (PeakData);
+			off_t byte = (peak_leftover_frame / fpp) * sizeof (PeakData);
 
 			if (::pwrite (peakfile, &x, sizeof (PeakData), byte) != sizeof (PeakData)) {
 				error << string_compose(_("%1: could not write peak file data (%2)"), _name, strerror (errno)) << endmsg;
@@ -718,12 +753,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 */
@@ -756,12 +791,12 @@ 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;
 	}
 
-	peakbuf = new PeakData[(to_do/frames_per_peak)+1];
+	peakbuf = new PeakData[(to_do/fpp)+1];
 	peaks_computed = 0;
 	current_frame = first_frame;
 	frames_done = 0;
@@ -769,11 +804,11 @@ AudioSource::compute_and_write_peaks (Sample* buf, nframes_t first_frame, nframe
 	while (to_do) {
 
 		/* if some frames were passed in (i.e. we're not flushing leftovers)
-		   and there are less than frames_per_peak to do, save them till
+		   and there are less than fpp to do, save them till
 		   next time
 		*/
 
-		if (force && (to_do < frames_per_peak)) {
+		if (force && (to_do < fpp)) {
 			/* keep the left overs around for next time */
 
 			if (peak_leftover_size < to_do) {
@@ -789,8 +824,8 @@ AudioSource::compute_and_write_peaks (Sample* buf, nframes_t first_frame, nframe
 
 			break;
 		}
-			
-		nframes_t this_time = min (frames_per_peak, to_do);
+
+		nframes_t this_time = min (fpp, to_do);
 
 		peakbuf[peaks_computed].max = buf[0];
 		peakbuf[peaks_computed].min = buf[0];
@@ -803,20 +838,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 / frames_per_peak) * sizeof (PeakData);
+
+	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 */
@@ -828,7 +863,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);
@@ -842,9 +877,8 @@ AudioSource::compute_and_write_peaks (Sample* buf, nframes_t first_frame, nframe
 
   out:
 	delete [] peakbuf;
-	if (buf2) {
-		delete [] buf2;
-	}
+	delete [] buf2;
+
 	return ret;
 }
 
@@ -860,7 +894,7 @@ 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);
 	}
@@ -874,7 +908,7 @@ AudioSource::file_changed (ustring path)
 
 	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 {
@@ -885,28 +919,18 @@ AudioSource::file_changed (ustring path)
 nframes_t
 AudioSource::available_peaks (double zoom_factor) const
 {
-	off_t end;
+	if (zoom_factor < _FPP) {
+		return length(_timeline_position); // peak data will come from the audio file
+	}
 
-	if (zoom_factor < frames_per_peak) {
-		return length(); // 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)) * frames_per_peak;
-}
-
-void
-AudioSource::update_length (nframes_t pos, nframes_t cnt)
-{
-	if (pos + cnt > _length) {
-		_length = pos+cnt;
-	}
+	return (end/sizeof(PeakData)) * _FPP;
 }