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