fix visual focus indication in IOSelector; import pays attention to audio file embedd...

[ardour.git] / libs / ardour / ardour / types.h

diff --git a/libs/ardour/ardour/types.h b/libs/ardour/ardour/types.h
index fa1d121d02aa5db06c8b2127b6df54d71aab19cf..32b3231c4e3e6b1eca0f7c64972f3e3f0ec62e54 100644 (file)
--- a/libs/ardour/ardour/types.h
+++ b/libs/ardour/ardour/types.h
@@ -26,6 +26,8 @@
 #endif
 
 #include <istream>
+#include <vector>
+#include <boost/shared_ptr.hpp>
 
 #include <inttypes.h>
 #include <jack/types.h>
@@ -39,9 +41,17 @@
 typedef int intptr_t;
 #endif
 
+/* at some point move this into the ARDOUR namespace,
+   but for now its outside because it replaces the
+   old global "jack_nframes_t"
+*/
+
+typedef uint32_t                    nframes_t;
+
 namespace ARDOUR {
 
        class Source;
+       class AudioSource;
 
        typedef jack_default_audio_sample_t Sample;
        typedef float                       pan_t;
@@ -63,8 +73,8 @@ namespace ARDOUR {
                OverlapExternal   // overlap extends to (at least) begin+end
        };
 
-       OverlapType coverage (jack_nframes_t start_a, jack_nframes_t end_a,
-                             jack_nframes_t start_b, jack_nframes_t end_b);
+       OverlapType coverage (nframes_t start_a, nframes_t end_a,
+                             nframes_t start_b, nframes_t end_b);
 
        enum AutomationType {
                GainAutomation = 0x1,
@@ -81,11 +91,17 @@ namespace ARDOUR {
                Play = 0x4
        };
 
+       std::string auto_state_to_string (AutoState);
+       AutoState string_to_auto_state (std::string);
+
        enum AutoStyle {
                Absolute = 0x1,
                Trim = 0x2
        };
 
+       std::string auto_style_to_string (AutoStyle);
+       AutoStyle string_to_auto_style (std::string);
+
        enum AlignStyle {
                CaptureTime,
                ExistingMaterial
@@ -144,19 +160,21 @@ namespace ARDOUR {
            BBT_Time       bbt;
 
            union { 
-               jack_nframes_t frames;
+               nframes_t frames;
                double         seconds;
            };
+
+           AnyTime() { type = Frames; frames = 0; }
        };
 
        struct AudioRange {
-           jack_nframes_t start;
-           jack_nframes_t end;
+           nframes_t start;
+           nframes_t end;
            uint32_t id;
            
-           AudioRange (jack_nframes_t s, jack_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) {}
            
-           jack_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;
@@ -166,7 +184,7 @@ namespace ARDOUR {
                    return start == other.start && end == other.end;
            }
 
-           OverlapType coverage (jack_nframes_t s, jack_nframes_t e) const {
+           OverlapType coverage (nframes_t s, nframes_t e) const {
                    return ARDOUR::coverage (start, end, s, e);
            }
        };
@@ -188,12 +206,34 @@ namespace ARDOUR {
            }
        };
 
+       /*
+           Slowest = 6.6dB/sec falloff at update rate of 40ms
+           Slow    = 6.8dB/sec falloff at update rate of 40ms
+       */
+
+       enum MeterFalloff {
+               MeterFalloffOff = 0,
+               MeterFalloffSlowest = 1,
+               MeterFalloffSlow = 2,
+               MeterFalloffMedium = 3,
+               MeterFalloffFast = 4,
+               MeterFalloffFaster = 5,
+               MeterFalloffFastest = 6
+       };
+
+       enum MeterHold {
+               MeterHoldOff = 0,
+               MeterHoldShort = 40,
+               MeterHoldMedium = 100,
+               MeterHoldLong = 200
+       };
+
        enum EditMode {
                Slide,
                Splice
        };
 
-        enum RegionPoint { 
+       enum RegionPoint { 
            Start,
            End,
            SyncPoint
@@ -209,10 +249,32 @@ namespace ARDOUR {
                PostFader
        };
 
+       enum MonitorModel {
+               HardwareMonitoring,
+               SoftwareMonitoring,
+               ExternalMonitoring,
+       };
+
        enum CrossfadeModel {
                FullCrossfade,
                ShortCrossfade
        };
+       
+       enum LayerModel {
+               LaterHigher,
+               MoveAddHigher,
+               AddHigher
+       };
+
+       enum SoloModel {
+               InverseMute,
+               SoloBus
+       };
+
+       enum AutoConnectOption {
+               AutoConnectPhysical = 0x1,
+               AutoConnectMaster = 0x2
+       };
 
        struct InterThreadInfo {
            volatile bool  done;
@@ -243,22 +305,55 @@ namespace ARDOUR {
            PeakDatum min;
            PeakDatum max;
        };
-}
+       
+       enum PluginType {
+               AudioUnit,
+               LADSPA,
+               VST
+       };
+
+       enum SlaveSource {
+               None = 0,
+               MTC,
+               JACK
+       };
+
+       enum ShuttleBehaviour {
+               Sprung,
+               Wheel
+       };
+
+       enum ShuttleUnits {
+               Percentage,
+               Semitones
+       };
+
+       typedef std::vector<boost::shared_ptr<AudioSource> > SourceList;
+
+} // namespace ARDOUR
 
 std::istream& operator>>(std::istream& o, ARDOUR::SampleFormat& sf);
 std::istream& operator>>(std::istream& o, ARDOUR::HeaderFormat& sf);
-
-static inline jack_nframes_t
-session_frame_to_track_frame (jack_nframes_t session_frame, double speed)
+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::SoloModel& sf);
+std::istream& operator>>(std::istream& o, ARDOUR::LayerModel& 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::ShuttleBehaviour& sf);
+std::istream& operator>>(std::istream& o, ARDOUR::ShuttleUnits& sf);
+
+static inline nframes_t
+session_frame_to_track_frame (nframes_t session_frame, double speed)
 {
-       return (jack_nframes_t)( (double)session_frame * speed );
+       return (nframes_t)( (double)session_frame * speed );
 }
 
-
-static inline jack_nframes_t
-track_frame_to_session_frame (jack_nframes_t track_frame, double speed)
+static inline nframes_t
+track_frame_to_session_frame (nframes_t track_frame, double speed)
 {
-       return (jack_nframes_t)( (double)track_frame / speed );
+       return (nframes_t)( (double)track_frame / speed );
 }