#include <istream>
#include <vector>
#include <map>
+#include <set>
#include <boost/shared_ptr.hpp>
#include <sys/types.h>
#include <stdint.h>
#include <inttypes.h>
-#include "timecode/bbt_time.h"
-#include "timecode/time.h"
+#include "temporal/bbt_time.h"
+#include "temporal/time.h"
+#include "temporal/types.h"
#include "pbd/id.h"
#include "evoral/Range.hpp"
#include "ardour/chan_count.h"
+#include "ardour/plugin_types.h"
#include <map>
+using Temporal::max_samplepos;
+using Temporal::max_samplecnt;
+
#if __GNUC__ < 3
typedef int intptr_t;
#endif
class AudioSource;
class Route;
class Region;
+ class Stripable;
+ class VCA;
+ class AutomationControl;
+ class SlavableAutomationControl;
typedef float Sample;
typedef float pan_t;
typedef uint64_t microseconds_t;
typedef uint32_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;
+ /* rebind Temporal position types into ARDOUR namespace */
+ typedef Temporal::samplecnt_t samplecnt_t;
+ typedef Temporal::samplepos_t samplepos_t;
+ typedef Temporal::sampleoffset_t sampleoffset_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;
+ typedef std::list<std::pair<sampleoffset_t, sampleoffset_t> > AudioIntervalResult;
// associate a set of intervals with regions (e.g. for silence detection)
typedef std::map<boost::shared_ptr<ARDOUR::Region>,AudioIntervalResult> AudioIntervalMap;
*/
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
+ 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 evoral/Parameter.hpp
+ *
+ * When you add things here, you REALLY SHOULD add a case clause to
+ * the constructor of ParameterDescriptor, unless the Controllables
+ * that the enum refers to are completely standard (0-1.0 range, 0.0 as
+ * normal, non-toggled, non-enumerated). Anything else needs to be
+ * added there so that things that try to represent them can do so
+ * with as much information as possible.
*/
enum AutomationType {
NullAutomation,
PanFrontBackAutomation,
PanLFEAutomation,
PluginAutomation,
+ PluginPropertyAutomation,
SoloAutomation,
+ SoloIsolateAutomation,
+ SoloSafeAutomation,
MuteAutomation,
MidiCCAutomation,
MidiPgmChangeAutomation,
MidiPitchBenderAutomation,
MidiChannelPressureAutomation,
+ MidiNotePressureAutomation,
MidiSystemExclusiveAutomation,
FadeInAutomation,
FadeOutAutomation,
EnvelopeAutomation,
- RecEnableAutomation
+ RecEnableAutomation,
+ RecSafeAutomation,
+ TrimAutomation,
+ PhaseAutomation,
+ MonitoringAutomation,
+ BusSendLevel,
+ BusSendEnable
};
enum AutoState {
- Off = 0x0,
- Write = 0x1,
- Touch = 0x2,
- Play = 0x4
+ Off = 0x00,
+ Write = 0x01,
+ Touch = 0x02,
+ Play = 0x04,
+ Latch = 0x08
};
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
MeterCustom
};
+ enum DiskIOPoint {
+ DiskIOPreFader, /* after the trim control, but before other processors */
+ DiskIOPostFader, /* before the main outs, after other processors */
+ DiskIOCustom, /* up to the user. Caveat Emptor! */
+ };
+
enum MeterType {
- MeterMaxSignal = 0x001,
- MeterMaxPeak = 0x002,
- MeterPeak = 0x004,
- MeterKrms = 0x008,
- MeterK20 = 0x010,
- MeterK14 = 0x020,
- MeterIEC1DIN = 0x040,
- MeterIEC1NOR = 0x080,
- MeterIEC2BBC = 0x100,
- MeterIEC2EBU = 0x200,
- MeterVU = 0x400,
- MeterK12 = 0x800
+ MeterMaxSignal = 0x0001,
+ MeterMaxPeak = 0x0002,
+ MeterPeak = 0x0004,
+ MeterKrms = 0x0008,
+ MeterK20 = 0x0010,
+ MeterK14 = 0x0020,
+ MeterIEC1DIN = 0x0040,
+ MeterIEC1NOR = 0x0080,
+ MeterIEC2BBC = 0x0100,
+ MeterIEC2EBU = 0x0200,
+ MeterVU = 0x0400,
+ MeterK12 = 0x0800,
+ MeterPeak0dB = 0x1000,
+ MeterMCP = 0x2000
};
enum TrackMode {
TrackColor
};
+ enum RoundMode {
+ RoundDownMaybe = -2, ///< Round down only if necessary
+ RoundDownAlways = -1, ///< Always round down, even if on a division
+ RoundNearest = 0, ///< Round to nearest
+ RoundUpAlways = 1, ///< Always round up, even if on a division
+ RoundUpMaybe = 2 ///< Round up only if necessary
+ };
+
+ enum SnapPref {
+ SnapToAny = 0, ///< Snaps to the closest of ( snap prefs, grid quantization )
+ SnapToGrid = 1, ///< Prefer snapping to the closest grid quantization, if a Grid selection is enabled
+ };
+
class AnyTime {
public:
enum Type {
Timecode,
BBT,
- Frames,
+ Samples,
Seconds
};
Timecode::BBT_Time bbt;
union {
- framecnt_t frames;
+ samplecnt_t samples;
double seconds;
};
- AnyTime() { type = Frames; frames = 0; }
+ AnyTime() { type = Samples; samples = 0; }
bool operator== (AnyTime const & other) const {
if (type != other.type) { return false; }
return timecode == other.timecode;
case BBT:
return bbt == other.bbt;
- case Frames:
- return frames == other.frames;
+ case Samples:
+ return samples == other.samples;
case Seconds:
return seconds == other.seconds;
}
timecode.seconds != 0 || timecode.frames != 0;
case BBT:
return bbt.bars != 0 || bbt.beats != 0 || bbt.ticks != 0;
- case Frames:
- return frames != 0;
+ case Samples:
+ return samples != 0;
case Seconds:
return seconds != 0;
}
- /* NOTREACHED */
- assert (false);
+ abort(); /* NOTREACHED */
return false;
}
};
+ /* used for translating audio samples to an exact musical position using a note divisor.
+ an exact musical position almost never falls exactly on an audio sample, but for sub-sample
+ musical accuracy we need to derive exact musical locations from a sample position
+ the division follows TempoMap::exact_beat_at_sample().
+ division
+ -1 musical location is the bar closest to sample
+ 0 musical location is the musical position of the sample
+ 1 musical location is the BBT beat closest to sample
+ n musical location is the quarter-note division n closest to sample
+ */
+ struct MusicSample {
+ samplepos_t sample;
+ int32_t division;
+
+ MusicSample (samplepos_t f, int32_t d) : sample (f), division (d) {}
+
+ void set (samplepos_t f, int32_t d) {sample = f; division = d; }
+
+ MusicSample operator- (MusicSample other) { return MusicSample (sample - other.sample, 0); }
+ };
+
/* XXX: slightly unfortunate that there is this and Evoral::Range<>,
but this has a uint32_t id which Evoral::Range<> does not.
*/
struct AudioRange {
- framepos_t start;
- framepos_t end;
+ samplepos_t start;
+ samplepos_t end;
uint32_t id;
- AudioRange (framepos_t s, framepos_t e, uint32_t i) : start (s), end (e) , id (i) {}
+ AudioRange (samplepos_t s, samplepos_t e, uint32_t i) : start (s), end (e) , id (i) {}
- framecnt_t length() { return end - start + 1; }
+ samplecnt_t length() const { return end - start + 1; }
bool operator== (const AudioRange& other) const {
return start == other.start && end == other.end && id == other.id;
return start == other.start && end == other.end;
}
- Evoral::OverlapType coverage (framepos_t s, framepos_t e) const {
+ Evoral::OverlapType coverage (samplepos_t s, samplepos_t e) const {
return Evoral::coverage (start, end, s, e);
}
};
enum EditMode {
Slide,
Splice,
+ Ripple,
Lock
};
+ enum RegionSelectionAfterSplit {
+ None = 0,
+ NewlyCreatedLeft = 1, // bit 0
+ NewlyCreatedRight = 2, // bit 1
+ NewlyCreatedBoth = 3,
+ Existing = 4, // bit 2
+ ExistingNewlyCreatedLeft = 5,
+ ExistingNewlyCreatedRight = 6,
+ ExistingNewlyCreatedBoth = 7
+ };
+
enum RegionPoint {
Start,
End,
AFLFromAfterProcessors
};
+ enum ClockDeltaMode {
+ NoDelta,
+ DeltaEditPoint,
+ DeltaOriginMarker
+ };
+
enum DenormalModel {
DenormalNone,
DenormalFTZ,
DenormalFTZDAZ
};
- enum RemoteModel {
- UserOrdered,
- MixerOrdered
- };
-
- enum CrossfadeModel {
- FullCrossfade,
- ShortCrossfade
- };
-
- enum CrossfadeChoice {
- RegionFades,
- ConstantPowerMinus3dB,
- ConstantPowerMinus6dB,
+ enum LayerModel {
+ LaterHigher,
+ Manual
};
enum ListenPosition {
AutoConnectMaster = 0x2
};
+ enum TracksAutoNamingRule {
+ UseDefaultNames = 0x1,
+ NameAfterDriver = 0x2
+ };
+
enum SampleFormat {
FormatFloat = 0,
FormatInt24,
FormatInt16
};
+ int format_data_width (ARDOUR::SampleFormat);
+
enum CDMarkerFormat {
CDMarkerNone,
CDMarkerCUE,
- CDMarkerTOC
+ CDMarkerTOC,
+ MP4Chaps
};
enum HeaderFormat {
CAF,
AIFF,
iXML,
- RF64
+ RF64,
+ RF64_WAV,
+ MBWF,
};
struct PeakData {
PeakDatum max;
};
- enum PluginType {
- AudioUnit,
- LADSPA,
- LV2,
- Windows_VST,
- LXVST,
- };
-
enum RunContext {
ButlerContext = 0,
TransportContext,
SrcFastest
};
- typedef std::list<framepos_t> AnalysisFeatureList;
+ typedef std::list<samplepos_t> AnalysisFeatureList;
typedef std::list<boost::shared_ptr<Route> > RouteList;
+ typedef std::list<boost::shared_ptr<Stripable> > StripableList;
typedef std::list<boost::weak_ptr <Route> > WeakRouteList;
+ typedef std::list<boost::weak_ptr <Stripable> > WeakStripableList;
+ typedef std::list<boost::shared_ptr<AutomationControl> > ControlList;
+ typedef std::list<boost::shared_ptr<SlavableAutomationControl> > SlavableControlList;
+ typedef std::set <boost::shared_ptr<AutomationControl> > AutomationControlSet;
+
+ typedef std::list<boost::shared_ptr<VCA> > VCAList;
class Bundle;
typedef std::vector<boost::shared_ptr<Bundle> > BundleList;
struct RouteProcessorChange {
enum Type {
GeneralChange = 0x0,
- MeterPointChange = 0x1
+ MeterPointChange = 0x1,
+ RealTimeChange = 0x2
};
RouteProcessorChange () : type (GeneralChange), meter_visibly_changed (true)
};
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 */
+ uint32_t master_out_channels; /* how many channels for the master bus, 0: no master bus */
};
enum FadeShape {
this equality cannot be assumed.
*/
TransportStopped = 0,
- TransportRolling = 1,
- TransportLooping = 2,
+ TransportRolling = 1,
+ TransportLooping = 2,
TransportStarting = 3,
};
/* these values happen to match the constants used by JACK but
this equality cannot be assumed.
*/
- IsInput = 0x1,
+ IsInput = 0x1,
IsOutput = 0x2,
IsPhysical = 0x4,
CanMonitor = 0x8,
- IsTerminal = 0x10
+ IsTerminal = 0x10,
+
+ /* non-JACK related flags */
+ Hidden = 0x20,
+ Shadow = 0x40
+ };
+
+ enum MidiPortFlags {
+ MidiPortMusic = 0x1,
+ MidiPortControl = 0x2,
+ MidiPortSelection = 0x4,
+ MidiPortVirtual = 0x8
};
struct LatencyRange {
uint32_t max; //< samples
};
-} // namespace ARDOUR
+ enum BufferingPreset {
+ Small,
+ Medium,
+ Large,
+ Custom,
+ };
+ enum AutoReturnTarget {
+ LastLocate = 0x1,
+ RangeSelectionStart = 0x2,
+ Loop = 0x4,
+ RegionSelectionStart = 0x8,
+ };
-/* these cover types declared above in this header. See enums.cc
- for the definitions.
-*/
+ enum PlaylistDisposition {
+ CopyPlaylist,
+ NewPlaylist,
+ SharePlaylist
+ };
-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::VUMeterStandard& 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::VUMeterStandard& 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);
-}
+ enum MidiTrackNameSource {
+ SMFTrackNumber,
+ SMFTrackName,
+ SMFInstrumentName
+ };
-/* for now, break the rules and use "using" to make this "global" */
+ enum MidiTempoMapDisposition {
+ SMFTempoIgnore,
+ SMFTempoUse,
+ };
-using ARDOUR::framepos_t;
+ struct CaptureInfo {
+ samplepos_t start;
+ samplecnt_t samples;
+ };
+ typedef std::vector<CaptureInfo*> CaptureInfos;
-#endif /* __ardour_types_h__ */
+} // namespace ARDOUR
+
+/* for now, break the rules and use "using" to make this "global" */
+
+using ARDOUR::samplepos_t;
+#endif /* __ardour_types_h__ */
projects / ardour.git / blobdiff