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