X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Ftypes.h;h=c34869bc2b5ca407fa97665d5930d90b8511491e;hb=7629120cda89dd4ec1b03ba4ddcc6f5dd1b0ca5a;hp=38a0e6d625a963b124d6a0625f040deb52403a9c;hpb=bb9cc45cd22af67ac275a5e73accbe14fee664d8;p=ardour.git diff --git a/libs/ardour/ardour/types.h b/libs/ardour/ardour/types.h index 38a0e6d625..c34869bc2b 100644 --- a/libs/ardour/ardour/types.h +++ b/libs/ardour/ardour/types.h @@ -20,57 +20,85 @@ #ifndef __ardour_types_h__ #define __ardour_types_h__ -#ifndef __STDC_FORMAT_MACROS -#define __STDC_FORMAT_MACROS /* PRI; C++ requires explicit requesting of these */ -#endif - #include #include +#include #include +#include +#include #include #include #include -#include "control_protocol/smpte.h" + +#include "timecode/bbt_time.h" +#include "timecode/time.h" + #include "pbd/id.h" +#include "ardour/chan_count.h" + #include #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; 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 microseconds_t; - typedef uint32_t nframes_t; + typedef jack_nframes_t pframes_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; + + /* 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 > AudioIntervalResult; + // associate a set of intervals with regions (e.g. for silence detection) + typedef std::map,AudioIntervalResult> AudioIntervalMap; + + typedef std::list > RegionList; + + struct IOChange { + + enum Type { + NoChange = 0, + ConfigurationChanged = 0x1, + ConnectionsChanged = 0x2 + } type; - enum IOChange { - NoChange = 0, - ConfigurationChanged = 0x1, - ConnectionsChanged = 0x2 + 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 { @@ -81,27 +109,43 @@ namespace ARDOUR { OverlapExternal // overlap extends to (at least) begin+end }; - OverlapType coverage (nframes_t start_a, nframes_t end_a, - nframes_t start_b, nframes_t end_b); + 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. + */ + + 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. + /** See evoral/Parameter.hpp */ enum AutomationType { - NullAutomation = 0x0, - GainAutomation = 0x1, - PanAutomation = 0x2, - PluginAutomation = 0x4, - SoloAutomation = 0x8, - MuteAutomation = 0x10, - MidiCCAutomation = 0x20, - MidiPgmChangeAutomation = 0x21, - MidiPitchBenderAutomation = 0x22, - MidiChannelPressureAutomation = 0x23, - MidiSystemExclusiveAutomation = 0x24, - FadeInAutomation = 0x40, - FadeOutAutomation = 0x80, - EnvelopeAutomation = 0x100 + NullAutomation, + GainAutomation, + PanAzimuthAutomation, + PanElevationAutomation, + PanWidthAutomation, + PanFrontBackAutomation, + PanLFEAutomation, + PluginAutomation, + SoloAutomation, + MuteAutomation, + MidiCCAutomation, + MidiPgmChangeAutomation, + MidiPitchBenderAutomation, + MidiChannelPressureAutomation, + MidiSystemExclusiveAutomation, + FadeInAutomation, + FadeOutAutomation, + EnvelopeAutomation }; enum AutoState { @@ -127,10 +171,18 @@ namespace ARDOUR { ExistingMaterial }; + enum AlignChoice { + UseCaptureTime, + UseExistingMaterial, + Automatic + }; + enum MeterPoint { MeterInput, MeterPreFader, - MeterPostFader + MeterPostFader, + MeterOutput, + MeterCustom }; enum TrackMode { @@ -156,49 +208,22 @@ namespace ARDOUR { 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, + Timecode, BBT, Frames, Seconds @@ -206,25 +231,60 @@ namespace ARDOUR { Type type; - SMPTE::Time smpte; - BBT_Time bbt; + Timecode::Time timecode; + Timecode::BBT_Time bbt; union { - nframes_t frames; + 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 + } + + 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; + } }; struct AudioRange { - nframes_t start; - nframes_t end; + framepos_t start; + framepos_t end; uint32_t id; - AudioRange (nframes_t s, nframes_t e, uint32_t i) : start (s), end (e) , id (i) {} + AudioRange (framepos_t s, framepos_t e, uint32_t i) : start (s), end (e) , id (i) {} - nframes_t length() { return end - start + 1; } + framecnt_t length() { return end - start + 1; } bool operator== (const AudioRange& other) const { return start == other.start && end == other.end && id == other.id; @@ -234,17 +294,17 @@ namespace ARDOUR { return start == other.start && end == other.end; } - OverlapType coverage (nframes_t s, nframes_t e) const { + OverlapType coverage (framepos_t s, framepos_t e) const { return ARDOUR::coverage (start, end, s, e); } }; struct MusicRange { - BBT_Time start; - BBT_Time end; + Timecode::BBT_Time start; + Timecode::BBT_Time end; uint32_t id; - MusicRange (BBT_Time& s, BBT_Time& e, uint32_t i) + MusicRange (Timecode::BBT_Time& s, Timecode::BBT_Time& e, uint32_t i) : start (s), end (e), id (i) {} bool operator== (const MusicRange& other) const { @@ -290,20 +350,47 @@ namespace ARDOUR { SyncPoint }; - enum Change { - range_guarantee = ~0 - }; - - enum Placement { PreFader, PostFader }; enum MonitorModel { - HardwareMonitoring, - SoftwareMonitoring, - ExternalMonitoring + 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 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 { @@ -324,12 +411,6 @@ namespace ARDOUR { ShortCrossfade }; - enum LayerModel { - LaterHigher, - MoveAddHigher, - AddHigher - }; - enum ListenPosition { AfterFaderListen, PreFaderListen @@ -342,6 +423,8 @@ namespace ARDOUR { }; struct InterThreadInfo { + InterThreadInfo () : done (false), cancel (false), progress (0), thread (0) {} + volatile bool done; volatile bool cancel; volatile float progress; @@ -381,7 +464,8 @@ namespace ARDOUR { AudioUnit, LADSPA, LV2, - VST + Windows_VST, + LXVST, }; enum RunContext { @@ -390,10 +474,9 @@ namespace ARDOUR { ExportContext }; - enum SlaveSource { - None = 0, - MTC, + enum SyncSource { JACK, + MTC, MIDIClock }; @@ -430,9 +513,10 @@ namespace ARDOUR { int opts; // really RubberBandStretcher::Options }; - typedef std::list AnalysisFeatureList; + typedef std::list AnalysisFeatureList; - typedef std::list > RouteList; + typedef std::list > RouteList; + typedef std::list > WeakRouteList; class Bundle; typedef std::vector > BundleList; @@ -453,39 +537,120 @@ namespace ARDOUR { Groove }; + struct CleanupReport { + std::vector 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::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::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); 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::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::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::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) ((long double) session_frame * (long double) 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) ((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__ */