1 files changed, 43 insertions, 47 deletions

diff --git a/libs/ardour/audio_diskstream.cc b/libs/ardour/audio_diskstream.cc
index f1d6cb2db8..580ce49231 100644
--- a/libs/ardour/audio_diskstream.cc
+++ b/libs/ardour/audio_diskstream.cc
@@ -249,7 +249,7 @@ AudioDiskstream::non_realtime_input_change ()
 	/* now refill channel buffers */
 
 	if (speed() != 1.0f || speed() != -1.0f) {
-		seek ((jack_nframes_t) (_session.transport_frame() * (double) speed()));
+		seek ((nframes_t) (_session.transport_frame() * (double) speed()));
 	} else {
 		seek (_session.transport_frame());
 	}
@@ -374,9 +374,7 @@ AudioDiskstream::setup_destructive_playlist ()
 
 	/* a single full-sized region */
 
-	cerr << "setup DS using " << srcs.front()->natural_position () << endl;
-
-	boost::shared_ptr<Region> region (RegionFactory::create (srcs, 0, max_frames, _name));
+	boost::shared_ptr<Region> region (RegionFactory::create (srcs, 0, max_frames - srcs.front()->natural_position(), _name));
 	_playlist->add_region (region, srcs.front()->natural_position());		
 }
 
@@ -389,21 +387,19 @@ AudioDiskstream::use_destructive_playlist ()
 	   with the (presumed single, full-extent) region.
 	*/
 
-	Playlist::RegionList* rl = _playlist->regions_at (0);
+	boost::shared_ptr<Region> rp = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
 
-	if (rl->empty()) {
+	if (!rp) {
 		reset_write_sources (false, true);
 		return;
 	}
 
-	boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (rl->front());
+	boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (rp);
 
 	if (region == 0) {
 		throw failed_constructor();
 	}
 
-	delete rl;
-
 	uint32_t n;
 	ChannelList::iterator chan;
 
@@ -417,7 +413,7 @@ AudioDiskstream::use_destructive_playlist ()
 }
 
 void
-AudioDiskstream::check_record_status (jack_nframes_t transport_frame, jack_nframes_t nframes, bool can_record)
+AudioDiskstream::check_record_status (nframes_t transport_frame, nframes_t nframes, bool can_record)
 {
 	int possibly_recording;
 	int rolling;
@@ -541,13 +537,13 @@ AudioDiskstream::check_record_status (jack_nframes_t transport_frame, jack_nfram
 }
 
 int
-AudioDiskstream::process (jack_nframes_t transport_frame, jack_nframes_t nframes, jack_nframes_t offset, bool can_record, bool rec_monitors_input)
+AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, nframes_t offset, bool can_record, bool rec_monitors_input)
 {
 	uint32_t n;
 	ChannelList::iterator c;
 	int ret = -1;
-	jack_nframes_t rec_offset = 0;
-	jack_nframes_t rec_nframes = 0;
+	nframes_t rec_offset = 0;
+	nframes_t rec_nframes = 0;
 	bool nominally_recording;
 	bool re = record_enabled ();
 	bool collect_playback = false;
@@ -666,7 +662,7 @@ AudioDiskstream::process (jack_nframes_t transport_frame, jack_nframes_t nframes
 
 			} else {
 
-				jack_nframes_t total = chan.capture_vector.len[0] + chan.capture_vector.len[1];
+				nframes_t total = chan.capture_vector.len[0] + chan.capture_vector.len[1];
 
 				if (rec_nframes > total) {
 					DiskOverrun ();
@@ -674,7 +670,7 @@ AudioDiskstream::process (jack_nframes_t transport_frame, jack_nframes_t nframes
 				}
 
 				Sample* buf = _io->input (n)->get_buffer (nframes) + offset;
-				jack_nframes_t first = chan.capture_vector.len[0];
+				nframes_t first = chan.capture_vector.len[0];
 
 				memcpy (chan.capture_wrap_buffer, buf, sizeof (Sample) * first);
 				memcpy (chan.capture_vector.buf[0], buf, sizeof (Sample) * first);
@@ -737,12 +733,12 @@ AudioDiskstream::process (jack_nframes_t transport_frame, jack_nframes_t nframes
 
 		/* we're doing playback */
 
-		jack_nframes_t necessary_samples;
+		nframes_t necessary_samples;
 
 		/* no varispeed playback if we're recording, because the output .... TBD */
 
 		if (rec_nframes == 0 && _actual_speed != 1.0f) {
-			necessary_samples = (jack_nframes_t) floor ((nframes * fabs (_actual_speed))) + 1;
+			necessary_samples = (nframes_t) floor ((nframes * fabs (_actual_speed))) + 1;
 		} else {
 			necessary_samples = nframes;
 		}
@@ -762,7 +758,7 @@ AudioDiskstream::process (jack_nframes_t transport_frame, jack_nframes_t nframes
 				chan.current_playback_buffer = chan.playback_vector.buf[0];
 
 			} else {
-				jack_nframes_t total = chan.playback_vector.len[0] + chan.playback_vector.len[1];
+				nframes_t total = chan.playback_vector.len[0] + chan.playback_vector.len[1];
 				
 				if (necessary_samples > total) {
 					DiskUnderrun ();
@@ -783,7 +779,7 @@ AudioDiskstream::process (jack_nframes_t transport_frame, jack_nframes_t nframes
 		if (rec_nframes == 0 && _actual_speed != 1.0f && _actual_speed != -1.0f) {
 			
 			uint64_t phase = last_phase;
-			jack_nframes_t i = 0;
+			nframes_t i = 0;
 
 			// Linearly interpolate into the alt buffer
 			// using 40.24 fixp maths (swh)
@@ -796,7 +792,7 @@ AudioDiskstream::process (jack_nframes_t transport_frame, jack_nframes_t nframes
 				i = 0;
 				phase = last_phase;
 
-				for (jack_nframes_t outsample = 0; outsample < nframes; ++outsample) {
+				for (nframes_t outsample = 0; outsample < nframes; ++outsample) {
 					i = phase >> 24;
 					fr = (phase & 0xFFFFFF) / 16777216.0f;
 					chan.speed_buffer[outsample] = 
@@ -835,7 +831,7 @@ AudioDiskstream::process (jack_nframes_t transport_frame, jack_nframes_t nframes
 }
 
 bool
-AudioDiskstream::commit (jack_nframes_t nframes)
+AudioDiskstream::commit (nframes_t nframes)
 {
 	bool need_butler = false;
 
@@ -895,7 +891,7 @@ AudioDiskstream::overwrite_existing_buffers ()
 	overwrite_queued = false;
 
 	/* assume all are the same size */
-	jack_nframes_t size = channels[0].playback_buf->bufsize();
+	nframes_t size = channels[0].playback_buf->bufsize();
 	
  	mixdown_buffer = new Sample[size];
  	gain_buffer = new float[size];
@@ -904,12 +900,12 @@ AudioDiskstream::overwrite_existing_buffers ()
 	size--;
 	
 	uint32_t n=0;
-	jack_nframes_t start;
+	nframes_t start;
 
 	for (ChannelList::iterator chan = channels.begin(); chan != channels.end(); ++chan, ++n) {
 
 		start = overwrite_frame;
-		jack_nframes_t cnt = size;
+		nframes_t cnt = size;
 		
 		/* to fill the buffer without resetting the playback sample, we need to
 		   do it one or two chunks (normally two).
@@ -922,7 +918,7 @@ AudioDiskstream::overwrite_existing_buffers ()
 		   
 		*/
 		
-		jack_nframes_t to_read = size - overwrite_offset;
+		nframes_t to_read = size - overwrite_offset;
 
 		if (read ((*chan).playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, start, to_read, *chan, n, reversed)) {
 			error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
@@ -953,7 +949,7 @@ AudioDiskstream::overwrite_existing_buffers ()
 }
 
 int
-AudioDiskstream::seek (jack_nframes_t frame, bool complete_refill)
+AudioDiskstream::seek (nframes_t frame, bool complete_refill)
 {
 	Glib::Mutex::Lock lm (state_lock);
 	uint32_t n;
@@ -984,7 +980,7 @@ AudioDiskstream::seek (jack_nframes_t frame, bool complete_refill)
 }
 
 int
-AudioDiskstream::can_internal_playback_seek (jack_nframes_t distance)
+AudioDiskstream::can_internal_playback_seek (nframes_t distance)
 {
 	ChannelList::iterator chan;
 
@@ -997,7 +993,7 @@ AudioDiskstream::can_internal_playback_seek (jack_nframes_t distance)
 }
 
 int
-AudioDiskstream::internal_playback_seek (jack_nframes_t distance)
+AudioDiskstream::internal_playback_seek (nframes_t distance)
 {
 	ChannelList::iterator chan;
 
@@ -1012,15 +1008,15 @@ AudioDiskstream::internal_playback_seek (jack_nframes_t distance)
 }
 
 int
-AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, jack_nframes_t& start, jack_nframes_t cnt, 
+AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, nframes_t& start, nframes_t cnt, 
 		  ChannelInfo& channel_info, int channel, bool reversed)
 {
-	jack_nframes_t this_read = 0;
+	nframes_t this_read = 0;
 	bool reloop = false;
-	jack_nframes_t loop_end = 0;
-	jack_nframes_t loop_start = 0;
-	jack_nframes_t loop_length = 0;
-	jack_nframes_t offset = 0;
+	nframes_t loop_end = 0;
+	nframes_t loop_start = 0;
+	nframes_t loop_length = 0;
+	nframes_t offset = 0;
 	Location *loc = 0;
 
 	if (!reversed) {
@@ -1120,14 +1116,14 @@ int
 AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
 {
 	int32_t ret = 0;
-	jack_nframes_t to_read;
+	nframes_t to_read;
 	RingBufferNPT<Sample>::rw_vector vector;
 	bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
-	jack_nframes_t total_space;
-	jack_nframes_t zero_fill;
+	nframes_t total_space;
+	nframes_t zero_fill;
 	uint32_t chan_n;
 	ChannelList::iterator i;
-	jack_nframes_t ts;
+	nframes_t ts;
 
 	assert(mixdown_buffer);
 	assert(gain_buffer);
@@ -1239,14 +1235,14 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
 		}
 	}
 	
-	jack_nframes_t file_frame_tmp = 0;
+	nframes_t file_frame_tmp = 0;
 
 	for (chan_n = 0, i = channels.begin(); i != channels.end(); ++i, ++chan_n) {
 
 		ChannelInfo& chan (*i);
 		Sample* buf1;
 		Sample* buf2;
-		jack_nframes_t len1, len2;
+		nframes_t len1, len2;
 
 		chan.playback_buf->get_write_vector (&vector);
 
@@ -1327,7 +1323,7 @@ AudioDiskstream::do_flush (Session::RunContext context, bool force_flush)
 	int32_t ret = 0;
 	RingBufferNPT<Sample>::rw_vector vector;
 	RingBufferNPT<CaptureTransition>::rw_vector transvec;
-	jack_nframes_t total;
+	nframes_t total;
 
 	_write_data_count = 0;
 
@@ -1357,7 +1353,7 @@ AudioDiskstream::do_flush (Session::RunContext context, bool force_flush)
 			ret = 1;
 		} 
 
-		to_write = min (disk_io_chunk_frames, (jack_nframes_t) vector.len[0]);
+		to_write = min (disk_io_chunk_frames, (nframes_t) vector.len[0]);
 		
 		// check the transition buffer when recording destructive
 		// important that we get this after the capture buf
@@ -1427,7 +1423,7 @@ AudioDiskstream::do_flush (Session::RunContext context, bool force_flush)
 			   of vector.len[1] to be flushed to disk as well.
 			*/
 		
-			to_write = min ((jack_nframes_t)(disk_io_chunk_frames - to_write), (jack_nframes_t) vector.len[1]);
+			to_write = min ((nframes_t)(disk_io_chunk_frames - to_write), (nframes_t) vector.len[1]);
 		
 			if ((*chan).write_source->write (vector.buf[1], to_write) != to_write) {
 				error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
@@ -1452,7 +1448,7 @@ AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_ca
 	bool more_work = true;
 	int err = 0;
 	boost::shared_ptr<AudioRegion> region;
-	jack_nframes_t total_capture;
+	nframes_t total_capture;
 	SourceList srcs;
 	SourceList::iterator src;
 	ChannelList::iterator chan;
@@ -2025,7 +2021,7 @@ AudioDiskstream::rename_write_sources ()
 }
 
 void
-AudioDiskstream::set_block_size (jack_nframes_t nframes)
+AudioDiskstream::set_block_size (nframes_t nframes)
 {
 	if (_session.get_block_size() > speed_buffer_size) {
 		speed_buffer_size = _session.get_block_size();
@@ -2047,7 +2043,7 @@ AudioDiskstream::allocate_temporary_buffers ()
 	*/
 
 	double sp = max (fabsf (_actual_speed), 1.2f);
-	jack_nframes_t required_wrap_size = (jack_nframes_t) floor (_session.get_block_size() * sp) + 1;
+	nframes_t required_wrap_size = (nframes_t) floor (_session.get_block_size() * sp) + 1;
 
 	if (required_wrap_size > wrap_buffer_size) {
 
@@ -2157,7 +2153,7 @@ AudioDiskstream::use_pending_capture_data (XMLNode& node)
 	boost::shared_ptr<AudioFileSource> fs;
 	boost::shared_ptr<AudioFileSource> first_fs;
 	SourceList pending_sources;
-	jack_nframes_t position;
+	nframes_t position;
 
 	if ((prop = node.property (X_("at"))) == 0) {
 		return -1;