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