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