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