#include <istream>
#include <vector>
+#include <map>
#include <boost/shared_ptr.hpp>
#include <sys/types.h>
#include <stdint.h>
+#include <pthread.h>
#include <inttypes.h>
-#include <jack/types.h>
-#include <jack/midiport.h>
-#include "control_protocol/timecode.h"
+
+#include "timecode/bbt_time.h"
+#include "timecode/time.h"
+
#include "pbd/id.h"
-#include "ardour/bbt_time.h"
+#include "evoral/Range.hpp"
+
#include "ardour/chan_count.h"
+#include "ardour/plugin_types.h"
#include <map>
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 jack_nframes_t pframes_t;
-
- /* Any position measured in audio frames.
- Assumed to be non-negative but not enforced.
- */
+ class Region;
+ class Stripable;
+ class VCA;
+ class AutomationControl;
+
+ typedef float Sample;
+ typedef float pan_t;
+ typedef float gain_t;
+ typedef uint32_t layer_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.
- */
+ /* 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.
- */
+ /* 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 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 within the region, second is the length of the interval
- typedef std::list<std::pair<frameoffset_t,framecnt_t> > AudioIntervalResult;
+ // 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 {
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
- };
-
- 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.
+ /* 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 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 = 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,
+ PluginPropertyAutomation,
+ SoloAutomation,
+ SoloIsolateAutomation,
+ SoloSafeAutomation,
+ MuteAutomation,
+ MidiCCAutomation,
+ MidiPgmChangeAutomation,
+ MidiPitchBenderAutomation,
+ MidiChannelPressureAutomation,
+ MidiSystemExclusiveAutomation,
+ FadeInAutomation,
+ FadeOutAutomation,
+ EnvelopeAutomation,
+ RecEnableAutomation,
+ RecSafeAutomation,
+ TrimAutomation,
+ PhaseAutomation,
+ MonitoringAutomation,
+ EQGain,
+ EQFrequency,
+ EQQ,
+ EQShape,
+ EQHPF,
+ EQEnable,
+ CompThreshold,
+ CompSpeed,
+ CompMode,
+ CompMakeup,
+ CompRedux,
+ CompEnable,
+ BusSendLevel,
+ BusSendEnable,
};
enum AutoState {
ExistingMaterial
};
+ enum AlignChoice {
+ UseCaptureTime,
+ UseExistingMaterial,
+ Automatic
+ };
+
enum MeterPoint {
MeterInput,
MeterPreFader,
MeterPostFader,
+ MeterOutput,
MeterCustom
};
+ enum MeterType {
+ 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 {
Normal,
NonLayered,
TrackColor
};
- enum TimecodeFormat {
- timecode_23976,
- timecode_24,
- timecode_24976,
- timecode_25,
- timecode_2997,
- timecode_2997drop,
- timecode_30,
- timecode_30drop,
- timecode_5994,
- timecode_60
+ 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
};
- struct AnyTime {
+ class AnyTime {
+ public:
enum Type {
Timecode,
BBT,
Type type;
- Timecode::Time timecode;
- BBT_Time bbt;
+ Timecode::Time timecode;
+ Timecode::BBT_Time bbt;
union {
framecnt_t frames;
};
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;
+ }
+
+ abort(); /* NOTREACHED */
+ 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 {
framepos_t start;
framepos_t end;
AudioRange (framepos_t s, framepos_t e, uint32_t i) : start (s), end (e) , id (i) {}
- framecnt_t length() { return end - start + 1; }
+ framecnt_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;
}
- OverlapType coverage (framepos_t s, framepos_t e) const {
- return ARDOUR::coverage (start, end, s, e);
+ 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;
+ 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 {
MeterFalloffOff = 0,
MeterFalloffSlowest = 1,
MeterFalloffSlow = 2,
- MeterFalloffMedium = 3,
- MeterFalloffFast = 4,
- MeterFalloffFaster = 5,
- MeterFalloffFastest = 6
+ MeterFalloffSlowish = 3,
+ MeterFalloffModerate = 4,
+ MeterFalloffMedium = 5,
+ MeterFalloffFast = 6,
+ MeterFalloffFaster = 7,
+ MeterFalloffFastest = 8,
};
enum MeterHold {
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,
};
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 VUMeterStandard {
+ MeteringVUfrench, // 0VU = -2dBu
+ MeteringVUamerican, // 0VU = 0dBu
+ MeteringVUstandard, // 0VU = +4dBu
+ MeteringVUeight // 0VU = +8dBu
+ };
+
+ 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 {
DenormalFTZDAZ
};
- enum RemoteModel {
- UserOrdered,
- MixerOrdered,
- EditorOrdered
- };
-
- enum CrossfadeModel {
- FullCrossfade,
- ShortCrossfade
- };
-
enum LayerModel {
LaterHigher,
- MoveAddHigher,
- AddHigher
+ Manual
};
enum ListenPosition {
AutoConnectMaster = 0x2
};
- struct InterThreadInfo {
- InterThreadInfo () : done (false), cancel (false), progress (0), thread (0) {}
-
- volatile bool done;
- volatile bool cancel;
- volatile float progress;
- pthread_t thread;
- };
+ enum TracksAutoNamingRule {
+ UseDefaultNames = 0x1,
+ NameAfterDriver = 0x2
+ };
enum SampleFormat {
FormatFloat = 0,
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,
- VST
- };
-
enum RunContext {
ButlerContext = 0,
TransportContext,
};
enum SyncSource {
- JACK,
+ /* These are "synonyms". It is important for JACK to be first
+ both here and in enums.cc, so that the string "JACK" is
+ correctly recognized in older session and preference files.
+ */
+ JACK = 0,
+ Engine = 0,
MTC,
- MIDIClock
+ MIDIClock,
+ LTC
};
enum ShuttleBehaviour {
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<framepos_t> AnalysisFeatureList;
- typedef std::list<boost::shared_ptr<Route> > RouteList;
+ 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<VCA> > VCAList;
class Bundle;
typedef std::vector<boost::shared_ptr<Bundle> > BundleList;
Rectified
};
- enum QuantizeType {
- Plain,
- Legato,
- Groove
- };
-
struct CleanupReport {
std::vector<std::string> paths;
size_t space;
struct RouteProcessorChange {
enum Type {
GeneralChange = 0x0,
- MeterPointChange = 0x1
+ MeterPointChange = 0x1,
+ RealTimeChange = 0x2
};
RouteProcessorChange () : type (GeneralChange), meter_visibly_changed (true)
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 */
- };
+ 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
+ FadeConstantPower,
+ FadeSymmetric,
+ };
+
+ enum TransportState {
+ /* these values happen to match the constants used by JACK but
+ this equality cannot be assumed.
+ */
+ TransportStopped = 0,
+ TransportRolling = 1,
+ TransportLooping = 2,
+ TransportStarting = 3,
+ };
+
+ enum PortFlags {
+ /* these values happen to match the constants used by JACK but
+ this equality cannot be assumed.
+ */
+ IsInput = 0x1,
+ IsOutput = 0x2,
+ IsPhysical = 0x4,
+ CanMonitor = 0x8,
+ IsTerminal = 0x10
+ };
+
+ struct LatencyRange {
+ uint32_t min; //< samples
+ uint32_t max; //< samples
+ };
+
+ enum BufferingPreset {
+ Small,
+ Medium,
+ Large,
+ Custom,
+ };
+
+ enum AutoReturnTarget {
+ LastLocate = 0x1,
+ RangeSelectionStart = 0x2,
+ Loop = 0x4,
+ RegionSelectionStart = 0x8,
+ };
+
+ enum PlaylistDisposition {
+ CopyPlaylist,
+ NewPlaylist,
+ SharePlaylist
};
} // 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::TracksAutoNamingRule& 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::RemoteModel& 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::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::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::TimecodeFormat& 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::istream& operator>>(std::istream& o, ARDOUR::FadeShape& sf);
+std::istream& operator>>(std::istream& o, ARDOUR::RegionSelectionAfterSplit& sf);
+std::istream& operator>>(std::istream& o, ARDOUR::BufferingPreset& var);
+std::istream& operator>>(std::istream& o, ARDOUR::AutoReturnTarget& sf);
+std::istream& operator>>(std::istream& o, ARDOUR::MeterType& 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::TracksAutoNamingRule& 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::PFLPosition& sf);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::AFLPosition& 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::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 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);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::FadeShape& sf);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::RegionSelectionAfterSplit& sf);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::BufferingPreset& var);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::AutoReturnTarget& sf);
+std::ostream& operator<<(std::ostream& o, const ARDOUR::MeterType& sf);
+
+/* because these operators work on types which can be used when making
+ a UI_CONFIG_VARIABLE (in gtk2_ardour) we need them to be exported.
+*/
+LIBARDOUR_API std::istream& operator>>(std::istream& o, ARDOUR::WaveformScale& sf);
+LIBARDOUR_API std::istream& operator>>(std::istream& o, ARDOUR::WaveformShape& sf);
+LIBARDOUR_API std::istream& operator>>(std::istream& o, ARDOUR::VUMeterStandard& sf);
+LIBARDOUR_API std::istream& operator>>(std::istream& o, ARDOUR::MeterLineUp& sf);
+
+LIBARDOUR_API std::ostream& operator<<(std::ostream& o, const ARDOUR::WaveformScale& sf);
+LIBARDOUR_API std::ostream& operator<<(std::ostream& o, const ARDOUR::WaveformShape& sf);
+LIBARDOUR_API std::ostream& operator<<(std::ostream& o, const ARDOUR::VUMeterStandard& sf);
+LIBARDOUR_API std::ostream& operator<<(std::ostream& o, const ARDOUR::MeterLineUp& sf);
+
static inline ARDOUR::framepos_t
session_frame_to_track_frame (ARDOUR::framepos_t session_frame, double speed)
{
- return (ARDOUR::framepos_t)( (double)session_frame * speed );
+ long double result = (long double) session_frame * (long double) speed;
+
+ if (result >= (long double) ARDOUR::max_framepos) {
+ return ARDOUR::max_framepos;
+ } else if (result <= (long double) (ARDOUR::max_framepos) * (ARDOUR::framepos_t)(-1)) {
+ return (ARDOUR::max_framepos * (ARDOUR::framepos_t)(-1));
+ } else {
+ return result;
+ }
}
static inline ARDOUR::framepos_t
track_frame_to_session_frame (ARDOUR::framepos_t track_frame, double speed)
{
- return (ARDOUR::framepos_t)( (double)track_frame / speed );
+ /* NB - do we need a check for speed == 0 ??? */
+ long double result = (long double) track_frame / (long double) speed;
+
+ if (result >= (long double) ARDOUR::max_framepos) {
+ return ARDOUR::max_framepos;
+ } else if (result <= (long double) (ARDOUR::max_framepos) * (ARDOUR::framepos_t)(-1)) {
+ return (ARDOUR::max_framepos * (ARDOUR::framepos_t)(-1));
+ } else {
+ return result;
+ }
}
/* for now, break the rules and use "using" to make this "global" */
#endif /* __ardour_types_h__ */
-