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