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