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    = 0,   ///< Snaps to the closest of ( snap prefs, grid quantization )
 249                 SnapToGrid   = 1,   ///< Prefer snapping to the closest grid quantization, if a Grid selection is enabled
 250         };
 251
 252         class AnyTime {
 253         public:
 254                 enum Type {
 255                         Timecode,
 256                         BBT,
 257                         Samples,
 258                         Seconds
 259                 };
 260
 261                 Type type;
 262
 263                 Timecode::Time     timecode;
 264                 Timecode::BBT_Time bbt;
 265
 266                 union {
 267                         samplecnt_t     samples;
 268                         double         seconds;
 269                 };
 270
 271                 AnyTime() { type = Samples; samples = 0; }
 272
 273                 bool operator== (AnyTime const & other) const {
 274                         if (type != other.type) { return false; }
 275
 276                         switch (type) {
 277                           case Timecode:
 278                                 return timecode == other.timecode;
 279                           case BBT:
 280                                 return bbt == other.bbt;
 281                           case Samples:
 282                                 return samples == other.samples;
 283                           case Seconds:
 284                                 return seconds == other.seconds;
 285                         }
 286                         return false; // get rid of warning
 287                 }
 288
 289                 bool not_zero() const
 290                 {
 291                         switch (type) {
 292                           case Timecode:
 293                                 return timecode.hours != 0 || timecode.minutes != 0 ||
 294                                        timecode.seconds != 0 || timecode.frames != 0;
 295                           case BBT:
 296                                 return bbt.bars != 0 || bbt.beats != 0 || bbt.ticks != 0;
 297                           case Samples:
 298                                 return samples != 0;
 299                           case Seconds:
 300                                 return seconds != 0;
 301                         }
 302
 303                         abort(); /* NOTREACHED */
 304                         return false;
 305                 }
 306         };
 307
 308         /* used for translating audio samples to an exact musical position using a note divisor.
 309            an exact musical position almost never falls exactly on an audio sample, but for sub-sample
 310            musical accuracy we need to derive exact musical locations from a sample position
 311            the division follows TempoMap::exact_beat_at_sample().
 312            division
 313            -1       musical location is the bar closest to sample
 314             0       musical location is the musical position of the sample
 315             1       musical location is the BBT beat closest to sample
 316             n       musical location is the quarter-note division n closest to sample
 317         */
 318         struct MusicSample {
 319                 samplepos_t sample;
 320                 int32_t    division;
 321
 322                 MusicSample (samplepos_t f, int32_t d) : sample (f), division (d) {}
 323
 324                 void set (samplepos_t f, int32_t d) {sample = f; division = d; }
 325
 326                 MusicSample operator- (MusicSample other) { return MusicSample (sample - other.sample, 0); }
 327         };
 328
 329         /* XXX: slightly unfortunate that there is this and Evoral::Range<>,
 330            but this has a uint32_t id which Evoral::Range<> does not.
 331         */
 332         struct AudioRange {
 333                 samplepos_t start;
 334                 samplepos_t end;
 335                 uint32_t id;
 336
 337                 AudioRange (samplepos_t s, samplepos_t e, uint32_t i) : start (s), end (e) , id (i) {}
 338
 339                 samplecnt_t length() const { return end - start + 1; }
 340
 341                 bool operator== (const AudioRange& other) const {
 342                         return start == other.start && end == other.end && id == other.id;
 343                 }
 344
 345                 bool equal (const AudioRange& other) const {
 346                         return start == other.start && end == other.end;
 347                 }
 348
 349                 Evoral::OverlapType coverage (samplepos_t s, samplepos_t e) const {
 350                         return Evoral::coverage (start, end, s, e);
 351                 }
 352         };
 353
 354         struct MusicRange {
 355                 Timecode::BBT_Time start;
 356                 Timecode::BBT_Time end;
 357                 uint32_t id;
 358
 359                 MusicRange (Timecode::BBT_Time& s, Timecode::BBT_Time& e, uint32_t i)
 360                         : start (s), end (e), id (i) {}
 361
 362                 bool operator== (const MusicRange& other) const {
 363                         return start == other.start && end == other.end && id == other.id;
 364                 }
 365
 366                 bool equal (const MusicRange& other) const {
 367                         return start == other.start && end == other.end;
 368                 }
 369         };
 370
 371         /*
 372             Slowest = 6.6dB/sec falloff at update rate of 40ms
 373             Slow    = 6.8dB/sec falloff at update rate of 40ms
 374         */
 375
 376         enum MeterFalloff {
 377                 MeterFalloffOff = 0,
 378                 MeterFalloffSlowest = 1,
 379                 MeterFalloffSlow = 2,
 380                 MeterFalloffSlowish = 3,
 381                 MeterFalloffModerate = 4,
 382                 MeterFalloffMedium = 5,
 383                 MeterFalloffFast = 6,
 384                 MeterFalloffFaster = 7,
 385                 MeterFalloffFastest = 8,
 386         };
 387
 388         enum MeterHold {
 389                 MeterHoldOff = 0,
 390                 MeterHoldShort = 40,
 391                 MeterHoldMedium = 100,
 392                 MeterHoldLong = 200
 393         };
 394
 395         enum EditMode {
 396                 Slide,
 397                 Splice,
 398                 Ripple,
 399                 Lock
 400         };
 401
 402         enum RegionSelectionAfterSplit {
 403                 None = 0,
 404                 NewlyCreatedLeft = 1,  // bit 0
 405                 NewlyCreatedRight = 2, // bit 1
 406                 NewlyCreatedBoth = 3,
 407                 Existing = 4,          // bit 2
 408                 ExistingNewlyCreatedLeft = 5,
 409                 ExistingNewlyCreatedRight = 6,
 410                 ExistingNewlyCreatedBoth = 7
 411         };
 412
 413         enum RegionPoint {
 414                 Start,
 415                 End,
 416                 SyncPoint
 417         };
 418
 419         enum Placement {
 420                 PreFader,
 421                 PostFader
 422         };
 423
 424         enum MonitorModel {
 425                 HardwareMonitoring, ///< JACK does monitoring
 426                 SoftwareMonitoring, ///< Ardour does monitoring
 427                 ExternalMonitoring  ///< we leave monitoring to the audio hardware
 428         };
 429
 430         enum MonitorChoice {
 431                 MonitorAuto = 0,
 432                 MonitorInput = 0x1,
 433                 MonitorDisk = 0x2,
 434                 MonitorCue = 0x4,
 435         };
 436
 437         enum MonitorState {
 438                 MonitoringSilence = 0x1,
 439                 MonitoringInput = 0x2,
 440                 MonitoringDisk = 0x4,
 441                 MonitoringCue = 0x6,
 442         };
 443
 444         enum MeterState {
 445                 MeteringInput, ///< meter the input IO, regardless of what is going through the route
 446                 MeteringRoute  ///< meter what is going through the route
 447         };
 448
 449         enum VUMeterStandard {
 450                 MeteringVUfrench,   // 0VU = -2dBu
 451                 MeteringVUamerican, // 0VU =  0dBu
 452                 MeteringVUstandard, // 0VU = +4dBu
 453                 MeteringVUeight     // 0VU = +8dBu
 454         };
 455
 456         enum MeterLineUp {
 457                 MeteringLineUp24,
 458                 MeteringLineUp20,
 459                 MeteringLineUp18,
 460                 MeteringLineUp15
 461         };
 462
 463         enum PFLPosition {
 464                 /** PFL signals come from before pre-fader processors */
 465                 PFLFromBeforeProcessors,
 466                 /** PFL signals come pre-fader but after pre-fader processors */
 467                 PFLFromAfterProcessors
 468         };
 469
 470         enum AFLPosition {
 471                 /** AFL signals come post-fader and before post-fader processors */
 472                 AFLFromBeforeProcessors,
 473                 /** AFL signals come post-fader but after post-fader processors */
 474                 AFLFromAfterProcessors
 475         };
 476
 477         enum ClockDeltaMode {
 478                 NoDelta,
 479                 DeltaEditPoint,
 480                 DeltaOriginMarker
 481         };
 482
 483         enum DenormalModel {
 484                 DenormalNone,
 485                 DenormalFTZ,
 486                 DenormalDAZ,
 487                 DenormalFTZDAZ
 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<samplepos_t> AnalysisFeatureList;
 584
 585         typedef std::list<boost::shared_ptr<Route> > RouteList;
 586         typedef std::list<boost::shared_ptr<Stripable> > StripableList;
 587         typedef std::list<boost::weak_ptr  <Route> > WeakRouteList;
 588         typedef std::list<boost::weak_ptr  <Stripable> > WeakStripableList;
 589         typedef std::list<boost::shared_ptr<AutomationControl> > ControlList;
 590         typedef std::list<boost::shared_ptr<SlavableAutomationControl> > SlavableControlList;
 591         typedef std::set <boost::shared_ptr<AutomationControl> > AutomationControlSet;
 592
 593         typedef std::list<boost::shared_ptr<VCA> > VCAList;
 594
 595         class Bundle;
 596         typedef std::vector<boost::shared_ptr<Bundle> > BundleList;
 597
 598         enum WaveformScale {
 599                 Linear,
 600                 Logarithmic
 601         };
 602
 603         enum WaveformShape {
 604                 Traditional,
 605                 Rectified
 606         };
 607
 608         struct CleanupReport {
 609                 std::vector<std::string> paths;
 610                 size_t                   space;
 611         };
 612
 613         enum PositionLockStyle {
 614                 AudioTime,
 615                 MusicTime
 616         };
 617
 618         /** A struct used to describe changes to processors in a route.
 619          *  This is useful because objects that respond to a change in processors
 620          *  can optimise what work they do based on details of what has changed.
 621         */
 622         struct RouteProcessorChange {
 623                 enum Type {
 624                         GeneralChange = 0x0,
 625                         MeterPointChange = 0x1,
 626                         RealTimeChange = 0x2
 627                 };
 628
 629                 RouteProcessorChange () : type (GeneralChange), meter_visibly_changed (true)
 630                 {}
 631
 632                 RouteProcessorChange (Type t) : type (t), meter_visibly_changed (true)
 633                 {}
 634
 635                 RouteProcessorChange (Type t, bool m) : type (t), meter_visibly_changed (m)
 636                 {}
 637
 638                 /** type of change; "GeneralChange" means anything could have changed */
 639                 Type type;
 640                 /** true if, when a MeterPointChange has occurred, the change is visible to the user */
 641                 bool meter_visibly_changed;
 642         };
 643
 644         struct BusProfile {
 645                 uint32_t master_out_channels; /* how many channels for the master bus, 0: no master bus */
 646         };
 647
 648         enum FadeShape {
 649                 FadeLinear,
 650                 FadeFast,
 651                 FadeSlow,
 652                 FadeConstantPower,
 653                 FadeSymmetric,
 654         };
 655
 656         enum TransportState {
 657                 /* these values happen to match the constants used by JACK but
 658                    this equality cannot be assumed.
 659                 */
 660                 TransportStopped = 0,
 661                 TransportRolling = 1,
 662                 TransportLooping = 2,
 663                 TransportStarting = 3,
 664         };
 665
 666         enum PortFlags {
 667                 /* these values happen to match the constants used by JACK but
 668                    this equality cannot be assumed.
 669                 */
 670                 IsInput = 0x1,
 671                 IsOutput = 0x2,
 672                 IsPhysical = 0x4,
 673                 CanMonitor = 0x8,
 674                 IsTerminal = 0x10,
 675
 676                 /* non-JACK related flags */
 677                 Hidden = 0x20,
 678                 Shadow = 0x40
 679         };
 680
 681         enum MidiPortFlags {
 682                 MidiPortMusic = 0x1,
 683                 MidiPortControl = 0x2,
 684                 MidiPortSelection = 0x4,
 685                 MidiPortVirtual = 0x8
 686         };
 687
 688         struct LatencyRange {
 689             uint32_t min; //< samples
 690             uint32_t max; //< samples
 691         };
 692
 693         enum BufferingPreset {
 694                 Small,
 695                 Medium,
 696                 Large,
 697                 Custom,
 698         };
 699
 700         enum AutoReturnTarget {
 701                 LastLocate = 0x1,
 702                 RangeSelectionStart = 0x2,
 703                 Loop = 0x4,
 704                 RegionSelectionStart = 0x8,
 705         };
 706
 707         enum PlaylistDisposition {
 708                 CopyPlaylist,
 709                 NewPlaylist,
 710                 SharePlaylist
 711         };
 712
 713         enum MidiTrackNameSource {
 714                 SMFTrackNumber,
 715                 SMFTrackName,
 716                 SMFInstrumentName
 717         };
 718
 719         enum MidiTempoMapDisposition {
 720                 SMFTempoIgnore,
 721                 SMFTempoUse,
 722         };
 723
 724         struct CaptureInfo {
 725                 samplepos_t start;
 726                 samplecnt_t samples;
 727         };
 728
 729         typedef std::vector<CaptureInfo*> CaptureInfos;
 730
 731 } // namespace ARDOUR
 732
 733 /* for now, break the rules and use "using" to make this "global" */
 734
 735 using ARDOUR::samplepos_t;
 736
 737 #endif /* __ardour_types_h__ */