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