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