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