X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Ftypes.h;h=d452cd6b541e2cc8fcc77a9f3b7d1391fc6e09ad;hb=2a6dcddcc513fa3ebc1aad4b2e5fede62277aba5;hp=264d0666a7b441f385c7c4f3b8deca02b593cdf6;hpb=8a28ea6154f78d491afe746b3a2b0230185afb91;p=ardour.git

diff --git a/libs/ardour/ardour/types.h b/libs/ardour/ardour/types.h
index 264d0666a7..d452cd6b54 100644
--- a/libs/ardour/ardour/types.h
+++ b/libs/ardour/ardour/types.h
@@ -20,33 +20,27 @@
 #ifndef __ardour_types_h__
 #define __ardour_types_h__
 
-#ifndef __STDC_FORMAT_MACROS
-#define __STDC_FORMAT_MACROS /* PRI<foo>; C++ requires explicit requesting of these */
-#endif
-
 #include <istream>
 #include <vector>
 #include <boost/shared_ptr.hpp>
+#include <sys/types.h>
+#include <stdint.h>
 
 #include <inttypes.h>
 #include <jack/types.h>
 #include <jack/midiport.h>
-#include <control_protocol/smpte.h>
-#include <pbd/id.h>
+#include "control_protocol/timecode.h"
+#include "pbd/id.h"
+
+#include "ardour/bbt_time.h"
+#include "ardour/chan_count.h"
 
 #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;
@@ -60,17 +54,39 @@ namespace ARDOUR {
 	typedef uint64_t                    microseconds_t;
 	typedef uint32_t                    nframes_t;
 
-	/** "Session frames", frames relative to the session timeline.
-	 * Everything related to transport position etc. should be of this type.
-	 * We might want to make this a compile time option for 32-bitters who
-	 * don't want to pay for extremely long session times they don't need...
-	 */
-	typedef int64_t sframes_t;
+        /* Any position measured in audio frames.
+           Assumed to be non-negative but not enforced.
+         */
+	typedef int64_t framepos_t;
 
-	enum IOChange {
-		NoChange = 0,
-		ConfigurationChanged = 0x1,
-		ConnectionsChanged = 0x2
+        /* Any distance from a given framepos_t.
+           Maybe positive or negative.
+        */
+	typedef int64_t frameoffset_t;
+
+	/* Any count of audio frames. 
+           Assumed to be positive but not enforced.
+        */
+	typedef int64_t framecnt_t;
+
+        static const framepos_t max_framepos = INT64_MAX;
+        static const framecnt_t max_framecnt = INT64_MAX;
+
+	struct IOChange {
+
+		enum Type {
+			NoChange = 0,
+			ConfigurationChanged = 0x1,
+			ConnectionsChanged = 0x2
+		} type;
+
+		IOChange () : type (NoChange) {}
+		IOChange (Type t) : type (t) {}
+
+		/** channel count of IO before a ConfigurationChanged, if appropriate */
+		ARDOUR::ChanCount before;
+		/** channel count of IO after a ConfigurationChanged, if appropriate */
+		ARDOUR::ChanCount after;
 	};
 
 	enum OverlapType {
@@ -80,9 +96,22 @@ namespace ARDOUR {
 		OverlapEnd,       // overlap begins within and covers end
 		OverlapExternal   // overlap extends to (at least) begin+end
 	};
+        
+        ARDOUR::OverlapType coverage (framepos_t sa, framepos_t ea,
+                                      framepos_t sb, framepos_t eb);
+
+        /* policies for inserting/pasting material where overlaps
+           might be an issue.
+        */
 
-	OverlapType coverage (nframes_t start_a, nframes_t end_a,
-	                      nframes_t start_b, nframes_t end_b);
+        enum InsertMergePolicy {
+                InsertMergeReject,  // no overlaps allowed
+                InsertMergeRelax,   // we just don't care about overlaps
+                InsertMergeReplace, // replace old with new
+                InsertMergeTruncateExisting, // shorten existing to avoid overlap
+                InsertMergeTruncateAddition, // shorten new to avoid overlap
+                InsertMergeExtend   // extend new (or old) to the range of old+new
+        };
 
 	/** See parameter.h
 	 * XXX: I don't think/hope these hex values matter anymore.
@@ -130,11 +159,13 @@ namespace ARDOUR {
 	enum MeterPoint {
 		MeterInput,
 		MeterPreFader,
-		MeterPostFader
+		MeterPostFader,
+		MeterCustom
 	};
 
 	enum TrackMode {
 		Normal,
+		NonLayered,
 		Destructive
 	};
 
@@ -148,111 +179,84 @@ namespace ARDOUR {
 		FilterChannels,  ///< Ignore events on certain channels
 		ForceChannel     ///< Force all events to a certain channel
 	};
-	
+
 	enum ColorMode {
 		MeterColors = 0,
 		ChannelColors,
 		TrackColor
 	};
 
-	struct BBT_Time {
-	    uint32_t bars;
-	    uint32_t beats;
-	    uint32_t ticks;
-
-	    BBT_Time() {
-		    bars = 1;
-		    beats = 1;
-		    ticks = 0;
-	    }
-
-	    /* we can't define arithmetic operators for BBT_Time, because
-	       the results depend on a TempoMap, but we can define
-	       a useful check on the less-than condition.
-	    */
-
-	    bool operator< (const BBT_Time& other) const {
-		    return bars < other.bars ||
-			    (bars == other.bars && beats < other.beats) ||
-			    (bars == other.bars && beats == other.beats && ticks < other.ticks);
-	    }
-
-	    bool operator== (const BBT_Time& other) const {
-		    return bars == other.bars && beats == other.beats && ticks == other.ticks;
-	    }
-
-	};
-	enum SmpteFormat {
-		smpte_23976,
-		smpte_24,
-		smpte_24976,
-		smpte_25,
-		smpte_2997,
-		smpte_2997drop,
-		smpte_30,
-		smpte_30drop,
-		smpte_5994,
-		smpte_60
+	enum TimecodeFormat {
+		timecode_23976,
+		timecode_24,
+		timecode_24976,
+		timecode_25,
+		timecode_2997,
+		timecode_2997drop,
+		timecode_30,
+		timecode_30drop,
+		timecode_5994,
+		timecode_60
 	};
 
 	struct AnyTime {
-	    enum Type {
-		    SMPTE,
-		    BBT,
-		    Frames,
-		    Seconds
-	    };
+		enum Type {
+			Timecode,
+			BBT,
+			Frames,
+			Seconds
+		};
 
-	    Type type;
+		Type type;
 
-	    SMPTE::Time    smpte;
-	    BBT_Time       bbt;
+		Timecode::Time    timecode;
+		BBT_Time       bbt;
 
-	    union {
-		nframes_t      frames;
-		double         seconds;
-	    };
+		union {
+			nframes_t      frames;
+			double         seconds;
+		};
 
-	    AnyTime() { type = Frames; frames = 0; }
+		AnyTime() { type = Frames; frames = 0; }
 	};
 
 	struct AudioRange {
-	    nframes_t start;
-	    nframes_t end;
-	    uint32_t id;
+		nframes_t start;
+		nframes_t end;
+		uint32_t id;
 
-	    AudioRange (nframes_t s, nframes_t e, uint32_t i) : start (s), end (e) , id (i) {}
+		AudioRange (nframes_t s, nframes_t e, uint32_t i) : start (s), end (e) , id (i) {}
 
-	    nframes_t length() { return end - start + 1; }
+		nframes_t length() { return end - start + 1; }
 
-	    bool operator== (const AudioRange& other) const {
-		    return start == other.start && end == other.end && id == other.id;
-	    }
+		bool operator== (const AudioRange& other) const {
+			return start == other.start && end == other.end && id == other.id;
+		}
 
-	    bool equal (const AudioRange& other) const {
-		    return start == other.start && end == other.end;
-	    }
+		bool equal (const AudioRange& other) const {
+			return start == other.start && end == other.end;
+		}
 
-	    OverlapType coverage (nframes_t s, nframes_t e) const {
-		    return ARDOUR::coverage (start, end, s, e);
-	    }
+		OverlapType coverage (nframes_t s, nframes_t e) const {
+			return ARDOUR::coverage (start, end, s, e);
+		}
 	};
 
 	struct MusicRange {
-	    BBT_Time start;
-	    BBT_Time end;
-	    uint32_t id;
+		BBT_Time start;
+		BBT_Time end;
+		uint32_t id;
 
-	    MusicRange (BBT_Time& s, BBT_Time& e, uint32_t i)
-		    : start (s), end (e), id (i) {}
+		MusicRange (BBT_Time& s, BBT_Time& e, uint32_t i)
+			: start (s), end (e), id (i) {}
 
-	    bool operator== (const MusicRange& other) const {
-		    return start == other.start && end == other.end && id == other.id;
-	    }
+		bool operator== (const MusicRange& other) const {
+			return start == other.start && end == other.end && id == other.id;
+		}
 
-	    bool equal (const MusicRange& other) const {
-		    return start == other.start && end == other.end;
-	    }
+		bool equal (const MusicRange& other) const {
+			return start == other.start && end == other.end;
+		}
 	};
 
 	/*
@@ -284,16 +288,11 @@ namespace ARDOUR {
 	};
 
 	enum RegionPoint {
-	    Start,
-	    End,
-	    SyncPoint
+		Start,
+		End,
+		SyncPoint
 	};
 
-	enum Change {
-		range_guarantee = ~0
-	};
-
-
 	enum Placement {
 		PreFader,
 		PostFader
@@ -329,21 +328,24 @@ namespace ARDOUR {
 		AddHigher
 	};
 
-	enum SoloModel {
-		InverseMute,
-		SoloBus
+	enum ListenPosition {
+		AfterFaderListen,
+		PreFaderListen
 	};
 
 	enum AutoConnectOption {
+		ManualConnect = 0x0,
 		AutoConnectPhysical = 0x1,
 		AutoConnectMaster = 0x2
 	};
 
 	struct InterThreadInfo {
-	    volatile bool  done;
-	    volatile bool  cancel;
-	    volatile float progress;
-	    pthread_t      thread;
+		InterThreadInfo () : done (false), cancel (false), progress (0), thread (0) {}
+			
+		volatile bool  done;
+		volatile bool  cancel;
+		volatile float progress;
+		pthread_t      thread;
 	};
 
 	enum SampleFormat {
@@ -369,10 +371,10 @@ namespace ARDOUR {
 	};
 
 	struct PeakData {
-	    typedef Sample PeakDatum;
+		typedef Sample PeakDatum;
 
-	    PeakDatum min;
-	    PeakDatum max;
+		PeakDatum min;
+		PeakDatum max;
 	};
 
 	enum PluginType {
@@ -381,17 +383,16 @@ namespace ARDOUR {
 		LV2,
 		VST
 	};
-	
+
 	enum RunContext {
 		ButlerContext = 0,
 		TransportContext,
 		ExportContext
 	};
 
-	enum SlaveSource {
-		None = 0,
-		MTC,
+	enum SyncSource {
 		JACK,
+		MTC,
 		MIDIClock
 	};
 
@@ -401,7 +402,7 @@ namespace ARDOUR {
 	};
 
 	enum ShuttleUnits {
- 		Percentage,
+		Percentage,
 		Semitones
 	};
 
@@ -416,55 +417,154 @@ namespace ARDOUR {
 	};
 
 	struct TimeFXRequest : public InterThreadInfo {
-		TimeFXRequest() : time_fraction(0), pitch_fraction(0),
+		TimeFXRequest()
+			: time_fraction(0), pitch_fraction(0),
 			quick_seek(false), antialias(false),  opts(0) {}
-	    float time_fraction;
-	    float pitch_fraction;
-	    /* SoundTouch */
-	    bool  quick_seek;
-	    bool  antialias;
-	    /* RubberBand */
-	    int   opts; // really RubberBandStretcher::Options
+		float time_fraction;
+		float pitch_fraction;
+		/* SoundTouch */
+		bool  quick_seek;
+		bool  antialias;
+		/* RubberBand */
+		int   opts; // really RubberBandStretcher::Options
 	};
 
-	typedef std::list<nframes64_t> AnalysisFeatureList;
+	typedef std::list<framepos_t> AnalysisFeatureList;
 
 	typedef std::list<boost::shared_ptr<Route> >      RouteList;
 
 	class Bundle;
 	typedef std::vector<boost::shared_ptr<Bundle> > BundleList;
 
+	enum WaveformScale {
+		Linear,
+		Logarithmic
+	};
+
+	enum WaveformShape {
+		Traditional,
+		Rectified
+	};
+
+	enum QuantizeType {
+		Plain,
+		Legato,
+		Groove
+	};
+
+	struct CleanupReport {
+		std::vector<std::string> paths;
+		size_t                   space;
+	};
+
+	enum PositionLockStyle {
+		AudioTime,
+		MusicTime
+	};
+
+	/** A struct used to describe changes to processors in a route.
+	 *  This is useful because objects that respond to a change in processors
+	 *  can optimise what work they do based on details of what has changed.
+	*/
+	struct RouteProcessorChange {
+		enum Type {
+			GeneralChange = 0x0,
+			MeterPointChange = 0x1
+		};
+
+		RouteProcessorChange () : type (GeneralChange), meter_visibly_changed (true)
+		{}
+
+		RouteProcessorChange (Type t) : type (t), meter_visibly_changed (true)
+		{}
+
+		RouteProcessorChange (Type t, bool m) : type (t), meter_visibly_changed (m)
+		{}
+
+		/** type of change; "GeneralChange" means anything could have changed */
+		Type type;
+		/** true if, when a MeterPointChange has occurred, the change is visible to the user */
+		bool meter_visibly_changed;
+	};
+
+        struct BusProfile {
+            AutoConnectOption input_ac;      /* override the RC config for input auto-connection */
+            AutoConnectOption output_ac;     /* override the RC config for output auto-connection */
+            uint32_t master_out_channels;    /* how many channels for the master bus */
+            uint32_t requested_physical_in;  /* now many of the available physical inputs to consider usable */
+            uint32_t requested_physical_out; /* now many of the available physical inputs to consider usable */
+        };
+
+	enum FadeShape {
+		FadeLinear,
+		FadeFast,
+		FadeSlow,
+		FadeLogA,
+		FadeLogB
+	};
+
 } // 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);
 std::istream& operator>>(std::istream& o, ARDOUR::EditMode& sf);
 std::istream& operator>>(std::istream& o, ARDOUR::MonitorModel& sf);
 std::istream& operator>>(std::istream& o, ARDOUR::RemoteModel& sf);
-std::istream& operator>>(std::istream& o, ARDOUR::SoloModel& sf);
+std::istream& operator>>(std::istream& o, ARDOUR::ListenPosition& sf);
 std::istream& operator>>(std::istream& o, ARDOUR::LayerModel& sf);
+std::istream& operator>>(std::istream& o, ARDOUR::InsertMergePolicy& sf);
 std::istream& operator>>(std::istream& o, ARDOUR::CrossfadeModel& sf);
-std::istream& operator>>(std::istream& o, ARDOUR::SlaveSource& sf);
+std::istream& operator>>(std::istream& o, ARDOUR::SyncSource& sf);
 std::istream& operator>>(std::istream& o, ARDOUR::ShuttleBehaviour& sf);
 std::istream& operator>>(std::istream& o, ARDOUR::ShuttleUnits& sf);
-std::istream& operator>>(std::istream& o, ARDOUR::SmpteFormat& sf);
+std::istream& operator>>(std::istream& o, ARDOUR::TimecodeFormat& sf);
 std::istream& operator>>(std::istream& o, ARDOUR::DenormalModel& sf);
-
-using ARDOUR::nframes_t;
-
-static inline nframes_t
-session_frame_to_track_frame (nframes_t session_frame, double speed)
+std::istream& operator>>(std::istream& o, ARDOUR::WaveformScale& sf);
+std::istream& operator>>(std::istream& o, ARDOUR::WaveformShape& sf);
+std::istream& operator>>(std::istream& o, ARDOUR::PositionLockStyle& sf);
+
+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::InsertMergePolicy& sf);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::CrossfadeModel& sf);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::SyncSource& 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);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::PositionLockStyle& sf);
+
+static inline ARDOUR::framepos_t
+session_frame_to_track_frame (ARDOUR::framepos_t session_frame, double speed)
 {
-	return (nframes_t)( (double)session_frame * speed );
+	return (ARDOUR::framepos_t)( (double)session_frame * speed );
 }
 
-static inline nframes_t
-track_frame_to_session_frame (nframes_t track_frame, double speed)
+static inline ARDOUR::framepos_t
+track_frame_to_session_frame (ARDOUR::framepos_t track_frame, double speed)
 {
-	return (nframes_t)( (double)track_frame / speed );
+	return (ARDOUR::framepos_t)( (double)track_frame / speed );
 }
 
+/* for now, break the rules and use "using" to make these "global" */
+
+using ARDOUR::nframes_t;
+using ARDOUR::framepos_t;
+
 
 #endif /* __ardour_types_h__ */