X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Ftypes.h;h=54c965ce67e4e954b44702dfa69845d0c1119405;hb=650c6d5824222a8879df5c5ba9645c264ed3b84f;hp=27ff8e93da90c19fa063f8a0e10a68d36a37b701;hpb=6d4e6dc580c18ee940a30345656c70c054a6fa2d;p=ardour.git diff --git a/libs/ardour/ardour/types.h b/libs/ardour/ardour/types.h index 27ff8e93da..54c965ce67 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,7 +15,6 @@ 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__ @@ -31,33 +30,44 @@ #include #include -#include -#include +#include +#include "control_protocol/timecode.h" +#include "pbd/id.h" + +#include "ardour/bbt_time.h" #include #if __GNUC__ < 3 - 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; + class Route; 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 int64_t nframes64_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; + typedef int64_t framepos_t; + /* any offset from a framepos_t, measured in audio frames */ + typedef int64_t frameoffset_t; + /* any count of audio frames */ + typedef int64_t framecnt_t; enum IOChange { NoChange = 0, @@ -69,19 +79,31 @@ namespace ARDOUR { 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 + OverlapEnd, // overlap begins within and covers end 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); + nframes_t start_b, nframes_t end_b); + /** See parameter.h + * XXX: I don't think/hope these hex values matter anymore. + */ enum AutomationType { + NullAutomation = 0x0, GainAutomation = 0x1, PanAutomation = 0x2, PluginAutomation = 0x4, SoloAutomation = 0x8, - MuteAutomation = 0x10 + MuteAutomation = 0x10, + MidiCCAutomation = 0x20, + MidiPgmChangeAutomation = 0x21, + MidiPitchBenderAutomation = 0x22, + MidiChannelPressureAutomation = 0x23, + MidiSystemExclusiveAutomation = 0x24, + FadeInAutomation = 0x40, + FadeOutAutomation = 0x80, + EnvelopeAutomation = 0x100 }; enum AutoState { @@ -110,100 +132,104 @@ namespace ARDOUR { enum MeterPoint { MeterInput, MeterPreFader, - MeterPostFader + MeterPostFader, + MeterCustom }; enum TrackMode { Normal, + NonLayered, Destructive }; - - struct BBT_Time { - uint32_t bars; - uint32_t beats; - uint32_t ticks; - BBT_Time() { - bars = 1; - beats = 1; - ticks = 0; - } + enum NoteMode { + Sustained, + Percussive + }; - /* 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. - */ + enum ChannelMode { + AllChannels = 0, ///< Pass through all channel information unmodified + FilterChannels, ///< Ignore events on certain channels + ForceChannel ///< Force all events to a certain channel + }; - 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); - } + enum ColorMode { + MeterColors = 0, + ChannelColors, + TrackColor + }; - bool operator== (const BBT_Time& other) const { - return bars == other.bars && beats == other.beats && ticks == other.ticks; - } - + 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; - - AudioRange (nframes_t s, nframes_t e, uint32_t i) : start (s), end (e) , id (i) {} - - nframes_t length() { return end - start + 1; } - - 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; - } - - OverlapType coverage (nframes_t s, nframes_t e) const { - return ARDOUR::coverage (start, end, s, e); - } - }; - + 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) {} + + nframes_t length() { return end - start + 1; } + + 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; + } + + 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; - - MusicRange (BBT_Time& s, BBT_Time& e, uint32_t i) - : start (s), end (e), id (i) {} + BBT_Time start; + BBT_Time end; + uint32_t id; - bool operator== (const MusicRange& other) const { - return start == other.start && end == other.end && id == other.id; - } + MusicRange (BBT_Time& s, BBT_Time& e, uint32_t i) + : start (s), end (e), id (i) {} - bool equal (const MusicRange& other) const { - return start == other.start && end == other.end; - } + 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; + } }; /* @@ -230,20 +256,16 @@ namespace ARDOUR { enum EditMode { Slide, - Splice - }; - - enum RegionPoint { - Start, - End, - SyncPoint + Splice, + Lock }; - enum Change { - range_guarantee = ~0 + enum RegionPoint { + Start, + End, + SyncPoint }; - enum Placement { PreFader, PostFader @@ -252,42 +274,62 @@ namespace ARDOUR { enum MonitorModel { HardwareMonitoring, SoftwareMonitoring, - ExternalMonitoring, + ExternalMonitoring + }; + + enum DenormalModel { + DenormalNone, + DenormalFTZ, + DenormalDAZ, + DenormalFTZDAZ + }; + + enum RemoteModel { + UserOrdered, + MixerOrdered, + EditorOrdered }; enum CrossfadeModel { FullCrossfade, ShortCrossfade }; - + enum LayerModel { LaterHigher, MoveAddHigher, 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; + volatile bool done; + volatile bool cancel; + volatile float progress; + pthread_t thread; }; enum SampleFormat { FormatFloat = 0, - FormatInt24 + FormatInt24, + FormatInt16 }; + enum CDMarkerFormat { + CDMarkerNone, + CDMarkerCUE, + CDMarkerTOC + }; enum HeaderFormat { BWF, @@ -300,22 +342,29 @@ namespace ARDOUR { }; struct PeakData { - typedef Sample PeakDatum; - - PeakDatum min; - PeakDatum max; + typedef Sample PeakDatum; + + PeakDatum min; + PeakDatum max; }; - + enum PluginType { AudioUnit, LADSPA, + LV2, VST }; - enum SlaveSource { - None = 0, + enum RunContext { + ButlerContext = 0, + TransportContext, + ExportContext + }; + + enum SyncSource { + JACK, MTC, - JACK + MIDIClock }; enum ShuttleBehaviour { @@ -324,38 +373,144 @@ namespace ARDOUR { }; enum ShuttleUnits { - Percentage, + Percentage, Semitones }; - typedef std::vector > SourceList; + typedef std::vector > SourceList; + + enum SrcQuality { + SrcBest, + SrcGood, + SrcQuick, + SrcFast, + SrcFastest + }; + + struct TimeFXRequest : public InterThreadInfo { + 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 + }; + + typedef std::list AnalysisFeatureList; + + typedef std::list > RouteList; + + class Bundle; + typedef std::vector > BundleList; + + enum WaveformScale { + Linear, + Logarithmic + }; + + enum WaveformShape { + Traditional, + Rectified + }; + + enum QuantizeType { + Plain, + Legato, + Groove + }; + + struct CleanupReport { + std::vector paths; + int64_t space; + }; + + /** 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; + }; } // 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::SoloModel& 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::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); - -static inline nframes_t -session_frame_to_track_frame (nframes_t session_frame, double speed) +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); + +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::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); + +static inline ARDOUR::nframes64_t +session_frame_to_track_frame (ARDOUR::nframes64_t session_frame, double speed) { - return (nframes_t)( (double)session_frame * speed ); + return (ARDOUR::nframes64_t)( (double)session_frame * speed ); } -static inline nframes_t -track_frame_to_session_frame (nframes_t track_frame, double speed) +static inline ARDOUR::nframes64_t +track_frame_to_session_frame (ARDOUR::nframes64_t track_frame, double speed) { - return (nframes_t)( (double)track_frame / speed ); + return (ARDOUR::nframes64_t)( (double)track_frame / speed ); } +/* for now, break the rules and use "using" to make these "global" */ + +using ARDOUR::nframes_t; +using ARDOUR::nframes64_t; + #endif /* __ardour_types_h__ */