libs/ardour/ardour/types.h

   1 /*
   2     Copyright (C) 2002 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #ifndef __ardour_types_h__
  21 #define __ardour_types_h__
  22
  23 #include <istream>
  24 #include <vector>
  25 #include <map>
  26 #include <boost/shared_ptr.hpp>
  27 #include <sys/types.h>
  28 #include <stdint.h>
  29 #include <pthread.h>
  30
  31 #include <inttypes.h>
  32
  33 #include "timecode/bbt_time.h"
  34 #include "timecode/time.h"
  35
  36 #include "pbd/id.h"
  37
  38 #include "evoral/Range.hpp"
  39
  40 #include "ardour/chan_count.h"
  41 #include "ardour/plugin_types.h"
  42
  43 #include <map>
  44
  45 #if __GNUC__ < 3
  46 typedef int intptr_t;
  47 #endif
  48
  49 namespace ARDOUR {
  50
  51         class Source;
  52         class AudioSource;
  53         class Route;
  54         class Region;
  55         class Stripable;
  56         class VCA;
  57         class AutomationControl;
  58
  59         typedef float    Sample;
  60         typedef float    pan_t;
  61         typedef float    gain_t;
  62         typedef uint32_t layer_t;
  63         typedef uint64_t microseconds_t;
  64         typedef uint32_t pframes_t;
  65
  66         /* Any position measured in audio frames.
  67            Assumed to be non-negative but not enforced.
  68         */
  69         typedef int64_t framepos_t;
  70
  71         /* Any distance from a given framepos_t.
  72            Maybe positive or negative.
  73         */
  74         typedef int64_t frameoffset_t;
  75
  76         /* Any count of audio frames.
  77            Assumed to be positive but not enforced.
  78         */
  79         typedef int64_t framecnt_t;
  80
  81         static const framepos_t max_framepos = INT64_MAX;
  82         static const framecnt_t max_framecnt = INT64_MAX;
  83         static const layer_t    max_layer    = UINT32_MAX;
  84
  85         // a set of (time) intervals: first of pair is the offset of the start within the region, second is the offset of the end
  86         typedef std::list<std::pair<frameoffset_t, frameoffset_t> > AudioIntervalResult;
  87         // associate a set of intervals with regions (e.g. for silence detection)
  88         typedef std::map<boost::shared_ptr<ARDOUR::Region>,AudioIntervalResult> AudioIntervalMap;
  89
  90         typedef std::list<boost::shared_ptr<Region> > RegionList;
  91
  92         struct IOChange {
  93
  94                 enum Type {
  95                         NoChange = 0,
  96                         ConfigurationChanged = 0x1,
  97                         ConnectionsChanged = 0x2
  98                 } type;
  99
 100                 IOChange () : type (NoChange) {}
 101                 IOChange (Type t) : type (t) {}
 102
 103                 /** channel count of IO before a ConfigurationChanged, if appropriate */
 104                 ARDOUR::ChanCount before;
 105                 /** channel count of IO after a ConfigurationChanged, if appropriate */
 106                 ARDOUR::ChanCount after;
 107         };
 108
 109         /* policies for inserting/pasting material where overlaps
 110            might be an issue.
 111         */
 112
 113         enum InsertMergePolicy {
 114                 InsertMergeReject,  ///< no overlaps allowed
 115                 InsertMergeRelax,   ///< we just don't care about overlaps
 116                 InsertMergeReplace, ///< replace old with new
 117                 InsertMergeTruncateExisting, ///< shorten existing to avoid overlap
 118                 InsertMergeTruncateAddition, ///< shorten new to avoid overlap
 119                 InsertMergeExtend   ///< extend new (or old) to the range of old+new
 120         };
 121
 122         /** See evoral/Parameter.hpp
 123          *
 124          * When you add things here, you REALLY SHOULD add a case clause to
 125          * the constructor of ParameterDescriptor, unless the Controllables
 126          * that the enum refers to are completely standard (0-1.0 range, 0.0 as
 127          * normal, non-toggled, non-enumerated). Anything else needs to be
 128          * added there so that things that try to represent them can do so
 129          * with as much information as possible.
 130          */
 131         enum AutomationType {
 132                 NullAutomation,
 133                 GainAutomation,
 134                 PanAzimuthAutomation,
 135                 PanElevationAutomation,
 136                 PanWidthAutomation,
 137                 PanFrontBackAutomation,
 138                 PanLFEAutomation,
 139                 PluginAutomation,
 140                 PluginPropertyAutomation,
 141                 SoloAutomation,
 142                 SoloIsolateAutomation,
 143                 SoloSafeAutomation,
 144                 MuteAutomation,
 145                 MidiCCAutomation,
 146                 MidiPgmChangeAutomation,
 147                 MidiPitchBenderAutomation,
 148                 MidiChannelPressureAutomation,
 149                 MidiNotePressureAutomation,
 150                 MidiSystemExclusiveAutomation,
 151                 FadeInAutomation,
 152                 FadeOutAutomation,
 153                 EnvelopeAutomation,
 154                 RecEnableAutomation,
 155                 RecSafeAutomation,
 156                 TrimAutomation,
 157                 PhaseAutomation,
 158                 MonitoringAutomation,
 159                 EQGain,
 160                 EQFrequency,
 161                 EQQ,
 162                 EQShape,
 163                 EQEnable,
 164                 EQHPF,
 165                 EQLPF,
 166                 EQFilterEnable,
 167                 CompThreshold,
 168                 CompSpeed,
 169                 CompMode,
 170                 CompMakeup,
 171                 CompRedux,
 172                 CompEnable,
 173                 BusSendLevel,
 174                 BusSendEnable,
 175         };
 176
 177         enum AutoState {
 178                 Off = 0x0,
 179                 Write = 0x1,
 180                 Touch = 0x2,
 181                 Play = 0x4
 182         };
 183
 184         std::string auto_state_to_string (AutoState);
 185         AutoState string_to_auto_state (std::string);
 186
 187         enum AutoStyle {
 188                 Absolute = 0x1,
 189                 Trim = 0x2
 190         };
 191
 192         std::string auto_style_to_string (AutoStyle);
 193         AutoStyle string_to_auto_style (std::string);
 194
 195         enum AlignStyle {
 196                 CaptureTime,
 197                 ExistingMaterial
 198         };
 199
 200         enum AlignChoice {
 201                 UseCaptureTime,
 202                 UseExistingMaterial,
 203                 Automatic
 204         };
 205
 206         enum MeterPoint {
 207                 MeterInput,
 208                 MeterPreFader,
 209                 MeterPostFader,
 210                 MeterOutput,
 211                 MeterCustom
 212         };
 213
 214         enum MeterType {
 215                 MeterMaxSignal = 0x0001,
 216                 MeterMaxPeak   = 0x0002,
 217                 MeterPeak      = 0x0004,
 218                 MeterKrms      = 0x0008,
 219                 MeterK20       = 0x0010,
 220                 MeterK14       = 0x0020,
 221                 MeterIEC1DIN   = 0x0040,
 222                 MeterIEC1NOR   = 0x0080,
 223                 MeterIEC2BBC   = 0x0100,
 224                 MeterIEC2EBU   = 0x0200,
 225                 MeterVU        = 0x0400,
 226                 MeterK12       = 0x0800,
 227                 MeterPeak0dB   = 0x1000,
 228                 MeterMCP       = 0x2000
 229         };
 230
 231         enum TrackMode {
 232                 Normal,
 233                 NonLayered,
 234                 Destructive
 235         };
 236
 237         enum NoteMode {
 238                 Sustained,
 239                 Percussive
 240         };
 241
 242         enum ChannelMode {
 243                 AllChannels = 0, ///< Pass through all channel information unmodified
 244                 FilterChannels,  ///< Ignore events on certain channels
 245                 ForceChannel     ///< Force all events to a certain channel
 246         };
 247
 248         enum ColorMode {
 249                 MeterColors = 0,
 250                 ChannelColors,
 251                 TrackColor
 252         };
 253
 254         enum RoundMode {
 255                 RoundDownMaybe  = -2,  ///< Round down only if necessary
 256                 RoundDownAlways = -1,  ///< Always round down, even if on a division
 257                 RoundNearest    = 0,   ///< Round to nearest
 258                 RoundUpAlways   = 1,   ///< Always round up, even if on a division
 259                 RoundUpMaybe    = 2    ///< Round up only if necessary
 260         };
 261
 262         class AnyTime {
 263         public:
 264                 enum Type {
 265                         Timecode,
 266                         BBT,
 267                         Frames,
 268                         Seconds
 269                 };
 270
 271                 Type type;
 272
 273                 Timecode::Time     timecode;
 274                 Timecode::BBT_Time bbt;
 275
 276                 union {
 277                         framecnt_t     frames;
 278                         double         seconds;
 279                 };
 280
 281                 AnyTime() { type = Frames; frames = 0; }
 282
 283                 bool operator== (AnyTime const & other) const {
 284                         if (type != other.type) { return false; }
 285
 286                         switch (type) {
 287                           case Timecode:
 288                                 return timecode == other.timecode;
 289                           case BBT:
 290                                 return bbt == other.bbt;
 291                           case Frames:
 292                                 return frames == other.frames;
 293                           case Seconds:
 294                                 return seconds == other.seconds;
 295                         }
 296                         return false; // get rid of warning
 297                 }
 298
 299                 bool not_zero() const
 300                 {
 301                         switch (type) {
 302                           case Timecode:
 303                                 return timecode.hours != 0 || timecode.minutes != 0 ||
 304                                        timecode.seconds != 0 || timecode.frames != 0;
 305                           case BBT:
 306                                 return bbt.bars != 0 || bbt.beats != 0 || bbt.ticks != 0;
 307                           case Frames:
 308                                 return frames != 0;
 309                           case Seconds:
 310                                 return seconds != 0;
 311                         }
 312
 313                         abort(); /* NOTREACHED */
 314                         return false;
 315                 }
 316         };
 317
 318         /* used for translating audio frames to an exact musical position using a note divisor.
 319            an exact musical position almost never falls exactly on an audio frame, but for sub-sample
 320            musical accuracy we need to derive exact musical locations from a frame position
 321            the division follows TempoMap::exact_beat_at_frame().
 322            division
 323            -1       musical location is the bar closest to frame
 324             0       musical location is the musical position of the frame
 325             1       musical location is the BBT beat closest to frame
 326             n       musical location is the quarter-note division n closest to frame
 327         */
 328         struct MusicFrame {
 329                 framepos_t frame;
 330                 int32_t    division;
 331
 332                 MusicFrame (framepos_t f, int32_t d) : frame (f), division (d) {}
 333
 334                 void set (framepos_t f, int32_t d) {frame = f; division = d; }
 335
 336                 MusicFrame operator- (MusicFrame other) { return MusicFrame (frame - other.frame, 0); }
 337         };
 338
 339         /* XXX: slightly unfortunate that there is this and Evoral::Range<>,
 340            but this has a uint32_t id which Evoral::Range<> does not.
 341         */
 342         struct AudioRange {
 343                 framepos_t start;
 344                 framepos_t end;
 345                 uint32_t id;
 346
 347                 AudioRange (framepos_t s, framepos_t e, uint32_t i) : start (s), end (e) , id (i) {}
 348
 349                 framecnt_t length() const { return end - start + 1; }
 350
 351                 bool operator== (const AudioRange& other) const {
 352                         return start == other.start && end == other.end && id == other.id;
 353                 }
 354
 355                 bool equal (const AudioRange& other) const {
 356                         return start == other.start && end == other.end;
 357                 }
 358
 359                 Evoral::OverlapType coverage (framepos_t s, framepos_t e) const {
 360                         return Evoral::coverage (start, end, s, e);
 361                 }
 362         };
 363
 364         struct MusicRange {
 365                 Timecode::BBT_Time start;
 366                 Timecode::BBT_Time end;
 367                 uint32_t id;
 368
 369                 MusicRange (Timecode::BBT_Time& s, Timecode::BBT_Time& e, uint32_t i)
 370                         : start (s), end (e), id (i) {}
 371
 372                 bool operator== (const MusicRange& other) const {
 373                         return start == other.start && end == other.end && id == other.id;
 374                 }
 375
 376                 bool equal (const MusicRange& other) const {
 377                         return start == other.start && end == other.end;
 378                 }
 379         };
 380
 381         /*
 382             Slowest = 6.6dB/sec falloff at update rate of 40ms
 383             Slow    = 6.8dB/sec falloff at update rate of 40ms
 384         */
 385
 386         enum MeterFalloff {
 387                 MeterFalloffOff = 0,
 388                 MeterFalloffSlowest = 1,
 389                 MeterFalloffSlow = 2,
 390                 MeterFalloffSlowish = 3,
 391                 MeterFalloffModerate = 4,
 392                 MeterFalloffMedium = 5,
 393                 MeterFalloffFast = 6,
 394                 MeterFalloffFaster = 7,
 395                 MeterFalloffFastest = 8,
 396         };
 397
 398         enum MeterHold {
 399                 MeterHoldOff = 0,
 400                 MeterHoldShort = 40,
 401                 MeterHoldMedium = 100,
 402                 MeterHoldLong = 200
 403         };
 404
 405         enum EditMode {
 406                 Slide,
 407                 Splice,
 408                 Ripple,
 409                 Lock
 410         };
 411
 412         enum RegionSelectionAfterSplit {
 413                 None = 0,
 414                 NewlyCreatedLeft = 1,  // bit 0
 415                 NewlyCreatedRight = 2, // bit 1
 416                 NewlyCreatedBoth = 3,
 417                 Existing = 4,          // bit 2
 418                 ExistingNewlyCreatedLeft = 5,
 419                 ExistingNewlyCreatedRight = 6,
 420                 ExistingNewlyCreatedBoth = 7
 421         };
 422
 423         enum RegionPoint {
 424                 Start,
 425                 End,
 426                 SyncPoint
 427         };
 428
 429         enum Placement {
 430                 PreFader,
 431                 PostFader
 432         };
 433
 434         enum MonitorModel {
 435                 HardwareMonitoring, ///< JACK does monitoring
 436                 SoftwareMonitoring, ///< Ardour does monitoring
 437                 ExternalMonitoring  ///< we leave monitoring to the audio hardware
 438         };
 439
 440         enum MonitorChoice {
 441                 MonitorAuto = 0,
 442                 MonitorInput = 0x1,
 443                 MonitorDisk = 0x2,
 444                 MonitorCue = 0x4,
 445         };
 446
 447         enum MonitorState {
 448                 MonitoringSilence = 0x1,
 449                 MonitoringInput = 0x2,
 450                 MonitoringDisk = 0x4,
 451         };
 452
 453         enum MeterState {
 454                 MeteringInput, ///< meter the input IO, regardless of what is going through the route
 455                 MeteringRoute  ///< meter what is going through the route
 456         };
 457
 458         enum VUMeterStandard {
 459                 MeteringVUfrench,   // 0VU = -2dBu
 460                 MeteringVUamerican, // 0VU =  0dBu
 461                 MeteringVUstandard, // 0VU = +4dBu
 462                 MeteringVUeight     // 0VU = +8dBu
 463         };
 464
 465         enum MeterLineUp {
 466                 MeteringLineUp24,
 467                 MeteringLineUp20,
 468                 MeteringLineUp18,
 469                 MeteringLineUp15
 470         };
 471
 472         enum PFLPosition {
 473                 /** PFL signals come from before pre-fader processors */
 474                 PFLFromBeforeProcessors,
 475                 /** PFL signals come pre-fader but after pre-fader processors */
 476                 PFLFromAfterProcessors
 477         };
 478
 479         enum AFLPosition {
 480                 /** AFL signals come post-fader and before post-fader processors */
 481                 AFLFromBeforeProcessors,
 482                 /** AFL signals come post-fader but after post-fader processors */
 483                 AFLFromAfterProcessors
 484         };
 485
 486         enum DenormalModel {
 487                 DenormalNone,
 488                 DenormalFTZ,
 489                 DenormalDAZ,
 490                 DenormalFTZDAZ
 491         };
 492
 493         enum LayerModel {
 494                 LaterHigher,
 495                 Manual
 496         };
 497
 498         enum ListenPosition {
 499                 AfterFaderListen,
 500                 PreFaderListen
 501         };
 502
 503         enum AutoConnectOption {
 504                 ManualConnect = 0x0,
 505                 AutoConnectPhysical = 0x1,
 506                 AutoConnectMaster = 0x2
 507         };
 508
 509     enum TracksAutoNamingRule {
 510         UseDefaultNames = 0x1,
 511         NameAfterDriver = 0x2
 512     };
 513
 514         enum SampleFormat {
 515                 FormatFloat = 0,
 516                 FormatInt24,
 517                 FormatInt16
 518         };
 519
 520         int format_data_width (ARDOUR::SampleFormat);
 521
 522         enum CDMarkerFormat {
 523                 CDMarkerNone,
 524                 CDMarkerCUE,
 525                 CDMarkerTOC,
 526                 MP4Chaps
 527         };
 528
 529         enum HeaderFormat {
 530                 BWF,
 531                 WAVE,
 532                 WAVE64,
 533                 CAF,
 534                 AIFF,
 535                 iXML,
 536                 RF64,
 537                 RF64_WAV,
 538                 MBWF,
 539         };
 540
 541         struct PeakData {
 542                 typedef Sample PeakDatum;
 543
 544                 PeakDatum min;
 545                 PeakDatum max;
 546         };
 547
 548         enum RunContext {
 549                 ButlerContext = 0,
 550                 TransportContext,
 551                 ExportContext
 552         };
 553
 554         enum SyncSource {
 555                 /* These are "synonyms". It is important for JACK to be first
 556                    both here and in enums.cc, so that the string "JACK" is
 557                    correctly recognized in older session and preference files.
 558                 */
 559                 JACK = 0,
 560                 Engine = 0,
 561                 MTC,
 562                 MIDIClock,
 563                 LTC
 564         };
 565
 566         enum ShuttleBehaviour {
 567                 Sprung,
 568                 Wheel
 569         };
 570
 571         enum ShuttleUnits {
 572                 Percentage,
 573                 Semitones
 574         };
 575
 576         typedef std::vector<boost::shared_ptr<Source> > SourceList;
 577
 578         enum SrcQuality {
 579                 SrcBest,
 580                 SrcGood,
 581                 SrcQuick,
 582                 SrcFast,
 583                 SrcFastest
 584         };
 585
 586         typedef std::list<framepos_t> AnalysisFeatureList;
 587
 588         typedef std::list<boost::shared_ptr<Route> > RouteList;
 589         typedef std::list<boost::shared_ptr<Stripable> > StripableList;
 590         typedef std::list<boost::weak_ptr  <Route> > WeakRouteList;
 591         typedef std::list<boost::weak_ptr  <Stripable> > WeakStripableList;
 592         typedef std::list<boost::shared_ptr<AutomationControl> > ControlList;
 593
 594         typedef std::list<boost::shared_ptr<VCA> > VCAList;
 595
 596         class Bundle;
 597         typedef std::vector<boost::shared_ptr<Bundle> > BundleList;
 598
 599         enum WaveformScale {
 600                 Linear,
 601                 Logarithmic
 602         };
 603
 604         enum WaveformShape {
 605                 Traditional,
 606                 Rectified
 607         };
 608
 609         struct CleanupReport {
 610                 std::vector<std::string> paths;
 611                 size_t                   space;
 612         };
 613
 614         enum PositionLockStyle {
 615                 AudioTime,
 616                 MusicTime
 617         };
 618
 619         /** A struct used to describe changes to processors in a route.
 620          *  This is useful because objects that respond to a change in processors
 621          *  can optimise what work they do based on details of what has changed.
 622         */
 623         struct RouteProcessorChange {
 624                 enum Type {
 625                         GeneralChange = 0x0,
 626                         MeterPointChange = 0x1,
 627                         RealTimeChange = 0x2
 628                 };
 629
 630                 RouteProcessorChange () : type (GeneralChange), meter_visibly_changed (true)
 631                 {}
 632
 633                 RouteProcessorChange (Type t) : type (t), meter_visibly_changed (true)
 634                 {}
 635
 636                 RouteProcessorChange (Type t, bool m) : type (t), meter_visibly_changed (m)
 637                 {}
 638
 639                 /** type of change; "GeneralChange" means anything could have changed */
 640                 Type type;
 641                 /** true if, when a MeterPointChange has occurred, the change is visible to the user */
 642                 bool meter_visibly_changed;
 643         };
 644
 645         struct BusProfile {
 646                 AutoConnectOption input_ac;      /* override the RC config for input auto-connection */
 647                 AutoConnectOption output_ac;     /* override the RC config for output auto-connection */
 648                 uint32_t master_out_channels;    /* how many channels for the master bus */
 649                 uint32_t requested_physical_in;  /* now many of the available physical inputs to consider usable */
 650                 uint32_t requested_physical_out; /* now many of the available physical inputs to consider usable */
 651         };
 652
 653         enum FadeShape {
 654                 FadeLinear,
 655                 FadeFast,
 656                 FadeSlow,
 657                 FadeConstantPower,
 658                 FadeSymmetric,
 659         };
 660
 661         enum TransportState {
 662                 /* these values happen to match the constants used by JACK but
 663                    this equality cannot be assumed.
 664                 */
 665                 TransportStopped = 0,
 666                 TransportRolling = 1,
 667                 TransportLooping = 2,
 668                 TransportStarting = 3,
 669         };
 670
 671         enum PortFlags {
 672                 /* these values happen to match the constants used by JACK but
 673                    this equality cannot be assumed.
 674                 */
 675                 IsInput = 0x1,
 676                 IsOutput = 0x2,
 677                 IsPhysical = 0x4,
 678                 CanMonitor = 0x8,
 679                 IsTerminal = 0x10,
 680
 681                 /* non-JACK related flags */
 682                 Hidden = 0x20,
 683                 Shadow = 0x40
 684         };
 685
 686         enum MidiPortFlags {
 687                 MidiPortMusic = 0x1,
 688                 MidiPortControl = 0x2,
 689                 MidiPortSelection = 0x4,
 690                 MidiPortVirtual = 0x8
 691         };
 692
 693         struct LatencyRange {
 694             uint32_t min; //< samples
 695             uint32_t max; //< samples
 696         };
 697
 698         enum BufferingPreset {
 699                 Small,
 700                 Medium,
 701                 Large,
 702                 Custom,
 703         };
 704
 705         enum AutoReturnTarget {
 706                 LastLocate = 0x1,
 707                 RangeSelectionStart = 0x2,
 708                 Loop = 0x4,
 709                 RegionSelectionStart = 0x8,
 710         };
 711
 712         enum PlaylistDisposition {
 713                 CopyPlaylist,
 714                 NewPlaylist,
 715                 SharePlaylist
 716         };
 717
 718         enum MidiTrackNameSource {
 719                 SMFTrackNumber,
 720                 SMFTrackName,
 721                 SMFInstrumentName
 722         };
 723
 724         enum MidiTempoMapDisposition {
 725                 SMFTempoIgnore,
 726                 SMFTempoUse,
 727         };
 728
 729 } // namespace ARDOUR
 730
 731 static inline ARDOUR::framepos_t
 732 session_frame_to_track_frame (ARDOUR::framepos_t session_frame, double speed)
 733 {
 734         long double result = (long double) session_frame * (long double) speed;
 735
 736         if (result >= (long double) ARDOUR::max_framepos) {
 737                 return ARDOUR::max_framepos;
 738         } else if (result <= (long double) (ARDOUR::max_framepos) * (ARDOUR::framepos_t)(-1)) {
 739                 return (ARDOUR::max_framepos * (ARDOUR::framepos_t)(-1));
 740         } else {
 741                 return result;
 742         }
 743 }
 744
 745 static inline ARDOUR::framepos_t
 746 track_frame_to_session_frame (ARDOUR::framepos_t track_frame, double speed)
 747 {
 748         /* NB - do we need a check for speed == 0 ??? */
 749         long double result = (long double) track_frame / (long double) speed;
 750
 751         if (result >= (long double) ARDOUR::max_framepos) {
 752                 return ARDOUR::max_framepos;
 753         } else if (result <= (long double) (ARDOUR::max_framepos) * (ARDOUR::framepos_t)(-1)) {
 754                 return (ARDOUR::max_framepos * (ARDOUR::framepos_t)(-1));
 755         } else {
 756                 return result;
 757         }
 758 }
 759
 760 /* for now, break the rules and use "using" to make this "global" */
 761
 762 using ARDOUR::framepos_t;
 763
 764
 765 #endif /* __ardour_types_h__ */