* libardour uses ARDOUR::nframes_t and ARDOUR::nframes64_t explicitly in headers

* use explicit operator<< and operator>> that in turn use PBD::EnumWriter when serializing and deserializing to/from rc files
* adds scrolling in mixer window (from 2.X)
* BBT math stuff - untested, but basically operational
* move LocaleGuard into its own file(s) in libs/pbd
* Tempo now uses nframes64_t everywhere (except for sample rate values)
* as in 2.X, use mkstemp and hack to avoid temp file nonsense, and remove erroneous free() from disk stats output


git-svn-id: svn://localhost/ardour2/branches/3.0@5961 d708f5d6-7413-0410-9779-e7cbd77b26cf

9 files changed, 109 insertions, 103 deletions

diff --git a/libs/ardour/ardour/ardour.h b/libs/ardour/ardour/ardour.h
index d7c67998c7..a1b3d06f62 100644
--- a/libs/ardour/ardour/ardour.h
+++ b/libs/ardour/ardour/ardour.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 1999 Paul Davis
+    Copyright (C) 1999-2009 Paul Davis
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -28,10 +28,11 @@
 
 #include "pbd/error.h"
 #include "pbd/failed_constructor.h"
+#include "pbd/locale_guard.h"
 
 #include "ardour/types.h"
 
-// #include <jack/jack.h> need this to inline jack_get_microseconds
+#include <jack/jack.h> 
 
 namespace MIDI {
 	class MachineControl;
@@ -56,13 +57,10 @@ namespace ARDOUR {
 
 	const layer_t max_layer = UCHAR_MAX;
 
-	microseconds_t get_microseconds ();
-/*	{
-        JACK has exported this functionality for a long time now
-	but inlining this causes problems
-        return (microseconds_t) jack_get_time();
+	static inline microseconds_t get_microseconds () {
+		return (microseconds_t) jack_get_time();
 	}
-*/
+
 	Change new_change ();
 
 	extern Change StartChanged;
@@ -71,12 +69,6 @@ namespace ARDOUR {
 	extern Change NameChanged;
 	extern Change BoundsChanged;
 
-	struct LocaleGuard {
-		LocaleGuard (const char*);
-		~LocaleGuard ();
-		const char* old;
-	};
-
 	static const double SHUTTLE_FRACT_SPEED1=0.48412291827; /* derived from A1,A2 */
 
 	void setup_fpu ();
diff --git a/libs/ardour/ardour/bbt_time.h b/libs/ardour/ardour/bbt_time.h
index 44921ae6cc..b92bd2f18f 100644
--- a/libs/ardour/ardour/bbt_time.h
+++ b/libs/ardour/ardour/bbt_time.h
@@ -25,8 +25,6 @@
 
 namespace ARDOUR {
 
-class TempoMetric;
-
 struct BBT_Time {
     uint32_t bars;
     uint32_t beats;
diff --git a/libs/ardour/ardour/configuration_variable.h b/libs/ardour/ardour/configuration_variable.h
index 90859b72b1..9c9cf4463e 100644
--- a/libs/ardour/ardour/configuration_variable.h
+++ b/libs/ardour/ardour/configuration_variable.h
@@ -20,11 +20,11 @@
 #ifndef __ardour_configuration_variable_h__
 #define __ardour_configuration_variable_h__
 
-#include <sstream>
-#include <ostream>
 #include <iostream>
+#include <sstream>
 
 #include "pbd/xml++.h"
+#include "ardour/types.h"
 
 namespace ARDOUR {
 
@@ -41,13 +41,8 @@ class ConfigVariableBase {
 	virtual std::string get_as_string () const = 0;
 	virtual void set_from_string (std::string const &) = 0;
 
-	void show_stored_value (const std::string&);
-
-	static void set_show_stored_values (bool);
-
   protected:
 	std::string _name;
-	static bool show_stores;
 
 	void notify ();
 	void miss ();
@@ -66,7 +61,7 @@ class ConfigVariable : public ConfigVariableBase
 	}
 
 	std::string get_as_string () const {
-		std::stringstream ss;
+		std::ostringstream ss;
 		ss << value;
 		return ss.str ();
 	}
diff --git a/libs/ardour/ardour/debug.h b/libs/ardour/ardour/debug.h
index a8f826babe..d91b3c1449 100644
--- a/libs/ardour/ardour/debug.h
+++ b/libs/ardour/ardour/debug.h
@@ -38,7 +38,8 @@ namespace ARDOUR {
 			MidiSourceIO = 0x1,
 			MidiPlaylistIO = 0x2,
 			MidiDiskstreamIO = 0x4,
-			SnapBBT = 0x8
+			SnapBBT = 0x8,
+			Configuration = 0x10
 		};
 	}
 
diff --git a/libs/ardour/ardour/mix.h b/libs/ardour/ardour/mix.h
index fed0f467b2..72b414d09c 100644
--- a/libs/ardour/ardour/mix.h
+++ b/libs/ardour/ardour/mix.h
@@ -26,39 +26,39 @@
 
 extern "C" {
 /* SSE functions */
-    float x86_sse_compute_peak         (const ARDOUR::Sample * buf, nframes_t nsamples, float current);
-    void  x86_sse_apply_gain_to_buffer (ARDOUR::Sample * buf, nframes_t nframes, float gain);
-    void  x86_sse_mix_buffers_with_gain(ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes, float gain);
-    void  x86_sse_mix_buffers_no_gain  (ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes);
+    float x86_sse_compute_peak         (const ARDOUR::Sample * buf, ARDOUR::nframes_t nsamples, float current);
+    void  x86_sse_apply_gain_to_buffer (ARDOUR::Sample * buf, ARDOUR::nframes_t nframes, float gain);
+    void  x86_sse_mix_buffers_with_gain(ARDOUR::Sample * dst, const ARDOUR::Sample * src, ARDOUR::nframes_t nframes, float gain);
+    void  x86_sse_mix_buffers_no_gain  (ARDOUR::Sample * dst, const ARDOUR::Sample * src, ARDOUR::nframes_t nframes);
 }
 
-void  x86_sse_find_peaks               (const ARDOUR::Sample * buf, nframes_t nsamples, float *min, float *max);
+void  x86_sse_find_peaks               (const ARDOUR::Sample * buf, ARDOUR::nframes_t nsamples, float *min, float *max);
 
 /* debug wrappers for SSE functions */
 
-float debug_compute_peak               (const ARDOUR::Sample * buf, nframes_t nsamples, float current);
-void  debug_apply_gain_to_buffer       (ARDOUR::Sample * buf, nframes_t nframes, float gain);
-void  debug_mix_buffers_with_gain      (ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes, float gain);
-void  debug_mix_buffers_no_gain        (ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes);
+float debug_compute_peak               (const ARDOUR::Sample * buf, ARDOUR::nframes_t nsamples, float current);
+void  debug_apply_gain_to_buffer       (ARDOUR::Sample * buf, ARDOUR::nframes_t nframes, float gain);
+void  debug_mix_buffers_with_gain      (ARDOUR::Sample * dst, const ARDOUR::Sample * src, ARDOUR::nframes_t nframes, float gain);
+void  debug_mix_buffers_no_gain        (ARDOUR::Sample * dst, const ARDOUR::Sample * src, ARDOUR::nframes_t nframes);
 
 #endif
 
 #if defined (__APPLE__)
 
-float veclib_compute_peak              (const ARDOUR::Sample * buf, nframes_t nsamples, float current);
-void veclib_find_peaks                 (const ARDOUR::Sample * buf, nframes_t nsamples, float *min, float *max);
-void  veclib_apply_gain_to_buffer      (ARDOUR::Sample * buf, nframes_t nframes, float gain);
-void  veclib_mix_buffers_with_gain     (ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes, float gain);
-void  veclib_mix_buffers_no_gain       (ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes);
+float veclib_compute_peak              (const ARDOUR::Sample * buf, ARDOUR::nframes_t nsamples, float current);
+void veclib_find_peaks                 (const ARDOUR::Sample * buf, ARDOUR::nframes_t nsamples, float *min, float *max);
+void  veclib_apply_gain_to_buffer      (ARDOUR::Sample * buf, ARDOUR::nframes_t nframes, float gain);
+void  veclib_mix_buffers_with_gain     (ARDOUR::Sample * dst, const ARDOUR::Sample * src, ARDOUR::nframes_t nframes, float gain);
+void  veclib_mix_buffers_no_gain       (ARDOUR::Sample * dst, const ARDOUR::Sample * src, ARDOUR::nframes_t nframes);
 
 #endif
 
 /* non-optimized functions */
 
-float default_compute_peak              (const ARDOUR::Sample * buf, nframes_t nsamples, float current);
-void  default_find_peaks                (const ARDOUR::Sample * buf, nframes_t nsamples, float *min, float *max);
-void  default_apply_gain_to_buffer      (ARDOUR::Sample * buf, nframes_t nframes, float gain);
-void  default_mix_buffers_with_gain     (ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes, float gain);
-void  default_mix_buffers_no_gain       (ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes);
+float default_compute_peak              (const ARDOUR::Sample * buf, ARDOUR::nframes_t nsamples, float current);
+void  default_find_peaks                (const ARDOUR::Sample * buf, ARDOUR::nframes_t nsamples, float *min, float *max);
+void  default_apply_gain_to_buffer      (ARDOUR::Sample * buf, ARDOUR::nframes_t nframes, float gain);
+void  default_mix_buffers_with_gain     (ARDOUR::Sample * dst, const ARDOUR::Sample * src, ARDOUR::nframes_t nframes, float gain);
+void  default_mix_buffers_no_gain       (ARDOUR::Sample * dst, const ARDOUR::Sample * src, ARDOUR::nframes_t nframes);
 
 #endif /* __ardour_mix_h__ */
diff --git a/libs/ardour/ardour/peak.h b/libs/ardour/ardour/peak.h
index 5be2c08f41..2283f50118 100644
--- a/libs/ardour/ardour/peak.h
+++ b/libs/ardour/ardour/peak.h
@@ -25,9 +25,9 @@
 #include "ardour/utils.h"
 
 static inline float
-default_compute_peak (const ARDOUR::Sample * const buf, nframes_t nsamples, float current)
+default_compute_peak (const ARDOUR::Sample * const buf, ARDOUR::nframes_t nsamples, float current)
 {
-	for (nframes_t i = 0; i < nsamples; ++i) {
+	for (ARDOUR::nframes_t i = 0; i < nsamples; ++i) {
 		current = f_max (current, fabsf (buf[i]));
 	}
 	return current;
diff --git a/libs/ardour/ardour/tempo.h b/libs/ardour/ardour/tempo.h
index 99dfffa81f..28c974bff1 100644
--- a/libs/ardour/ardour/tempo.h
+++ b/libs/ardour/ardour/tempo.h
@@ -81,18 +81,18 @@ class MetricSection {
   public:
 	MetricSection (const BBT_Time& start)
 		: _start (start), _frame (0), _movable (true) {}
-	MetricSection (nframes_t start)
+	MetricSection (nframes64_t start)
 		: _frame (start), _movable (true) {}
 
 	virtual ~MetricSection() {}
 
 	const BBT_Time& start() const { return _start; }
-	nframes_t       frame() const { return _frame; }
+	nframes64_t       frame() const { return _frame; }
 
 	void set_movable (bool yn) { _movable = yn; }
 	bool movable() const { return _movable; }
 
-	virtual void set_frame (nframes_t f) {
+	virtual void set_frame (nframes64_t f) {
 		_frame = f;
 	}
 
@@ -108,7 +108,7 @@ class MetricSection {
 
   private:
 	BBT_Time       _start;
-	nframes_t      _frame;
+	nframes64_t      _frame;
 	bool           _movable;
 };
 
@@ -116,7 +116,7 @@ class MeterSection : public MetricSection, public Meter {
   public:
 	MeterSection (const BBT_Time& start, double bpb, double note_type)
 		: MetricSection (start), Meter (bpb, note_type) {}
-	MeterSection (nframes_t start, double bpb, double note_type)
+	MeterSection (nframes64_t start, double bpb, double note_type)
 		: MetricSection (start), Meter (bpb, note_type) {}
 	MeterSection (const XMLNode&);
 
@@ -129,7 +129,7 @@ class TempoSection : public MetricSection, public Tempo {
   public:
 	TempoSection (const BBT_Time& start, double qpm, double note_type)
 		: MetricSection (start), Tempo (qpm, note_type) {}
-	TempoSection (nframes_t start, double qpm, double note_type)
+	TempoSection (nframes64_t start, double qpm, double note_type)
 		: MetricSection (start), Tempo (qpm, note_type) {}
 	TempoSection (const XMLNode&);
 
@@ -149,25 +149,25 @@ class TempoMetric {
 	
 	void set_tempo (const Tempo& t)    { _tempo = &t; }
 	void set_meter (const Meter& m)    { _meter = &m; }
-	void set_frame (nframes_t f)       { _frame = f; }
+	void set_frame (nframes64_t f)     { _frame = f; }
 	void set_start (const BBT_Time& t) { _start = t; }
 	
 	const Meter&    meter() const { return *_meter; }
 	const Tempo&    tempo() const { return *_tempo; }
-	nframes_t       frame() const { return _frame; }
+	nframes64_t     frame() const { return _frame; }
 	const BBT_Time& start() const { return _start; }
 	
   private:
 	const Meter*   _meter;
 	const Tempo*   _tempo;
-	nframes_t      _frame;
+	nframes64_t    _frame;
 	BBT_Time       _start;
 };
 
 class TempoMap : public PBD::StatefulDestructible
 {
   public:
-	TempoMap (nframes_t frame_rate);
+	TempoMap (nframes64_t frame_rate);
 	~TempoMap();
 
 	/* measure-based stuff */
@@ -179,13 +179,13 @@ class TempoMap : public PBD::StatefulDestructible
 
 	struct BBTPoint {
 		BBTPointType type;
-		nframes_t frame;
+		nframes64_t  frame;
 		const Meter* meter;
 		const Tempo* tempo;
 		uint32_t bar;
 		uint32_t beat;
 
-		BBTPoint (const Meter& m, const Tempo& t, nframes_t f,
+		BBTPoint (const Meter& m, const Tempo& t, nframes64_t f,
 				BBTPointType ty, uint32_t b, uint32_t e)
 			: type (ty), frame (f), meter (&m), tempo (&t), bar (b), beat (e) {}
 	};
@@ -197,27 +197,27 @@ class TempoMap : public PBD::StatefulDestructible
 		(obj.*method)(*metrics);
 	}
 
-	BBTPointList *get_points (nframes_t start, nframes_t end) const;
+	BBTPointList *get_points (nframes64_t start, nframes64_t end) const;
 
-	void      bbt_time (nframes_t when, BBT_Time&) const;
-	nframes_t frame_time (const BBT_Time&) const;
-	nframes_t bbt_duration_at (nframes_t, const BBT_Time&, int dir) const;
+	void      bbt_time (nframes64_t when, BBT_Time&) const;
+	nframes64_t frame_time (const BBT_Time&) const;
+	nframes64_t bbt_duration_at (nframes64_t, const BBT_Time&, int dir) const;
 
 	void bbt_time_add (nframes64_t origin, BBT_Time& start, const BBT_Time& shift);
 
 	static const Tempo& default_tempo() { return _default_tempo; }
 	static const Meter& default_meter() { return _default_meter; }
 
-	const Tempo& tempo_at (nframes_t) const;
-	const Meter& meter_at (nframes_t) const;
+	const Tempo& tempo_at (nframes64_t) const;
+	const Meter& meter_at (nframes64_t) const;
 
-	const TempoSection& tempo_section_at (nframes_t);
+	const TempoSection& tempo_section_at (nframes64_t);
 
 	void add_tempo(const Tempo&, BBT_Time where);
 	void add_meter(const Meter&, BBT_Time where);
 
-	void add_tempo(const Tempo&, nframes_t where);
-	void add_meter(const Meter&, nframes_t where);
+	void add_tempo(const Tempo&, nframes64_t where);
+	void add_meter(const Meter&, nframes64_t where);
 
 	void move_tempo (TempoSection&, const BBT_Time& to);
 	void move_meter (MeterSection&, const BBT_Time& to);
@@ -228,12 +228,12 @@ class TempoMap : public PBD::StatefulDestructible
 	void replace_tempo (TempoSection& existing, const Tempo& replacement);
 	void replace_meter (MeterSection& existing, const Meter& replacement);
 
-	nframes_t round_to_bar  (nframes_t frame, int dir);
-	nframes_t round_to_beat (nframes_t frame, int dir);
-	nframes_t round_to_beat_subdivision (nframes_t fr, int sub_num, int dir);
-	nframes_t round_to_tick (nframes_t frame, int dir);
+	nframes64_t round_to_bar  (nframes64_t frame, int dir);
+	nframes64_t round_to_beat (nframes64_t frame, int dir);
+	nframes64_t round_to_beat_subdivision (nframes64_t fr, int sub_num, int dir);
+	nframes64_t round_to_tick (nframes64_t frame, int dir);
 
-	void set_length (nframes_t frames);
+	void set_length (nframes64_t frames);
 
 	XMLNode& get_state (void);
 	int set_state (const XMLNode&, int version);
@@ -242,21 +242,21 @@ class TempoMap : public PBD::StatefulDestructible
 	void clear ();
 
 	TempoMetric metric_at (BBT_Time bbt) const;
-	TempoMetric metric_at (nframes_t) const;
-	void bbt_time_with_metric (nframes_t, BBT_Time&, const TempoMetric&) const;
+	TempoMetric metric_at (nframes64_t) const;
+	void bbt_time_with_metric (nframes64_t, BBT_Time&, const TempoMetric&) const;
 
-	void change_existing_tempo_at (nframes_t, double bpm, double note_type);
+	BBT_Time bbt_add (const BBT_Time&, const BBT_Time&, const TempoMetric&) const;
+	BBT_Time bbt_add (const BBT_Time& a, const BBT_Time& b) const;
+	BBT_Time bbt_subtract (const BBT_Time&, const BBT_Time&) const;
+
+	void change_existing_tempo_at (nframes64_t, double bpm, double note_type);
 	void change_initial_tempo (double bpm, double note_type);
 
-	void insert_time (nframes_t, nframes_t);
+	void insert_time (nframes64_t, nframes64_t);
 
 	int n_tempos () const;
 	int n_meters () const;
 
-	BBT_Time bbt_add (const BBT_Time& a, const BBT_Time& b, const TempoMetric& metric);
-	BBT_Time bbt_add (const BBT_Time& a, const BBT_Time& b);
-	BBT_Time bbt_subtract (const BBT_Time& a, const BBT_Time& b);
-
 	nframes_t frame_rate () const { return _frame_rate; }
 
 	sigc::signal<void,ARDOUR::Change> StateChanged;
@@ -267,26 +267,26 @@ class TempoMap : public PBD::StatefulDestructible
 
 	Metrics*             metrics;
 	nframes_t           _frame_rate;
-	nframes_t            last_bbt_when;
+	nframes64_t          last_bbt_when;
 	bool                 last_bbt_valid;
 	BBT_Time             last_bbt;
 	mutable Glib::RWLock lock;
 
 	void timestamp_metrics (bool use_bbt);
 
-	nframes_t round_to_type (nframes_t fr, int dir, BBTPointType);
+	nframes64_t round_to_type (nframes64_t fr, int dir, BBTPointType);
 
-	nframes_t frame_time_unlocked (const BBT_Time&) const;
+	nframes64_t frame_time_unlocked (const BBT_Time&) const;
 
-	void bbt_time_unlocked (nframes_t, BBT_Time&) const;
+	void bbt_time_unlocked (nframes64_t, BBT_Time&) const;
 
-	nframes_t bbt_duration_at_unlocked (const BBT_Time& when, const BBT_Time& bbt, int dir) const;
+	nframes64_t bbt_duration_at_unlocked (const BBT_Time& when, const BBT_Time& bbt, int dir) const;
 
 	const MeterSection& first_meter() const;
 	const TempoSection& first_tempo() const;
 
-	nframes_t count_frames_between (const BBT_Time&, const BBT_Time&) const;
-	nframes_t count_frames_between_metrics (const Meter&, const Tempo&,
+	nframes64_t count_frames_between (const BBT_Time&, const BBT_Time&) const;
+	nframes64_t count_frames_between_metrics (const Meter&, const Tempo&,
 			const BBT_Time&, const BBT_Time&) const;
 
 	int move_metric_section (MetricSection&, const BBT_Time& to);
diff --git a/libs/ardour/ardour/types.h b/libs/ardour/ardour/types.h
index c6fc2419b2..6ec954075c 100644
--- a/libs/ardour/ardour/types.h
+++ b/libs/ardour/ardour/types.h
@@ -39,16 +39,9 @@
 #include <map>
 
 #if __GNUC__ < 3
-
 typedef int intptr_t;
 #endif
 
-/* eventually, we'd like everything (including JACK) to
-   move to this. for now, its a dedicated type.
-*/
-
-typedef int64_t                    nframes64_t;
-
 namespace ARDOUR {
 
 	class Source;
@@ -61,6 +54,8 @@ namespace ARDOUR {
 	typedef uint32_t                    layer_t;
 	typedef uint64_t                    microseconds_t;
 	typedef uint32_t                    nframes_t;
+	typedef int64_t                     nframes64_t;
+
 
 	/** "Session frames", frames relative to the session timeline.
 	 * Everything related to transport position etc. should be of this type.
@@ -430,6 +425,11 @@ namespace ARDOUR {
 
 } // namespace ARDOUR
 
+
+/* these cover types declared above in this header. See enums.cc
+   for the definitions.
+*/
+
 std::istream& operator>>(std::istream& o, ARDOUR::SampleFormat& sf);
 std::istream& operator>>(std::istream& o, ARDOUR::HeaderFormat& sf);
 std::istream& operator>>(std::istream& o, ARDOUR::AutoConnectOption& sf);
@@ -447,20 +447,40 @@ std::istream& operator>>(std::istream& o, ARDOUR::DenormalModel& sf);
 std::istream& operator>>(std::istream& o, ARDOUR::WaveformScale& sf);
 std::istream& operator>>(std::istream& o, ARDOUR::WaveformShape& sf);
 
-using ARDOUR::nframes_t;
-
-static inline nframes_t
-session_frame_to_track_frame (nframes_t session_frame, double speed)
+std::ostream& operator<<(std::ostream& o, const ARDOUR::SampleFormat& sf);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::HeaderFormat& sf);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::AutoConnectOption& sf);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::EditMode& sf);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::MonitorModel& sf);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::RemoteModel& sf);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::ListenPosition& sf);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::LayerModel& sf);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::CrossfadeModel& sf);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::SlaveSource& sf);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::ShuttleBehaviour& sf);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::ShuttleUnits& sf);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::TimecodeFormat& sf);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::DenormalModel& sf);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::WaveformScale& sf);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::WaveformShape& sf);
+
+static inline ARDOUR::nframes64_t
+session_frame_to_track_frame (ARDOUR::nframes64_t session_frame, double speed)
 {
-	return (nframes_t)( (double)session_frame * speed );
+	return (ARDOUR::nframes64_t)( (double)session_frame * speed );
 }
 
-static inline nframes_t
-track_frame_to_session_frame (nframes_t track_frame, double speed)
+static inline ARDOUR::nframes64_t
+track_frame_to_session_frame (ARDOUR::nframes64_t track_frame, double speed)
 {
-	return (nframes_t)( (double)track_frame / speed );
+	return (ARDOUR::nframes64_t)( (double)track_frame / speed );
 }
 
+/* for now, break the rules and use "using" to make these "global" */
+
+using ARDOUR::nframes_t;
+using ARDOUR::nframes64_t;
+
 
 #endif /* __ardour_types_h__ */
 
diff --git a/libs/ardour/ardour/utils.h b/libs/ardour/ardour/utils.h
index 027e95dae8..c43b7ed37e 100644
--- a/libs/ardour/ardour/utils.h
+++ b/libs/ardour/ardour/utils.h
@@ -60,7 +60,7 @@ Glib::ustring path_expand (Glib::ustring);
 Glib::ustring region_name_from_path (Glib::ustring path, bool strip_channels, bool add_channel_suffix = false, uint32_t total = 0, uint32_t this_one = 0);
 bool path_is_paired (Glib::ustring path, Glib::ustring& pair_base);
 
-void compute_equal_power_fades (nframes_t nframes, float* in, float* out);
+void compute_equal_power_fades (ARDOUR::nframes_t nframes, float* in, float* out);
 
 const char* slave_source_to_string (ARDOUR::SlaveSource src);
 ARDOUR::SlaveSource string_to_slave_source (std::string str);