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