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