ardour/ardour/types.h

Go to the documentation of this file.

/*
 * Copyright (C) 2002-2018 Paul Davis <paul@linuxaudiosystems.com>
 * Copyright (C) 2005 Karsten Wiese <fzuuzf@googlemail.com>
 * Copyright (C) 2006-2014 David Robillard <d@drobilla.net>
 * Copyright (C) 2008-2009 Hans Baier <hansfbaier@googlemail.com>
 * Copyright (C) 2009-2012 Carl Hetherington <carl@carlh.net>
 * Copyright (C) 2010-2011 Sakari Bergen <sakari.bergen@beatwaves.net>
 * Copyright (C) 2012-2019 Robin Gareus <robin@gareus.org>
 * Copyright (C) 2013-2015 Tim Mayberry <mojofunk@gmail.com>
 * Copyright (C) 2013-2017 Nick Mainsbridge <mainsbridge@gmail.com>
 * Copyright (C) 2013-2018 Colin Fletcher <colin.m.fletcher@googlemail.com>
 * Copyright (C) 2014-2015 John Emmas <john@creativepost.co.uk>
 * Copyright (C) 2015 Len Ovens <len@ovenwerks.net>
 * Copyright (C) 2017-2019 Ben Loftis <ben@harrisonconsoles.com>
 *
 * 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
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
#pragma once
 
#include <bitset>
#include <cstdint>
#include <istream>
#include <map>
#include <memory>
#include <set>
#include <vector>
 
#include <sys/types.h>
#include <pthread.h>
 
#include <inttypes.h>
 
#include "temporal/bbt_time.h"
#include "temporal/range.h"
#include "temporal/superclock.h"
#include "temporal/time.h"
#include "temporal/timeline.h"
#include "temporal/types.h"
 
#include "pbd/id.h"
#include "pbd/microseconds.h"
 
#include "ardour/chan_count.h"
#include "ardour/plugin_types.h"
 
#include <map>
 
using Temporal::max_samplepos;
using Temporal::max_samplecnt;
 
#if defined (__GNUC__) && (__GNUC__ < 3)
typedef int intptr_t;
#endif
 
namespace ARDOUR {
 
class Source;
class AudioSource;
class GraphNode;
class Route;
class Region;
class Playlist;
class Stripable;
class Trigger;
class VCA;
class AutomationControl;
class SlavableAutomationControl;
 
typedef float    Sample;
typedef float    pan_t;
typedef float    gain_t;
typedef uint32_t layer_t;
typedef uint32_t pframes_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;
 
typedef Temporal::timepos_t timepos_t;
typedef Temporal::timecnt_t timecnt_t;
typedef Temporal::superclock_t superclock_t;
 
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<sampleoffset_t, sampleoffset_t> > AudioIntervalResult;
// associate a set of intervals with regions (e.g. for silence detection)
typedef std::map<std::shared_ptr<ARDOUR::Region>,AudioIntervalResult> AudioIntervalMap;
 
typedef std::list<std::shared_ptr<Region> > RegionList;
typedef std::set<std::shared_ptr<Playlist> > PlaylistSet;
 
struct IOChange {
 
        enum Type {
                NoChange = 0,
                ConfigurationChanged = 0x1,
                ConnectionsChanged = 0x2
        } type;
 
        IOChange () : type (NoChange) {}
        IOChange (Type t) : type (t) {}
 
        ARDOUR::ChanCount before;
        ARDOUR::ChanCount after;
};
 
/* policies for inserting/pasting material where overlaps
   might be an issue.
*/
 
enum InsertMergePolicy {
        InsertMergeReject,  
        InsertMergeRelax,   
        InsertMergeReplace, 
        InsertMergeTruncateExisting, 
        InsertMergeTruncateAddition, 
        InsertMergeExtend   
};
 
enum AutomationType {
        NullAutomation,
        GainAutomation,
        PanAzimuthAutomation,
        PanElevationAutomation,
        PanWidthAutomation,
        PanFrontBackAutomation,
        PanLFEAutomation,
        PluginAutomation,
        PluginPropertyAutomation,
        SoloAutomation,
        SoloIsolateAutomation,
        SoloSafeAutomation,
        MuteAutomation,
        MidiCCAutomation,
        MidiPgmChangeAutomation,
        MidiPitchBenderAutomation,
        MidiChannelPressureAutomation,
        MidiNotePressureAutomation,
        MidiSystemExclusiveAutomation,
        FadeInAutomation,
        FadeOutAutomation,
        EnvelopeAutomation,
        RecEnableAutomation,
        RecSafeAutomation,
        TrimAutomation,
        PhaseAutomation,
        MonitoringAutomation,
        BusSendLevel,
        BusSendEnable,
        SurroundSendLevel,
        InsertReturnLevel,
        MainOutVolume,
        MidiVelocityAutomation,
        PanSurroundX,
        PanSurroundY,
        PanSurroundZ,
        PanSurroundSize,
        PanSurroundSnap,
        BinauralRenderMode,
        PanSurroundElevationEnable,
        PanSurroundZones,
        PanSurroundRamp,
 
        /* used only by Controllable Descriptor to access send parameters */
 
        SendLevelAutomation,
        SendEnableAutomation,
        SendAzimuthAutomation,
};
 
enum AutoState {
        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 AlignStyle {
        CaptureTime,
        ExistingMaterial
};
 
enum AlignChoice {
        UseCaptureTime,
        UseExistingMaterial,
        Automatic
};
 
enum MeterPoint {
        MeterInput,
        MeterPreFader,
        MeterPostFader,
        MeterOutput,
        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 = 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,
        /* No longer in use but kept to allow loading of older sessions */
        Destructive,
};
 
enum RecordMode {
        RecLayered,
        RecNonLayered,
        RecSoundOnSound
};
 
enum SectionOperation {
        CopyPasteSection,
        CutPasteSection,
        InsertSection,
        DeleteSection,
};
 
enum NoteMode {
        Sustained,
        Percussive
};
 
enum ChannelMode {
        AllChannels = 0, 
        FilterChannels,  
        ForceChannel     
};
 
enum ColorMode {
        MeterColors = 0,
        ChannelColors,
        TrackColor
};
 
enum SnapPref {
        SnapToAny_Visual    = 0, 
        SnapToGrid_Scaled   = 1, 
        SnapToGrid_Unscaled = 2, 
};
 
class AnyTime {
                                        public:
        enum Type {
                Timecode,
                BBT,
                BBT_Offset,
                Samples,
                Seconds
        };
 
        Type type;
 
        Timecode::Time     timecode;
        union {
                Temporal::BBT_Time bbt;
                Temporal::BBT_Offset bbt_offset;
        };
 
        union {
                samplecnt_t     samples;
                double         seconds;
        };
 
        AnyTime () : type (Samples), samples (0) {}
        AnyTime (Temporal::BBT_Offset bt) : type (BBT_Offset), bbt_offset (bt) {}
        AnyTime (std::string const &);
 
        std::string str() const;
 
        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 BBT_Offset:
                        return bbt_offset == other.bbt_offset;
                case Samples:
                        return samples == other.samples;
                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 BBT_Offset:
                        return bbt_offset.bars != 0 || bbt_offset.beats != 0 || bbt_offset.ticks != 0;
                case Samples:
                        return samples != 0;
                case Seconds:
                        return seconds != 0;
                }
 
                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); }
};
 
/* Just a Temporal::Range with an ID for identity
 */
struct TimelineRange : public Temporal::TimeRange
{
        uint32_t id;
 
        TimelineRange (Temporal::timepos_t const & s, Temporal::timepos_t e, uint32_t i) : Temporal::TimeRange (s, e), id (i) {}
 
        samplecnt_t length_samples() const { return length().samples(); }
 
        bool operator== (const TimelineRange& other) const {
                return id == other.id && Temporal::TimeRange::operator== (other);
        }
 
        bool equal (const TimelineRange& other) const {
                return Temporal::TimeRange::operator== (other);
        }
};
 
class CueMarker {
  public:
        CueMarker (std::string const& text, timepos_t const & position) : _text (text), _position (position) {}
 
        std::string text() const { return _text; }
        void set_text (std::string const & str) { _text = str; }
 
        timepos_t position() const { return _position; }
        void set_position (timepos_t const & pos) { _position = pos; }
 
        bool operator== (CueMarker const & other) const { return _position == other.position() && _text == other.text(); }
        bool operator< (CueMarker const & other) const { return _position < other.position(); }
 
  private:
        std::string _text;
        timepos_t _position;
};
 
typedef std::set<CueMarker> CueMarkers;
 
/*
  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 MeterHold {
        MeterHoldOff = 0,
        MeterHoldShort = 40,
        MeterHoldMedium = 100,
        MeterHoldLong = 200
};
 
enum EditMode {
        Slide,
        Ripple,
        Lock
};
 
enum SnapTarget {
        SnapTargetGrid,
        SnapTargetOther,
        SnapTargetBoth
};
 
enum RippleMode {
        RippleSelected,
        RippleAll,
        RippleInterview
};
 
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 RangeSelectionAfterSplit {
        ClearSel = 0,
        PreserveSel = 1,  // bit 0
        ForceSel = 2      // bit 1
};
 
enum TimeSelectionAfterSectionPaste {
        SectionSelectNoop = 0,
        SectionSelectClear = 1,
        SectionSelectRetain = 2,
        SectionSelectRetainAndMovePlayhead = 3,
};
 
enum RegionPoint {
        Start,
        End,
        SyncPoint
};
 
enum Placement {
        PreFader,
        PostFader
};
 
enum MonitorModel {
        HardwareMonitoring, 
        SoftwareMonitoring, 
        ExternalMonitoring  
};
 
enum MonitorChoice {
        MonitorAuto = 0,
        MonitorInput = 0x1,
        MonitorDisk = 0x2,
        MonitorCue = 0x3,
};
 
enum FastWindOp {
        FastWindOff = 0,
        FastWindVarispeed = 0x1,  //rewind/ffwd commands will varispeed the transport (incl reverse playback)
        FastWindLocate = 0x2,     //rewind/ffwd commands will jump to next/prior marker
};
 
enum MonitorState {
        MonitoringSilence = 0x0,
        MonitoringInput = 0x2,
        MonitoringDisk = 0x4,
        MonitoringCue = 0x6,
};
 
enum VUMeterStandard {
        MeteringVUfrench,   
        MeteringVUamerican, 
        MeteringVUstandard, 
        MeteringVUeight     
};
 
enum MeterLineUp {
        MeteringLineUp24,
        MeteringLineUp20,
        MeteringLineUp18,
        MeteringLineUp15
};
 
enum InputMeterLayout {
        LayoutVertical,
        LayoutHorizontal,
        LayoutAutomatic,
};
 
enum PFLPosition {
        PFLFromBeforeProcessors,
        PFLFromAfterProcessors
};
 
enum AFLPosition {
        AFLFromBeforeProcessors,
        AFLFromAfterProcessors
};
 
enum ClockDeltaMode {
        NoDelta,
        DeltaEditPoint,
        DeltaOriginMarker
};
 
enum DenormalModel {
        DenormalNone,
        DenormalFTZ,
        DenormalDAZ,
        DenormalFTZDAZ
};
 
enum LayerModel {
        LaterHigher,
        Manual
};
 
enum ListenPosition {
        AfterFaderListen,
        PreFaderListen
};
 
enum AutoConnectOption {
        ManualConnect = 0x0,
        AutoConnectPhysical = 0x1,
        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,
        MP4Chaps
};
 
enum HeaderFormat {
        BWF,
        WAVE,
        WAVE64,
        CAF,
        AIFF,
        iXML,
        RF64,
        RF64_WAV,
        MBWF,
        FLAC,
};
 
struct PeakData {
        typedef Sample PeakDatum;
 
        PeakDatum min;
        PeakDatum max;
};
 
enum RunContext {
        ButlerContext = 0,
        TransportContext,
        ExportContext
};
 
enum SyncSource {
        /* The first two 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,
        LTC,
};
 
enum TransportRequestSource {
        TRS_Engine,
        TRS_MTC,
        TRS_MIDIClock,
        TRS_LTC,
        TRS_MMC,
        TRS_UI,
};
 
enum TransportRequestType {
        TR_StartStop = 0x1,
        TR_Speed     = 0x2,
        TR_Locate    = 0x4
};
 
enum ShuttleUnits {
        Percentage,
        Semitones
};
 
typedef std::vector<std::shared_ptr<Source> > SourceList;
 
enum SrcQuality {
        SrcBest,
        SrcGood,
        SrcQuick,
        SrcFast,
        SrcFastest
};
 
typedef std::list<samplepos_t> AnalysisFeatureList;
typedef std::vector<samplepos_t> XrunPositions;
 
typedef std::list<std::shared_ptr<Route> > RouteList;
typedef std::list<std::shared_ptr<GraphNode> > GraphNodeList;
typedef std::list<std::shared_ptr<Stripable> > StripableList;
typedef std::list<std::weak_ptr  <Route> > WeakRouteList;
typedef std::list<std::weak_ptr  <Stripable> > WeakStripableList;
typedef std::list<std::shared_ptr<AutomationControl> > AutomationControlList;
typedef std::list<std::weak_ptr  <AutomationControl> > WeakAutomationControlList;
typedef std::list<std::shared_ptr<SlavableAutomationControl> > SlavableAutomationControlList;
typedef std::set <AutomationType> AutomationTypeSet;
 
typedef std::list<std::shared_ptr<VCA> > VCAList;
 
class Bundle;
typedef std::vector<std::shared_ptr<Bundle> > BundleList;
 
class IOPlug;
typedef std::vector<std::shared_ptr<IOPlug> > IOPlugList;
 
enum RegionEquivalence {
        Exact,
        Enclosed,
        Overlap,
        LayerTime
};
 
enum WaveformScale {
        Linear,
        Logarithmic
};
 
enum WaveformShape {
        Traditional,
        Rectified
};
 
enum ScreenSaverMode {
        InhibitNever,
        InhibitWhileRecording,
        InhibitAlways
};
 
struct CleanupReport {
        CleanupReport () : space (0) {}
        std::vector<std::string> paths;
        size_t                   space;
};
 
enum PluginGUIBehavior {
        PluginGUIHide,
        PluginGUIDestroyAny,
        PluginGUIDestroyVST,
};
 
enum AppleNSGLViewMode {
        NSGLHiRes,
        NSGLLoRes,
        NSGLDisable,
};
 
struct RouteProcessorChange {
        enum Type {
                NoProcessorChange = 0x0,
                MeterPointChange  = 0x1,
                RealTimeChange    = 0x2,
                GeneralChange     = 0x4,
                SendReturnChange  = 0x8,
                CustomPinChange   = 0x10
        };
 
        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 type;
        bool meter_visibly_changed;
};
 
struct BusProfile {
        BusProfile() : master_out_channels (0) {}
        uint32_t master_out_channels; /* how many channels for the master bus, 0: no master bus */
};
 
enum FadeShape {
        FadeLinear,
        FadeFast,
        FadeSlow,
        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,
 
        /* non-JACK related flags */
        Hidden = 0x20,
        Shadow = 0x40,
 
        TransportMasterPort = 0x80,  // incoming data, used by slaves
        TransportGenerator  = 0x100, // outgoing, timecode/clock generators
        TransportSyncPort   = 0x180  // = TransportMasterPort | TransportGenerator
};
 
enum MidiPortFlags {
        MidiPortMusic = 0x1,
        MidiPortControl = 0x2,
        MidiPortSelection = 0x4,
        MidiPortVirtual = 0x8
};
 
struct LatencyRange {
        LatencyRange () : min (0), max (0) {}
        LatencyRange (const LatencyRange& other) : min (other.min), max (other.max) {}
 
        uint32_t min; //< samples
        uint32_t max; //< samples
 
        bool operator==(const LatencyRange& other) const {
                return (min == other.min && max == other.max);
        }
 
        LatencyRange& operator=(const LatencyRange& other) {
                min = other.min;
                max = other.max;
                return *this;
        }
};
 
enum BufferingPreset {
        Small,
        Medium,
        Large,
        Custom,
};
 
enum AutoReturnTarget {
        LastLocate = 0x1,
        RangeSelectionStart = 0x2,
        Loop = 0x4,
        RegionSelectionStart = 0x8,
};
 
enum PlaylistDisposition {
        CopyPlaylist,
        NewPlaylist,
        SharePlaylist
};
 
enum MidiTrackNameSource {
        SMFTrackNumber,
        SMFTrackName,
        SMFFileAndTrackName,
        SMFInstrumentName
};
 
enum MidiTempoMapDisposition {
        SMFTempoIgnore,
        SMFTempoUse,
};
 
struct CaptureInfo {
        samplepos_t   start;
        samplecnt_t   samples;
        samplecnt_t   loop_offset;
        XrunPositions xruns;
};
 
enum LoopFadeChoice {
        NoLoopFade,
        EndLoopFade,
        BothLoopFade,
        XFadeLoop,
};
 
enum OverwriteReason {
        PlaylistChanged = 0x1,   // actual playlist was swapped/reset
        PlaylistModified = 0x2,  // contents of playlist changed
        LoopDisabled = 0x4,
        LoopChanged = 0x8,
};
 
enum LocateTransportDisposition {
        MustRoll,
        MustStop,
        RollIfAppropriate
};
 
enum CueBehavior {
        FollowCues = 0x1,
        ImplicitlyIgnoreCues = 0x2
};
 
typedef std::vector<CaptureInfo*> CaptureInfos;
 
struct FollowAction {
        enum Type {
                None,
                Stop,
                Again,
                ForwardTrigger, /* any "next" skipping empties */
                ReverseTrigger, /* any "prev" skipping empties */
                FirstTrigger,
                LastTrigger,
                JumpTrigger,
        };
 
        /* We could theoretically limit this to default_triggers_per_box but
         * doing it this way makes it likely that this will not change. Could
         * be worth a constexpr-style compile time assert to check
         * default_triggers_per_box < 64
         */
 
        typedef std::bitset<64> Targets;
 
        Type type;
        Targets targets;
 
        FollowAction () : type (None) {}
        FollowAction (Type t, Targets const & tgts = Targets()) : type (t), targets (tgts) {}
        FollowAction (Type t, std::string const & bitstring) : type (t), targets (bitstring) {}
        FollowAction (std::string const &);
 
        static Targets target_any () { Targets t; t.set(); return t; }
        static Targets target_other (uint8_t skip) { Targets t; t.set (); t.reset (skip); return t; }
        static Targets target_next_wrap (uint8_t from) { Targets t; if (from < t.size() - 1) { t.set (from + 1); } else { t.set (0); } return t; }
        static Targets target_prev_wrap (uint8_t from) { Targets t; if (from) { t.set (from - 1); } else { t.set (t.size() - 1); } return t; }
        static Targets target_next_nowrap (uint8_t from) { Targets t; if (from < t.size() - 1) { t.set (from + 1); } return t; }
        static Targets target_prev_nowrap (uint8_t from) { Targets t; if (from) { t.set (from - 1); } return t; }
 
        bool operator!= (FollowAction const & other) const {
                return other.type != type || other.targets != targets;
        }
 
        bool operator== (FollowAction const & other) const {
                return other.type == type && other.targets == targets;
        }
 
        bool is_arrangement() {
                return (
                        (type==ForwardTrigger) ||
                        (type==ReverseTrigger) ||
                        (type==JumpTrigger)    );
        }
 
        std::string to_string() const;
};
 
struct CueEvent {
        int32_t cue;
        samplepos_t time;
 
        CueEvent (int32_t c, samplepos_t t) : cue (c), time (t) {}
};
 
typedef std::vector<CueEvent> CueEvents;
 
/* Describes the one or two contiguous time ranges processsed by a process
 * callback. The @param cnt member indicates if there are 1 or 2 valid
 * elements; It will only be 2 if a locate-for-loop-end occured during the
 * process cycle.
 *
 * Owned by Session. Readable ONLY within process context AFTER
 * Session::process() has returned.
 */
 
struct ProcessedRanges {
        samplepos_t start[2];
        samplepos_t end[2];
        uint32_t    cnt;
 
        ProcessedRanges() : start { 0, 0 }, end { 0, 0 }, cnt (0) {}
};
 
enum SelectionOperation {
        SelectionSet,
        SelectionAdd,
        SelectionToggle,
        SelectionRemove,
        SelectionExtend /* UI only operation, not core */
};
 
enum RecordState {
        Disabled = 0,
        Enabled = 1,
        Recording = 2
};
 
 
} // namespace ARDOUR
 
/* for now, break the rules and use "using" to make this "global" */
 
using ARDOUR::samplepos_t;