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, 128 insertions, 128 deletions

diff --git a/libs/ardour/ardour/session.h b/libs/ardour/ardour/session.h
index 02534c682f..b052ba5b69 100644
--- a/libs/ardour/ardour/session.h
+++ b/libs/ardour/ardour/session.h
@@ -300,7 +300,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	StripableList get_stripables () const;
 	boost::shared_ptr<RouteList> get_tracks() const;
 	boost::shared_ptr<RouteList> get_routes_with_internal_returns() const;
-	boost::shared_ptr<RouteList> get_routes_with_regions_at (framepos_t const) const;
+	boost::shared_ptr<RouteList> get_routes_with_regions_at (samplepos_t const) const;
 
 	uint32_t nstripables (bool with_monitor = false) const;
 	uint32_t nroutes() const { return routes.reader()->size(); }
@@ -385,8 +385,8 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	 */
 	PBD::Signal0<void> TransportStateChange;
 
-	PBD::Signal1<void,framepos_t> PositionChanged; /* sent after any non-sequential motion */
-	PBD::Signal1<void,framepos_t> Xrun;
+	PBD::Signal1<void,samplepos_t> PositionChanged; /* sent after any non-sequential motion */
+	PBD::Signal1<void,samplepos_t> Xrun;
 	PBD::Signal0<void> TransportLooped;
 
 	/** emitted when a locate has occurred */
@@ -414,15 +414,15 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 
 	void queue_event (SessionEvent*);
 
-	void request_roll_at_and_return (framepos_t start, framepos_t return_to);
-	void request_bounded_roll (framepos_t start, framepos_t end);
+	void request_roll_at_and_return (samplepos_t start, samplepos_t return_to);
+	void request_bounded_roll (samplepos_t start, samplepos_t end);
 	void request_stop (bool abort = false, bool clear_state = false);
-	void request_locate (framepos_t frame, bool with_roll = false);
+	void request_locate (samplepos_t sample, bool with_roll = false);
 
 	void request_play_loop (bool yn, bool leave_rolling = false);
 	bool get_play_loop () const { return play_loop; }
 
-	framepos_t last_transport_start () const { return _last_roll_location; }
+	samplepos_t last_transport_start () const { return _last_roll_location; }
 	void goto_end ();
 	void goto_start (bool and_roll = false);
 	void use_rf_shuttle_speed ();
@@ -440,16 +440,16 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 
 	int wipe ();
 
-	framepos_t current_end_frame () const;
-	framepos_t current_start_frame () const;
+	samplepos_t current_end_sample () const;
+	samplepos_t current_start_sample () const;
 	/** "actual" sample rate of session, set by current audioengine rate, pullup/down etc. */
-	framecnt_t frame_rate () const { return _current_frame_rate; }
+	samplecnt_t sample_rate () const { return _current_sample_rate; }
 	/** "native" sample rate of session, regardless of current audioengine rate, pullup/down etc */
-	framecnt_t nominal_frame_rate () const { return _nominal_frame_rate; }
-	framecnt_t frames_per_hour () const { return _frames_per_hour; }
+	samplecnt_t nominal_sample_rate () const { return _nominal_sample_rate; }
+	samplecnt_t frames_per_hour () const { return _frames_per_hour; }
 
 	double samples_per_timecode_frame() const { return _samples_per_timecode_frame; }
-	framecnt_t timecode_frames_per_hour() const { return _timecode_frames_per_hour; }
+	samplecnt_t timecode_frames_per_hour() const { return _timecode_frames_per_hour; }
 
 	MIDI::byte get_mtc_timecode_bits() const {
 		return mtc_timecode_bits;   /* encoding of SMTPE type for MTC */
@@ -468,16 +468,16 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 
 	void set_auto_punch_location (Location *);
 	void set_auto_loop_location (Location *);
-	void set_session_extents (framepos_t start, framepos_t end);
+	void set_session_extents (samplepos_t start, samplepos_t end);
 	bool end_is_free () const { return _session_range_end_is_free; }
 	void set_end_is_free (bool);
 	int location_name(std::string& result, std::string base = std::string(""));
 
 	pframes_t get_block_size()        const { return current_block_size; }
-	framecnt_t worst_output_latency () const { return _worst_output_latency; }
-	framecnt_t worst_input_latency ()  const { return _worst_input_latency; }
-	framecnt_t worst_track_latency ()  const { return _worst_track_latency; }
-	framecnt_t worst_playback_latency () const { return _worst_output_latency + _worst_track_latency; }
+	samplecnt_t worst_output_latency () const { return _worst_output_latency; }
+	samplecnt_t worst_input_latency ()  const { return _worst_input_latency; }
+	samplecnt_t worst_track_latency ()  const { return _worst_track_latency; }
+	samplecnt_t worst_playback_latency () const { return _worst_output_latency + _worst_track_latency; }
 
 	struct SaveAs {
 		std::string new_parent_folder;  /* parent folder where new session folder will be created */
@@ -677,11 +677,11 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 
 	/* Time */
 
-	framepos_t transport_frame () const {return _transport_frame; }
-	framepos_t record_location () const {return _last_record_location; }
-	framepos_t audible_frame (bool* latent_locate = NULL) const;
-	framepos_t requested_return_frame() const { return _requested_return_frame; }
-	void set_requested_return_frame(framepos_t return_to);
+	samplepos_t transport_sample () const {return _transport_sample; }
+	samplepos_t record_location () const {return _last_record_location; }
+	samplepos_t audible_sample (bool* latent_locate = NULL) const;
+	samplepos_t requested_return_sample() const { return _requested_return_sample; }
+	void set_requested_return_sample(samplepos_t return_to);
 
 	enum PullupFormat {
 		pullup_Plus4Plus1,
@@ -697,21 +697,21 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 
 	void sync_time_vars();
 
-	void bbt_time (framepos_t when, Timecode::BBT_Time&);
-	void timecode_to_sample(Timecode::Time& timecode, framepos_t& sample, bool use_offset, bool use_subframes) const;
-	void sample_to_timecode(framepos_t sample, Timecode::Time& timecode, bool use_offset, bool use_subframes) const;
+	void bbt_time (samplepos_t when, Timecode::BBT_Time&);
+	void timecode_to_sample(Timecode::Time& timecode, samplepos_t& sample, bool use_offset, bool use_subframes) const;
+	void sample_to_timecode(samplepos_t sample, Timecode::Time& timecode, bool use_offset, bool use_subframes) const;
 	void timecode_time (Timecode::Time &);
-	void timecode_time (framepos_t when, Timecode::Time&);
-	void timecode_time_subframes (framepos_t when, Timecode::Time&);
+	void timecode_time (samplepos_t when, Timecode::Time&);
+	void timecode_time_subframes (samplepos_t when, Timecode::Time&);
 
-	void timecode_duration (framecnt_t, Timecode::Time&) const;
-	void timecode_duration_string (char *, size_t len, framecnt_t) const;
+	void timecode_duration (samplecnt_t, Timecode::Time&) const;
+	void timecode_duration_string (char *, size_t len, samplecnt_t) const;
 
-	framecnt_t convert_to_frames (AnyTime const & position);
-	framecnt_t any_duration_to_frames (framepos_t position, AnyTime const & duration);
+	samplecnt_t convert_to_samples (AnyTime const & position);
+	samplecnt_t any_duration_to_samples (samplepos_t position, AnyTime const & duration);
 
-	static PBD::Signal1<void, framepos_t> StartTimeChanged;
-	static PBD::Signal1<void, framepos_t> EndTimeChanged;
+	static PBD::Signal1<void, samplepos_t> StartTimeChanged;
+	static PBD::Signal1<void, samplepos_t> EndTimeChanged;
 
 	void   request_sync_source (Slave*);
 	bool   synced_to_engine() const { return _slave && config.get_external_sync() && Config->get_sync_source() == Engine; }
@@ -747,9 +747,9 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	boost::shared_ptr<ExportHandler> get_export_handler ();
 	boost::shared_ptr<ExportStatus> get_export_status ();
 
-	int start_audio_export (framepos_t position, bool realtime = false, bool region_export = false, bool comensate_master_latency = false);
+	int start_audio_export (samplepos_t position, bool realtime = false, bool region_export = false, bool comensate_master_latency = false);
 
-	PBD::Signal1<int, framecnt_t> ProcessExport;
+	PBD::Signal1<int, samplecnt_t> ProcessExport;
 	static PBD::Signal2<void,std::string, std::string> Exported;
 
 	void add_source (boost::shared_ptr<Source>);
@@ -779,10 +779,10 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	/** handlers should return 0 for "ignore the rate mismatch",
 	    !0 for "do not use this session"
 	*/
-	static PBD::Signal2<int, framecnt_t, framecnt_t> AskAboutSampleRateMismatch;
+	static PBD::Signal2<int, samplecnt_t, samplecnt_t> AskAboutSampleRateMismatch;
 
 	/** non interactive message */
-	static PBD::Signal2<void, framecnt_t, framecnt_t> NotifyAboutSampleRateMismatch;
+	static PBD::Signal2<void, samplecnt_t, samplecnt_t> NotifyAboutSampleRateMismatch;
 
 	/** handlers should return !0 for use pending state, 0 for ignore it.
 	 */
@@ -825,7 +825,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 
 	/* flattening stuff */
 
-	boost::shared_ptr<Region> write_one_track (Track&, framepos_t start, framepos_t end,
+	boost::shared_ptr<Region> write_one_track (Track&, samplepos_t start, samplepos_t end,
 	                                           bool overwrite, std::vector<boost::shared_ptr<Source> >&, InterThreadInfo& wot,
 	                                           boost::shared_ptr<Processor> endpoint,
 	                                           bool include_endpoint, bool for_export, bool for_freeze);
@@ -910,7 +910,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 
 	/* s/w "RAID" management */
 
-	boost::optional<framecnt_t> available_capture_duration();
+	boost::optional<samplecnt_t> available_capture_duration();
 
 	/* I/O bundles */
 
@@ -1004,25 +1004,25 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	void request_cancel_play_range ();
 	bool get_play_range () const { return _play_range; }
 
-	void maybe_update_session_range (framepos_t, framepos_t);
+	void maybe_update_session_range (samplepos_t, samplepos_t);
 
 	/* preroll */
-	framecnt_t preroll_samples (framepos_t) const;
+	samplecnt_t preroll_samples (samplepos_t) const;
 
-	void request_preroll_record_punch (framepos_t start, framecnt_t preroll);
-	void request_preroll_record_trim (framepos_t start, framecnt_t preroll);
+	void request_preroll_record_punch (samplepos_t start, samplecnt_t preroll);
+	void request_preroll_record_trim (samplepos_t start, samplecnt_t preroll);
 	void request_count_in_record ();
 
-	framepos_t preroll_record_punch_pos () const { return _preroll_record_punch_pos; }
+	samplepos_t preroll_record_punch_pos () const { return _preroll_record_punch_pos; }
 	bool preroll_record_punch_enabled () const { return _preroll_record_punch_pos >= 0; }
 
-	framecnt_t preroll_record_trim_len () const { return _preroll_record_trim_len; }
+	samplecnt_t preroll_record_trim_len () const { return _preroll_record_trim_len; }
 
 	/* temporary hacks to allow selection to be pushed from GUI into backend.
 	   Whenever we move the selection object into libardour, these will go away.
 	 */
-	void set_range_selection (framepos_t start, framepos_t end);
-	void set_object_selection (framepos_t start, framepos_t end);
+	void set_range_selection (samplepos_t start, samplepos_t end);
+	void set_object_selection (samplepos_t start, samplepos_t end);
 	void clear_range_selection ();
 	void clear_object_selection ();
 
@@ -1115,7 +1115,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 
 	boost::shared_ptr<SessionPlaylists> playlists;
 
-	void send_mmc_locate (framepos_t);
+	void send_mmc_locate (samplepos_t);
 	void queue_full_time_code () { _send_timecode_update = true; }
 	void queue_song_position_pointer () { /* currently does nothing */ }
 
@@ -1206,7 +1206,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
   protected:
 	friend class AudioEngine;
 	void set_block_size (pframes_t nframes);
-	void set_frame_rate (framecnt_t nframes);
+	void set_sample_rate (samplecnt_t nframes);
 #ifdef USE_TRACKS_CODE_FEATURES
 	void reconnect_existing_routes (bool withLock, bool reconnect_master = true, bool reconnect_inputs = true, bool reconnect_outputs = true);
 #endif
@@ -1236,12 +1236,12 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	process_function_type    last_process_function;
 	bool                    _bounce_processing_active;
 	bool                     waiting_for_sync_offset;
-	framecnt_t              _base_frame_rate;     // sample-rate of the session at creation time, "native" SR
-	framecnt_t              _nominal_frame_rate;  // overridden by audioengine setting
-	framecnt_t              _current_frame_rate;  // this includes video pullup offset
+	samplecnt_t              _base_sample_rate;     // sample-rate of the session at creation time, "native" SR
+	samplecnt_t              _nominal_sample_rate;  // overridden by audioengine setting
+	samplecnt_t              _current_sample_rate;  // this includes video pullup offset
 	int                      transport_sub_state;
 	mutable gint            _record_status;
-	framepos_t              _transport_frame;
+	samplepos_t              _transport_sample;
 	gint                    _seek_counter;
 	Location*               _session_range_location; ///< session range, or 0 if there is nothing in the session yet
 	bool                    _session_range_end_is_free;
@@ -1257,13 +1257,13 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	CubicInterpolation       interpolation;
 
 	bool                     auto_play_legal;
-	framepos_t              _last_slave_transport_frame;
-	framecnt_t               maximum_output_latency;
-	framepos_t              _requested_return_frame;
+	samplepos_t              _last_slave_transport_sample;
+	samplecnt_t               maximum_output_latency;
+	samplepos_t              _requested_return_sample;
 	pframes_t                current_block_size;
-	framecnt_t              _worst_output_latency;
-	framecnt_t              _worst_input_latency;
-	framecnt_t              _worst_track_latency;
+	samplecnt_t              _worst_output_latency;
+	samplecnt_t              _worst_input_latency;
+	samplecnt_t              _worst_track_latency;
 	bool                    _have_captured;
 	bool                    _non_soloed_outs_muted;
 	bool                    _listening;
@@ -1306,7 +1306,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	void unblock_processing() { g_atomic_int_set (&processing_prohibited, 0); }
 	bool processing_blocked() const { return g_atomic_int_get (&processing_prohibited); }
 
-	static const framecnt_t bounce_chunk_size;
+	static const samplecnt_t bounce_chunk_size;
 
 	/* slave tracking */
 
@@ -1320,26 +1320,26 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	SlaveState _slave_state;
 	gint _mtc_active;
 	gint _ltc_active;
-	framepos_t slave_wait_end;
+	samplepos_t slave_wait_end;
 
 	void reset_slave_state ();
 	bool follow_slave (pframes_t);
-	void calculate_moving_average_of_slave_delta (int dir, framecnt_t this_delta);
-	void track_slave_state (float slave_speed, framepos_t slave_transport_frame, framecnt_t this_delta);
+	void calculate_moving_average_of_slave_delta (int dir, samplecnt_t this_delta);
+	void track_slave_state (float slave_speed, samplepos_t slave_transport_sample, samplecnt_t this_delta);
 
 	void switch_to_sync_source (SyncSource); /* !RT context */
 	void drop_sync_source ();  /* !RT context */
 	void use_sync_source (Slave*); /* RT context */
 
 	bool post_export_sync;
-	framepos_t post_export_position;
+	samplepos_t post_export_position;
 
 	bool _exporting;
 	bool _export_rolling;
 	bool _realtime_export;
 	bool _region_export;
-	framepos_t _export_preroll;
-	framepos_t _export_latency;
+	samplepos_t _export_preroll;
+	samplepos_t _export_latency;
 
 	boost::shared_ptr<ExportHandler> export_handler;
 	boost::shared_ptr<ExportStatus>  export_status;
@@ -1380,7 +1380,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 		}
 	}
 
-	bool maybe_stop (framepos_t limit);
+	bool maybe_stop (samplepos_t limit);
 	bool maybe_sync_start (pframes_t &);
 
 	void check_declick_out ();
@@ -1389,13 +1389,13 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	std::string             _name;
 	bool                    _is_new;
 	bool                    _send_qf_mtc;
-	/** Number of process frames since the last MTC output (when sending MTC); used to
+	/** Number of process samples since the last MTC output (when sending MTC); used to
 	 *  know when to send full MTC messages every so often.
 	 */
 	pframes_t               _pframes_since_last_mtc;
 	bool                     play_loop;
 	bool                     loop_changing;
-	framepos_t               last_loopend;
+	samplepos_t               last_loopend;
 
 	boost::scoped_ptr<SessionDirectory> _session_dir;
 
@@ -1421,13 +1421,13 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	int        load_state (std::string snapshot_name);
 	static int parse_stateful_loading_version (const std::string&);
 
-	framepos_t _last_roll_location;
-	/** the session frame time at which we last rolled, located, or changed transport direction */
-	framepos_t _last_roll_or_reversal_location;
-	framepos_t _last_record_location;
+	samplepos_t _last_roll_location;
+	/** the session sample time at which we last rolled, located, or changed transport direction */
+	samplepos_t _last_roll_or_reversal_location;
+	samplepos_t _last_record_location;
 
 	bool              pending_locate_roll;
-	framepos_t        pending_locate_frame;
+	samplepos_t        pending_locate_sample;
 	bool              pending_locate_flush;
 	bool              pending_abort;
 	bool              pending_auto_loop;
@@ -1470,7 +1470,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	uint32_t    rf_scale;
 
 	void set_rf_speed (float speed);
-	void reset_rf_scale (framecnt_t frames_moved);
+	void reset_rf_scale (samplecnt_t samples_moved);
 
 	Locations*       _locations;
 	void location_added (Location*);
@@ -1494,7 +1494,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 
 	PBD::ScopedConnectionList loop_connections;
 	void             auto_loop_changed (Location *);
-	void             auto_loop_declick_range (Location *, framepos_t &, framepos_t &);
+	void             auto_loop_declick_range (Location *, samplepos_t &, samplepos_t &);
 
 	int  ensure_engine (uint32_t desired_sample_rate, bool);
 	void pre_engine_init (std::string path);
@@ -1509,19 +1509,19 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 
 	void enable_record ();
 
-	void increment_transport_position (framecnt_t val) {
-		if (max_framepos - val < _transport_frame) {
-			_transport_frame = max_framepos;
+	void increment_transport_position (samplecnt_t val) {
+		if (max_samplepos - val < _transport_sample) {
+			_transport_sample = max_samplepos;
 		} else {
-			_transport_frame += val;
+			_transport_sample += val;
 		}
 	}
 
-	void decrement_transport_position (framecnt_t val) {
-		if (val < _transport_frame) {
-			_transport_frame -= val;
+	void decrement_transport_position (samplecnt_t val) {
+		if (val < _transport_sample) {
+			_transport_sample -= val;
 		} else {
-			_transport_frame = 0;
+			_transport_sample = 0;
 		}
 	}
 
@@ -1633,19 +1633,19 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	Timecode::Time transmitting_timecode_time;
 	int next_quarter_frame_to_send;
 
-	double _samples_per_timecode_frame; /* has to be floating point because of drop frame */
-	framecnt_t _frames_per_hour;
-	framecnt_t _timecode_frames_per_hour;
+	double _samples_per_timecode_frame; /* has to be floating point because of drop sample */
+	samplecnt_t _frames_per_hour;
+	samplecnt_t _timecode_frames_per_hour;
 
 	/* cache the most-recently requested time conversions. This helps when we
-	 * have multiple clocks showing the same time (e.g. the transport frame) */
+	 * have multiple clocks showing the same time (e.g. the transport sample) */
 	bool last_timecode_valid;
-	framepos_t last_timecode_when;
+	samplepos_t last_timecode_when;
 	Timecode::Time last_timecode;
 
-	bool _send_timecode_update; ///< Flag to send a full frame (Timecode) MTC message this cycle
+	bool _send_timecode_update; ///< Flag to send a full sample (Timecode) MTC message this cycle
 
-	int send_midi_time_code_for_cycle (framepos_t, framepos_t, pframes_t nframes);
+	int send_midi_time_code_for_cycle (samplepos_t, samplepos_t, pframes_t nframes);
 
 	LTCEncoder*       ltc_encoder;
 	ltcsnd_sample_t*  ltc_enc_buf;
@@ -1656,13 +1656,13 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 
 	double            ltc_speed;
 	int32_t           ltc_enc_byte;
-	framepos_t        ltc_enc_pos;
+	samplepos_t        ltc_enc_pos;
 	double            ltc_enc_cnt;
-	framepos_t        ltc_enc_off;
+	samplepos_t        ltc_enc_off;
 	bool              restarting;
-	framepos_t        ltc_prev_cycle;
+	samplepos_t        ltc_prev_cycle;
 
-	framepos_t        ltc_timecode_offset;
+	samplepos_t        ltc_timecode_offset;
 	bool              ltc_timecode_negative_offset;
 
 	LatencyRange      ltc_out_latency;
@@ -1673,7 +1673,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	void ltc_tx_resync_latency();
 	void ltc_tx_recalculate_position();
 	void ltc_tx_parse_offset();
-	void ltc_tx_send_time_code_for_cycle (framepos_t, framepos_t, double, double, pframes_t nframes);
+	void ltc_tx_send_time_code_for_cycle (samplepos_t, samplepos_t, double, double, pframes_t nframes);
 	PBD::ScopedConnectionList ltc_tx_connections;
 
 
@@ -1693,11 +1693,11 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	void unset_play_loop ();
 	void overwrite_some_buffers (Track *);
 	void flush_all_inserts ();
-	int  micro_locate (framecnt_t distance);
-	void locate (framepos_t, bool with_roll, bool with_flush, bool with_loop=false, bool force=false, bool with_mmc=true);
-	void start_locate (framepos_t, bool with_roll, bool with_flush, bool for_loop_enabled=false, bool force=false);
-	void force_locate (framepos_t frame, bool with_roll = false);
-	void set_transport_speed (double speed, framepos_t destination_frame, bool abort = false, bool clear_state = false, bool as_default = false);
+	int  micro_locate (samplecnt_t distance);
+	void locate (samplepos_t, bool with_roll, bool with_flush, bool with_loop=false, bool force=false, bool with_mmc=true);
+	void start_locate (samplepos_t, bool with_roll, bool with_flush, bool for_loop_enabled=false, bool force=false);
+	void force_locate (samplepos_t sample, bool with_roll = false);
+	void set_transport_speed (double speed, samplepos_t destination_sample, bool abort = false, bool clear_state = false, bool as_default = false);
 	void stop_transport (bool abort = false, bool clear_state = false);
 	void start_transport ();
 	void realtime_stop (bool abort, bool clear_state);
@@ -1711,15 +1711,15 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	void engine_halted ();
 	void xrun_recovery ();
 	void set_track_loop (bool);
-	bool select_playhead_priority_target (framepos_t&);
+	bool select_playhead_priority_target (samplepos_t&);
 	void follow_playhead_priority ();
 
 	/* These are synchronous and so can only be called from within the process
 	 * cycle
 	 */
 
-	int  send_full_time_code (framepos_t, pframes_t nframes);
-	void send_song_position_pointer (framepos_t);
+	int  send_full_time_code (samplepos_t, pframes_t nframes);
+	void send_song_position_pointer (samplepos_t);
 
 	TempoMap    *_tempo_map;
 	void          tempo_map_changed (const PBD::PropertyChange&);
@@ -1807,8 +1807,8 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	void remove_playlist (boost::weak_ptr<Playlist>);
 	void track_playlist_changed (boost::weak_ptr<Track>);
 	void playlist_region_added (boost::weak_ptr<Region>);
-	void playlist_ranges_moved (std::list<Evoral::RangeMove<framepos_t> > const &);
-	void playlist_regions_extended (std::list<Evoral::Range<framepos_t> > const &);
+	void playlist_ranges_moved (std::list<Evoral::RangeMove<samplepos_t> > const &);
+	void playlist_regions_extended (std::list<Evoral::Range<samplepos_t> > const &);
 
 	/* CURVES and AUTOMATION LISTS */
 	std::map<PBD::ID, AutomationList*> automation_lists;
@@ -1829,7 +1829,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 
 	/* FLATTEN */
 
-	int flatten_one_track (AudioTrack&, framepos_t start, framecnt_t cnt);
+	int flatten_one_track (AudioTrack&, samplepos_t start, samplecnt_t cnt);
 
 	/* INSERT AND SEND MANAGEMENT */
 
@@ -1894,7 +1894,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	 */
 	std::list<GQuark> _current_trans_quarks;
 
-	int  backend_sync_callback (TransportState, framepos_t);
+	int  backend_sync_callback (TransportState, samplepos_t);
 
 	void process_rtop (SessionEvent*);
 
@@ -1917,24 +1917,24 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	boost::shared_ptr<Amp> _click_gain;
 	Sample*                 click_data;
 	Sample*                 click_emphasis_data;
-	framecnt_t              click_length;
-	framecnt_t              click_emphasis_length;
+	samplecnt_t              click_length;
+	samplecnt_t              click_emphasis_length;
 	mutable Glib::Threads::RWLock    click_lock;
 
 	static const Sample     default_click[];
-	static const framecnt_t default_click_length;
+	static const samplecnt_t default_click_length;
 	static const Sample     default_click_emphasis[];
-	static const framecnt_t default_click_emphasis_length;
+	static const samplecnt_t default_click_emphasis_length;
 
 	Click *get_click();
-	framepos_t _clicks_cleared;
+	samplepos_t _clicks_cleared;
 	void   setup_click_sounds (int which);
-	void   setup_click_sounds (Sample**, Sample const *, framecnt_t*, framecnt_t, std::string const &);
+	void   setup_click_sounds (Sample**, Sample const *, samplecnt_t*, samplecnt_t, std::string const &);
 	void   clear_clicks ();
-	void   click (framepos_t start, framecnt_t nframes);
-	void   run_click (framepos_t start, framecnt_t nframes);
-	void   add_click (framepos_t pos, bool emphasis);
-	framecnt_t _count_in_samples;
+	void   click (samplepos_t start, samplecnt_t nframes);
+	void   run_click (samplepos_t start, samplecnt_t nframes);
+	void   add_click (samplepos_t pos, bool emphasis);
+	samplecnt_t _count_in_samples;
 
 	/* range playback */
 
@@ -1946,14 +1946,14 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	/* temporary hacks to allow selection to be pushed from GUI into backend
 	   Whenever we move the selection object into libardour, these will go away.
 	*/
-	Evoral::Range<framepos_t> _range_selection;
-	Evoral::Range<framepos_t> _object_selection;
+	Evoral::Range<samplepos_t> _range_selection;
+	Evoral::Range<samplepos_t> _object_selection;
 
 	void unset_preroll_record_punch ();
 	void unset_preroll_record_trim ();
 
-	framepos_t _preroll_record_punch_pos;
-	framecnt_t _preroll_record_trim_len;
+	samplepos_t _preroll_record_punch_pos;
+	samplecnt_t _preroll_record_trim_len;
 	bool _count_in_once;
 
 	/* main outs */
@@ -1986,7 +1986,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	static bool _disable_all_loaded_plugins;
 	static bool _bypass_all_loaded_plugins;
 
-	mutable bool have_looped; ///< Used in ::audible_frame(*)
+	mutable bool have_looped; ///< Used in ::audible_sample(*)
 
 	void update_route_record_state ();
 	gint _have_rec_enabled_track;
@@ -2031,7 +2031,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 	void rt_set_controls (boost::shared_ptr<ControlList>, double val, PBD::Controllable::GroupControlDisposition group_override);
 	void rt_clear_all_solo_state (boost::shared_ptr<RouteList>, bool yn, PBD::Controllable::GroupControlDisposition group_override);
 
-	void set_session_range_location (framepos_t, framepos_t);
+	void set_session_range_location (samplepos_t, samplepos_t);
 
 	void setup_midi_machine_control ();
 
@@ -2043,11 +2043,11 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 
 	void update_locations_after_tempo_map_change (const Locations::LocationList &);
 
-	void start_time_changed (framepos_t);
-	void end_time_changed (framepos_t);
+	void start_time_changed (samplepos_t);
+	void end_time_changed (samplepos_t);
 
 	void set_track_monitor_input_status (bool);
-	framepos_t compute_stop_limit () const;
+	samplepos_t compute_stop_limit () const;
 
 	boost::shared_ptr<Speakers> _speakers;
 	void load_nested_sources (const XMLNode& node);