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