X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Ftypes.h;h=05d6d0b27d47563ca2950c5785f3afec74eda217;hb=4d49961c93fe23dc4f76a5bcb60c93d0c80bcd3c;hp=95f3c471f2519e69331228f2bb3794c1ab7a4185;hpb=8af0757b61990767f2a85e68f535a5af9976fd79;p=ardour.git

diff --git a/libs/ardour/ardour/types.h b/libs/ardour/ardour/types.h
index 95f3c471f2..05d6d0b27d 100644
--- a/libs/ardour/ardour/types.h
+++ b/libs/ardour/ardour/types.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2002 Paul Davis 
+    Copyright (C) 2002 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
@@ -15,58 +15,129 @@
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
-    $Id$
 */
 
 #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 <map>
+#include <boost/shared_ptr.hpp>
+#include <sys/types.h>
+#include <stdint.h>
 
 #include <inttypes.h>
 #include <jack/types.h>
+#include <jack/midiport.h>
+
+#include "timecode/bbt_time.h"
+#include "timecode/time.h"
+
+#include "pbd/id.h"
+
+#include "evoral/Range.hpp"
+
+#include "ardour/chan_count.h"
+
 #include <map>
 
 #if __GNUC__ < 3
-
 typedef int intptr_t;
 #endif
 
 namespace ARDOUR {
 
 	class Source;
+	class AudioSource;
+	class Route;
+	class Region;
 
 	typedef jack_default_audio_sample_t Sample;
 	typedef float                       pan_t;
 	typedef float                       gain_t;
 	typedef uint32_t                    layer_t;
-	typedef uint64_t                    id_t;
-
-	enum IOChange {
-		NoChange = 0,
-		ConfigurationChanged = 0x1,
-		ConnectionsChanged = 0x2
+	typedef uint64_t                    microseconds_t;
+	typedef jack_nframes_t              pframes_t;
+
+	/* Any position measured in audio frames.
+	   Assumed to be non-negative but not enforced.
+	*/
+	typedef int64_t framepos_t;
+
+	/* 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;
+	static const layer_t    max_layer    = UINT32_MAX;
+
+	// a set of (time) intervals: first of pair is the offset of the start within the region, second is the offset of the end
+	typedef std::list<std::pair<frameoffset_t, frameoffset_t> > AudioIntervalResult;
+	// associate a set of intervals with regions (e.g. for silence detection)
+	typedef std::map<boost::shared_ptr<ARDOUR::Region>,AudioIntervalResult> AudioIntervalMap;
+
+	typedef std::list<boost::shared_ptr<Region> > RegionList;
+
+	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 {
-		OverlapNone,      // no overlap
-		OverlapInternal,  // the overlap is 100% with the object
-		OverlapStart,     // overlap covers start, but ends within
-		OverlapEnd,       // overlap begins within and covers end 
-		OverlapExternal   // overlap extends to (at least) begin+end
+	/* policies for inserting/pasting material where overlaps
+	   might be an issue.
+	*/
+
+	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
 	};
 
-	OverlapType coverage (jack_nframes_t start_a, jack_nframes_t end_a,
-			      jack_nframes_t start_b, jack_nframes_t end_b);
-
+	/** See evoral/Parameter.hpp
+	 */
 	enum AutomationType {
-		GainAutomation = 0x1,
-		PanAutomation = 0x2,
-		PluginAutomation = 0x4,
-		SoloAutomation = 0x8,
-		MuteAutomation = 0x10,
+		NullAutomation,
+		GainAutomation,
+		PanAzimuthAutomation,
+		PanElevationAutomation,
+		PanWidthAutomation,
+		PanFrontBackAutomation,
+		PanLFEAutomation,
+		PluginAutomation,
+		SoloAutomation,
+		MuteAutomation,
+		MidiCCAutomation,
+		MidiPgmChangeAutomation,
+		MidiPitchBenderAutomation,
+		MidiChannelPressureAutomation,
+		MidiSystemExclusiveAutomation,
+		FadeInAutomation,
+		FadeOutAutomation,
+		EnvelopeAutomation,
+		RecEnableAutomation
 	};
 
 	enum AutoState {
@@ -76,168 +147,497 @@ 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
 	};
 
+	enum AlignChoice {
+		UseCaptureTime,
+		UseExistingMaterial,
+		Automatic
+	};
+
 	enum MeterPoint {
 		MeterInput,
 		MeterPreFader,
-		MeterPostFader
-	};
-
-	enum smpte_wrap_t {
-		smpte_wrap_none = 0,
-		smpte_wrap_frames,
-		smpte_wrap_seconds,
-		smpte_wrap_minutes,
-		smpte_wrap_hours
-	};
-  
-	struct SMPTE_Time {
-		bool negative;
-		long hours;
-		long minutes;
-		long seconds;
-		long frames;
-		long subframes; // mostly not used
-
-		SMPTE_Time() {
-			negative = false;
-			hours = 0;
-			minutes = 0;
-			seconds = 0;
-			frames = 0;
-			subframes = 0;
-		}
-		
-	};
-
-	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;
-	    }
-	    
+		MeterPostFader,
+		MeterOutput,
+		MeterCustom
+	};
+
+	enum MeterType {
+		MeterMaxSignal = 0x01,
+		MeterMaxPeak   = 0x02,
+		MeterPeak      = 0x04,
+		MeterKrms      = 0x08
+	};
+
+	enum TrackMode {
+		Normal,
+		NonLayered,
+		Destructive
+	};
+
+	enum NoteMode {
+		Sustained,
+		Percussive
 	};
 
-	struct AnyTime {
-	    enum Type {
-		    SMPTE,
-		    BBT,
-		    Frames,
-		    Seconds
-	    };
+	enum ChannelMode {
+		AllChannels = 0, ///< Pass through all channel information unmodified
+		FilterChannels,  ///< Ignore events on certain channels
+		ForceChannel     ///< Force all events to a certain channel
+	};
 
-	    Type type;
+	enum ColorMode {
+		MeterColors = 0,
+		ChannelColors,
+		TrackColor
+	};
 
-	    SMPTE_Time     smpte;
-	    BBT_Time       bbt;
+	class AnyTime {
+	public:
+		enum Type {
+			Timecode,
+			BBT,
+			Frames,
+			Seconds
+		};
+
+		Type type;
+
+		Timecode::Time     timecode;
+		Timecode::BBT_Time bbt;
+
+		union {
+			framecnt_t     frames;
+			double         seconds;
+		};
+
+		AnyTime() { type = Frames; frames = 0; }
+
+		bool operator== (AnyTime const & other) const {
+			if (type != other.type) { return false; }
+
+			switch (type) {
+			  case Timecode:
+				return timecode == other.timecode;
+			  case BBT:
+				return bbt == other.bbt;
+			  case Frames:
+				return frames == other.frames;
+			  case Seconds:
+				return seconds == other.seconds;
+			}
+			return false; // get rid of warning
+		}
 
-	    union { 
-		jack_nframes_t frames;
-		double         seconds;
-	    };
+		bool not_zero() const
+		{
+			switch (type) {
+			  case Timecode:
+				return timecode.hours != 0 || timecode.minutes != 0 ||
+				       timecode.seconds != 0 || timecode.frames != 0;
+			  case BBT:
+				return bbt.bars != 0 || bbt.beats != 0 || bbt.ticks != 0;
+			  case Frames:
+				return frames != 0;
+			  case Seconds:
+				return seconds != 0;
+			}
+
+			/* NOTREACHED */
+			assert (false);
+			return false;
+		}
 	};
 
+	/* XXX: slightly unfortunate that there is this and Evoral::Range<>,
+	   but this has a uint32_t id which Evoral::Range<> does not.
+	*/
 	struct AudioRange {
-	    jack_nframes_t start;
-	    jack_nframes_t end;
-	    uint32_t id;
-	    
-	    AudioRange (jack_nframes_t s, jack_nframes_t e, uint32_t i) : start (s), end (e) , id (i) {}
-	    
-	    jack_nframes_t length() { return end - start + 1; } 
+		framepos_t start;
+		framepos_t end;
+		uint32_t id;
 
-	    bool operator== (const AudioRange& other) const {
-		    return start == other.start && end == other.end && id == other.id;
-	    }
+		AudioRange (framepos_t s, framepos_t e, uint32_t i) : start (s), end (e) , id (i) {}
 
-	    bool equal (const AudioRange& other) const {
-		    return start == other.start && end == other.end;
-	    }
+		framecnt_t length() { return end - start + 1; }
 
-	    OverlapType coverage (jack_nframes_t s, jack_nframes_t e) const {
-		    return ARDOUR::coverage (start, end, s, e);
-	    }
+		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;
+		}
+
+		Evoral::OverlapType coverage (framepos_t s, framepos_t e) const {
+			return Evoral::coverage (start, end, s, e);
+		}
 	};
-	
+
 	struct MusicRange {
-	    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) {}
+		Timecode::BBT_Time start;
+		Timecode::BBT_Time end;
+		uint32_t id;
+
+		MusicRange (Timecode::BBT_Time& s, Timecode::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;
+		}
 	};
 
-	enum EditMode {
-		Slide,
-		Splice,
+	/*
+	    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,
+		MeterFalloffSlowish = 3,
+		MeterFalloffModerate = 4,
+		MeterFalloffMedium = 5,
+		MeterFalloffFast = 6,
+		MeterFalloffFaster = 7,
+		MeterFalloffFastest = 8,
 	};
 
-        enum RegionPoint { 
-	    Start,
-	    End,
-	    SyncPoint
+	enum MeterHold {
+		MeterHoldOff = 0,
+		MeterHoldShort = 40,
+		MeterHoldMedium = 100,
+		MeterHoldLong = 200
 	};
 
-	enum Change {
-		range_guarantee = ~0
+	enum EditMode {
+		Slide,
+		Splice,
+		Lock
 	};
 
+	enum RegionPoint {
+		Start,
+		End,
+		SyncPoint
+	};
 
 	enum Placement {
 		PreFader,
 		PostFader
 	};
 
+        enum RouteSortOrderKey { 
+		EditorSort,
+		MixerSort
+	};
+	    
+	enum MonitorModel {
+		HardwareMonitoring, ///< JACK does monitoring
+		SoftwareMonitoring, ///< Ardour does monitoring
+		ExternalMonitoring  ///< we leave monitoring to the audio hardware
+	};
+
+	enum MonitorChoice {
+		MonitorAuto = 0,
+		MonitorInput = 0x1,
+		MonitorDisk = 0x2,
+		MonitorCue = 0x4,
+	};
+
+	enum MonitorState {
+		MonitoringSilence = 0x1,
+		MonitoringInput = 0x2,
+		MonitoringDisk = 0x4,
+	};
+
+	enum MeterState {
+		MeteringInput, ///< meter the input IO, regardless of what is going through the route
+		MeteringRoute  ///< meter what is going through the route
+	};
+
+	enum MeterLineUp {
+		MeteringLineUp24,
+		MeteringLineUp20,
+		MeteringLineUp18,
+		MeteringLineUp15
+	};
+
+	enum PFLPosition {
+		/** PFL signals come from before pre-fader processors */
+		PFLFromBeforeProcessors,
+		/** PFL signals come pre-fader but after pre-fader processors */
+		PFLFromAfterProcessors
+	};
+
+	enum AFLPosition {
+		/** AFL signals come post-fader and before post-fader processors */
+		AFLFromBeforeProcessors,
+		/** AFL signals come post-fader but after post-fader processors */
+		AFLFromAfterProcessors
+	};
+
+	enum DenormalModel {
+		DenormalNone,
+		DenormalFTZ,
+		DenormalDAZ,
+		DenormalFTZDAZ
+	};
+
+	enum RemoteModel {
+		UserOrdered,
+		MixerOrdered,
+		EditorOrdered
+	};
+
 	enum CrossfadeModel {
 		FullCrossfade,
 		ShortCrossfade
 	};
 
-	struct InterThreadInfo {
-	    volatile bool  done;
-	    volatile bool  cancel;
-	    volatile float progress;
-	    pthread_t      thread;
+	enum CrossfadeChoice {
+		RegionFades,
+		ConstantPowerMinus3dB,
+		ConstantPowerMinus6dB,
+	};
+
+	enum ListenPosition {
+		AfterFaderListen,
+		PreFaderListen
+	};
+
+	enum AutoConnectOption {
+		ManualConnect = 0x0,
+		AutoConnectPhysical = 0x1,
+		AutoConnectMaster = 0x2
+	};
+
+	enum SampleFormat {
+		FormatFloat = 0,
+		FormatInt24,
+		FormatInt16
+	};
+
+	enum CDMarkerFormat {
+		CDMarkerNone,
+		CDMarkerCUE,
+		CDMarkerTOC
+	};
+
+	enum HeaderFormat {
+		BWF,
+		WAVE,
+		WAVE64,
+		CAF,
+		AIFF,
+		iXML,
+		RF64
+	};
+
+	struct PeakData {
+		typedef Sample PeakDatum;
+
+		PeakDatum min;
+		PeakDatum max;
+	};
+
+	enum PluginType {
+		AudioUnit,
+		LADSPA,
+		LV2,
+		Windows_VST,
+		LXVST,
+	};
+
+	enum RunContext {
+		ButlerContext = 0,
+		TransportContext,
+		ExportContext
+	};
+
+	enum SyncSource {
+		JACK,
+		MTC,
+		MIDIClock,
+		LTC
+	};
+
+	enum ShuttleBehaviour {
+		Sprung,
+		Wheel
 	};
-};
+
+	enum ShuttleUnits {
+		Percentage,
+		Semitones
+	};
+
+	typedef std::vector<boost::shared_ptr<Source> > SourceList;
+
+	enum SrcQuality {
+		SrcBest,
+		SrcGood,
+		SrcQuick,
+		SrcFast,
+		SrcFastest
+	};
+
+	typedef std::list<framepos_t> AnalysisFeatureList;
+
+	typedef std::list<boost::shared_ptr<Route> > RouteList;
+	typedef std::list<boost::weak_ptr  <Route> > WeakRouteList;
+
+	class Bundle;
+	typedef std::vector<boost::shared_ptr<Bundle> > BundleList;
+
+	enum WaveformScale {
+		Linear,
+		Logarithmic
+	};
+
+	enum WaveformShape {
+		Traditional,
+		Rectified
+	};
+
+	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,
+		FadeConstantPower,
+		FadeSymmetric,
+	};
+
+} // 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::MeterLineUp& sf);
+std::istream& operator>>(std::istream& o, ARDOUR::PFLPosition& sf);
+std::istream& operator>>(std::istream& o, ARDOUR::AFLPosition& sf);
+std::istream& operator>>(std::istream& o, ARDOUR::RemoteModel& sf);
+std::istream& operator>>(std::istream& o, ARDOUR::ListenPosition& 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::CrossfadeChoice& 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, Timecode::TimecodeFormat& sf);
+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);
+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::MeterLineUp& sf);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::PFLPosition& sf);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::AFLPosition& 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::InsertMergePolicy& sf);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::CrossfadeModel& sf);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::CrossfadeChoice& 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 Timecode::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 (ARDOUR::framepos_t) ((long double) session_frame * (long double) speed);
+}
+
+static inline ARDOUR::framepos_t
+track_frame_to_session_frame (ARDOUR::framepos_t track_frame, double speed)
+{
+	return (ARDOUR::framepos_t) ((long double) track_frame / (long double) speed);
+}
+
+/* for now, break the rules and use "using" to make this "global" */
+
+using ARDOUR::framepos_t;
+
 
 #endif /* __ardour_types_h__ */