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