libs/ardour/ardour/types.h

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