libs/ardour/ardour/types.h

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