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