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 <set>
  27 #include <boost/shared_ptr.hpp>
  28 #include <sys/types.h>
  29 #include <stdint.h>
  30 #include <pthread.h>
  31
  32 #include <inttypes.h>
  33
  34 #include "temporal/bbt_time.h"
  35 #include "temporal/time.h"
  36 #include "temporal/types.h"
  37
  38 #include "pbd/id.h"
  39
  40 #include "evoral/Range.hpp"
  41
  42 #include "ardour/chan_count.h"
  43 #include "ardour/plugin_types.h"
  44
  45 #include <map>
  46
  47 using Temporal::max_samplepos;
  48 using Temporal::max_samplecnt;
  49
  50 #if __GNUC__ < 3
  51 typedef int intptr_t;
  52 #endif
  53
  54 namespace ARDOUR {
  55
  56 class Source;
  57 class AudioSource;
  58 class Route;
  59 class Region;
  60 class Stripable;
  61 class VCA;
  62 class AutomationControl;
  63 class SlavableAutomationControl;
  64
  65 typedef float    Sample;
  66 typedef float    pan_t;
  67 typedef float    gain_t;
  68 typedef uint32_t layer_t;
  69 typedef uint64_t microseconds_t;
  70 typedef uint32_t pframes_t;
  71
  72 /* rebind Temporal position types into ARDOUR namespace */
  73 typedef Temporal::samplecnt_t samplecnt_t;
  74 typedef Temporal::samplepos_t samplepos_t;
  75 typedef Temporal::sampleoffset_t sampleoffset_t;
  76
  77 static const layer_t    max_layer    = UINT32_MAX;
  78
  79 // a set of (time) intervals: first of pair is the offset of the start within the region, second is the offset of the end
  80 typedef std::list<std::pair<sampleoffset_t, sampleoffset_t> > AudioIntervalResult;
  81 // associate a set of intervals with regions (e.g. for silence detection)
  82 typedef std::map<boost::shared_ptr<ARDOUR::Region>,AudioIntervalResult> AudioIntervalMap;
  83
  84 typedef std::list<boost::shared_ptr<Region> > RegionList;
  85
  86 struct IOChange {
  87
  88         enum Type {
  89                 NoChange = 0,
  90                 ConfigurationChanged = 0x1,
  91                 ConnectionsChanged = 0x2
  92         } type;
  93
  94         IOChange () : type (NoChange) {}
  95         IOChange (Type t) : type (t) {}
  96
  97         /** channel count of IO before a ConfigurationChanged, if appropriate */
  98         ARDOUR::ChanCount before;
  99         /** channel count of IO after a ConfigurationChanged, if appropriate */
 100         ARDOUR::ChanCount after;
 101 };
 102
 103 /* policies for inserting/pasting material where overlaps
 104    might be an issue.
 105 */
 106
 107 enum InsertMergePolicy {
 108         InsertMergeReject,  ///< no overlaps allowed
 109         InsertMergeRelax,   ///< we just don't care about overlaps
 110         InsertMergeReplace, ///< replace old with new
 111         InsertMergeTruncateExisting, ///< shorten existing to avoid overlap
 112         InsertMergeTruncateAddition, ///< shorten new to avoid overlap
 113         InsertMergeExtend   ///< extend new (or old) to the range of old+new
 114 };
 115
 116 /** See evoral/Parameter.hpp
 117  *
 118  * When you add things here, you REALLY SHOULD add a case clause to
 119  * the constructor of ParameterDescriptor, unless the Controllables
 120  * that the enum refers to are completely standard (0-1.0 range, 0.0 as
 121  * normal, non-toggled, non-enumerated). Anything else needs to be
 122  * added there so that things that try to represent them can do so
 123  * with as much information as possible.
 124  */
 125 enum AutomationType {
 126         NullAutomation,
 127         GainAutomation,
 128         PanAzimuthAutomation,
 129         PanElevationAutomation,
 130         PanWidthAutomation,
 131         PanFrontBackAutomation,
 132         PanLFEAutomation,
 133         PluginAutomation,
 134         PluginPropertyAutomation,
 135         SoloAutomation,
 136         SoloIsolateAutomation,
 137         SoloSafeAutomation,
 138         MuteAutomation,
 139         MidiCCAutomation,
 140         MidiPgmChangeAutomation,
 141         MidiPitchBenderAutomation,
 142         MidiChannelPressureAutomation,
 143         MidiNotePressureAutomation,
 144         MidiSystemExclusiveAutomation,
 145         FadeInAutomation,
 146         FadeOutAutomation,
 147         EnvelopeAutomation,
 148         RecEnableAutomation,
 149         RecSafeAutomation,
 150         TrimAutomation,
 151         PhaseAutomation,
 152         MonitoringAutomation,
 153         BusSendLevel,
 154         BusSendEnable,
 155
 156         /* used only by Controllable Descriptor to access send parameters */
 157
 158         SendLevelAutomation,
 159         SendEnableAutomation,
 160         SendAzimuthAutomation,
 161 };
 162
 163 enum AutoState {
 164         Off   = 0x00,
 165         Write = 0x01,
 166         Touch = 0x02,
 167         Play  = 0x04,
 168         Latch = 0x08
 169 };
 170
 171 std::string auto_state_to_string (AutoState);
 172 AutoState string_to_auto_state (std::string);
 173
 174 enum AlignStyle {
 175         CaptureTime,
 176         ExistingMaterial
 177 };
 178
 179 enum AlignChoice {
 180         UseCaptureTime,
 181         UseExistingMaterial,
 182         Automatic
 183 };
 184
 185 enum MeterPoint {
 186         MeterInput,
 187         MeterPreFader,
 188         MeterPostFader,
 189         MeterOutput,
 190         MeterCustom
 191 };
 192
 193 enum DiskIOPoint {
 194         DiskIOPreFader,  /* after the trim control, but before other processors */
 195         DiskIOPostFader, /* before the main outs, after other processors */
 196         DiskIOCustom,   /* up to the user. Caveat Emptor! */
 197 };
 198
 199 enum MeterType {
 200         MeterMaxSignal = 0x0001,
 201         MeterMaxPeak   = 0x0002,
 202         MeterPeak      = 0x0004,
 203         MeterKrms      = 0x0008,
 204         MeterK20       = 0x0010,
 205         MeterK14       = 0x0020,
 206         MeterIEC1DIN   = 0x0040,
 207         MeterIEC1NOR   = 0x0080,
 208         MeterIEC2BBC   = 0x0100,
 209         MeterIEC2EBU   = 0x0200,
 210         MeterVU        = 0x0400,
 211         MeterK12       = 0x0800,
 212         MeterPeak0dB   = 0x1000,
 213         MeterMCP       = 0x2000
 214 };
 215
 216 enum TrackMode {
 217         Normal,
 218         NonLayered,
 219         Destructive
 220 };
 221
 222 enum NoteMode {
 223         Sustained,
 224         Percussive
 225 };
 226
 227 enum ChannelMode {
 228         AllChannels = 0, ///< Pass through all channel information unmodified
 229         FilterChannels,  ///< Ignore events on certain channels
 230         ForceChannel     ///< Force all events to a certain channel
 231 };
 232
 233 enum ColorMode {
 234         MeterColors = 0,
 235         ChannelColors,
 236         TrackColor
 237 };
 238
 239 enum RoundMode {
 240         RoundDownMaybe  = -2,  ///< Round down only if necessary
 241         RoundDownAlways = -1,  ///< Always round down, even if on a division
 242         RoundNearest    = 0,   ///< Round to nearest
 243         RoundUpAlways   = 1,   ///< Always round up, even if on a division
 244         RoundUpMaybe    = 2    ///< Round up only if necessary
 245 };
 246
 247 enum SnapPref {
 248         SnapToAny_Visual    = 0, /**< Snap to the editor's visual snap
 249                                   * (incoprorating snap prefs and the current zoom scaling)
 250                                   * this defines the behavior for visual mouse drags, for example */
 251
 252         SnapToGrid_Scaled   = 1, /**< Snap to the selected grid quantization with visual scaling.
 253                                   * Ignores other snap preferences (markers, regions, etc)
 254                                   * this defines the behavior for nudging the playhead to next/prev grid, for example */
 255
 256         SnapToGrid_Unscaled = 2, /**< Snap to the selected grid quantization.
 257                                   * If one is selected, and ignore any visual scaling
 258                                   * this is the behavior for automated processes like "snap regions to grid"
 259                                   * but note that midi quantization uses its own mechanism, not the grid */
 260 };
 261
 262 class AnyTime {
 263                                         public:
 264         enum Type {
 265                 Timecode,
 266                 BBT,
 267                 Samples,
 268                 Seconds
 269         };
 270
 271         Type type;
 272
 273         Timecode::Time     timecode;
 274         Timecode::BBT_Time bbt;
 275
 276         union {
 277                 samplecnt_t     samples;
 278                 double         seconds;
 279         };
 280
 281         AnyTime() { type = Samples; samples = 0; }
 282
 283         bool operator== (AnyTime const & other) const {
 284                 if (type != other.type) { return false; }
 285
 286                 switch (type) {
 287                 case Timecode:
 288                         return timecode == other.timecode;
 289                 case BBT:
 290                         return bbt == other.bbt;
 291                 case Samples:
 292                         return samples == other.samples;
 293                 case Seconds:
 294                         return seconds == other.seconds;
 295                 }
 296                 return false; // get rid of warning
 297         }
 298
 299         bool not_zero() const
 300         {
 301                 switch (type) {
 302                 case Timecode:
 303                         return timecode.hours != 0 || timecode.minutes != 0 ||
 304                                 timecode.seconds != 0 || timecode.frames != 0;
 305                 case BBT:
 306                         return bbt.bars != 0 || bbt.beats != 0 || bbt.ticks != 0;
 307                 case Samples:
 308                         return samples != 0;
 309                 case Seconds:
 310                         return seconds != 0;
 311                 }
 312
 313                 abort(); /* NOTREACHED */
 314                 return false;
 315         }
 316 };
 317
 318 /* used for translating audio samples to an exact musical position using a note divisor.
 319    an exact musical position almost never falls exactly on an audio sample, but for sub-sample
 320    musical accuracy we need to derive exact musical locations from a sample position
 321    the division follows TempoMap::exact_beat_at_sample().
 322    division
 323    -1       musical location is the bar closest to sample
 324    0       musical location is the musical position of the sample
 325    1       musical location is the BBT beat closest to sample
 326    n       musical location is the quarter-note division n closest to sample
 327 */
 328 struct MusicSample {
 329         samplepos_t sample;
 330         int32_t    division;
 331
 332         MusicSample (samplepos_t f, int32_t d) : sample (f), division (d) {}
 333
 334         void set (samplepos_t f, int32_t d) {sample = f; division = d; }
 335
 336         MusicSample operator- (MusicSample other) { return MusicSample (sample - other.sample, 0); }
 337 };
 338
 339 /* XXX: slightly unfortunate that there is this and Evoral::Range<>,
 340    but this has a uint32_t id which Evoral::Range<> does not.
 341 */
 342 struct AudioRange {
 343         samplepos_t start;
 344         samplepos_t end;
 345         uint32_t id;
 346
 347         AudioRange (samplepos_t s, samplepos_t e, uint32_t i) : start (s), end (e) , id (i) {}
 348
 349         samplecnt_t length() const { return end - start + 1; }
 350
 351         bool operator== (const AudioRange& other) const {
 352                 return start == other.start && end == other.end && id == other.id;
 353         }
 354
 355         bool equal (const AudioRange& other) const {
 356                 return start == other.start && end == other.end;
 357         }
 358
 359         Evoral::OverlapType coverage (samplepos_t s, samplepos_t e) const {
 360                 return Evoral::coverage (start, end, s, e);
 361         }
 362 };
 363
 364 struct MusicRange {
 365         Timecode::BBT_Time start;
 366         Timecode::BBT_Time end;
 367         uint32_t id;
 368
 369         MusicRange (Timecode::BBT_Time& s, Timecode::BBT_Time& e, uint32_t i)
 370                 : start (s), end (e), id (i) {}
 371
 372         bool operator== (const MusicRange& other) const {
 373                 return start == other.start && end == other.end && id == other.id;
 374         }
 375
 376         bool equal (const MusicRange& other) const {
 377                 return start == other.start && end == other.end;
 378         }
 379 };
 380
 381 /*
 382   Slowest = 6.6dB/sec falloff at update rate of 40ms
 383   Slow    = 6.8dB/sec falloff at update rate of 40ms
 384 */
 385
 386 enum MeterFalloff {
 387         MeterFalloffOff = 0,
 388         MeterFalloffSlowest = 1,
 389         MeterFalloffSlow = 2,
 390         MeterFalloffSlowish = 3,
 391         MeterFalloffModerate = 4,
 392         MeterFalloffMedium = 5,
 393         MeterFalloffFast = 6,
 394         MeterFalloffFaster = 7,
 395         MeterFalloffFastest = 8,
 396 };
 397
 398 enum MeterHold {
 399         MeterHoldOff = 0,
 400         MeterHoldShort = 40,
 401         MeterHoldMedium = 100,
 402         MeterHoldLong = 200
 403 };
 404
 405 enum EditMode {
 406         Slide,
 407         Splice,
 408         Ripple,
 409         Lock
 410 };
 411
 412 enum RegionSelectionAfterSplit {
 413         None = 0,
 414         NewlyCreatedLeft = 1,  // bit 0
 415         NewlyCreatedRight = 2, // bit 1
 416         NewlyCreatedBoth = 3,
 417         Existing = 4,          // bit 2
 418         ExistingNewlyCreatedLeft = 5,
 419         ExistingNewlyCreatedRight = 6,
 420         ExistingNewlyCreatedBoth = 7
 421 };
 422
 423 enum RegionPoint {
 424         Start,
 425         End,
 426         SyncPoint
 427 };
 428
 429 enum Placement {
 430         PreFader,
 431         PostFader
 432 };
 433
 434 enum MonitorModel {
 435         HardwareMonitoring, ///< JACK does monitoring
 436         SoftwareMonitoring, ///< Ardour does monitoring
 437         ExternalMonitoring  ///< we leave monitoring to the audio hardware
 438 };
 439
 440 enum MonitorChoice {
 441         MonitorAuto = 0,
 442         MonitorInput = 0x1,
 443         MonitorDisk = 0x2,
 444         MonitorCue = 0x3,
 445 };
 446
 447 enum MonitorState {
 448         MonitoringSilence = 0x1,
 449         MonitoringInput = 0x2,
 450         MonitoringDisk = 0x4,
 451         MonitoringCue = 0x6,
 452 };
 453
 454 enum MeterState {
 455         MeteringInput, ///< meter the input IO, regardless of what is going through the route
 456         MeteringRoute  ///< meter what is going through the route
 457 };
 458
 459 enum VUMeterStandard {
 460         MeteringVUfrench,   // 0VU = -2dBu
 461         MeteringVUamerican, // 0VU =  0dBu
 462         MeteringVUstandard, // 0VU = +4dBu
 463         MeteringVUeight     // 0VU = +8dBu
 464 };
 465
 466 enum MeterLineUp {
 467         MeteringLineUp24,
 468         MeteringLineUp20,
 469         MeteringLineUp18,
 470         MeteringLineUp15
 471 };
 472
 473 enum PFLPosition {
 474         /** PFL signals come from before pre-fader processors */
 475         PFLFromBeforeProcessors,
 476         /** PFL signals come pre-fader but after pre-fader processors */
 477         PFLFromAfterProcessors
 478 };
 479
 480 enum AFLPosition {
 481         /** AFL signals come post-fader and before post-fader processors */
 482         AFLFromBeforeProcessors,
 483         /** AFL signals come post-fader but after post-fader processors */
 484         AFLFromAfterProcessors
 485 };
 486
 487 enum ClockDeltaMode {
 488         NoDelta,
 489         DeltaEditPoint,
 490         DeltaOriginMarker
 491 };
 492
 493 enum DenormalModel {
 494         DenormalNone,
 495         DenormalFTZ,
 496         DenormalDAZ,
 497         DenormalFTZDAZ
 498 };
 499
 500 enum LayerModel {
 501         LaterHigher,
 502         Manual
 503 };
 504
 505 enum ListenPosition {
 506         AfterFaderListen,
 507         PreFaderListen
 508 };
 509
 510 enum AutoConnectOption {
 511         ManualConnect = 0x0,
 512         AutoConnectPhysical = 0x1,
 513         AutoConnectMaster = 0x2
 514 };
 515
 516 enum TracksAutoNamingRule {
 517         UseDefaultNames = 0x1,
 518         NameAfterDriver = 0x2
 519 };
 520
 521 enum SampleFormat {
 522         FormatFloat = 0,
 523         FormatInt24,
 524         FormatInt16
 525 };
 526
 527 int format_data_width (ARDOUR::SampleFormat);
 528
 529 enum CDMarkerFormat {
 530         CDMarkerNone,
 531         CDMarkerCUE,
 532         CDMarkerTOC,
 533         MP4Chaps
 534 };
 535
 536 enum HeaderFormat {
 537         BWF,
 538         WAVE,
 539         WAVE64,
 540         CAF,
 541         AIFF,
 542         iXML,
 543         RF64,
 544         RF64_WAV,
 545         MBWF,
 546         FLAC,
 547 };
 548
 549 struct PeakData {
 550         typedef Sample PeakDatum;
 551
 552         PeakDatum min;
 553         PeakDatum max;
 554 };
 555
 556 enum RunContext {
 557         ButlerContext = 0,
 558         TransportContext,
 559         ExportContext
 560 };
 561
 562 enum SyncSource {
 563         /* The first two are "synonyms". It is important for JACK to be first
 564            both here and in enums.cc, so that the string "JACK" is
 565            correctly recognized in older session and preference files.
 566         */
 567         JACK = 0,
 568         Engine = 0,
 569         MTC,
 570         MIDIClock,
 571         LTC,
 572 };
 573
 574 enum TransportRequestSource {
 575         TRS_Engine,
 576         TRS_MTC,
 577         TRS_MIDIClock,
 578         TRS_LTC,
 579         TRS_MMC,
 580         TRS_UI,
 581 };
 582
 583 enum TransportRequestType {
 584         TR_Stop   = 0x1,
 585         TR_Start  = 0x2,
 586         TR_Speed  = 0x4,
 587         TR_Locate = 0x8
 588 };
 589
 590 enum ShuttleBehaviour {
 591         Sprung,
 592         Wheel
 593 };
 594
 595 enum ShuttleUnits {
 596         Percentage,
 597         Semitones
 598 };
 599
 600 typedef std::vector<boost::shared_ptr<Source> > SourceList;
 601
 602 enum SrcQuality {
 603         SrcBest,
 604         SrcGood,
 605         SrcQuick,
 606         SrcFast,
 607         SrcFastest
 608 };
 609
 610 typedef std::list<samplepos_t> AnalysisFeatureList;
 611
 612 typedef std::list<boost::shared_ptr<Route> > RouteList;
 613 typedef std::list<boost::shared_ptr<Stripable> > StripableList;
 614 typedef std::list<boost::weak_ptr  <Route> > WeakRouteList;
 615 typedef std::list<boost::weak_ptr  <Stripable> > WeakStripableList;
 616 typedef std::list<boost::shared_ptr<AutomationControl> > ControlList;
 617 typedef std::list<boost::shared_ptr<SlavableAutomationControl> > SlavableControlList;
 618 typedef std::set <boost::shared_ptr<AutomationControl> > AutomationControlSet;
 619
 620 typedef std::list<boost::shared_ptr<VCA> > VCAList;
 621
 622 class Bundle;
 623 typedef std::vector<boost::shared_ptr<Bundle> > BundleList;
 624
 625 enum RegionEquivalence {
 626         Exact,
 627         Enclosed,
 628         Overlap
 629 };
 630
 631 enum WaveformScale {
 632         Linear,
 633         Logarithmic
 634 };
 635
 636 enum WaveformShape {
 637         Traditional,
 638         Rectified
 639 };
 640
 641 struct CleanupReport {
 642         std::vector<std::string> paths;
 643         size_t                   space;
 644 };
 645
 646 enum PositionLockStyle {
 647         AudioTime,
 648         MusicTime
 649 };
 650
 651 /** A struct used to describe changes to processors in a route.
 652  *  This is useful because objects that respond to a change in processors
 653  *  can optimise what work they do based on details of what has changed.
 654  */
 655 struct RouteProcessorChange {
 656         enum Type {
 657                 GeneralChange = 0x0,
 658                 MeterPointChange = 0x1,
 659                 RealTimeChange = 0x2
 660         };
 661
 662         RouteProcessorChange () : type (GeneralChange), meter_visibly_changed (true)
 663         {}
 664
 665         RouteProcessorChange (Type t) : type (t), meter_visibly_changed (true)
 666         {}
 667
 668         RouteProcessorChange (Type t, bool m) : type (t), meter_visibly_changed (m)
 669         {}
 670
 671         /** type of change; "GeneralChange" means anything could have changed */
 672         Type type;
 673         /** true if, when a MeterPointChange has occurred, the change is visible to the user */
 674         bool meter_visibly_changed;
 675 };
 676
 677 struct BusProfile {
 678         uint32_t master_out_channels; /* how many channels for the master bus, 0: no master bus */
 679 };
 680
 681 enum FadeShape {
 682         FadeLinear,
 683         FadeFast,
 684         FadeSlow,
 685         FadeConstantPower,
 686         FadeSymmetric,
 687 };
 688
 689 enum TransportState {
 690         /* these values happen to match the constants used by JACK but
 691            this equality cannot be assumed.
 692         */
 693         TransportStopped = 0,
 694         TransportRolling = 1,
 695         TransportLooping = 2,
 696         TransportStarting = 3,
 697 };
 698
 699 enum PortFlags {
 700         /* these values happen to match the constants used by JACK but
 701            this equality cannot be assumed.
 702         */
 703         IsInput = 0x1,
 704         IsOutput = 0x2,
 705         IsPhysical = 0x4,
 706         CanMonitor = 0x8,
 707         IsTerminal = 0x10,
 708
 709         /* non-JACK related flags */
 710         Hidden = 0x20,
 711         Shadow = 0x40
 712 };
 713
 714 enum MidiPortFlags {
 715         MidiPortMusic = 0x1,
 716         MidiPortControl = 0x2,
 717         MidiPortSelection = 0x4,
 718         MidiPortVirtual = 0x8
 719 };
 720
 721 struct LatencyRange {
 722         uint32_t min; //< samples
 723         uint32_t max; //< samples
 724 };
 725
 726 enum BufferingPreset {
 727         Small,
 728         Medium,
 729         Large,
 730         Custom,
 731 };
 732
 733 enum AutoReturnTarget {
 734         LastLocate = 0x1,
 735         RangeSelectionStart = 0x2,
 736         Loop = 0x4,
 737         RegionSelectionStart = 0x8,
 738 };
 739
 740 enum PlaylistDisposition {
 741         CopyPlaylist,
 742         NewPlaylist,
 743         SharePlaylist
 744 };
 745
 746 enum MidiTrackNameSource {
 747         SMFTrackNumber,
 748         SMFTrackName,
 749         SMFInstrumentName
 750 };
 751
 752 enum MidiTempoMapDisposition {
 753         SMFTempoIgnore,
 754         SMFTempoUse,
 755 };
 756
 757 struct CaptureInfo {
 758         samplepos_t start;
 759         samplecnt_t samples;
 760 };
 761
 762 typedef std::vector<CaptureInfo*> CaptureInfos;
 763
 764 } // namespace ARDOUR
 765
 766 /* for now, break the rules and use "using" to make this "global" */
 767
 768 using ARDOUR::samplepos_t;
 769
 770 #endif /* __ardour_types_h__ */