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