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
  42 #include <map>
  43
  44 #if __GNUC__ < 3
  45 typedef int intptr_t;
  46 #endif
  47
  48 namespace ARDOUR {
  49
  50         class Source;
  51         class AudioSource;
  52         class Route;
  53         class Region;
  54
  55         typedef float    Sample;
  56         typedef float    pan_t;
  57         typedef float    gain_t;
  58         typedef uint32_t layer_t;
  59         typedef uint64_t microseconds_t;
  60         typedef uint32_t pframes_t;
  61
  62         /* Any position measured in audio frames.
  63            Assumed to be non-negative but not enforced.
  64         */
  65         typedef int64_t framepos_t;
  66
  67         /* Any distance from a given framepos_t.
  68            Maybe positive or negative.
  69         */
  70         typedef int64_t frameoffset_t;
  71
  72         /* Any count of audio frames.
  73            Assumed to be positive but not enforced.
  74         */
  75         typedef int64_t framecnt_t;
  76
  77         static const framepos_t max_framepos = INT64_MAX;
  78         static const framecnt_t max_framecnt = INT64_MAX;
  79         static const layer_t    max_layer    = UINT32_MAX;
  80
  81         // a set of (time) intervals: first of pair is the offset of the start within the region, second is the offset of the end
  82         typedef std::list<std::pair<frameoffset_t, frameoffset_t> > AudioIntervalResult;
  83         // associate a set of intervals with regions (e.g. for silence detection)
  84         typedef std::map<boost::shared_ptr<ARDOUR::Region>,AudioIntervalResult> AudioIntervalMap;
  85
  86         typedef std::list<boost::shared_ptr<Region> > RegionList;
  87
  88         struct IOChange {
  89
  90                 enum Type {
  91                         NoChange = 0,
  92                         ConfigurationChanged = 0x1,
  93                         ConnectionsChanged = 0x2
  94                 } type;
  95
  96                 IOChange () : type (NoChange) {}
  97                 IOChange (Type t) : type (t) {}
  98
  99                 /** channel count of IO before a ConfigurationChanged, if appropriate */
 100                 ARDOUR::ChanCount before;
 101                 /** channel count of IO after a ConfigurationChanged, if appropriate */
 102                 ARDOUR::ChanCount after;
 103         };
 104
 105         /* policies for inserting/pasting material where overlaps
 106            might be an issue.
 107         */
 108
 109         enum InsertMergePolicy {
 110                 InsertMergeReject,  // no overlaps allowed
 111                 InsertMergeRelax,   // we just don't care about overlaps
 112                 InsertMergeReplace, // replace old with new
 113                 InsertMergeTruncateExisting, // shorten existing to avoid overlap
 114                 InsertMergeTruncateAddition, // shorten new to avoid overlap
 115                 InsertMergeExtend   // extend new (or old) to the range of old+new
 116         };
 117
 118         /** See evoral/Parameter.hpp
 119          */
 120         enum AutomationType {
 121                 NullAutomation,
 122                 GainAutomation,
 123                 PanAzimuthAutomation,
 124                 PanElevationAutomation,
 125                 PanWidthAutomation,
 126                 PanFrontBackAutomation,
 127                 PanLFEAutomation,
 128                 PluginAutomation,
 129                 SoloAutomation,
 130                 MuteAutomation,
 131                 MidiCCAutomation,
 132                 MidiPgmChangeAutomation,
 133                 MidiPitchBenderAutomation,
 134                 MidiChannelPressureAutomation,
 135                 MidiSystemExclusiveAutomation,
 136                 FadeInAutomation,
 137                 FadeOutAutomation,
 138                 EnvelopeAutomation,
 139                 RecEnableAutomation
 140         };
 141
 142         enum AutoState {
 143                 Off = 0x0,
 144                 Write = 0x1,
 145                 Touch = 0x2,
 146                 Play = 0x4
 147         };
 148
 149         std::string auto_state_to_string (AutoState);
 150         AutoState string_to_auto_state (std::string);
 151
 152         enum AutoStyle {
 153                 Absolute = 0x1,
 154                 Trim = 0x2
 155         };
 156
 157         std::string auto_style_to_string (AutoStyle);
 158         AutoStyle string_to_auto_style (std::string);
 159
 160         enum AlignStyle {
 161                 CaptureTime,
 162                 ExistingMaterial
 163         };
 164
 165         enum AlignChoice {
 166                 UseCaptureTime,
 167                 UseExistingMaterial,
 168                 Automatic
 169         };
 170
 171         enum MeterPoint {
 172                 MeterInput,
 173                 MeterPreFader,
 174                 MeterPostFader,
 175                 MeterOutput,
 176                 MeterCustom
 177         };
 178
 179         enum MeterType {
 180                 MeterMaxSignal = 0x001,
 181                 MeterMaxPeak   = 0x002,
 182                 MeterPeak      = 0x004,
 183                 MeterKrms      = 0x008,
 184                 MeterK20       = 0x010,
 185                 MeterK14       = 0x020,
 186                 MeterIEC1DIN   = 0x040,
 187                 MeterIEC1NOR   = 0x080,
 188                 MeterIEC2BBC   = 0x100,
 189                 MeterIEC2EBU   = 0x200,
 190                 MeterVU        = 0x400
 191         };
 192
 193         enum TrackMode {
 194                 Normal,
 195                 NonLayered,
 196                 Destructive
 197         };
 198
 199         enum NoteMode {
 200                 Sustained,
 201                 Percussive
 202         };
 203
 204         enum ChannelMode {
 205                 AllChannels = 0, ///< Pass through all channel information unmodified
 206                 FilterChannels,  ///< Ignore events on certain channels
 207                 ForceChannel     ///< Force all events to a certain channel
 208         };
 209
 210         enum ColorMode {
 211                 MeterColors = 0,
 212                 ChannelColors,
 213                 TrackColor
 214         };
 215
 216         class AnyTime {
 217         public:
 218                 enum Type {
 219                         Timecode,
 220                         BBT,
 221                         Frames,
 222                         Seconds
 223                 };
 224
 225                 Type type;
 226
 227                 Timecode::Time     timecode;
 228                 Timecode::BBT_Time bbt;
 229
 230                 union {
 231                         framecnt_t     frames;
 232                         double         seconds;
 233                 };
 234
 235                 AnyTime() { type = Frames; frames = 0; }
 236
 237                 bool operator== (AnyTime const & other) const {
 238                         if (type != other.type) { return false; }
 239
 240                         switch (type) {
 241                           case Timecode:
 242                                 return timecode == other.timecode;
 243                           case BBT:
 244                                 return bbt == other.bbt;
 245                           case Frames:
 246                                 return frames == other.frames;
 247                           case Seconds:
 248                                 return seconds == other.seconds;
 249                         }
 250                         return false; // get rid of warning
 251                 }
 252
 253                 bool not_zero() const
 254                 {
 255                         switch (type) {
 256                           case Timecode:
 257                                 return timecode.hours != 0 || timecode.minutes != 0 ||
 258                                        timecode.seconds != 0 || timecode.frames != 0;
 259                           case BBT:
 260                                 return bbt.bars != 0 || bbt.beats != 0 || bbt.ticks != 0;
 261                           case Frames:
 262                                 return frames != 0;
 263                           case Seconds:
 264                                 return seconds != 0;
 265                         }
 266
 267                         /* NOTREACHED */
 268                         assert (false);
 269                         return false;
 270                 }
 271         };
 272
 273         /* XXX: slightly unfortunate that there is this and Evoral::Range<>,
 274            but this has a uint32_t id which Evoral::Range<> does not.
 275         */
 276         struct AudioRange {
 277                 framepos_t start;
 278                 framepos_t end;
 279                 uint32_t id;
 280
 281                 AudioRange (framepos_t s, framepos_t e, uint32_t i) : start (s), end (e) , id (i) {}
 282
 283                 framecnt_t length() { return end - start + 1; }
 284
 285                 bool operator== (const AudioRange& other) const {
 286                         return start == other.start && end == other.end && id == other.id;
 287                 }
 288
 289                 bool equal (const AudioRange& other) const {
 290                         return start == other.start && end == other.end;
 291                 }
 292
 293                 Evoral::OverlapType coverage (framepos_t s, framepos_t e) const {
 294                         return Evoral::coverage (start, end, s, e);
 295                 }
 296         };
 297
 298         struct MusicRange {
 299                 Timecode::BBT_Time start;
 300                 Timecode::BBT_Time end;
 301                 uint32_t id;
 302
 303                 MusicRange (Timecode::BBT_Time& s, Timecode::BBT_Time& e, uint32_t i)
 304                         : start (s), end (e), id (i) {}
 305
 306                 bool operator== (const MusicRange& other) const {
 307                         return start == other.start && end == other.end && id == other.id;
 308                 }
 309
 310                 bool equal (const MusicRange& other) const {
 311                         return start == other.start && end == other.end;
 312                 }
 313         };
 314
 315         /*
 316             Slowest = 6.6dB/sec falloff at update rate of 40ms
 317             Slow    = 6.8dB/sec falloff at update rate of 40ms
 318         */
 319
 320         enum MeterFalloff {
 321                 MeterFalloffOff = 0,
 322                 MeterFalloffSlowest = 1,
 323                 MeterFalloffSlow = 2,
 324                 MeterFalloffSlowish = 3,
 325                 MeterFalloffModerate = 4,
 326                 MeterFalloffMedium = 5,
 327                 MeterFalloffFast = 6,
 328                 MeterFalloffFaster = 7,
 329                 MeterFalloffFastest = 8,
 330         };
 331
 332         enum MeterHold {
 333                 MeterHoldOff = 0,
 334                 MeterHoldShort = 40,
 335                 MeterHoldMedium = 100,
 336                 MeterHoldLong = 200
 337         };
 338
 339         enum EditMode {
 340                 Slide,
 341                 Splice,
 342                 Lock
 343         };
 344
 345         enum RegionPoint {
 346                 Start,
 347                 End,
 348                 SyncPoint
 349         };
 350
 351         enum Placement {
 352                 PreFader,
 353                 PostFader
 354         };
 355
 356         enum RouteSortOrderKey {
 357                 EditorSort,
 358                 MixerSort
 359         };
 360
 361         enum MonitorModel {
 362                 HardwareMonitoring, ///< JACK does monitoring
 363                 SoftwareMonitoring, ///< Ardour does monitoring
 364                 ExternalMonitoring  ///< we leave monitoring to the audio hardware
 365         };
 366
 367         enum MonitorChoice {
 368                 MonitorAuto = 0,
 369                 MonitorInput = 0x1,
 370                 MonitorDisk = 0x2,
 371                 MonitorCue = 0x4,
 372         };
 373
 374         enum MonitorState {
 375                 MonitoringSilence = 0x1,
 376                 MonitoringInput = 0x2,
 377                 MonitoringDisk = 0x4,
 378         };
 379
 380         enum MeterState {
 381                 MeteringInput, ///< meter the input IO, regardless of what is going through the route
 382                 MeteringRoute  ///< meter what is going through the route
 383         };
 384
 385         enum VUMeterStandard {
 386                 MeteringVUfrench,   // 0VU = -2dBu
 387                 MeteringVUamerican, // 0VU =  0dBu
 388                 MeteringVUstandard, // 0VU = +4dBu
 389                 MeteringVUeight     // 0VU = +8dBu
 390         };
 391
 392         enum MeterLineUp {
 393                 MeteringLineUp24,
 394                 MeteringLineUp20,
 395                 MeteringLineUp18,
 396                 MeteringLineUp15
 397         };
 398
 399         enum PFLPosition {
 400                 /** PFL signals come from before pre-fader processors */
 401                 PFLFromBeforeProcessors,
 402                 /** PFL signals come pre-fader but after pre-fader processors */
 403                 PFLFromAfterProcessors
 404         };
 405
 406         enum AFLPosition {
 407                 /** AFL signals come post-fader and before post-fader processors */
 408                 AFLFromBeforeProcessors,
 409                 /** AFL signals come post-fader but after post-fader processors */
 410                 AFLFromAfterProcessors
 411         };
 412
 413         enum DenormalModel {
 414                 DenormalNone,
 415                 DenormalFTZ,
 416                 DenormalDAZ,
 417                 DenormalFTZDAZ
 418         };
 419
 420         enum RemoteModel {
 421                 UserOrdered,
 422                 MixerOrdered,
 423                 EditorOrdered
 424         };
 425
 426         enum CrossfadeModel {
 427                 FullCrossfade,
 428                 ShortCrossfade
 429         };
 430
 431         enum CrossfadeChoice {
 432                 RegionFades,
 433                 ConstantPowerMinus3dB,
 434                 ConstantPowerMinus6dB,
 435         };
 436
 437         enum ListenPosition {
 438                 AfterFaderListen,
 439                 PreFaderListen
 440         };
 441
 442         enum AutoConnectOption {
 443                 ManualConnect = 0x0,
 444                 AutoConnectPhysical = 0x1,
 445                 AutoConnectMaster = 0x2
 446         };
 447
 448         enum SampleFormat {
 449                 FormatFloat = 0,
 450                 FormatInt24,
 451                 FormatInt16
 452         };
 453
 454         enum CDMarkerFormat {
 455                 CDMarkerNone,
 456                 CDMarkerCUE,
 457                 CDMarkerTOC
 458         };
 459
 460         enum HeaderFormat {
 461                 BWF,
 462                 WAVE,
 463                 WAVE64,
 464                 CAF,
 465                 AIFF,
 466                 iXML,
 467                 RF64
 468         };
 469
 470         struct PeakData {
 471                 typedef Sample PeakDatum;
 472
 473                 PeakDatum min;
 474                 PeakDatum max;
 475         };
 476
 477         enum PluginType {
 478                 AudioUnit,
 479                 LADSPA,
 480                 LV2,
 481                 Windows_VST,
 482                 LXVST,
 483         };
 484
 485         enum RunContext {
 486                 ButlerContext = 0,
 487                 TransportContext,
 488                 ExportContext
 489         };
 490
 491         enum SyncSource {
 492                 Engine = 0,
 493                 JACK = 0,
 494                 MTC,
 495                 MIDIClock,
 496                 LTC
 497         };
 498
 499         enum ShuttleBehaviour {
 500                 Sprung,
 501                 Wheel
 502         };
 503
 504         enum ShuttleUnits {
 505                 Percentage,
 506                 Semitones
 507         };
 508
 509         typedef std::vector<boost::shared_ptr<Source> > SourceList;
 510
 511         enum SrcQuality {
 512                 SrcBest,
 513                 SrcGood,
 514                 SrcQuick,
 515                 SrcFast,
 516                 SrcFastest
 517         };
 518
 519         typedef std::list<framepos_t> AnalysisFeatureList;
 520
 521         typedef std::list<boost::shared_ptr<Route> > RouteList;
 522         typedef std::list<boost::weak_ptr  <Route> > WeakRouteList;
 523
 524         class Bundle;
 525         typedef std::vector<boost::shared_ptr<Bundle> > BundleList;
 526
 527         enum WaveformScale {
 528                 Linear,
 529                 Logarithmic
 530         };
 531
 532         enum WaveformShape {
 533                 Traditional,
 534                 Rectified
 535         };
 536
 537         struct CleanupReport {
 538                 std::vector<std::string> paths;
 539                 size_t                   space;
 540         };
 541
 542         enum PositionLockStyle {
 543                 AudioTime,
 544                 MusicTime
 545         };
 546
 547         /** A struct used to describe changes to processors in a route.
 548          *  This is useful because objects that respond to a change in processors
 549          *  can optimise what work they do based on details of what has changed.
 550         */
 551         struct RouteProcessorChange {
 552                 enum Type {
 553                         GeneralChange = 0x0,
 554                         MeterPointChange = 0x1
 555                 };
 556
 557                 RouteProcessorChange () : type (GeneralChange), meter_visibly_changed (true)
 558                 {}
 559
 560                 RouteProcessorChange (Type t) : type (t), meter_visibly_changed (true)
 561                 {}
 562
 563                 RouteProcessorChange (Type t, bool m) : type (t), meter_visibly_changed (m)
 564                 {}
 565
 566                 /** type of change; "GeneralChange" means anything could have changed */
 567                 Type type;
 568                 /** true if, when a MeterPointChange has occurred, the change is visible to the user */
 569                 bool meter_visibly_changed;
 570         };
 571
 572         struct BusProfile {
 573                 AutoConnectOption input_ac;      /* override the RC config for input auto-connection */
 574                 AutoConnectOption output_ac;     /* override the RC config for output auto-connection */
 575                 uint32_t master_out_channels;    /* how many channels for the master bus */
 576                 uint32_t requested_physical_in;  /* now many of the available physical inputs to consider usable */
 577                 uint32_t requested_physical_out; /* now many of the available physical inputs to consider usable */
 578         };
 579
 580         enum FadeShape {
 581                 FadeLinear,
 582                 FadeFast,
 583                 FadeSlow,
 584                 FadeConstantPower,
 585                 FadeSymmetric,
 586         };
 587
 588         enum TransportState {
 589                 /* these values happen to match the constants used by JACK but
 590                    this equality cannot be assumed.
 591                 */
 592                 TransportStopped = 0,
 593                 TransportRolling = 1,
 594                 TransportLooping = 2,
 595                 TransportStarting = 3,
 596         };
 597
 598         enum PortFlags {
 599                 /* these values happen to match the constants used by JACK but
 600                    this equality cannot be assumed.
 601                 */
 602                 IsInput = 0x1,
 603                 IsOutput = 0x2,
 604                 IsPhysical = 0x4,
 605                 CanMonitor = 0x8,
 606                 IsTerminal = 0x10
 607         };
 608
 609         struct LatencyRange {
 610             uint32_t min; //< samples
 611             uint32_t max; //< samples
 612         };
 613
 614 /* PLATFORM SPECIFIC #ifdef's here */
 615
 616         /** Define the native thread type used on the platform */
 617         typedef pthread_t AudioBackendNativeThread;
 618         static inline bool self_thread_equal (AudioBackendNativeThread thr) {
 619                 return pthread_equal (thr, pthread_self());
 620         }
 621
 622 /* PLATFORM SPECIFIC #endif's here */
 623
 624 } // namespace ARDOUR
 625
 626
 627 /* these cover types declared above in this header. See enums.cc
 628    for the definitions.
 629 */
 630
 631 std::istream& operator>>(std::istream& o, ARDOUR::SampleFormat& sf);
 632 std::istream& operator>>(std::istream& o, ARDOUR::HeaderFormat& sf);
 633 std::istream& operator>>(std::istream& o, ARDOUR::AutoConnectOption& sf);
 634 std::istream& operator>>(std::istream& o, ARDOUR::EditMode& sf);
 635 std::istream& operator>>(std::istream& o, ARDOUR::MonitorModel& sf);
 636 std::istream& operator>>(std::istream& o, ARDOUR::VUMeterStandard& sf);
 637 std::istream& operator>>(std::istream& o, ARDOUR::MeterLineUp& sf);
 638 std::istream& operator>>(std::istream& o, ARDOUR::PFLPosition& sf);
 639 std::istream& operator>>(std::istream& o, ARDOUR::AFLPosition& sf);
 640 std::istream& operator>>(std::istream& o, ARDOUR::RemoteModel& sf);
 641 std::istream& operator>>(std::istream& o, ARDOUR::ListenPosition& sf);
 642 std::istream& operator>>(std::istream& o, ARDOUR::InsertMergePolicy& sf);
 643 std::istream& operator>>(std::istream& o, ARDOUR::CrossfadeModel& sf);
 644 std::istream& operator>>(std::istream& o, ARDOUR::CrossfadeChoice& sf);
 645 std::istream& operator>>(std::istream& o, ARDOUR::SyncSource& sf);
 646 std::istream& operator>>(std::istream& o, ARDOUR::ShuttleBehaviour& sf);
 647 std::istream& operator>>(std::istream& o, ARDOUR::ShuttleUnits& sf);
 648 std::istream& operator>>(std::istream& o, Timecode::TimecodeFormat& sf);
 649 std::istream& operator>>(std::istream& o, ARDOUR::DenormalModel& sf);
 650 std::istream& operator>>(std::istream& o, ARDOUR::WaveformScale& sf);
 651 std::istream& operator>>(std::istream& o, ARDOUR::WaveformShape& sf);
 652 std::istream& operator>>(std::istream& o, ARDOUR::PositionLockStyle& sf);
 653
 654 std::ostream& operator<<(std::ostream& o, const ARDOUR::SampleFormat& sf);
 655 std::ostream& operator<<(std::ostream& o, const ARDOUR::HeaderFormat& sf);
 656 std::ostream& operator<<(std::ostream& o, const ARDOUR::AutoConnectOption& sf);
 657 std::ostream& operator<<(std::ostream& o, const ARDOUR::EditMode& sf);
 658 std::ostream& operator<<(std::ostream& o, const ARDOUR::MonitorModel& sf);
 659 std::ostream& operator<<(std::ostream& o, const ARDOUR::VUMeterStandard& sf);
 660 std::ostream& operator<<(std::ostream& o, const ARDOUR::MeterLineUp& sf);
 661 std::ostream& operator<<(std::ostream& o, const ARDOUR::PFLPosition& sf);
 662 std::ostream& operator<<(std::ostream& o, const ARDOUR::AFLPosition& sf);
 663 std::ostream& operator<<(std::ostream& o, const ARDOUR::RemoteModel& sf);
 664 std::ostream& operator<<(std::ostream& o, const ARDOUR::ListenPosition& sf);
 665 std::ostream& operator<<(std::ostream& o, const ARDOUR::InsertMergePolicy& sf);
 666 std::ostream& operator<<(std::ostream& o, const ARDOUR::CrossfadeModel& sf);
 667 std::ostream& operator<<(std::ostream& o, const ARDOUR::CrossfadeChoice& sf);
 668 std::ostream& operator<<(std::ostream& o, const ARDOUR::SyncSource& sf);
 669 std::ostream& operator<<(std::ostream& o, const ARDOUR::ShuttleBehaviour& sf);
 670 std::ostream& operator<<(std::ostream& o, const ARDOUR::ShuttleUnits& sf);
 671 std::ostream& operator<<(std::ostream& o, const Timecode::TimecodeFormat& sf);
 672 std::ostream& operator<<(std::ostream& o, const ARDOUR::DenormalModel& sf);
 673 std::ostream& operator<<(std::ostream& o, const ARDOUR::WaveformScale& sf);
 674 std::ostream& operator<<(std::ostream& o, const ARDOUR::WaveformShape& sf);
 675 std::ostream& operator<<(std::ostream& o, const ARDOUR::PositionLockStyle& sf);
 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