globally change all use of "frame" to refer to audio into "sample".

Generated by tools/f2s. Some hand-editing will be required in a few places to fix up comments related to timecode
and video in order to keep the legible

1 files changed, 371 insertions, 371 deletions

diff --git a/gtk2_ardour/editor_drag.cc b/gtk2_ardour/editor_drag.cc
index 9b5838aaad..aad1778972 100644
--- a/gtk2_ardour/editor_drag.cc
+++ b/gtk2_ardour/editor_drag.cc
@@ -86,7 +86,7 @@ DragManager::DragManager (Editor* e)
 	, _ending (false)
 	, _current_pointer_x (0.0)
 	, _current_pointer_y (0.0)
-	, _current_pointer_frame (0)
+	, _current_pointer_sample (0)
 	, _old_follow_playhead (false)
 {
 }
@@ -139,7 +139,7 @@ DragManager::start_grab (GdkEvent* e, Gdk::Cursor* c)
 	_old_follow_playhead = _editor->follow_playhead ();
 	_editor->set_follow_playhead (false);
 
-	_current_pointer_frame = _editor->canvas_event_sample (e, &_current_pointer_x, &_current_pointer_y);
+	_current_pointer_sample = _editor->canvas_event_sample (e, &_current_pointer_x, &_current_pointer_y);
 
 	for (list<Drag*>::const_iterator i = _drags.begin(); i != _drags.end(); ++i) {
 		(*i)->start_grab (e, c);
@@ -191,7 +191,7 @@ DragManager::motion_handler (GdkEvent* e, bool from_autoscroll)
 	 * Can we guarantee that this is true?
 	 */
 
-	_current_pointer_frame = _editor->canvas_event_sample (e, &_current_pointer_x, &_current_pointer_y);
+	_current_pointer_sample = _editor->canvas_event_sample (e, &_current_pointer_x, &_current_pointer_y);
 
 	for (list<Drag*>::iterator i = _drags.begin(); i != _drags.end(); ++i) {
 		bool const t = (*i)->motion_handler (e, from_autoscroll);
@@ -222,7 +222,7 @@ Drag::Drag (Editor* e, ArdourCanvas::Item* i, bool trackview_only)
 	: _editor (e)
 	, _drags (0)
 	, _item (i)
-	, _pointer_frame_offset (0)
+	, _pointer_sample_offset (0)
 	, _x_constrained (false)
 	, _y_constrained (false)
 	, _was_rolling (false)
@@ -235,9 +235,9 @@ Drag::Drag (Editor* e, ArdourCanvas::Item* i, bool trackview_only)
 	, _grab_y (0.0)
 	, _last_pointer_x (0.0)
 	, _last_pointer_y (0.0)
-	, _raw_grab_frame (0)
-	, _grab_frame (0)
-	, _last_pointer_frame (0)
+	, _raw_grab_sample (0)
+	, _grab_sample (0)
+	, _last_pointer_sample (0)
 	, _snap_delta (0)
 	, _snap_delta_music (0.0)
 	, _constraint_pressed (false)
@@ -267,11 +267,11 @@ Drag::start_grab (GdkEvent* event, Gdk::Cursor *cursor)
 	/* we set up x/y dragging constraints on first move */
 	_constraint_pressed = ArdourKeyboard::indicates_constraint (event->button.state);
 
-	_raw_grab_frame = _editor->canvas_event_sample (event, &_grab_x, &_grab_y);
+	_raw_grab_sample = _editor->canvas_event_sample (event, &_grab_x, &_grab_y);
 
-	setup_pointer_frame_offset ();
-	_grab_frame = adjusted_frame (_raw_grab_frame, event).frame;
-	_last_pointer_frame = _grab_frame;
+	setup_pointer_sample_offset ();
+	_grab_sample = adjusted_sample (_raw_grab_sample, event).sample;
+	_last_pointer_sample = _grab_sample;
 	_last_pointer_x = _grab_x;
 
 	if (_trackview_only) {
@@ -326,13 +326,13 @@ Drag::end_grab (GdkEvent* event)
 	return _move_threshold_passed;
 }
 
-MusicFrame
-Drag::adjusted_frame (framepos_t f, GdkEvent const * event, bool snap) const
+MusicSample
+Drag::adjusted_sample (samplepos_t f, GdkEvent const * event, bool snap) const
 {
-	MusicFrame pos (0, 0);
+	MusicSample pos (0, 0);
 
-	if (f > _pointer_frame_offset) {
-		pos.frame = f - _pointer_frame_offset;
+	if (f > _pointer_sample_offset) {
+		pos.sample = f - _pointer_sample_offset;
 	}
 
 	if (snap) {
@@ -342,13 +342,13 @@ Drag::adjusted_frame (framepos_t f, GdkEvent const * event, bool snap) const
 	return pos;
 }
 
-framepos_t
-Drag::adjusted_current_frame (GdkEvent const * event, bool snap) const
+samplepos_t
+Drag::adjusted_current_sample (GdkEvent const * event, bool snap) const
 {
-	return adjusted_frame (_drags->current_pointer_frame (), event, snap).frame;
+	return adjusted_sample (_drags->current_pointer_sample (), event, snap).sample;
 }
 
-frameoffset_t
+sampleoffset_t
 Drag::snap_delta (guint state) const
 {
 	if (ArdourKeyboard::indicates_snap_delta (state)) {
@@ -384,17 +384,17 @@ Drag::current_pointer_y () const
 }
 
 void
-Drag::setup_snap_delta (MusicFrame pos)
+Drag::setup_snap_delta (MusicSample pos)
 {
 	TempoMap& map (_editor->session()->tempo_map());
-	MusicFrame snap (pos);
+	MusicSample snap (pos);
 	_editor->snap_to (snap, ARDOUR::RoundNearest, false, true);
-	_snap_delta = snap.frame - pos.frame;
+	_snap_delta = snap.sample - pos.sample;
 
 	_snap_delta_music = 0.0;
 
 	if (_snap_delta != 0) {
-		_snap_delta_music = map.exact_qn_at_frame (snap.frame, snap.division) - map.exact_qn_at_frame (pos.frame, pos.division);
+		_snap_delta_music = map.exact_qn_at_sample (snap.sample, snap.division) - map.exact_qn_at_sample (pos.sample, pos.division);
 	}
 }
 
@@ -408,13 +408,13 @@ Drag::motion_handler (GdkEvent* event, bool from_autoscroll)
 		return false;
 	}
 
-	pair<framecnt_t, int> const threshold = move_threshold ();
+	pair<samplecnt_t, int> const threshold = move_threshold ();
 
 	bool const old_move_threshold_passed = _move_threshold_passed;
 
 	if (!_move_threshold_passed) {
 
-		bool const xp = (::llabs (_drags->current_pointer_frame () - _raw_grab_frame) >= threshold.first);
+		bool const xp = (::llabs (_drags->current_pointer_sample () - _raw_grab_sample) >= threshold.first);
 		bool const yp = (::fabs ((current_pointer_y () - _grab_y)) >= threshold.second);
 
 		_move_threshold_passed = ((xp && x_movement_matters()) || (yp && y_movement_matters()));
@@ -485,7 +485,7 @@ Drag::motion_handler (GdkEvent* event, bool from_autoscroll)
 
 				_last_pointer_x = _drags->current_pointer_x ();
 				_last_pointer_y = current_pointer_y ();
-				_last_pointer_frame = adjusted_current_frame (event, false);
+				_last_pointer_sample = adjusted_current_sample (event, false);
 			}
 
 			return true;
@@ -510,14 +510,14 @@ Drag::abort ()
 }
 
 void
-Drag::show_verbose_cursor_time (framepos_t frame)
+Drag::show_verbose_cursor_time (samplepos_t sample)
 {
-	_editor->verbose_cursor()->set_time (frame);
+	_editor->verbose_cursor()->set_time (sample);
 	_editor->verbose_cursor()->show ();
 }
 
 void
-Drag::show_verbose_cursor_duration (framepos_t start, framepos_t end, double /*xoffset*/)
+Drag::show_verbose_cursor_duration (samplepos_t start, samplepos_t end, double /*xoffset*/)
 {
 	_editor->verbose_cursor()->set_duration (start, end);
 	_editor->verbose_cursor()->show ();
@@ -535,12 +535,12 @@ Drag::add_midi_region (MidiTimeAxisView* view, bool commit)
 {
 	if (_editor->session()) {
 		const TempoMap& map (_editor->session()->tempo_map());
-		framecnt_t pos = grab_frame();
+		samplecnt_t pos = grab_sample();
 		/* not that the frame rate used here can be affected by pull up/down which
 		   might be wrong.
 		*/
-		framecnt_t len = map.frame_at_beat (max (0.0, map.beat_at_frame (pos)) + 1.0) - pos;
-		return view->add_region (grab_frame(), len, commit);
+		samplecnt_t len = map.sample_at_beat (max (0.0, map.beat_at_sample (pos)) + 1.0) - pos;
+		return view->add_region (grab_sample(), len, commit);
 	}
 
 	return boost::shared_ptr<Region>();
@@ -640,7 +640,7 @@ RegionMotionDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 	Drag::start_grab (event, cursor);
 	setup_snap_delta (_last_position);
 
-	show_verbose_cursor_time (_last_position.frame);
+	show_verbose_cursor_time (_last_position.sample);
 
 	pair<TimeAxisView*, double> const tv = _editor->trackview_by_y_position (current_pointer_y ());
 	if (tv.first) {
@@ -660,9 +660,9 @@ RegionMotionDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 }
 
 double
-RegionMotionDrag::compute_x_delta (GdkEvent const * event, MusicFrame* pending_region_position)
+RegionMotionDrag::compute_x_delta (GdkEvent const * event, MusicSample* pending_region_position)
 {
-	/* compute the amount of pointer motion in frames, and where
+	/* compute the amount of pointer motion in samples, and where
 	   the region would be if we moved it by that much.
 	*/
 	if (_x_constrained) {
@@ -670,30 +670,30 @@ RegionMotionDrag::compute_x_delta (GdkEvent const * event, MusicFrame* pending_r
 		return 0.0;
 	}
 
-	*pending_region_position = adjusted_frame (_drags->current_pointer_frame (), event, false);
+	*pending_region_position = adjusted_sample (_drags->current_pointer_sample (), event, false);
 
-	framecnt_t sync_offset;
+	samplecnt_t sync_offset;
 	int32_t sync_dir;
 
 	sync_offset = _primary->region()->sync_offset (sync_dir);
 
 	/* we don't handle a sync point that lies before zero.
 	 */
-	if (sync_dir >= 0 || (sync_dir < 0 && pending_region_position->frame >= sync_offset)) {
+	if (sync_dir >= 0 || (sync_dir < 0 && pending_region_position->sample >= sync_offset)) {
 
-		framecnt_t const sd = snap_delta (event->button.state);
-		MusicFrame sync_snap (pending_region_position->frame + (sync_dir * sync_offset) + sd, 0);
+		samplecnt_t const sd = snap_delta (event->button.state);
+		MusicSample sync_snap (pending_region_position->sample + (sync_dir * sync_offset) + sd, 0);
 		_editor->snap_to_with_modifier (sync_snap, event);
 		if (sync_offset == 0 && sd == 0) {
 			*pending_region_position = sync_snap;
 		} else {
-			pending_region_position->set (_primary->region()->adjust_to_sync (sync_snap.frame) - sd, 0);
+			pending_region_position->set (_primary->region()->adjust_to_sync (sync_snap.sample) - sd, 0);
 		}
 	} else {
 		*pending_region_position = _last_position;
 	}
 
-	if (pending_region_position->frame > max_framepos - _primary->region()->length()) {
+	if (pending_region_position->sample > max_samplepos - _primary->region()->length()) {
 		*pending_region_position = _last_position;
 	}
 
@@ -701,19 +701,19 @@ RegionMotionDrag::compute_x_delta (GdkEvent const * event, MusicFrame* pending_r
 
 	bool const x_move_allowed = !_x_constrained;
 
-	if ((pending_region_position->frame != _last_position.frame) && x_move_allowed) {
+	if ((pending_region_position->sample != _last_position.sample) && x_move_allowed) {
 
 		/* x movement since last time (in pixels) */
-		dx = _editor->sample_to_pixel_unrounded (pending_region_position->frame - _last_position.frame);
+		dx = _editor->sample_to_pixel_unrounded (pending_region_position->sample - _last_position.sample);
 
 		/* total x movement */
-		framecnt_t total_dx = _editor->pixel_to_sample (_total_x_delta + dx);
+		samplecnt_t total_dx = _editor->pixel_to_sample (_total_x_delta + dx);
 
 		for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
-			frameoffset_t const off = i->view->region()->position() + total_dx;
+			sampleoffset_t const off = i->view->region()->position() + total_dx;
 			if (off < 0) {
 				dx = dx - _editor->sample_to_pixel_unrounded (off);
-				*pending_region_position = MusicFrame (pending_region_position->frame - off, 0);
+				*pending_region_position = MusicSample (pending_region_position->sample - off, 0);
 				break;
 			}
 		}
@@ -954,11 +954,11 @@ RegionMotionDrag::motion (GdkEvent* event, bool first_move)
 
 	/* Work out the change in x */
 	TempoMap& tmap = _editor->session()->tempo_map();
-	MusicFrame pending_region_position (0, 0);
+	MusicSample pending_region_position (0, 0);
 	double const x_delta = compute_x_delta (event, &pending_region_position);
 
-	double const last_pos_qn = tmap.exact_qn_at_frame (_last_position.frame, _last_position.division);
-	double const qn_delta = tmap.exact_qn_at_frame (pending_region_position.frame, pending_region_position.division) - last_pos_qn;
+	double const last_pos_qn = tmap.exact_qn_at_sample (_last_position.sample, _last_position.division);
+	double const qn_delta = tmap.exact_qn_at_sample (pending_region_position.sample, pending_region_position.division) - last_pos_qn;
 
 	_last_position = pending_region_position;
 
@@ -1163,7 +1163,7 @@ RegionMotionDrag::motion (GdkEvent* event, bool first_move)
 			i->layer += this_delta_layer;
 
 			if (_brushing) {
-				_editor->mouse_brush_insert_region (rv, pending_region_position.frame);
+				_editor->mouse_brush_insert_region (rv, pending_region_position.sample);
 			} else {
 				Duple track_origin;
 
@@ -1204,8 +1204,8 @@ RegionMotionDrag::motion (GdkEvent* event, bool first_move)
 
 		/* Now move the region view */
 		if (rv->region()->position_lock_style() == MusicTime) {
-			double const last_qn = tmap.quarter_note_at_frame (rv->get_position());
-			framepos_t const x_pos_music = tmap.frame_at_quarter_note (last_qn + qn_delta);
+			double const last_qn = tmap.quarter_note_at_sample (rv->get_position());
+			samplepos_t const x_pos_music = tmap.sample_at_quarter_note (last_qn + qn_delta);
 
 			rv->set_position (x_pos_music, 0);
 			rv->move (0, y_delta);
@@ -1218,7 +1218,7 @@ RegionMotionDrag::motion (GdkEvent* event, bool first_move)
 	_total_x_delta += x_delta;
 
 	if (x_delta != 0 && !_brushing) {
-		show_verbose_cursor_time (_last_position.frame);
+		show_verbose_cursor_time (_last_position.sample);
 	}
 
 	/* keep track of pointer movement */
@@ -1406,7 +1406,7 @@ RegionMoveDrag::finished (GdkEvent* ev, bool movement_occurred)
 		i->view->get_canvas_group()->show ();
 	}
 
-	bool const changed_position = (_last_position.frame != _primary->region()->position());
+	bool const changed_position = (_last_position.sample != _primary->region()->position());
 	bool const changed_tracks = (_time_axis_views[_views.front().time_axis_view] != &_views.front().view->get_time_axis_view());
 
 	if (_copy) {
@@ -1468,15 +1468,15 @@ RegionMoveDrag::create_destination_time_axis (boost::shared_ptr<Region> region,
 }
 
 void
-RegionMoveDrag::finished_copy (bool const changed_position, bool const /*changed_tracks*/, MusicFrame last_position, int32_t const ev_state)
+RegionMoveDrag::finished_copy (bool const changed_position, bool const /*changed_tracks*/, MusicSample last_position, int32_t const ev_state)
 {
 	RegionSelection new_views;
 	PlaylistSet modified_playlists;
 	RouteTimeAxisView* new_time_axis_view = 0;
-	framecnt_t const drag_delta = _primary->region()->position() - _last_position.frame;
+	samplecnt_t const drag_delta = _primary->region()->position() - _last_position.sample;
 
 	TempoMap& tmap (_editor->session()->tempo_map());
-	const double last_pos_qn = tmap.exact_qn_at_frame (last_position.frame, last_position.division);
+	const double last_pos_qn = tmap.exact_qn_at_sample (last_position.sample, last_position.division);
 	const double qn_delta = _primary->region()->quarter_note() - last_pos_qn;
 
 	if (_brushing) {
@@ -1502,7 +1502,7 @@ RegionMoveDrag::finished_copy (bool const changed_position, bool const /*changed
 			continue;
 		}
 
-		MusicFrame where (0, 0);
+		MusicSample where (0, 0);
 		double quarter_note;
 
 		if (changed_position && !_x_constrained) {
@@ -1585,7 +1585,7 @@ void
 RegionMoveDrag::finished_no_copy (
 	bool const changed_position,
 	bool const changed_tracks,
-	MusicFrame last_position,
+	MusicSample last_position,
 	int32_t const ev_state
 	)
 {
@@ -1594,13 +1594,13 @@ RegionMoveDrag::finished_no_copy (
 	PlaylistSet frozen_playlists;
 	set<RouteTimeAxisView*> views_to_update;
 	RouteTimeAxisView* new_time_axis_view = 0;
-	framecnt_t const drag_delta = _primary->region()->position() - last_position.frame;
+	samplecnt_t const drag_delta = _primary->region()->position() - last_position.sample;
 
 	typedef map<boost::shared_ptr<Playlist>, RouteTimeAxisView*> PlaylistMapping;
 	PlaylistMapping playlist_mapping;
 
 	TempoMap& tmap (_editor->session()->tempo_map());
-	const double last_pos_qn = tmap.exact_qn_at_frame (last_position.frame, last_position.division);
+	const double last_pos_qn = tmap.exact_qn_at_sample (last_position.sample, last_position.division);
 	const double qn_delta = _primary->region()->quarter_note() - last_pos_qn;
 
 	std::set<boost::shared_ptr<const Region> > uniq;
@@ -1651,7 +1651,7 @@ RegionMoveDrag::finished_no_copy (
 
 		views_to_update.insert (dest_rtv);
 
-		MusicFrame where (0, 0);
+		MusicSample where (0, 0);
 		double quarter_note;
 
 		if (changed_position && !_x_constrained) {
@@ -1743,11 +1743,11 @@ RegionMoveDrag::finished_no_copy (
 				playlist->freeze ();
 			}
 			if (rv == _primary) {
-				rv->region()->set_position (where.frame, last_position.division);
+				rv->region()->set_position (where.sample, last_position.division);
 			} else {
 				if (rv->region()->position_lock_style() == AudioTime) {
-					/* move by frame offset */
-					rv->region()->set_position (where.frame, 0);
+					/* move by sample offset */
+					rv->region()->set_position (where.sample, 0);
 				} else {
 					/* move by music offset */
 					rv->region()->set_position_music (rv->region()->quarter_note() - qn_delta);
@@ -1854,7 +1854,7 @@ RegionMoveDrag::insert_region_into_playlist (
 	boost::shared_ptr<Region> region,
 	RouteTimeAxisView*        dest_rtv,
 	layer_t                   dest_layer,
-	MusicFrame                where,
+	MusicSample                where,
 	double                    quarter_note,
 	PlaylistSet&              modified_playlists,
 	bool                      for_music
@@ -1875,9 +1875,9 @@ RegionMoveDrag::insert_region_into_playlist (
 		dest_playlist->clear_changes ();
 	}
 	if (for_music) {
-		dest_playlist->add_region (region, where.frame, 1.0, false, where.division, quarter_note, true);
+		dest_playlist->add_region (region, where.sample, 1.0, false, where.division, quarter_note, true);
 	} else {
-		dest_playlist->add_region (region, where.frame, 1.0, false, where.division);
+		dest_playlist->add_region (region, where.sample, 1.0, false, where.division);
 	}
 
 	if (dest_rtv->view()->layer_display() == Stacked || dest_rtv->view()->layer_display() == Expanded) {
@@ -1967,16 +1967,16 @@ RegionMoveDrag::RegionMoveDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p,
 {
 	DEBUG_TRACE (DEBUG::Drags, "New RegionMoveDrag\n");
 
-	_last_position = MusicFrame (_primary->region()->position(), 0);
+	_last_position = MusicSample (_primary->region()->position(), 0);
 }
 
 void
-RegionMoveDrag::setup_pointer_frame_offset ()
+RegionMoveDrag::setup_pointer_sample_offset ()
 {
-	_pointer_frame_offset = raw_grab_frame() - _last_position.frame;
+	_pointer_sample_offset = raw_grab_sample() - _last_position.sample;
 }
 
-RegionInsertDrag::RegionInsertDrag (Editor* e, boost::shared_ptr<Region> r, RouteTimeAxisView* v, framepos_t pos)
+RegionInsertDrag::RegionInsertDrag (Editor* e, boost::shared_ptr<Region> r, RouteTimeAxisView* v, samplepos_t pos)
 	: RegionMotionDrag (e, 0, 0, list<RegionView*> (), false)
 {
 	DEBUG_TRACE (DEBUG::Drags, "New RegionInsertDrag\n");
@@ -1990,7 +1990,7 @@ RegionInsertDrag::RegionInsertDrag (Editor* e, boost::shared_ptr<Region> r, Rout
 	_primary->set_position (pos, 0);
 	_views.push_back (DraggingView (_primary, this, v));
 
-	_last_position = MusicFrame (pos, 0);
+	_last_position = MusicSample (pos, 0);
 
 	_item = _primary->get_canvas_group ();
 }
@@ -2012,11 +2012,11 @@ RegionInsertDrag::finished (GdkEvent * event, bool)
 	playlist->clear_changes ();
 	_editor->snap_to_with_modifier (_last_position, event);
 
-	playlist->add_region (_primary->region (), _last_position.frame, 1.0, false, _last_position.division);
+	playlist->add_region (_primary->region (), _last_position.sample, 1.0, false, _last_position.division);
 
 	// Mixbus doesn't seem to ripple when inserting regions from the list: should we? yes, probably
 	if (Config->get_edit_mode() == Ripple) {
-		playlist->ripple (_last_position.frame, _primary->region()->length(), _primary->region());
+		playlist->ripple (_last_position.sample, _primary->region()->length(), _primary->region());
 	}
 
 	_editor->session()->add_command (new StatefulDiffCommand (playlist));
@@ -2080,7 +2080,7 @@ RegionSpliceDrag::motion (GdkEvent* event, bool)
 	RegionSelection copy;
 	_editor->selection->regions.by_position(copy);
 
-	framepos_t const pf = adjusted_current_frame (event);
+	samplepos_t const pf = adjusted_current_sample (event);
 
 	for (RegionSelection::iterator i = copy.begin(); i != copy.end(); ++i) {
 
@@ -2101,11 +2101,11 @@ RegionSpliceDrag::motion (GdkEvent* event, bool)
 		}
 
 		if (dir > 0) {
-			if (pf < (*i)->region()->last_frame() + 1) {
+			if (pf < (*i)->region()->last_sample() + 1) {
 				continue;
 			}
 		} else {
-			if (pf > (*i)->region()->first_frame()) {
+			if (pf > (*i)->region()->first_sample()) {
 				continue;
 			}
 		}
@@ -2132,10 +2132,10 @@ RegionSpliceDrag::aborted (bool)
  */
 
 void
-RegionRippleDrag::add_all_after_to_views(TimeAxisView *tav, framepos_t where, const RegionSelection &exclude, bool drag_in_progress)
+RegionRippleDrag::add_all_after_to_views(TimeAxisView *tav, samplepos_t where, const RegionSelection &exclude, bool drag_in_progress)
 {
 
-	boost::shared_ptr<RegionList> rl = tav->playlist()->regions_with_start_within (Evoral::Range<framepos_t>(where, max_framepos));
+	boost::shared_ptr<RegionList> rl = tav->playlist()->regions_with_start_within (Evoral::Range<samplepos_t>(where, max_samplepos));
 
 	RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(tav);
 	RegionSelection to_ripple;
@@ -2172,7 +2172,7 @@ RegionRippleDrag::add_all_after_to_views(TimeAxisView *tav, framepos_t where, co
 }
 
 void
-RegionRippleDrag::remove_unselected_from_views(framecnt_t amount, bool move_regions)
+RegionRippleDrag::remove_unselected_from_views(samplecnt_t amount, bool move_regions)
 {
 
 	for (std::list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ) {
@@ -2227,7 +2227,7 @@ RegionRippleDrag::RegionRippleDrag (Editor* e, ArdourCanvas::Item* i, RegionView
 	DEBUG_TRACE (DEBUG::Drags, "New RegionRippleDrag\n");
 	// compute length of selection
 	RegionSelection selected_regions = _editor->selection->regions;
-	selection_length = selected_regions.end_frame() - selected_regions.start();
+	selection_length = selected_regions.end_sample() - selected_regions.start();
 
 	// we'll only allow dragging to another track in ripple mode if all the regions
 	// being dragged start off on the same track
@@ -2291,17 +2291,17 @@ RegionRippleDrag::motion (GdkEvent* event, bool first_move)
 		return;
 	}
 
-	framepos_t where = adjusted_current_frame (event);
+	samplepos_t where = adjusted_current_sample (event);
 	assert (where >= 0);
-	MusicFrame after (0, 0);
+	MusicSample after (0, 0);
 	double delta = compute_x_delta (event, &after);
 
-	framecnt_t amount = _editor->pixel_to_sample (delta);
+	samplecnt_t amount = _editor->pixel_to_sample (delta);
 
 	if (allow_moves_across_tracks) {
 		// all the originally selected regions were on the same track
 
-		framecnt_t adjust = 0;
+		samplecnt_t adjust = 0;
 		if (prev_tav && tv != prev_tav) {
 			// dragged onto a different track
 			// remove the unselected regions from _views, restore them to their original positions
@@ -2430,19 +2430,19 @@ RegionCreateDrag::motion (GdkEvent* event, bool first_move)
 	} else {
 
 		if (_region) {
-			framepos_t const f = adjusted_current_frame (event);
-			if (f <= grab_frame()) {
+			samplepos_t const f = adjusted_current_sample (event);
+			if (f <= grab_sample()) {
 				_region->set_initial_position (f);
 			}
 
-			/* Don't use a zero-length region, and subtract 1 frame from the snapped length
+			/* Don't use a zero-length region, and subtract 1 sample from the snapped length
 			   so that if this region is duplicated, its duplicate starts on
-			   a snap point rather than 1 frame after a snap point.  Otherwise things get
-			   a bit confusing as if a region starts 1 frame after a snap point, one cannot
+			   a snap point rather than 1 sample after a snap point.  Otherwise things get
+			   a bit confusing as if a region starts 1 sample after a snap point, one cannot
 			   place snapped notes at the start of the region.
 			*/
-			if (f != grab_frame()) {
-				framecnt_t const len = (framecnt_t) fabs ((double)(f - grab_frame () - 1));
+			if (f != grab_sample()) {
+				samplecnt_t const len = (samplecnt_t) fabs ((double)(f - grab_sample () - 1));
 				_region->set_length (len < 1 ? 1 : len, _editor->get_grid_music_divisions (event->button.state));
 			}
 		}
@@ -2698,7 +2698,7 @@ VideoTimeLineDrag::VideoTimeLineDrag (Editor* e, ArdourCanvas::Item* i)
 	RegionSelection rs;
 	TrackViewList empty;
 	empty.clear();
-	_editor->get_regions_after(rs, (framepos_t) 0, empty);
+	_editor->get_regions_after(rs, (samplepos_t) 0, empty);
 	std::list<RegionView*> views = rs.by_layer();
 
 	_stuck = false;
@@ -2741,7 +2741,7 @@ VideoTimeLineDrag::start_grab (GdkEvent* event, Gdk::Cursor*)
 
 	for (list<AVDraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
 		if (i->initial_position < _max_backwards_drag || _max_backwards_drag < 0) {
-			_max_backwards_drag = ARDOUR_UI::instance()->video_timeline->quantify_frames_to_apv (i->initial_position);
+			_max_backwards_drag = ARDOUR_UI::instance()->video_timeline->quantify_samples_to_apv (i->initial_position);
 		}
 	}
 	DEBUG_TRACE (DEBUG::Drags, string_compose("VideoTimeLineDrag: max backwards-drag: %1\n", _max_backwards_drag));
@@ -2767,8 +2767,8 @@ VideoTimeLineDrag::motion (GdkEvent* event, bool first_move)
 		return;
 	}
 
-	framecnt_t dt = adjusted_current_frame (event) - raw_grab_frame() + _pointer_frame_offset;
-	dt = ARDOUR_UI::instance()->video_timeline->quantify_frames_to_apv(_startdrag_video_offset+dt) - _startdrag_video_offset;
+	samplecnt_t dt = adjusted_current_sample (event) - raw_grab_sample() + _pointer_sample_offset;
+	dt = ARDOUR_UI::instance()->video_timeline->quantify_samples_to_apv(_startdrag_video_offset+dt) - _startdrag_video_offset;
 
 	if (_max_backwards_drag >= 0 && dt <= - _max_backwards_drag) {
 		dt = - _max_backwards_drag;
@@ -2789,7 +2789,7 @@ VideoTimeLineDrag::motion (GdkEvent* event, bool first_move)
 		rv->region_changed(ARDOUR::Properties::position);
 	}
 
-	const framepos_t offset = ARDOUR_UI::instance()->video_timeline->get_offset();
+	const samplepos_t offset = ARDOUR_UI::instance()->video_timeline->get_offset();
 	Timecode::Time timecode;
 	Timecode::Time timediff;
 	char buf[128];
@@ -2837,8 +2837,8 @@ VideoTimeLineDrag::finished (GdkEvent * /*event*/, bool movement_occurred)
 	}
 
 	_editor->session()->maybe_update_session_range(
-			std::max(ARDOUR_UI::instance()->video_timeline->get_offset(), (ARDOUR::frameoffset_t) 0),
-			std::max(ARDOUR_UI::instance()->video_timeline->get_offset() + ARDOUR_UI::instance()->video_timeline->get_duration(), (ARDOUR::frameoffset_t) 0)
+			std::max(ARDOUR_UI::instance()->video_timeline->get_offset(), (ARDOUR::sampleoffset_t) 0),
+			std::max(ARDOUR_UI::instance()->video_timeline->get_offset() + ARDOUR_UI::instance()->video_timeline->get_duration(), (ARDOUR::sampleoffset_t) 0)
 			);
 
 
@@ -2875,12 +2875,12 @@ TrimDrag::start_grab (GdkEvent* event, Gdk::Cursor*)
 	TimeAxisView* tvp = &_primary->get_time_axis_view ();
 	RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
 
-	framepos_t const region_start = _primary->region()->position();
-	framepos_t const region_end = _primary->region()->last_frame();
-	framecnt_t const region_length = _primary->region()->length();
+	samplepos_t const region_start = _primary->region()->position();
+	samplepos_t const region_end = _primary->region()->last_sample();
+	samplecnt_t const region_length = _primary->region()->length();
 
-	framepos_t const pf = adjusted_current_frame (event);
-	setup_snap_delta (MusicFrame(region_start, 0));
+	samplepos_t const pf = adjusted_current_sample (event);
+	setup_snap_delta (MusicSample(region_start, 0));
 
 	if (Keyboard::modifier_state_equals (event->button.state, ArdourKeyboard::trim_contents_modifier ())) {
 		/* Move the contents of the region around without changing the region bounds */
@@ -2937,10 +2937,10 @@ TrimDrag::motion (GdkEvent* event, bool first_move)
 	TimeAxisView* tvp = &_primary->get_time_axis_view ();
 	RouteTimeAxisView* tv = dynamic_cast<RouteTimeAxisView*>(tvp);
 	pair<set<boost::shared_ptr<Playlist> >::iterator,bool> insert_result;
-	frameoffset_t frame_delta = 0;
+	sampleoffset_t sample_delta = 0;
 
-	MusicFrame adj_frame = adjusted_frame (_drags->current_pointer_frame () + snap_delta (event->button.state), event, true);
-	framecnt_t dt = adj_frame.frame - raw_grab_frame () + _pointer_frame_offset - snap_delta (event->button.state);
+	MusicSample adj_sample = adjusted_sample (_drags->current_pointer_sample () + snap_delta (event->button.state), event, true);
+	samplecnt_t dt = adj_sample.sample - raw_grab_sample () + _pointer_sample_offset - snap_delta (event->button.state);
 
 	if (first_move) {
 
@@ -3020,7 +3020,7 @@ TrimDrag::motion (GdkEvent* event, bool first_move)
 					if (!arv) continue;
 					boost::shared_ptr<AudioRegion> ar (arv->audio_region());
 					if (ar->locked()) continue;
-					framecnt_t len = ar->fade_in()->back()->when;
+					samplecnt_t len = ar->fade_in()->back()->when;
 					if (len < dt) dt = min(dt, len);
 				}
 				break;
@@ -3030,7 +3030,7 @@ TrimDrag::motion (GdkEvent* event, bool first_move)
 					if (!arv) continue;
 					boost::shared_ptr<AudioRegion> ar (arv->audio_region());
 					if (ar->locked()) continue;
-					framecnt_t len = ar->fade_out()->back()->when;
+					samplecnt_t len = ar->fade_out()->back()->when;
 					if (len < -dt) dt = max(dt, -len);
 				}
 				break;
@@ -3043,15 +3043,15 @@ TrimDrag::motion (GdkEvent* event, bool first_move)
 	case StartTrim:
 		for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
 			bool changed = i->view->trim_front (i->initial_position + dt, non_overlap_trim
-							    , adj_frame.division);
+							    , adj_sample.division);
 
 			if (changed && _preserve_fade_anchor) {
 				AudioRegionView* arv = dynamic_cast<AudioRegionView*> (i->view);
 				if (arv) {
 					boost::shared_ptr<AudioRegion> ar (arv->audio_region());
-					framecnt_t len = ar->fade_in()->back()->when;
-					framecnt_t diff = ar->first_frame() - i->initial_position;
-					framepos_t new_length = len - diff;
+					samplecnt_t len = ar->fade_in()->back()->when;
+					samplecnt_t diff = ar->first_sample() - i->initial_position;
+					samplepos_t new_length = len - diff;
 					i->anchored_fade_length = min (ar->length(), new_length);
 					//i->anchored_fade_length = ar->verify_xfade_bounds (new_length, true  /*START*/ );
 					arv->reset_fade_in_shape_width (ar, i->anchored_fade_length, true);
@@ -3062,14 +3062,14 @@ TrimDrag::motion (GdkEvent* event, bool first_move)
 
 	case EndTrim:
 		for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
-			bool changed = i->view->trim_end (i->initial_end + dt, non_overlap_trim, adj_frame.division);
+			bool changed = i->view->trim_end (i->initial_end + dt, non_overlap_trim, adj_sample.division);
 			if (changed && _preserve_fade_anchor) {
 				AudioRegionView* arv = dynamic_cast<AudioRegionView*> (i->view);
 				if (arv) {
 					boost::shared_ptr<AudioRegion> ar (arv->audio_region());
-					framecnt_t len = ar->fade_out()->back()->when;
-					framecnt_t diff = 1 + ar->last_frame() - i->initial_end;
-					framepos_t new_length = len + diff;
+					samplecnt_t len = ar->fade_out()->back()->when;
+					samplecnt_t diff = 1 + ar->last_sample() - i->initial_end;
+					samplepos_t new_length = len + diff;
 					i->anchored_fade_length = min (ar->length(), new_length);
 					//i->anchored_fade_length = ar->verify_xfade_bounds (new_length, false  /*END*/ );
 					arv->reset_fade_out_shape_width (ar, i->anchored_fade_length, true);
@@ -3080,10 +3080,10 @@ TrimDrag::motion (GdkEvent* event, bool first_move)
 
 	case ContentsTrim:
 		{
-			frame_delta = (last_pointer_frame() - adjusted_current_frame(event));
+			sample_delta = (last_pointer_sample() - adjusted_current_sample(event));
 
 			for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
-				i->view->move_contents (frame_delta);
+				i->view->move_contents (sample_delta);
 			}
 		}
 		break;
@@ -3094,10 +3094,10 @@ TrimDrag::motion (GdkEvent* event, bool first_move)
 		show_verbose_cursor_time (rv->region()->position());
 		break;
 	case EndTrim:
-		show_verbose_cursor_duration (rv->region()->position(), rv->region()->last_frame());
+		show_verbose_cursor_duration (rv->region()->position(), rv->region()->last_sample());
 		break;
 	case ContentsTrim:
-		// show_verbose_cursor_time (frame_delta);
+		// show_verbose_cursor_time (sample_delta);
 		break;
 	}
 }
@@ -3174,8 +3174,8 @@ TrimDrag::finished (GdkEvent* event, bool movement_occurred)
 
 	} else {
 		/* no mouse movement */
-		if (adjusted_current_frame (event) != adjusted_frame (_drags->current_pointer_frame(), event, false).frame) {
-			_editor->point_trim (event, adjusted_current_frame (event));
+		if (adjusted_current_sample (event) != adjusted_sample (_drags->current_pointer_sample(), event, false).sample) {
+			_editor->point_trim (event, adjusted_current_sample (event));
 		}
 	}
 
@@ -3205,7 +3205,7 @@ TrimDrag::aborted (bool movement_occurred)
 }
 
 void
-TrimDrag::setup_pointer_frame_offset ()
+TrimDrag::setup_pointer_sample_offset ()
 {
 	list<DraggingView>::iterator i = _views.begin ();
 	while (i != _views.end() && i->view != _primary) {
@@ -3218,10 +3218,10 @@ TrimDrag::setup_pointer_frame_offset ()
 
 	switch (_operation) {
 	case StartTrim:
-		_pointer_frame_offset = raw_grab_frame() - i->initial_position;
+		_pointer_sample_offset = raw_grab_sample() - i->initial_position;
 		break;
 	case EndTrim:
-		_pointer_frame_offset = raw_grab_frame() - i->initial_end;
+		_pointer_sample_offset = raw_grab_sample() - i->initial_end;
 		break;
 	case ContentsTrim:
 		break;
@@ -3246,13 +3246,13 @@ void
 MeterMarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 {
 	Drag::start_grab (event, cursor);
-	show_verbose_cursor_time (adjusted_current_frame(event));
+	show_verbose_cursor_time (adjusted_current_sample(event));
 }
 
 void
-MeterMarkerDrag::setup_pointer_frame_offset ()
+MeterMarkerDrag::setup_pointer_sample_offset ()
 {
-	_pointer_frame_offset = raw_grab_frame() - _marker->meter().frame();
+	_pointer_sample_offset = raw_grab_sample() - _marker->meter().sample();
 }
 
 void
@@ -3288,14 +3288,14 @@ MeterMarkerDrag::motion (GdkEvent* event, bool first_move)
 			Timecode::BBT_Time bbt = _real_section->bbt();
 
 			/* we can't add a meter where one currently exists */
-			if (_real_section->frame() < adjusted_current_frame (event, false)) {
+			if (_real_section->sample() < adjusted_current_sample (event, false)) {
 				++bbt.bars;
 			} else {
 				--bbt.bars;
 			}
-			const framepos_t frame = map.frame_at_bbt (bbt);
+			const samplepos_t sample = map.sample_at_bbt (bbt);
 			_real_section = map.add_meter (Meter (_marker->meter().divisions_per_bar(), _marker->meter().note_divisor())
-						       , bbt, frame, _real_section->position_lock_style());
+						       , bbt, sample, _real_section->position_lock_style());
 			if (!_real_section) {
 				aborted (true);
 				return;
@@ -3309,19 +3309,19 @@ MeterMarkerDrag::motion (GdkEvent* event, bool first_move)
 		}
 	}
 
-	framepos_t pf = adjusted_current_frame (event);
+	samplepos_t pf = adjusted_current_sample (event);
 
 	if (_real_section->position_lock_style() == AudioTime && _editor->snap_musical()) {
 		/* never snap to music for audio locked */
-		pf = adjusted_current_frame (event, false);
+		pf = adjusted_current_sample (event, false);
 	}
 
 	_editor->session()->tempo_map().gui_set_meter_position (_real_section, pf);
 
 	/* fake marker meeds to stay under the mouse, unlike the real one. */
-	_marker->set_position (adjusted_current_frame (event, false));
+	_marker->set_position (adjusted_current_sample (event, false));
 
-	show_verbose_cursor_time (_real_section->frame());
+	show_verbose_cursor_time (_real_section->sample());
 }
 
 void
@@ -3352,7 +3352,7 @@ MeterMarkerDrag::finished (GdkEvent* event, bool movement_occurred)
 void
 MeterMarkerDrag::aborted (bool moved)
 {
-	_marker->set_position (_marker->meter().frame ());
+	_marker->set_position (_marker->meter().sample ());
 	if (moved) {
 		/* reinstate old snap setting */
 		_editor->set_snap_to (_old_snap_type);
@@ -3389,14 +3389,14 @@ TempoMarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 	if (!_real_section->active()) {
 		show_verbose_cursor_text (_("inactive"));
 	} else {
-		show_verbose_cursor_time (adjusted_current_frame (event));
+		show_verbose_cursor_time (adjusted_current_sample (event));
 	}
 }
 
 void
-TempoMarkerDrag::setup_pointer_frame_offset ()
+TempoMarkerDrag::setup_pointer_sample_offset ()
 {
-	_pointer_frame_offset = raw_grab_frame() - _real_section->frame();
+	_pointer_sample_offset = raw_grab_sample() - _real_section->sample();
 }
 
 void
@@ -3436,15 +3436,15 @@ TempoMarkerDrag::motion (GdkEvent* event, bool first_move)
 
 		} else {
 			const Tempo tempo (_marker->tempo());
-			const framepos_t frame = adjusted_current_frame (event) + 1;
+			const samplepos_t sample = adjusted_current_sample (event) + 1;
 
 			_editor->begin_reversible_command (_("copy tempo mark"));
 
 			if (_real_section->position_lock_style() == MusicTime) {
 				const int32_t divisions = _editor->get_grid_music_divisions (event->button.state);
-				_real_section = map.add_tempo (tempo, map.exact_qn_at_frame (frame, divisions), 0, MusicTime);
+				_real_section = map.add_tempo (tempo, map.exact_qn_at_sample (sample, divisions), 0, MusicTime);
 			} else {
-				_real_section = map.add_tempo (tempo, 0.0, frame, AudioTime);
+				_real_section = map.add_tempo (tempo, 0.0, sample, AudioTime);
 			}
 
 			if (!_real_section) {
@@ -3470,15 +3470,15 @@ TempoMarkerDrag::motion (GdkEvent* event, bool first_move)
 		show_verbose_cursor_text (strs.str());
 
 	} else if (_movable && !_real_section->locked_to_meter()) {
-		framepos_t pf;
+		samplepos_t pf;
 
 		if (_editor->snap_musical()) {
 			/* we can't snap to a grid that we are about to move.
 			 * gui_move_tempo() will sort out snap using the supplied beat divisions.
 			*/
-			pf = adjusted_current_frame (event, false);
+			pf = adjusted_current_sample (event, false);
 		} else {
-			pf = adjusted_current_frame (event);
+			pf = adjusted_current_sample (event);
 		}
 
 		/* snap to beat is 1, snap to bar is -1 (sorry) */
@@ -3486,9 +3486,9 @@ TempoMarkerDrag::motion (GdkEvent* event, bool first_move)
 
 		map.gui_set_tempo_position (_real_section, pf, sub_num);
 
-		show_verbose_cursor_time (_real_section->frame());
+		show_verbose_cursor_time (_real_section->sample());
 	}
-	_marker->set_position (adjusted_current_frame (event, false));
+	_marker->set_position (adjusted_current_sample (event, false));
 }
 
 void
@@ -3518,7 +3518,7 @@ TempoMarkerDrag::finished (GdkEvent* event, bool movement_occurred)
 void
 TempoMarkerDrag::aborted (bool moved)
 {
-	_marker->set_position (_marker->tempo().frame());
+	_marker->set_position (_marker->tempo().sample());
 	if (moved) {
 		TempoMap& map (_editor->session()->tempo_map());
 		map.set_state (*_before_state, Stateful::current_state_version);
@@ -3543,9 +3543,9 @@ BBTRulerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 {
 	Drag::start_grab (event, cursor);
 	TempoMap& map (_editor->session()->tempo_map());
-	_tempo = const_cast<TempoSection*> (&map.tempo_section_at_frame (raw_grab_frame()));
+	_tempo = const_cast<TempoSection*> (&map.tempo_section_at_sample (raw_grab_sample()));
 
-	if (adjusted_current_frame (event, false) <= _tempo->frame()) {
+	if (adjusted_current_sample (event, false) <= _tempo->sample()) {
 		_drag_valid = false;
 		return;
 	}
@@ -3565,29 +3565,29 @@ BBTRulerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 }
 
 void
-BBTRulerDrag::setup_pointer_frame_offset ()
+BBTRulerDrag::setup_pointer_sample_offset ()
 {
 	TempoMap& map (_editor->session()->tempo_map());
 	/* get current state */
 	_before_state = &map.get_state();
 
-	const double beat_at_frame = max (0.0, map.beat_at_frame (raw_grab_frame()));
+	const double beat_at_sample = max (0.0, map.beat_at_sample (raw_grab_sample()));
 	const uint32_t divisions = _editor->get_grid_beat_divisions (0);
 	double beat = 0.0;
 
 	if (divisions > 0) {
-		beat = floor (beat_at_frame) + (floor (((beat_at_frame - floor (beat_at_frame)) * divisions)) / divisions);
+		beat = floor (beat_at_sample) + (floor (((beat_at_sample - floor (beat_at_sample)) * divisions)) / divisions);
 	} else {
 		/* while it makes some sense for the user to determine the division to 'grab',
 		   grabbing a bar often leads to confusing results wrt the actual tempo section being altered
 		   and the result over steep tempo curves. Use sixteenths.
 		*/
-		beat = floor (beat_at_frame) + (floor (((beat_at_frame - floor (beat_at_frame)) * 4)) / 4);
+		beat = floor (beat_at_sample) + (floor (((beat_at_sample - floor (beat_at_sample)) * 4)) / 4);
 	}
 
 	_grab_qn = map.quarter_note_at_beat (beat);
 
-	_pointer_frame_offset = raw_grab_frame() - map.frame_at_quarter_note (_grab_qn);
+	_pointer_sample_offset = raw_grab_sample() - map.sample_at_quarter_note (_grab_qn);
 
 }
 
@@ -3603,17 +3603,17 @@ BBTRulerDrag::motion (GdkEvent* event, bool first_move)
 	}
 
 	TempoMap& map (_editor->session()->tempo_map());
-	framepos_t pf;
+	samplepos_t pf;
 
 	if (_editor->snap_musical()) {
-		pf = adjusted_current_frame (event, false);
+		pf = adjusted_current_sample (event, false);
 	} else {
-		pf = adjusted_current_frame (event);
+		pf = adjusted_current_sample (event);
 	}
 
 	if (ArdourKeyboard::indicates_constraint (event->button.state)) {
-		/* adjust previous tempo to match pointer frame */
-		_editor->session()->tempo_map().gui_stretch_tempo (_tempo, map.frame_at_quarter_note (_grab_qn), pf, _grab_qn, map.quarter_note_at_frame (pf));
+		/* adjust previous tempo to match pointer sample */
+		_editor->session()->tempo_map().gui_stretch_tempo (_tempo, map.sample_at_quarter_note (_grab_qn), pf, _grab_qn, map.quarter_note_at_sample (pf));
 	}
 
 	ostringstream sstr;
@@ -3683,7 +3683,7 @@ TempoTwistDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 	TempoMap& map (_editor->session()->tempo_map());
 	/* get current state */
 	_before_state = &map.get_state();
-	_tempo = const_cast<TempoSection*> (&map.tempo_section_at_frame (raw_grab_frame()));
+	_tempo = const_cast<TempoSection*> (&map.tempo_section_at_sample (raw_grab_sample()));
 
 	if (_tempo->locked_to_meter()) {
 		_drag_valid = false;
@@ -3714,26 +3714,26 @@ TempoTwistDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 }
 
 void
-TempoTwistDrag::setup_pointer_frame_offset ()
+TempoTwistDrag::setup_pointer_sample_offset ()
 {
 	TempoMap& map (_editor->session()->tempo_map());
-	const double beat_at_frame = max (0.0, map.beat_at_frame (raw_grab_frame()));
+	const double beat_at_sample = max (0.0, map.beat_at_sample (raw_grab_sample()));
 	const uint32_t divisions = _editor->get_grid_beat_divisions (0);
 	double beat = 0.0;
 
 	if (divisions > 0) {
-		beat = floor (beat_at_frame) + (floor (((beat_at_frame - floor (beat_at_frame)) * divisions)) / divisions);
+		beat = floor (beat_at_sample) + (floor (((beat_at_sample - floor (beat_at_sample)) * divisions)) / divisions);
 	} else {
 		/* while it makes some sense for the user to determine the division to 'grab',
 		   grabbing a bar often leads to confusing results wrt the actual tempo section being altered
 		   and the result over steep tempo curves. Use sixteenths.
 		*/
-		beat = floor (beat_at_frame) + (floor (((beat_at_frame - floor (beat_at_frame)) * 4)) / 4);
+		beat = floor (beat_at_sample) + (floor (((beat_at_sample - floor (beat_at_sample)) * 4)) / 4);
 	}
 
 	_grab_qn = map.quarter_note_at_beat (beat);
 
-	_pointer_frame_offset = raw_grab_frame() - map.frame_at_quarter_note (_grab_qn);
+	_pointer_sample_offset = raw_grab_sample() - map.sample_at_quarter_note (_grab_qn);
 
 }
 
@@ -3751,17 +3751,17 @@ TempoTwistDrag::motion (GdkEvent* event, bool first_move)
 		_editor->begin_reversible_command (_("twist tempo"));
 	}
 
-	framepos_t pf;
+	samplepos_t pf;
 
 	if (_editor->snap_musical()) {
-		pf = adjusted_current_frame (event, false);
+		pf = adjusted_current_sample (event, false);
 	} else {
-		pf = adjusted_current_frame (event);
+		pf = adjusted_current_sample (event);
 	}
 
-	/* adjust this and the next tempi to match pointer frame */
+	/* adjust this and the next tempi to match pointer sample */
 	double new_bpm = max (1.5, _grab_tempo.note_types_per_minute() + ((grab_y() - min (-1.0, current_pointer_y())) / 5.0));
-	_editor->session()->tempo_map().gui_twist_tempi (_tempo, new_bpm, map.frame_at_quarter_note (_grab_qn), pf);
+	_editor->session()->tempo_map().gui_twist_tempi (_tempo, new_bpm, map.sample_at_quarter_note (_grab_qn), pf);
 
 	ostringstream sstr;
 	sstr << "start: " << fixed << setprecision(3) << _tempo->note_types_per_minute() << "\n";
@@ -3826,7 +3826,7 @@ TempoEndDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 	TempoSection* prev = 0;
 	if ((prev = tmap.previous_tempo_section (_tempo)) != 0) {
 		_editor->tempo_curve_selected (tmap.previous_tempo_section (_tempo), true);
-		sstr << "end: " << fixed << setprecision(3) << tmap.tempo_section_at_frame (_tempo->frame() - 1).end_note_types_per_minute() << "\n";
+		sstr << "end: " << fixed << setprecision(3) << tmap.tempo_section_at_sample (_tempo->sample() - 1).end_note_types_per_minute() << "\n";
 	}
 
 	if (_tempo->clamped()) {
@@ -3838,11 +3838,11 @@ TempoEndDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 }
 
 void
-TempoEndDrag::setup_pointer_frame_offset ()
+TempoEndDrag::setup_pointer_sample_offset ()
 {
 	TempoMap& map (_editor->session()->tempo_map());
 
-	_pointer_frame_offset = raw_grab_frame() - map.frame_at_quarter_note (_grab_qn);
+	_pointer_sample_offset = raw_grab_sample() - map.sample_at_quarter_note (_grab_qn);
 
 }
 
@@ -3859,11 +3859,11 @@ TempoEndDrag::motion (GdkEvent* event, bool first_move)
 		_editor->begin_reversible_command (_("stretch end tempo"));
 	}
 
-	framepos_t const pf = adjusted_current_frame (event, false);
-	map.gui_stretch_tempo_end (&map.tempo_section_at_frame (_tempo->frame() - 1), map.frame_at_quarter_note (_grab_qn), pf);
+	samplepos_t const pf = adjusted_current_sample (event, false);
+	map.gui_stretch_tempo_end (&map.tempo_section_at_sample (_tempo->sample() - 1), map.sample_at_quarter_note (_grab_qn), pf);
 
 	ostringstream sstr;
-	sstr << "end: " << fixed << setprecision(3) << map.tempo_section_at_frame (_tempo->frame() - 1).end_note_types_per_minute() << "\n";
+	sstr << "end: " << fixed << setprecision(3) << map.tempo_section_at_sample (_tempo->sample() - 1).end_note_types_per_minute() << "\n";
 
 	if (_tempo->clamped()) {
 		sstr << "start: " << fixed << setprecision(3) << _tempo->note_types_per_minute();
@@ -3918,7 +3918,7 @@ CursorDrag::CursorDrag (Editor* e, EditorCursor& c, bool s)
  *  the diskstream buffers to be refilled, which is too slow).
  */
 void
-CursorDrag::fake_locate (framepos_t t)
+CursorDrag::fake_locate (samplepos_t t)
 {
 	if (_editor->session () == 0) {
 		return;
@@ -3928,7 +3928,7 @@ CursorDrag::fake_locate (framepos_t t)
 
 	Session* s = _editor->session ();
 	if (s->timecode_transmission_suspended ()) {
-		framepos_t const f = _editor->playhead_cursor->current_frame ();
+		samplepos_t const f = _editor->playhead_cursor->current_sample ();
 		/* This is asynchronous so it will be sent "now"
 		 */
 		s->send_mmc_locate (f);
@@ -3947,15 +3947,15 @@ void
 CursorDrag::start_grab (GdkEvent* event, Gdk::Cursor* c)
 {
 	Drag::start_grab (event, c);
-	setup_snap_delta (MusicFrame (_editor->playhead_cursor->current_frame(), 0));
+	setup_snap_delta (MusicSample (_editor->playhead_cursor->current_sample(), 0));
 
 	_grab_zoom = _editor->samples_per_pixel;
 
-	MusicFrame where (_editor->canvas_event_sample (event) + snap_delta (event->button.state), 0);
+	MusicSample where (_editor->canvas_event_sample (event) + snap_delta (event->button.state), 0);
 
 	_editor->snap_to_with_modifier (where, event);
 	_editor->_dragging_playhead = true;
-	_editor->_control_scroll_target = where.frame;
+	_editor->_control_scroll_target = where.sample;
 
 	Session* s = _editor->session ();
 
@@ -3989,7 +3989,7 @@ CursorDrag::start_grab (GdkEvent* event, Gdk::Cursor* c)
 		}
 	}
 
-	fake_locate (where.frame - snap_delta (event->button.state));
+	fake_locate (where.sample - snap_delta (event->button.state));
 	
 	_last_y_delta = 0;
 }
@@ -3997,12 +3997,12 @@ CursorDrag::start_grab (GdkEvent* event, Gdk::Cursor* c)
 void
 CursorDrag::motion (GdkEvent* event, bool)
 {
-	MusicFrame where (_editor->canvas_event_sample (event) + snap_delta (event->button.state), 0);
+	MusicSample where (_editor->canvas_event_sample (event) + snap_delta (event->button.state), 0);
 
 	_editor->snap_to_with_modifier (where, event);
 
-	if (where.frame != last_pointer_frame()) {
-		fake_locate (where.frame - snap_delta (event->button.state));
+	if (where.sample != last_pointer_sample()) {
+		fake_locate (where.sample - snap_delta (event->button.state));
 	}
 	
 	//maybe do zooming, too, if the option is enabled
@@ -4054,7 +4054,7 @@ CursorDrag::finished (GdkEvent* event, bool movement_occurred)
 
 	Session* s = _editor->session ();
 	if (s) {
-		s->request_locate (_editor->playhead_cursor->current_frame (), _was_rolling);
+		s->request_locate (_editor->playhead_cursor->current_sample (), _was_rolling);
 		_editor->_pending_locate_request = true;
 		s->request_resume_timecode_transmission ();
 	}
@@ -4070,7 +4070,7 @@ CursorDrag::aborted (bool)
 		_editor->_dragging_playhead = false;
 	}
 
-	_editor->playhead_cursor->set_position (adjusted_frame (grab_frame (), 0, false).frame);
+	_editor->playhead_cursor->set_position (adjusted_sample (grab_sample (), 0, false).sample);
 }
 
 FadeInDrag::FadeInDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
@@ -4086,37 +4086,37 @@ FadeInDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 
 	AudioRegionView* arv = dynamic_cast<AudioRegionView*> (_primary);
 	boost::shared_ptr<AudioRegion> const r = arv->audio_region ();
-	setup_snap_delta (MusicFrame (r->position(), 0));
+	setup_snap_delta (MusicSample (r->position(), 0));
 
 	show_verbose_cursor_duration (r->position(), r->position() + r->fade_in()->back()->when, 32);
 }
 
 void
-FadeInDrag::setup_pointer_frame_offset ()
+FadeInDrag::setup_pointer_sample_offset ()
 {
 	AudioRegionView* arv = dynamic_cast<AudioRegionView*> (_primary);
 	boost::shared_ptr<AudioRegion> const r = arv->audio_region ();
-	_pointer_frame_offset = raw_grab_frame() - ((framecnt_t) r->fade_in()->back()->when + r->position());
+	_pointer_sample_offset = raw_grab_sample() - ((samplecnt_t) r->fade_in()->back()->when + r->position());
 }
 
 void
 FadeInDrag::motion (GdkEvent* event, bool)
 {
-	framecnt_t fade_length;
+	samplecnt_t fade_length;
 
-	MusicFrame pos (_editor->canvas_event_sample (event) + snap_delta (event->button.state), 0);
+	MusicSample pos (_editor->canvas_event_sample (event) + snap_delta (event->button.state), 0);
 	_editor->snap_to_with_modifier (pos, event);
 
-	pos.frame -= snap_delta (event->button.state);
+	pos.sample -= snap_delta (event->button.state);
 
 	boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (_primary->region ());
 
-	if (pos.frame < (region->position() + 64)) {
+	if (pos.sample < (region->position() + 64)) {
 		fade_length = 64; // this should be a minimum defined somewhere
-	} else if (pos.frame > region->position() + region->length() - region->fade_out()->back()->when) {
+	} else if (pos.sample > region->position() + region->length() - region->fade_out()->back()->when) {
 		fade_length = region->length() - region->fade_out()->back()->when - 1;
 	} else {
-		fade_length = pos.frame - region->position();
+		fade_length = pos.sample - region->position();
 	}
 
 	for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
@@ -4140,20 +4140,20 @@ FadeInDrag::finished (GdkEvent* event, bool movement_occurred)
 		return;
 	}
 
-	framecnt_t fade_length;
-	MusicFrame pos (_editor->canvas_event_sample (event) + snap_delta (event->button.state), 0);
+	samplecnt_t fade_length;
+	MusicSample pos (_editor->canvas_event_sample (event) + snap_delta (event->button.state), 0);
 
 	_editor->snap_to_with_modifier (pos, event);
-	pos.frame -= snap_delta (event->button.state);
+	pos.sample -= snap_delta (event->button.state);
 
 	boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (_primary->region ());
 
-	if (pos.frame < (region->position() + 64)) {
+	if (pos.sample < (region->position() + 64)) {
 		fade_length = 64; // this should be a minimum defined somewhere
-	} else if (pos.frame >= region->position() + region->length() - region->fade_out()->back()->when) {
+	} else if (pos.sample >= region->position() + region->length() - region->fade_out()->back()->when) {
 		fade_length = region->length() - region->fade_out()->back()->when - 1;
 	} else {
-		fade_length = pos.frame - region->position();
+		fade_length = pos.sample - region->position();
 	}
 
 	bool in_command = false;
@@ -4212,36 +4212,36 @@ FadeOutDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 
 	AudioRegionView* arv = dynamic_cast<AudioRegionView*> (_primary);
 	boost::shared_ptr<AudioRegion> r = arv->audio_region ();
-	setup_snap_delta (MusicFrame (r->last_frame(), 0));
+	setup_snap_delta (MusicSample (r->last_sample(), 0));
 
-	show_verbose_cursor_duration (r->last_frame() - r->fade_out()->back()->when, r->last_frame());
+	show_verbose_cursor_duration (r->last_sample() - r->fade_out()->back()->when, r->last_sample());
 }
 
 void
-FadeOutDrag::setup_pointer_frame_offset ()
+FadeOutDrag::setup_pointer_sample_offset ()
 {
 	AudioRegionView* arv = dynamic_cast<AudioRegionView*> (_primary);
 	boost::shared_ptr<AudioRegion> r = arv->audio_region ();
-	_pointer_frame_offset = raw_grab_frame() - (r->length() - (framecnt_t) r->fade_out()->back()->when + r->position());
+	_pointer_sample_offset = raw_grab_sample() - (r->length() - (samplecnt_t) r->fade_out()->back()->when + r->position());
 }
 
 void
 FadeOutDrag::motion (GdkEvent* event, bool)
 {
-	framecnt_t fade_length;
-	MusicFrame pos (_editor->canvas_event_sample (event) + snap_delta (event->button.state), 0);
+	samplecnt_t fade_length;
+	MusicSample pos (_editor->canvas_event_sample (event) + snap_delta (event->button.state), 0);
 
 	_editor->snap_to_with_modifier (pos, event);
-	pos.frame -= snap_delta (event->button.state);
+	pos.sample -= snap_delta (event->button.state);
 
 	boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (_primary->region ());
 
-	if (pos.frame > (region->last_frame() - 64)) {
+	if (pos.sample > (region->last_sample() - 64)) {
 		fade_length = 64; // this should really be a minimum fade defined somewhere
-	} else if (pos.frame <= region->position() + region->fade_in()->back()->when) {
+	} else if (pos.sample <= region->position() + region->fade_in()->back()->when) {
 		fade_length = region->length() - region->fade_in()->back()->when - 1;
 	} else {
-		fade_length = region->last_frame() - pos.frame;
+		fade_length = region->last_sample() - pos.sample;
 	}
 
 	for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
@@ -4255,7 +4255,7 @@ FadeOutDrag::motion (GdkEvent* event, bool)
 		tmp->reset_fade_out_shape_width (tmp->audio_region(), fade_length);
 	}
 
-	show_verbose_cursor_duration (region->last_frame() - fade_length, region->last_frame());
+	show_verbose_cursor_duration (region->last_sample() - fade_length, region->last_sample());
 }
 
 void
@@ -4265,20 +4265,20 @@ FadeOutDrag::finished (GdkEvent* event, bool movement_occurred)
 		return;
 	}
 
-	framecnt_t fade_length;
-	MusicFrame pos (_editor->canvas_event_sample (event) + snap_delta (event->button.state), 0);
+	samplecnt_t fade_length;
+	MusicSample pos (_editor->canvas_event_sample (event) + snap_delta (event->button.state), 0);
 
 	_editor->snap_to_with_modifier (pos, event);
-	pos.frame -= snap_delta (event->button.state);
+	pos.sample -= snap_delta (event->button.state);
 
 	boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (_primary->region ());
 
-	if (pos.frame > (region->last_frame() - 64)) {
+	if (pos.sample > (region->last_sample() - 64)) {
 		fade_length = 64; // this should really be a minimum fade defined somewhere
-	} else if (pos.frame <= region->position() + region->fade_in()->back()->when) {
+	} else if (pos.sample <= region->position() + region->fade_in()->back()->when) {
 		fade_length = region->length() - region->fade_in()->back()->when - 1;
 	} else {
-		fade_length = region->last_frame() - pos.frame;
+		fade_length = region->last_sample() - pos.sample;
 	}
 
 	bool in_command = false;
@@ -4373,7 +4373,7 @@ MarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 	} else {
 		show_verbose_cursor_time (location->end());
 	}
-	setup_snap_delta (MusicFrame (is_start ? location->start() : location->end(), 0));
+	setup_snap_delta (MusicSample (is_start ? location->start() : location->end(), 0));
 
 	Selection::Operation op = ArdourKeyboard::selection_type (event->button.state);
 
@@ -4391,13 +4391,13 @@ MarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 	{
 		Locations::LocationList ll;
 		list<ArdourMarker*> to_add;
-		framepos_t s, e;
+		samplepos_t s, e;
 		_editor->selection->markers.range (s, e);
 		s = min (_marker->position(), s);
 		e = max (_marker->position(), e);
 		s = min (s, e);
 		e = max (s, e);
-		if (e < max_framepos) {
+		if (e < max_samplepos) {
 			++e;
 		}
 		_editor->session()->locations()->find_all_between (s, e, ll, Location::Flags (0));
@@ -4460,25 +4460,25 @@ MarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 }
 
 void
-MarkerDrag::setup_pointer_frame_offset ()
+MarkerDrag::setup_pointer_sample_offset ()
 {
 	bool is_start;
 	Location *location = _editor->find_location_from_marker (_marker, is_start);
-	_pointer_frame_offset = raw_grab_frame() - (is_start ? location->start() : location->end());
+	_pointer_sample_offset = raw_grab_sample() - (is_start ? location->start() : location->end());
 }
 
 void
 MarkerDrag::motion (GdkEvent* event, bool)
 {
-	framecnt_t f_delta = 0;
+	samplecnt_t f_delta = 0;
 	bool is_start;
 	bool move_both = false;
 	Location *real_location;
 	Location *copy_location = 0;
-	framecnt_t const sd = snap_delta (event->button.state);
+	samplecnt_t const sd = snap_delta (event->button.state);
 
-	framecnt_t const newframe = adjusted_frame (_drags->current_pointer_frame () + sd, event, true).frame - sd;
-	framepos_t next = newframe;
+	samplecnt_t const newframe = adjusted_sample (_drags->current_pointer_sample () + sd, event, true).sample - sd;
+	samplepos_t next = newframe;
 
 	if (Keyboard::modifier_state_contains (event->button.state, ArdourKeyboard::push_points_modifier ())) {
 		move_both = true;
@@ -4560,8 +4560,8 @@ MarkerDrag::motion (GdkEvent* event, bool)
 
 		} else {
 
-			framepos_t new_start = copy_location->start() + f_delta;
-			framepos_t new_end = copy_location->end() + f_delta;
+			samplepos_t new_start = copy_location->start() + f_delta;
+			samplepos_t new_end = copy_location->end() + f_delta;
 
 			if (is_start) { // start-of-range marker
 
@@ -4760,7 +4760,7 @@ ControlPointDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/)
 	_fixed_grab_x = _point->get_x() + _editor->sample_to_pixel_unrounded (_point->line().offset());
 	_fixed_grab_y = _point->get_y();
 
-	setup_snap_delta (MusicFrame (_editor->pixel_to_sample (_fixed_grab_x), 0));
+	setup_snap_delta (MusicSample (_editor->pixel_to_sample (_fixed_grab_x), 0));
 
 	float const fraction = 1 - (_point->get_y() / _point->line().height());
 	show_verbose_cursor_text (_point->line().get_verbose_cursor_string (fraction));
@@ -4813,14 +4813,14 @@ ControlPointDrag::motion (GdkEvent* event, bool first_motion)
 		cy = zero_gain_y;
 	}
 
-	MusicFrame cx_mf (_editor->pixel_to_sample (cx) + snap_delta (event->button.state), 0);
+	MusicSample cx_mf (_editor->pixel_to_sample (cx) + snap_delta (event->button.state), 0);
 
 	if (!_x_constrained && need_snap) {
 		_editor->snap_to_with_modifier (cx_mf, event);
 	}
 
-	cx_mf.frame -= snap_delta (event->button.state);
-	cx_mf.frame = min (cx_mf.frame, _point->line().maximum_time() + _point->line().offset());
+	cx_mf.sample -= snap_delta (event->button.state);
+	cx_mf.sample = min (cx_mf.sample, _point->line().maximum_time() + _point->line().offset());
 
 	float const fraction = 1.0 - (cy / _point->line().height());
 
@@ -4830,7 +4830,7 @@ ControlPointDrag::motion (GdkEvent* event, bool first_motion)
 		_point->line().start_drag_single (_point, _fixed_grab_x, initial_fraction);
 	}
 	pair<float, float> result;
-	result = _point->line().drag_motion (_editor->sample_to_pixel_unrounded (cx_mf.frame), fraction, false, _pushing, _final_index);
+	result = _point->line().drag_motion (_editor->sample_to_pixel_unrounded (cx_mf.sample), fraction, false, _pushing, _final_index);
 	show_verbose_cursor_text (_point->line().get_verbose_cursor_relative_string (result.first, result.second));
 }
 
@@ -4897,16 +4897,16 @@ LineDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/)
 
 	_line->grab_item().canvas_to_item (mx, my);
 
-	framecnt_t const frame_within_region = (framecnt_t) floor (mx * _editor->samples_per_pixel);
+	samplecnt_t const sample_within_region = (samplecnt_t) floor (mx * _editor->samples_per_pixel);
 
-	if (!_line->control_points_adjacent (frame_within_region, _before, _after)) {
+	if (!_line->control_points_adjacent (sample_within_region, _before, _after)) {
 		/* no adjacent points */
 		return;
 	}
 
 	Drag::start_grab (event, _editor->cursors()->fader);
 
-	/* store grab start in item frame */
+	/* store grab start in item sample */
 	double const bx = _line->nth (_before)->get_x();
 	double const ax = _line->nth (_after)->get_x();
 	double const click_ratio = (ax - mx) / (ax - bx);
@@ -4967,7 +4967,7 @@ LineDrag::finished (GdkEvent* event, bool movement_occurred)
 		AutomationTimeAxisView* atv;
 
 		if ((atv = dynamic_cast<AutomationTimeAxisView*>(_editor->clicked_axisview)) != 0) {
-			framepos_t where = grab_frame ();
+			samplepos_t where = grab_sample ();
 
 			double cx = 0;
 			double cy = _fixed_grab_y;
@@ -5018,7 +5018,7 @@ FeatureLineDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/)
 
 	_item->parent()->canvas_to_item (cx, cy);
 
-	/* store grab start in parent frame */
+	/* store grab start in parent sample */
 	_region_view_grab_x = cx;
 
 	_before = *(float*) _item->get_data ("position");
@@ -5082,33 +5082,33 @@ void
 RubberbandSelectDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
 {
 	Drag::start_grab (event);
-	show_verbose_cursor_time (adjusted_current_frame (event, UIConfiguration::instance().get_rubberbanding_snaps_to_grid()));
+	show_verbose_cursor_time (adjusted_current_sample (event, UIConfiguration::instance().get_rubberbanding_snaps_to_grid()));
 }
 
 void
 RubberbandSelectDrag::motion (GdkEvent* event, bool)
 {
-	framepos_t start;
-	framepos_t end;
+	samplepos_t start;
+	samplepos_t end;
 	double y1;
 	double y2;
-	framepos_t const pf = adjusted_current_frame (event, UIConfiguration::instance().get_rubberbanding_snaps_to_grid());
-	MusicFrame grab (grab_frame (), 0);
+	samplepos_t const pf = adjusted_current_sample (event, UIConfiguration::instance().get_rubberbanding_snaps_to_grid());
+	MusicSample grab (grab_sample (), 0);
 
 	if (UIConfiguration::instance().get_rubberbanding_snaps_to_grid ()) {
 		_editor->snap_to_with_modifier (grab, event);
 	} else {
-		grab.frame = raw_grab_frame ();
+		grab.sample = raw_grab_sample ();
 	}
 
 	/* base start and end on initial click position */
 
-	if (pf < grab.frame) {
+	if (pf < grab.sample) {
 		start = pf;
-		end = grab.frame;
+		end = grab.sample;
 	} else {
 		end = pf;
-		start = grab.frame;
+		start = grab.sample;
 	}
 
 	if (current_pointer_y() < grab_y()) {
@@ -5167,13 +5167,13 @@ RubberbandSelectDrag::motion (GdkEvent* event, bool)
 void
 RubberbandSelectDrag::do_select_things (GdkEvent* event, bool drag_in_progress)
 {
-	framepos_t x1;
-	framepos_t x2;
-	framepos_t grab = grab_frame ();
-	framepos_t lpf = last_pointer_frame ();
+	samplepos_t x1;
+	samplepos_t x2;
+	samplepos_t grab = grab_sample ();
+	samplepos_t lpf = last_pointer_sample ();
 
 	if (!UIConfiguration::instance().get_rubberbanding_snaps_to_grid ()) {
-		grab = raw_grab_frame ();
+		grab = raw_grab_sample ();
 		lpf = _editor->pixel_to_sample_from_event (last_pointer_x());
 	}
 
@@ -5257,10 +5257,10 @@ TimeFXDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 
 	_editor->get_selection().add (_primary);
 
-	MusicFrame where (_primary->region()->position(), 0);
+	MusicSample where (_primary->region()->position(), 0);
 	setup_snap_delta (where);
 
-	show_verbose_cursor_duration (where.frame, adjusted_current_frame (event), 0);
+	show_verbose_cursor_duration (where.sample, adjusted_current_sample (event), 0);
 }
 
 void
@@ -5271,16 +5271,16 @@ TimeFXDrag::motion (GdkEvent* event, bool)
 	pair<TimeAxisView*, double> const tv = _editor->trackview_by_y_position (grab_y());
 	int layer = tv.first->layer_display() == Overlaid ? 0 : tv.second;
 	int layers = tv.first->layer_display() == Overlaid ? 1 : cv->layers();
-	MusicFrame pf (_editor->canvas_event_sample (event) + snap_delta (event->button.state), 0);
+	MusicSample pf (_editor->canvas_event_sample (event) + snap_delta (event->button.state), 0);
 
 	_editor->snap_to_with_modifier (pf, event);
-	pf.frame -= snap_delta (event->button.state);
+	pf.sample -= snap_delta (event->button.state);
 
-	if (pf.frame > rv->region()->position()) {
-		rv->get_time_axis_view().show_timestretch (rv->region()->position(), pf.frame, layers, layer);
+	if (pf.sample > rv->region()->position()) {
+		rv->get_time_axis_view().show_timestretch (rv->region()->position(), pf.sample, layers, layer);
 	}
 
-	show_verbose_cursor_duration (_primary->region()->position(), pf.frame, 0);
+	show_verbose_cursor_duration (_primary->region()->position(), pf.sample, 0);
 }
 
 void
@@ -5299,14 +5299,14 @@ TimeFXDrag::finished (GdkEvent* event, bool movement_occurred)
 
 		_primary->get_time_axis_view().hide_timestretch ();
 
-		framepos_t adjusted_frame_pos = adjusted_current_frame (event);
+		samplepos_t adjusted_sample_pos = adjusted_current_sample (event);
 
-		if (adjusted_frame_pos < _primary->region()->position()) {
+		if (adjusted_sample_pos < _primary->region()->position()) {
 			/* backwards drag of the left edge - not usable */
 			return;
 		}
 
-		framecnt_t newlen = adjusted_frame_pos - _primary->region()->position();
+		samplecnt_t newlen = adjusted_sample_pos - _primary->region()->position();
 
 		fraction = (double) newlen / (double) _primary->region()->length();
 
@@ -5352,7 +5352,7 @@ ScrubDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
 void
 ScrubDrag::motion (GdkEvent* /*event*/, bool)
 {
-	_editor->scrub (adjusted_current_frame (0, false), _drags->current_pointer_x ());
+	_editor->scrub (adjusted_current_sample (0, false), _drags->current_pointer_x ());
 }
 
 void
@@ -5381,7 +5381,7 @@ SelectionDrag::SelectionDrag (Editor* e, ArdourCanvas::Item* i, Operation o)
 
 	if (_time_selection_at_start) {
 		start_at_start = _editor->get_selection().time.start();
-		end_at_start = _editor->get_selection().time.end_frame();
+		end_at_start = _editor->get_selection().time.end_sample();
 	}
 }
 
@@ -5431,25 +5431,25 @@ SelectionDrag::start_grab (GdkEvent* event, Gdk::Cursor*)
 	if (_operation == SelectionMove) {
 		show_verbose_cursor_time (_editor->selection->time[_editor->clicked_selection].start);
 	} else {
-		show_verbose_cursor_time (adjusted_current_frame (event));
+		show_verbose_cursor_time (adjusted_current_sample (event));
 	}
 }
 
 void
-SelectionDrag::setup_pointer_frame_offset ()
+SelectionDrag::setup_pointer_sample_offset ()
 {
 	switch (_operation) {
 	case CreateSelection:
-		_pointer_frame_offset = 0;
+		_pointer_sample_offset = 0;
 		break;
 
 	case SelectionStartTrim:
 	case SelectionMove:
-		_pointer_frame_offset = raw_grab_frame() - _editor->selection->time[_editor->clicked_selection].start;
+		_pointer_sample_offset = raw_grab_sample() - _editor->selection->time[_editor->clicked_selection].start;
 		break;
 
 	case SelectionEndTrim:
-		_pointer_frame_offset = raw_grab_frame() - _editor->selection->time[_editor->clicked_selection].end;
+		_pointer_sample_offset = raw_grab_sample() - _editor->selection->time[_editor->clicked_selection].end;
 		break;
 
 	case SelectionExtend:
@@ -5460,14 +5460,14 @@ SelectionDrag::setup_pointer_frame_offset ()
 void
 SelectionDrag::motion (GdkEvent* event, bool first_move)
 {
-	framepos_t start = 0;
-	framepos_t end = 0;
-	framecnt_t length = 0;
-	framecnt_t distance = 0;
-	MusicFrame start_mf (0, 0);
-	framepos_t const pending_position = adjusted_current_frame (event);
+	samplepos_t start = 0;
+	samplepos_t end = 0;
+	samplecnt_t length = 0;
+	samplecnt_t distance = 0;
+	MusicSample start_mf (0, 0);
+	samplepos_t const pending_position = adjusted_current_sample (event);
 
-	if (_operation != CreateSelection && pending_position == last_pointer_frame()) {
+	if (_operation != CreateSelection && pending_position == last_pointer_sample()) {
 		return;
 	}
 
@@ -5478,22 +5478,22 @@ SelectionDrag::motion (GdkEvent* event, bool first_move)
 	switch (_operation) {
 	case CreateSelection:
 	{
-		MusicFrame grab (grab_frame (), 0);
+		MusicSample grab (grab_sample (), 0);
 		if (first_move) {
-			grab.frame = adjusted_current_frame (event, false);
-			if (grab.frame < pending_position) {
+			grab.sample = adjusted_current_sample (event, false);
+			if (grab.sample < pending_position) {
 				_editor->snap_to (grab, RoundDownMaybe);
 			}  else {
 				_editor->snap_to (grab, RoundUpMaybe);
 			}
 		}
 
-		if (pending_position < grab.frame) {
+		if (pending_position < grab.sample) {
 			start = pending_position;
-			end = grab.frame;
+			end = grab.sample;
 		} else {
 			end = pending_position;
-			start = grab.frame;
+			start = grab.sample;
 		}
 
 		/* first drag: Either add to the selection
@@ -5634,10 +5634,10 @@ SelectionDrag::motion (GdkEvent* event, bool first_move)
 		distance = pending_position - start;
 		start = pending_position;
 
-		start_mf.frame = start;
+		start_mf.sample = start;
 		_editor->snap_to (start_mf);
 
-		end = start_mf.frame + length;
+		end = start_mf.sample + length;
 
 		break;
 
@@ -5688,7 +5688,7 @@ SelectionDrag::finished (GdkEvent* event, bool movement_occurred)
 			}
 
 			if (_editor->get_selection().time.length() != 0) {
-				s->set_range_selection (_editor->get_selection().time.start(), _editor->get_selection().time.end_frame());
+				s->set_range_selection (_editor->get_selection().time.start(), _editor->get_selection().time.end_sample());
 			} else {
 				s->clear_range_selection ();
 			}
@@ -5707,9 +5707,9 @@ SelectionDrag::finished (GdkEvent* event, bool movement_occurred)
 
 		if (_operation == SelectionExtend) {
 			if (_time_selection_at_start) {
-				framepos_t pos = adjusted_current_frame (event, false);
-				framepos_t start = min (pos, start_at_start);
-				framepos_t end = max (pos, end_at_start);
+				samplepos_t pos = adjusted_current_sample (event, false);
+				samplepos_t start = min (pos, start_at_start);
+				samplepos_t end = max (pos, end_at_start);
 				_editor->selection->set (start, end);
 			}
 		} else {
@@ -5800,14 +5800,14 @@ RangeMarkerBarDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
 
 	Drag::start_grab (event, cursor);
 
-	show_verbose_cursor_time (adjusted_current_frame (event));
+	show_verbose_cursor_time (adjusted_current_sample (event));
 }
 
 void
 RangeMarkerBarDrag::motion (GdkEvent* event, bool first_move)
 {
-	framepos_t start = 0;
-	framepos_t end = 0;
+	samplepos_t start = 0;
+	samplepos_t end = 0;
 	ArdourCanvas::Rectangle *crect;
 
 	switch (_operation) {
@@ -5829,18 +5829,18 @@ RangeMarkerBarDrag::motion (GdkEvent* event, bool first_move)
 		break;
 	}
 
-	framepos_t const pf = adjusted_current_frame (event);
+	samplepos_t const pf = adjusted_current_sample (event);
 
 	if (_operation == CreateSkipMarker || _operation == CreateRangeMarker || _operation == CreateTransportMarker || _operation == CreateCDMarker) {
-		MusicFrame grab (grab_frame (), 0);
+		MusicSample grab (grab_sample (), 0);
 		_editor->snap_to (grab);
 
-		if (pf < grab_frame()) {
+		if (pf < grab_sample()) {
 			start = pf;
-			end = grab.frame;
+			end = grab.sample;
 		} else {
 			end = pf;
-			start = grab.frame;
+			start = grab.sample;
 		}
 
 		/* first drag: Either add to the selection
@@ -5933,7 +5933,7 @@ RangeMarkerBarDrag::finished (GdkEvent* event, bool movement_occurred)
 
 			/* didn't drag, so just locate */
 
-			_editor->session()->request_locate (grab_frame(), _editor->session()->transport_rolling());
+			_editor->session()->request_locate (grab_sample(), _editor->session()->transport_rolling());
 
 		} else if (_operation == CreateCDMarker) {
 
@@ -5942,17 +5942,17 @@ RangeMarkerBarDrag::finished (GdkEvent* event, bool movement_occurred)
 
 		} else { /* operation == CreateRangeMarker || CreateSkipMarker */
 
-			framepos_t start;
-			framepos_t end;
+			samplepos_t start;
+			samplepos_t end;
 
-			_editor->session()->locations()->marks_either_side (grab_frame(), start, end);
+			_editor->session()->locations()->marks_either_side (grab_sample(), start, end);
 
-			if (end == max_framepos) {
-				end = _editor->session()->current_end_frame ();
+			if (end == max_samplepos) {
+				end = _editor->session()->current_end_sample ();
 			}
 
-			if (start == max_framepos) {
-				start = _editor->session()->current_start_frame ();
+			if (start == max_samplepos) {
+				start = _editor->session()->current_start_sample ();
 			}
 
 			switch (_editor->mouse_mode) {
@@ -6010,10 +6010,10 @@ NoteDrag::NoteDrag (Editor* e, ArdourCanvas::Item* i)
 }
 
 void
-NoteDrag::setup_pointer_frame_offset ()
+NoteDrag::setup_pointer_sample_offset ()
 {
-	_pointer_frame_offset = raw_grab_frame()
-		- _editor->session()->tempo_map().frame_at_quarter_note (_region->session_relative_qn (_primary->note()->time().to_double()));
+	_pointer_sample_offset = raw_grab_sample()
+		- _editor->session()->tempo_map().sample_at_quarter_note (_region->session_relative_qn (_primary->note()->time().to_double()));
 }
 
 void
@@ -6027,7 +6027,7 @@ NoteDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
 		_copy = false;
 	}
 
-	setup_snap_delta (MusicFrame (_region->source_beats_to_absolute_frames (_primary->note()->time ()), 0));
+	setup_snap_delta (MusicSample (_region->source_beats_to_absolute_samples (_primary->note()->time ()), 0));
 
 	if (!(_was_selected = _primary->selected())) {
 
@@ -6061,22 +6061,22 @@ NoteDrag::total_dx (GdkEvent * event) const
 
 	TempoMap& map (_editor->session()->tempo_map());
 
-	/* dx in frames */
-	frameoffset_t const dx = _editor->pixel_to_sample (_drags->current_pointer_x() - grab_x());
+	/* dx in samples */
+	sampleoffset_t const dx = _editor->pixel_to_sample (_drags->current_pointer_x() - grab_x());
 
 	/* primary note time */
-	frameoffset_t const n = map.frame_at_quarter_note (_region->session_relative_qn (_primary->note()->time().to_double()));
+	sampleoffset_t const n = map.sample_at_quarter_note (_region->session_relative_qn (_primary->note()->time().to_double()));
 
 	/* primary note time in quarter notes */
 	double const n_qn = _region->session_relative_qn (_primary->note()->time().to_double());
 
-	/* new time of the primary note in session frames */
-	frameoffset_t st = n + dx + snap_delta (event->button.state);
+	/* new time of the primary note in session samples */
+	sampleoffset_t st = n + dx + snap_delta (event->button.state);
 
 	/* possibly snap and return corresponding delta in quarter notes */
-	MusicFrame snap (st, 0);
+	MusicSample snap (st, 0);
 	_editor->snap_to_with_modifier (snap, event);
-	double ret = map.exact_qn_at_frame (snap.frame, snap.division) - n_qn - snap_delta_music (event->button.state);
+	double ret = map.exact_qn_at_sample (snap.sample, snap.division) - n_qn - snap_delta_music (event->button.state);
 
 	/* prevent the earliest note being dragged earlier than the region's start position */
 	if (_earliest + ret < _region->midi_region()->start_beats()) {
@@ -6254,7 +6254,7 @@ AutomationRangeDrag::setup (list<boost::shared_ptr<AutomationLine> > const & lin
 		list<boost::shared_ptr<AutomationLine> >::const_iterator j = i;
 		++j;
 
-		pair<framepos_t, framepos_t> r = (*i)->get_point_x_range ();
+		pair<samplepos_t, samplepos_t> r = (*i)->get_point_x_range ();
 
 		/* check this range against all the AudioRanges that we are using */
 		list<AudioRange>::const_iterator k = _ranges.begin ();
@@ -6335,7 +6335,7 @@ AutomationRangeDrag::motion (GdkEvent*, bool first_move)
 
 			for (list<AudioRange>::const_iterator i = _ranges.begin(); i != _ranges.end(); ++i) {
 
-				framecnt_t const half = (i->start + i->end) / 2;
+				samplecnt_t const half = (i->start + i->end) / 2;
 
 				/* find the line that this audio range starts in */
 				list<Line>::iterator j = _lines.begin();
@@ -6350,7 +6350,7 @@ AutomationRangeDrag::motion (GdkEvent*, bool first_move)
 				   64 samples length plucked out of thin air.
 				*/
 
-					framepos_t a = i->start + 64;
+					samplepos_t a = i->start + 64;
 					if (a > half) {
 						a = half;
 					}
@@ -6382,7 +6382,7 @@ AutomationRangeDrag::motion (GdkEvent*, bool first_move)
 					   64 samples length plucked out of thin air.
 					*/
 
-					framepos_t b = i->end - 64;
+					samplepos_t b = i->end - 64;
 					if (b < half) {
 						b = half;
 					}
@@ -6491,19 +6491,19 @@ PatchChangeDrag::PatchChangeDrag (Editor* e, PatchChange* i, MidiRegionView* r)
 	, _cumulative_dx (0)
 {
 	DEBUG_TRACE (DEBUG::Drags, string_compose ("New PatchChangeDrag, patch @ %1, grab @ %2\n",
-						   _region_view->source_beats_to_absolute_frames (_patch_change->patch()->time()),
-						   grab_frame()));
+						   _region_view->source_beats_to_absolute_samples (_patch_change->patch()->time()),
+						   grab_sample()));
 }
 
 void
 PatchChangeDrag::motion (GdkEvent* ev, bool)
 {
-	framepos_t f = adjusted_current_frame (ev);
+	samplepos_t f = adjusted_current_sample (ev);
 	boost::shared_ptr<Region> r = _region_view->region ();
 	f = max (f, r->position ());
-	f = min (f, r->last_frame ());
+	f = min (f, r->last_sample ());
 
-	framecnt_t const dxf = f - grab_frame(); // permitted dx in frames
+	samplecnt_t const dxf = f - grab_sample(); // permitted dx in samples
 	double const dxu = _editor->sample_to_pixel (dxf); // permitted fx in units
 	_patch_change->move (ArdourCanvas::Duple (dxu - _cumulative_dx, 0));
 	_cumulative_dx = dxu;
@@ -6520,13 +6520,13 @@ PatchChangeDrag::finished (GdkEvent* ev, bool movement_occurred)
 	}
 
 	boost::shared_ptr<Region> r (_region_view->region ());
-	framepos_t f = adjusted_current_frame (ev);
+	samplepos_t f = adjusted_current_sample (ev);
 	f = max (f, r->position ());
-	f = min (f, r->last_frame ());
+	f = min (f, r->last_sample ());
 
 	_region_view->move_patch_change (
 		*_patch_change,
-		_region_view->region_frames_to_region_beats (f - (r->position() - r->start()))
+		_region_view->region_samples_to_region_beats (f - (r->position() - r->start()))
 		);
 }
 
@@ -6537,10 +6537,10 @@ PatchChangeDrag::aborted (bool)
 }
 
 void
-PatchChangeDrag::setup_pointer_frame_offset ()
+PatchChangeDrag::setup_pointer_sample_offset ()
 {
 	boost::shared_ptr<Region> region = _region_view->region ();
-	_pointer_frame_offset = raw_grab_frame() - _region_view->source_beats_to_absolute_frames (_patch_change->patch()->time());
+	_pointer_sample_offset = raw_grab_sample() - _region_view->source_beats_to_absolute_samples (_patch_change->patch()->time());
 }
 
 MidiRubberbandSelectDrag::MidiRubberbandSelectDrag (Editor* e, MidiRegionView* rv)
@@ -6551,7 +6551,7 @@ MidiRubberbandSelectDrag::MidiRubberbandSelectDrag (Editor* e, MidiRegionView* r
 }
 
 void
-MidiRubberbandSelectDrag::select_things (int button_state, framepos_t x1, framepos_t x2, double y1, double y2, bool /*drag_in_progress*/)
+MidiRubberbandSelectDrag::select_things (int button_state, samplepos_t x1, samplepos_t x2, double y1, double y2, bool /*drag_in_progress*/)
 {
 	_region_view->update_drag_selection (
 		x1, x2, y1, y2,
@@ -6572,7 +6572,7 @@ MidiVerticalSelectDrag::MidiVerticalSelectDrag (Editor* e, MidiRegionView* rv)
 }
 
 void
-MidiVerticalSelectDrag::select_things (int button_state, framepos_t /*x1*/, framepos_t /*x2*/, double y1, double y2, bool /*drag_in_progress*/)
+MidiVerticalSelectDrag::select_things (int button_state, samplepos_t /*x1*/, samplepos_t /*x2*/, double y1, double y2, bool /*drag_in_progress*/)
 {
 	double const y = _region_view->midi_view()->y_position ();
 
@@ -6599,7 +6599,7 @@ EditorRubberbandSelectDrag::EditorRubberbandSelectDrag (Editor* e, ArdourCanvas:
 }
 
 void
-EditorRubberbandSelectDrag::select_things (int button_state, framepos_t x1, framepos_t x2, double y1, double y2, bool drag_in_progress)
+EditorRubberbandSelectDrag::select_things (int button_state, samplepos_t x1, samplepos_t x2, double y1, double y2, bool drag_in_progress)
 {
 	if (drag_in_progress) {
 		/* We just want to select things at the end of the drag, not during it */
@@ -6642,15 +6642,15 @@ NoteCreateDrag::~NoteCreateDrag ()
 	delete _drag_rect;
 }
 
-framecnt_t
-NoteCreateDrag::grid_frames (framepos_t t) const
+samplecnt_t
+NoteCreateDrag::grid_samples (samplepos_t t) const
 {
 
 	const Evoral::Beats grid_beats = _region_view->get_grid_beats (t);
-	const Evoral::Beats t_beats = _region_view->region_frames_to_region_beats (t);
+	const Evoral::Beats t_beats = _region_view->region_samples_to_region_beats (t);
 
-	return _region_view->region_beats_to_region_frames (t_beats + grid_beats)
-		- _region_view->region_beats_to_region_frames (t_beats);
+	return _region_view->region_beats_to_region_samples (t_beats + grid_beats)
+		- _region_view->region_beats_to_region_samples (t_beats);
 }
 
 void
@@ -6661,16 +6661,16 @@ NoteCreateDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 	_drag_rect = new ArdourCanvas::Rectangle (_region_view->get_canvas_group ());
 	TempoMap& map (_editor->session()->tempo_map());
 
-	const framepos_t pf = _drags->current_pointer_frame ();
+	const samplepos_t pf = _drags->current_pointer_sample ();
 	const int32_t divisions = _editor->get_grid_music_divisions (event->button.state);
 
 	const Evoral::Beats grid_beats = _region_view->get_grid_beats (pf);
 
-	double eqaf = map.exact_qn_at_frame (pf, divisions);
+	double eqaf = map.exact_qn_at_sample (pf, divisions);
 
 	if (divisions != 0) {
 
-		const double qaf = map.quarter_note_at_frame (pf);
+		const double qaf = map.quarter_note_at_sample (pf);
 
 		/* Hack so that we always snap to the note that we are over, instead of snapping
 		   to the next one if we're more than halfway through the one we're over.
@@ -6682,9 +6682,9 @@ NoteCreateDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 		}
 	}
 
-	_note[0] = map.frame_at_quarter_note (eqaf) - _region_view->region()->position();
+	_note[0] = map.sample_at_quarter_note (eqaf) - _region_view->region()->position();
 	/* minimum initial length is grid beats */
-	_note[1] = map.frame_at_quarter_note (eqaf + grid_beats.to_double()) - _region_view->region()->position();
+	_note[1] = map.sample_at_quarter_note (eqaf + grid_beats.to_double()) - _region_view->region()->position();
 
 	double const x0 = _editor->sample_to_pixel (_note[0]);
 	double const x1 = _editor->sample_to_pixel (_note[1]);
@@ -6700,15 +6700,15 @@ void
 NoteCreateDrag::motion (GdkEvent* event, bool)
 {
 	TempoMap& map (_editor->session()->tempo_map());
-	const framepos_t pf = _drags->current_pointer_frame ();
+	const samplepos_t pf = _drags->current_pointer_sample ();
 	const int32_t divisions = _editor->get_grid_music_divisions (event->button.state);
-	double eqaf = map.exact_qn_at_frame (pf, divisions);
+	double eqaf = map.exact_qn_at_sample (pf, divisions);
 
 	if (divisions != 0) {
 
 		const Evoral::Beats grid_beats = _region_view->get_grid_beats (pf);
 
-		const double qaf = map.quarter_note_at_frame (pf);
+		const double qaf = map.quarter_note_at_sample (pf);
 		/* Hack so that we always snap to the note that we are over, instead of snapping
 		   to the next one if we're more than halfway through the one we're over.
 		*/
@@ -6720,7 +6720,7 @@ NoteCreateDrag::motion (GdkEvent* event, bool)
 
 		eqaf += grid_beats.to_double();
 	}
-	_note[1] = max ((framepos_t)0, map.frame_at_quarter_note (eqaf) - _region_view->region()->position ());
+	_note[1] = max ((samplepos_t)0, map.sample_at_quarter_note (eqaf) - _region_view->region()->position ());
 
 	double const x0 = _editor->sample_to_pixel (_note[0]);
 	double const x1 = _editor->sample_to_pixel (_note[1]);
@@ -6732,17 +6732,17 @@ void
 NoteCreateDrag::finished (GdkEvent* ev, bool had_movement)
 {
 	/* we create a note even if there was no movement */
-	framepos_t const start = min (_note[0], _note[1]);
-	framepos_t const start_sess_rel = start + _region_view->region()->position();
-	framecnt_t length = max (_editor->pixel_to_sample (1.0), (framecnt_t) fabs ((double)(_note[0] - _note[1])));
-	framecnt_t const g = grid_frames (start_sess_rel);
+	samplepos_t const start = min (_note[0], _note[1]);
+	samplepos_t const start_sess_rel = start + _region_view->region()->position();
+	samplecnt_t length = max (_editor->pixel_to_sample (1.0), (samplecnt_t) fabs ((double)(_note[0] - _note[1])));
+	samplecnt_t const g = grid_samples (start_sess_rel);
 
 	if (_editor->get_grid_music_divisions (ev->button.state) != 0 && length < g) {
 		length = g;
 	}
 
 	TempoMap& map (_editor->session()->tempo_map());
-	const double qn_length = map.quarter_notes_between_frames (start_sess_rel, start_sess_rel + length);
+	const double qn_length = map.quarter_notes_between_samples (start_sess_rel, start_sess_rel + length);
 	Evoral::Beats qn_length_beats = max (Evoral::Beats::ticks(1), Evoral::Beats (qn_length));
 
 	_editor->begin_reversible_command (_("Create Note"));
@@ -6786,10 +6786,10 @@ HitCreateDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 
 	_y = _region_view->note_to_y (_region_view->y_to_note (y_to_region (event->button.y)));
 
-	const framepos_t pf = _drags->current_pointer_frame ();
+	const samplepos_t pf = _drags->current_pointer_sample ();
 	const int32_t divisions = _editor->get_grid_music_divisions (event->button.state);
 
-	const double eqaf = map.exact_qn_at_frame (pf, divisions);
+	const double eqaf = map.exact_qn_at_sample (pf, divisions);
 
 	boost::shared_ptr<MidiRegion> mr = _region_view->midi_region();
 
@@ -6797,7 +6797,7 @@ HitCreateDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 		return;
 	}
 
-	const framepos_t start = map.frame_at_quarter_note (eqaf) - _region_view->region()->position();
+	const samplepos_t start = map.sample_at_quarter_note (eqaf) - _region_view->region()->position();
 	Evoral::Beats length = _region_view->get_grid_beats (pf);
 
 	_editor->begin_reversible_command (_("Create Hit"));
@@ -6812,15 +6812,15 @@ HitCreateDrag::motion (GdkEvent* event, bool)
 {
 	TempoMap& map (_editor->session()->tempo_map());
 
-	const framepos_t pf = _drags->current_pointer_frame ();
+	const samplepos_t pf = _drags->current_pointer_sample ();
 	const int32_t divisions = _editor->get_grid_music_divisions (event->button.state);
 
 	if (divisions == 0) {
 		return;
 	}
 
-	const double eqaf = map.exact_qn_at_frame (pf, divisions);
-	const framepos_t start = map.frame_at_quarter_note (eqaf) - _region_view->region()->position ();
+	const double eqaf = map.exact_qn_at_sample (pf, divisions);
+	const samplepos_t start = map.sample_at_quarter_note (eqaf) - _region_view->region()->position ();
 
 	if (_last_pos == start) {
 		return;
@@ -6879,7 +6879,7 @@ CrossfadeEdgeDrag::motion (GdkEvent*, bool)
 {
 	double distance;
 	double new_length;
-	framecnt_t len;
+	samplecnt_t len;
 
 	boost::shared_ptr<AudioRegion> ar (arv->audio_region());
 
@@ -6911,7 +6911,7 @@ CrossfadeEdgeDrag::finished (GdkEvent*, bool)
 {
 	double distance;
 	double new_length;
-	framecnt_t len;
+	samplecnt_t len;
 
 	boost::shared_ptr<AudioRegion> ar (arv->audio_region());
 
@@ -6956,7 +6956,7 @@ CrossfadeEdgeDrag::aborted (bool)
 	}
 }
 
-RegionCutDrag::RegionCutDrag (Editor* e, ArdourCanvas::Item* item, framepos_t pos)
+RegionCutDrag::RegionCutDrag (Editor* e, ArdourCanvas::Item* item, samplepos_t pos)
 	: Drag (e, item, true)
 	, line (new EditorCursor (*e))
 {
@@ -6980,10 +6980,10 @@ RegionCutDrag::start_grab (GdkEvent* event, Gdk::Cursor* c)
 void
 RegionCutDrag::motion (GdkEvent* event, bool)
 {
-	MusicFrame pos (_drags->current_pointer_frame(), 0);
+	MusicSample pos (_drags->current_pointer_sample(), 0);
 	_editor->snap_to_with_modifier (pos, event);
 
-	line->set_position (pos.frame);
+	line->set_position (pos.sample);
 }
 
 void
@@ -6992,11 +6992,11 @@ RegionCutDrag::finished (GdkEvent* event, bool)
 	_editor->get_track_canvas()->canvas()->re_enter();
 
 
-	MusicFrame pos (_drags->current_pointer_frame(), 0);
+	MusicSample pos (_drags->current_pointer_sample(), 0);
 	_editor->snap_to_with_modifier (pos, event);
 	line->hide ();
 
-	RegionSelection rs = _editor->get_regions_from_selection_and_mouse (pos.frame);
+	RegionSelection rs = _editor->get_regions_from_selection_and_mouse (pos.sample);
 
 	if (rs.empty()) {
 		return;