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                 Constrained
 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 SampleFormat {
 461                 FormatFloat = 0,
 462                 FormatInt24,
 463                 FormatInt16
 464         };
 465
 466         int format_data_width (ARDOUR::SampleFormat);
 467
 468         enum CDMarkerFormat {
 469                 CDMarkerNone,
 470                 CDMarkerCUE,
 471                 CDMarkerTOC,
 472                 MP4Chaps
 473         };
 474
 475         enum HeaderFormat {
 476                 BWF,
 477                 WAVE,
 478                 WAVE64,
 479                 CAF,
 480                 AIFF,
 481                 iXML,
 482                 RF64
 483         };
 484
 485         struct PeakData {
 486                 typedef Sample PeakDatum;
 487
 488                 PeakDatum min;
 489                 PeakDatum max;
 490         };
 491
 492         enum RunContext {
 493                 ButlerContext = 0,
 494                 TransportContext,
 495                 ExportContext
 496         };
 497
 498         enum SyncSource {
 499                 /* These are "synonyms". It is important for JACK to be first
 500                    both here and in enums.cc, so that the string "JACK" is
 501                    correctly recognized in older session and preference files.
 502                 */
 503                 JACK = 0,
 504                 Engine = 0,
 505                 MTC,
 506                 MIDIClock,
 507                 LTC
 508         };
 509
 510         enum ShuttleBehaviour {
 511                 Sprung,
 512                 Wheel
 513         };
 514
 515         enum ShuttleUnits {
 516                 Percentage,
 517                 Semitones
 518         };
 519
 520         typedef std::vector<boost::shared_ptr<Source> > SourceList;
 521
 522         enum SrcQuality {
 523                 SrcBest,
 524                 SrcGood,
 525                 SrcQuick,
 526                 SrcFast,
 527                 SrcFastest
 528         };
 529
 530         typedef std::list<framepos_t> AnalysisFeatureList;
 531
 532         typedef std::list<boost::shared_ptr<Route> > RouteList;
 533         typedef std::list<boost::weak_ptr  <Route> > WeakRouteList;
 534
 535         class Bundle;
 536         typedef std::vector<boost::shared_ptr<Bundle> > BundleList;
 537
 538         enum WaveformScale {
 539                 Linear,
 540                 Logarithmic
 541         };
 542
 543         enum WaveformShape {
 544                 Traditional,
 545                 Rectified
 546         };
 547
 548         struct CleanupReport {
 549                 std::vector<std::string> paths;
 550                 size_t                   space;
 551         };
 552
 553         enum PositionLockStyle {
 554                 AudioTime,
 555                 MusicTime
 556         };
 557
 558         /** A struct used to describe changes to processors in a route.
 559          *  This is useful because objects that respond to a change in processors
 560          *  can optimise what work they do based on details of what has changed.
 561         */
 562         struct RouteProcessorChange {
 563                 enum Type {
 564                         GeneralChange = 0x0,
 565                         MeterPointChange = 0x1,
 566                         RealTimeChange = 0x2
 567                 };
 568
 569                 RouteProcessorChange () : type (GeneralChange), meter_visibly_changed (true)
 570                 {}
 571
 572                 RouteProcessorChange (Type t) : type (t), meter_visibly_changed (true)
 573                 {}
 574
 575                 RouteProcessorChange (Type t, bool m) : type (t), meter_visibly_changed (m)
 576                 {}
 577
 578                 /** type of change; "GeneralChange" means anything could have changed */
 579                 Type type;
 580                 /** true if, when a MeterPointChange has occurred, the change is visible to the user */
 581                 bool meter_visibly_changed;
 582         };
 583
 584         struct BusProfile {
 585                 AutoConnectOption input_ac;      /* override the RC config for input auto-connection */
 586                 AutoConnectOption output_ac;     /* override the RC config for output auto-connection */
 587                 uint32_t master_out_channels;    /* how many channels for the master bus */
 588                 uint32_t requested_physical_in;  /* now many of the available physical inputs to consider usable */
 589                 uint32_t requested_physical_out; /* now many of the available physical inputs to consider usable */
 590         };
 591
 592         enum FadeShape {
 593                 FadeLinear,
 594                 FadeFast,
 595                 FadeSlow,
 596                 FadeConstantPower,
 597                 FadeSymmetric,
 598         };
 599
 600         enum TransportState {
 601                 /* these values happen to match the constants used by JACK but
 602                    this equality cannot be assumed.
 603                 */
 604                 TransportStopped = 0,
 605                 TransportRolling = 1,
 606                 TransportLooping = 2,
 607                 TransportStarting = 3,
 608         };
 609
 610         enum PortFlags {
 611                 /* these values happen to match the constants used by JACK but
 612                    this equality cannot be assumed.
 613                 */
 614                 IsInput = 0x1,
 615                 IsOutput = 0x2,
 616                 IsPhysical = 0x4,
 617                 CanMonitor = 0x8,
 618                 IsTerminal = 0x10
 619         };
 620
 621         struct LatencyRange {
 622             uint32_t min; //< samples
 623             uint32_t max; //< samples
 624         };
 625
 626 } // namespace ARDOUR
 627
 628
 629 /* these cover types declared above in this header. See enums.cc
 630    for the definitions.
 631 */
 632 std::istream& operator>>(std::istream& o, ARDOUR::SampleFormat& sf);
 633 std::istream& operator>>(std::istream& o, ARDOUR::HeaderFormat& sf);
 634 std::istream& operator>>(std::istream& o, ARDOUR::AutoConnectOption& sf);
 635 std::istream& operator>>(std::istream& o, ARDOUR::EditMode& sf);
 636 std::istream& operator>>(std::istream& o, ARDOUR::MonitorModel& sf);
 637 std::istream& operator>>(std::istream& o, ARDOUR::PFLPosition& sf);
 638 std::istream& operator>>(std::istream& o, ARDOUR::AFLPosition& sf);
 639 std::istream& operator>>(std::istream& o, ARDOUR::RemoteModel& sf);
 640 std::istream& operator>>(std::istream& o, ARDOUR::ListenPosition& sf);
 641 std::istream& operator>>(std::istream& o, ARDOUR::LayerModel& sf);
 642 std::istream& operator>>(std::istream& o, ARDOUR::InsertMergePolicy& sf);
 643 std::istream& operator>>(std::istream& o, ARDOUR::SyncSource& sf);
 644 std::istream& operator>>(std::istream& o, ARDOUR::ShuttleBehaviour& sf);
 645 std::istream& operator>>(std::istream& o, ARDOUR::ShuttleUnits& sf);
 646 std::istream& operator>>(std::istream& o, Timecode::TimecodeFormat& sf);
 647 std::istream& operator>>(std::istream& o, ARDOUR::DenormalModel& sf);
 648 std::istream& operator>>(std::istream& o, ARDOUR::PositionLockStyle& sf);
 649 std::istream& operator>>(std::istream& o, ARDOUR::FadeShape& sf);
 650 std::istream& operator>>(std::istream& o, ARDOUR::RegionSelectionAfterSplit& sf);
 651
 652 std::ostream& operator<<(std::ostream& o, const ARDOUR::SampleFormat& sf);
 653 std::ostream& operator<<(std::ostream& o, const ARDOUR::HeaderFormat& sf);
 654 std::ostream& operator<<(std::ostream& o, const ARDOUR::AutoConnectOption& sf);
 655 std::ostream& operator<<(std::ostream& o, const ARDOUR::EditMode& sf);
 656 std::ostream& operator<<(std::ostream& o, const ARDOUR::MonitorModel& sf);
 657 std::ostream& operator<<(std::ostream& o, const ARDOUR::PFLPosition& sf);
 658 std::ostream& operator<<(std::ostream& o, const ARDOUR::AFLPosition& sf);
 659 std::ostream& operator<<(std::ostream& o, const ARDOUR::RemoteModel& sf);
 660 std::ostream& operator<<(std::ostream& o, const ARDOUR::ListenPosition& sf);
 661 std::ostream& operator<<(std::ostream& o, const ARDOUR::LayerModel& sf);
 662 std::ostream& operator<<(std::ostream& o, const ARDOUR::InsertMergePolicy& sf);
 663 std::ostream& operator<<(std::ostream& o, const ARDOUR::SyncSource& sf);
 664 std::ostream& operator<<(std::ostream& o, const ARDOUR::ShuttleBehaviour& sf);
 665 std::ostream& operator<<(std::ostream& o, const ARDOUR::ShuttleUnits& sf);
 666 std::ostream& operator<<(std::ostream& o, const Timecode::TimecodeFormat& sf);
 667 std::ostream& operator<<(std::ostream& o, const ARDOUR::DenormalModel& sf);
 668 std::ostream& operator<<(std::ostream& o, const ARDOUR::PositionLockStyle& sf);
 669 std::ostream& operator<<(std::ostream& o, const ARDOUR::FadeShape& sf);
 670 std::ostream& operator<<(std::ostream& o, const ARDOUR::RegionSelectionAfterSplit& sf);
 671
 672
 673 /* because these operators work on types which can be used when making
 674    a UI_CONFIG_VARIABLE (in gtk2_ardour) we need them to be exported.
 675 */
 676 LIBARDOUR_API std::istream& operator>>(std::istream& o, ARDOUR::WaveformScale& sf);
 677 LIBARDOUR_API std::istream& operator>>(std::istream& o, ARDOUR::WaveformShape& sf);
 678 LIBARDOUR_API std::istream& operator>>(std::istream& o, ARDOUR::VUMeterStandard& sf);
 679 LIBARDOUR_API std::istream& operator>>(std::istream& o, ARDOUR::MeterLineUp& sf);
 680
 681 LIBARDOUR_API std::ostream& operator<<(std::ostream& o, const ARDOUR::WaveformScale& sf);
 682 LIBARDOUR_API std::ostream& operator<<(std::ostream& o, const ARDOUR::WaveformShape& sf);
 683 LIBARDOUR_API std::ostream& operator<<(std::ostream& o, const ARDOUR::VUMeterStandard& sf);
 684 LIBARDOUR_API std::ostream& operator<<(std::ostream& o, const ARDOUR::MeterLineUp& sf);
 685
 686
 687 static inline ARDOUR::framepos_t
 688 session_frame_to_track_frame (ARDOUR::framepos_t session_frame, double speed)
 689 {
 690         return (ARDOUR::framepos_t) ((long double) session_frame * (long double) speed);
 691 }
 692
 693 static inline ARDOUR::framepos_t
 694 track_frame_to_session_frame (ARDOUR::framepos_t track_frame, double speed)
 695 {
 696         return (ARDOUR::framepos_t) ((long double) track_frame / (long double) speed);
 697 }
 698
 699 /* for now, break the rules and use "using" to make this "global" */
 700
 701 using ARDOUR::framepos_t;
 702
 703
 704 #endif /* __ardour_types_h__ */
 705