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