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 MonitorModel {
 357                 HardwareMonitoring, ///< JACK does monitoring
 358                 SoftwareMonitoring, ///< Ardour does monitoring
 359                 ExternalMonitoring  ///< we leave monitoring to the audio hardware
 360         };
 361
 362         enum MonitorChoice {
 363                 MonitorAuto = 0,
 364                 MonitorInput = 0x1,
 365                 MonitorDisk = 0x2,
 366                 MonitorCue = 0x4,
 367         };
 368
 369         enum MonitorState {
 370                 MonitoringSilence = 0x1,
 371                 MonitoringInput = 0x2,
 372                 MonitoringDisk = 0x4,
 373         };
 374
 375         enum MeterState {
 376                 MeteringInput, ///< meter the input IO, regardless of what is going through the route
 377                 MeteringRoute  ///< meter what is going through the route
 378         };
 379
 380         enum VUMeterStandard {
 381                 MeteringVUfrench,   // 0VU = -2dBu
 382                 MeteringVUamerican, // 0VU =  0dBu
 383                 MeteringVUstandard, // 0VU = +4dBu
 384                 MeteringVUeight     // 0VU = +8dBu
 385         };
 386
 387         enum MeterLineUp {
 388                 MeteringLineUp24,
 389                 MeteringLineUp20,
 390                 MeteringLineUp18,
 391                 MeteringLineUp15
 392         };
 393
 394         enum PFLPosition {
 395                 /** PFL signals come from before pre-fader processors */
 396                 PFLFromBeforeProcessors,
 397                 /** PFL signals come pre-fader but after pre-fader processors */
 398                 PFLFromAfterProcessors
 399         };
 400
 401         enum AFLPosition {
 402                 /** AFL signals come post-fader and before post-fader processors */
 403                 AFLFromBeforeProcessors,
 404                 /** AFL signals come post-fader but after post-fader processors */
 405                 AFLFromAfterProcessors
 406         };
 407
 408         enum DenormalModel {
 409                 DenormalNone,
 410                 DenormalFTZ,
 411                 DenormalDAZ,
 412                 DenormalFTZDAZ
 413         };
 414
 415         enum RemoteModel {
 416                 UserOrdered,
 417                 MixerOrdered
 418         };
 419
 420         enum CrossfadeModel {
 421                 FullCrossfade,
 422                 ShortCrossfade
 423         };
 424
 425         enum CrossfadeChoice {
 426                 RegionFades,
 427                 ConstantPowerMinus3dB,
 428                 ConstantPowerMinus6dB,
 429         };
 430
 431         enum ListenPosition {
 432                 AfterFaderListen,
 433                 PreFaderListen
 434         };
 435
 436         enum AutoConnectOption {
 437                 ManualConnect = 0x0,
 438                 AutoConnectPhysical = 0x1,
 439                 AutoConnectMaster = 0x2
 440         };
 441
 442         enum SampleFormat {
 443                 FormatFloat = 0,
 444                 FormatInt24,
 445                 FormatInt16
 446         };
 447
 448         enum CDMarkerFormat {
 449                 CDMarkerNone,
 450                 CDMarkerCUE,
 451                 CDMarkerTOC
 452         };
 453
 454         enum HeaderFormat {
 455                 BWF,
 456                 WAVE,
 457                 WAVE64,
 458                 CAF,
 459                 AIFF,
 460                 iXML,
 461                 RF64
 462         };
 463
 464         struct PeakData {
 465                 typedef Sample PeakDatum;
 466
 467                 PeakDatum min;
 468                 PeakDatum max;
 469         };
 470
 471         enum PluginType {
 472                 AudioUnit,
 473                 LADSPA,
 474                 LV2,
 475                 Windows_VST,
 476                 LXVST,
 477         };
 478
 479         enum RunContext {
 480                 ButlerContext = 0,
 481                 TransportContext,
 482                 ExportContext
 483         };
 484
 485         enum SyncSource {
 486                 /* These are "synonyms". It is important for JACK to be first
 487                    both here and in enums.cc, so that the string "JACK" is
 488                    correctly recognized in older session and preference files.
 489                 */
 490                 JACK = 0,
 491                 Engine = 0,
 492                 MTC,
 493                 MIDIClock,
 494                 LTC
 495         };
 496
 497         enum ShuttleBehaviour {
 498                 Sprung,
 499                 Wheel
 500         };
 501
 502         enum ShuttleUnits {
 503                 Percentage,
 504                 Semitones
 505         };
 506
 507         typedef std::vector<boost::shared_ptr<Source> > SourceList;
 508
 509         enum SrcQuality {
 510                 SrcBest,
 511                 SrcGood,
 512                 SrcQuick,
 513                 SrcFast,
 514                 SrcFastest
 515         };
 516
 517         typedef std::list<framepos_t> AnalysisFeatureList;
 518
 519         typedef std::list<boost::shared_ptr<Route> > RouteList;
 520         typedef std::list<boost::weak_ptr  <Route> > WeakRouteList;
 521
 522         class Bundle;
 523         typedef std::vector<boost::shared_ptr<Bundle> > BundleList;
 524
 525         enum WaveformScale {
 526                 Linear,
 527                 Logarithmic
 528         };
 529
 530         enum WaveformShape {
 531                 Traditional,
 532                 Rectified
 533         };
 534
 535         struct CleanupReport {
 536                 std::vector<std::string> paths;
 537                 size_t                   space;
 538         };
 539
 540         enum PositionLockStyle {
 541                 AudioTime,
 542                 MusicTime
 543         };
 544
 545         /** A struct used to describe changes to processors in a route.
 546          *  This is useful because objects that respond to a change in processors
 547          *  can optimise what work they do based on details of what has changed.
 548         */
 549         struct RouteProcessorChange {
 550                 enum Type {
 551                         GeneralChange = 0x0,
 552                         MeterPointChange = 0x1
 553                 };
 554
 555                 RouteProcessorChange () : type (GeneralChange), meter_visibly_changed (true)
 556                 {}
 557
 558                 RouteProcessorChange (Type t) : type (t), meter_visibly_changed (true)
 559                 {}
 560
 561                 RouteProcessorChange (Type t, bool m) : type (t), meter_visibly_changed (m)
 562                 {}
 563
 564                 /** type of change; "GeneralChange" means anything could have changed */
 565                 Type type;
 566                 /** true if, when a MeterPointChange has occurred, the change is visible to the user */
 567                 bool meter_visibly_changed;
 568         };
 569
 570         struct BusProfile {
 571                 AutoConnectOption input_ac;      /* override the RC config for input auto-connection */
 572                 AutoConnectOption output_ac;     /* override the RC config for output auto-connection */
 573                 uint32_t master_out_channels;    /* how many channels for the master bus */
 574                 uint32_t requested_physical_in;  /* now many of the available physical inputs to consider usable */
 575                 uint32_t requested_physical_out; /* now many of the available physical inputs to consider usable */
 576         };
 577
 578         enum FadeShape {
 579                 FadeLinear,
 580                 FadeFast,
 581                 FadeSlow,
 582                 FadeConstantPower,
 583                 FadeSymmetric,
 584         };
 585
 586         enum TransportState {
 587                 /* these values happen to match the constants used by JACK but
 588                    this equality cannot be assumed.
 589                 */
 590                 TransportStopped = 0,
 591                 TransportRolling = 1,
 592                 TransportLooping = 2,
 593                 TransportStarting = 3,
 594         };
 595
 596         enum PortFlags {
 597                 /* these values happen to match the constants used by JACK but
 598                    this equality cannot be assumed.
 599                 */
 600                 IsInput = 0x1,
 601                 IsOutput = 0x2,
 602                 IsPhysical = 0x4,
 603                 CanMonitor = 0x8,
 604                 IsTerminal = 0x10
 605         };
 606
 607         struct LatencyRange {
 608             uint32_t min; //< samples
 609             uint32_t max; //< samples
 610         };
 611
 612 } // namespace ARDOUR
 613
 614
 615 /* these cover types declared above in this header. See enums.cc
 616    for the definitions.
 617 */
 618
 619 std::istream& operator>>(std::istream& o, ARDOUR::SampleFormat& sf);
 620 std::istream& operator>>(std::istream& o, ARDOUR::HeaderFormat& sf);
 621 std::istream& operator>>(std::istream& o, ARDOUR::AutoConnectOption& sf);
 622 std::istream& operator>>(std::istream& o, ARDOUR::EditMode& sf);
 623 std::istream& operator>>(std::istream& o, ARDOUR::MonitorModel& sf);
 624 std::istream& operator>>(std::istream& o, ARDOUR::VUMeterStandard& sf);
 625 std::istream& operator>>(std::istream& o, ARDOUR::MeterLineUp& sf);
 626 std::istream& operator>>(std::istream& o, ARDOUR::PFLPosition& sf);
 627 std::istream& operator>>(std::istream& o, ARDOUR::AFLPosition& sf);
 628 std::istream& operator>>(std::istream& o, ARDOUR::RemoteModel& sf);
 629 std::istream& operator>>(std::istream& o, ARDOUR::ListenPosition& sf);
 630 std::istream& operator>>(std::istream& o, ARDOUR::InsertMergePolicy& sf);
 631 std::istream& operator>>(std::istream& o, ARDOUR::CrossfadeModel& sf);
 632 std::istream& operator>>(std::istream& o, ARDOUR::CrossfadeChoice& sf);
 633 std::istream& operator>>(std::istream& o, ARDOUR::SyncSource& sf);
 634 std::istream& operator>>(std::istream& o, ARDOUR::ShuttleBehaviour& sf);
 635 std::istream& operator>>(std::istream& o, ARDOUR::ShuttleUnits& sf);
 636 std::istream& operator>>(std::istream& o, Timecode::TimecodeFormat& sf);
 637 std::istream& operator>>(std::istream& o, ARDOUR::DenormalModel& sf);
 638 std::istream& operator>>(std::istream& o, ARDOUR::WaveformScale& sf);
 639 std::istream& operator>>(std::istream& o, ARDOUR::WaveformShape& sf);
 640 std::istream& operator>>(std::istream& o, ARDOUR::PositionLockStyle& sf);
 641
 642 std::ostream& operator<<(std::ostream& o, const ARDOUR::SampleFormat& sf);
 643 std::ostream& operator<<(std::ostream& o, const ARDOUR::HeaderFormat& sf);
 644 std::ostream& operator<<(std::ostream& o, const ARDOUR::AutoConnectOption& sf);
 645 std::ostream& operator<<(std::ostream& o, const ARDOUR::EditMode& sf);
 646 std::ostream& operator<<(std::ostream& o, const ARDOUR::MonitorModel& sf);
 647 std::ostream& operator<<(std::ostream& o, const ARDOUR::VUMeterStandard& sf);
 648 std::ostream& operator<<(std::ostream& o, const ARDOUR::MeterLineUp& sf);
 649 std::ostream& operator<<(std::ostream& o, const ARDOUR::PFLPosition& sf);
 650 std::ostream& operator<<(std::ostream& o, const ARDOUR::AFLPosition& sf);
 651 std::ostream& operator<<(std::ostream& o, const ARDOUR::RemoteModel& sf);
 652 std::ostream& operator<<(std::ostream& o, const ARDOUR::ListenPosition& sf);
 653 std::ostream& operator<<(std::ostream& o, const ARDOUR::InsertMergePolicy& sf);
 654 std::ostream& operator<<(std::ostream& o, const ARDOUR::CrossfadeModel& sf);
 655 std::ostream& operator<<(std::ostream& o, const ARDOUR::CrossfadeChoice& sf);
 656 std::ostream& operator<<(std::ostream& o, const ARDOUR::SyncSource& sf);
 657 std::ostream& operator<<(std::ostream& o, const ARDOUR::ShuttleBehaviour& sf);
 658 std::ostream& operator<<(std::ostream& o, const ARDOUR::ShuttleUnits& sf);
 659 std::ostream& operator<<(std::ostream& o, const Timecode::TimecodeFormat& sf);
 660 std::ostream& operator<<(std::ostream& o, const ARDOUR::DenormalModel& sf);
 661 std::ostream& operator<<(std::ostream& o, const ARDOUR::WaveformScale& sf);
 662 std::ostream& operator<<(std::ostream& o, const ARDOUR::WaveformShape& sf);
 663 std::ostream& operator<<(std::ostream& o, const ARDOUR::PositionLockStyle& sf);
 664
 665 static inline ARDOUR::framepos_t
 666 session_frame_to_track_frame (ARDOUR::framepos_t session_frame, double speed)
 667 {
 668         return (ARDOUR::framepos_t) ((long double) session_frame * (long double) speed);
 669 }
 670
 671 static inline ARDOUR::framepos_t
 672 track_frame_to_session_frame (ARDOUR::framepos_t track_frame, double speed)
 673 {
 674         return (ARDOUR::framepos_t) ((long double) track_frame / (long double) speed);
 675 }
 676
 677 /* for now, break the rules and use "using" to make this "global" */
 678
 679 using ARDOUR::framepos_t;
 680
 681
 682 #endif /* __ardour_types_h__ */
 683