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 ListenPosition {
 424                 AfterFaderListen,
 425                 PreFaderListen
 426         };
 427
 428         enum AutoConnectOption {
 429                 ManualConnect = 0x0,
 430                 AutoConnectPhysical = 0x1,
 431                 AutoConnectMaster = 0x2
 432         };
 433
 434         enum SampleFormat {
 435                 FormatFloat = 0,
 436                 FormatInt24,
 437                 FormatInt16
 438         };
 439
 440         enum CDMarkerFormat {
 441                 CDMarkerNone,
 442                 CDMarkerCUE,
 443                 CDMarkerTOC
 444         };
 445
 446         enum HeaderFormat {
 447                 BWF,
 448                 WAVE,
 449                 WAVE64,
 450                 CAF,
 451                 AIFF,
 452                 iXML,
 453                 RF64
 454         };
 455
 456         struct PeakData {
 457                 typedef Sample PeakDatum;
 458
 459                 PeakDatum min;
 460                 PeakDatum max;
 461         };
 462
 463         enum RunContext {
 464                 ButlerContext = 0,
 465                 TransportContext,
 466                 ExportContext
 467         };
 468
 469         enum SyncSource {
 470                 /* These are "synonyms". It is important for JACK to be first
 471                    both here and in enums.cc, so that the string "JACK" is
 472                    correctly recognized in older session and preference files.
 473                 */
 474                 JACK = 0,
 475                 Engine = 0,
 476                 MTC,
 477                 MIDIClock,
 478                 LTC
 479         };
 480
 481         enum ShuttleBehaviour {
 482                 Sprung,
 483                 Wheel
 484         };
 485
 486         enum ShuttleUnits {
 487                 Percentage,
 488                 Semitones
 489         };
 490
 491         typedef std::vector<boost::shared_ptr<Source> > SourceList;
 492
 493         enum SrcQuality {
 494                 SrcBest,
 495                 SrcGood,
 496                 SrcQuick,
 497                 SrcFast,
 498                 SrcFastest
 499         };
 500
 501         typedef std::list<framepos_t> AnalysisFeatureList;
 502
 503         typedef std::list<boost::shared_ptr<Route> > RouteList;
 504         typedef std::list<boost::weak_ptr  <Route> > WeakRouteList;
 505
 506         class Bundle;
 507         typedef std::vector<boost::shared_ptr<Bundle> > BundleList;
 508
 509         enum WaveformScale {
 510                 Linear,
 511                 Logarithmic
 512         };
 513
 514         enum WaveformShape {
 515                 Traditional,
 516                 Rectified
 517         };
 518
 519         struct CleanupReport {
 520                 std::vector<std::string> paths;
 521                 size_t                   space;
 522         };
 523
 524         enum PositionLockStyle {
 525                 AudioTime,
 526                 MusicTime
 527         };
 528
 529         /** A struct used to describe changes to processors in a route.
 530          *  This is useful because objects that respond to a change in processors
 531          *  can optimise what work they do based on details of what has changed.
 532         */
 533         struct RouteProcessorChange {
 534                 enum Type {
 535                         GeneralChange = 0x0,
 536                         MeterPointChange = 0x1
 537                 };
 538
 539                 RouteProcessorChange () : type (GeneralChange), meter_visibly_changed (true)
 540                 {}
 541
 542                 RouteProcessorChange (Type t) : type (t), meter_visibly_changed (true)
 543                 {}
 544
 545                 RouteProcessorChange (Type t, bool m) : type (t), meter_visibly_changed (m)
 546                 {}
 547
 548                 /** type of change; "GeneralChange" means anything could have changed */
 549                 Type type;
 550                 /** true if, when a MeterPointChange has occurred, the change is visible to the user */
 551                 bool meter_visibly_changed;
 552         };
 553
 554         struct BusProfile {
 555                 AutoConnectOption input_ac;      /* override the RC config for input auto-connection */
 556                 AutoConnectOption output_ac;     /* override the RC config for output auto-connection */
 557                 uint32_t master_out_channels;    /* how many channels for the master bus */
 558                 uint32_t requested_physical_in;  /* now many of the available physical inputs to consider usable */
 559                 uint32_t requested_physical_out; /* now many of the available physical inputs to consider usable */
 560         };
 561
 562         enum FadeShape {
 563                 FadeLinear,
 564                 FadeFast,
 565                 FadeSlow,
 566                 FadeConstantPower,
 567                 FadeSymmetric,
 568         };
 569
 570         enum TransportState {
 571                 /* these values happen to match the constants used by JACK but
 572                    this equality cannot be assumed.
 573                 */
 574                 TransportStopped = 0,
 575                 TransportRolling = 1,
 576                 TransportLooping = 2,
 577                 TransportStarting = 3,
 578         };
 579
 580         enum PortFlags {
 581                 /* these values happen to match the constants used by JACK but
 582                    this equality cannot be assumed.
 583                 */
 584                 IsInput = 0x1,
 585                 IsOutput = 0x2,
 586                 IsPhysical = 0x4,
 587                 CanMonitor = 0x8,
 588                 IsTerminal = 0x10
 589         };
 590
 591         struct LatencyRange {
 592             uint32_t min; //< samples
 593             uint32_t max; //< samples
 594         };
 595
 596 } // namespace ARDOUR
 597
 598
 599 /* these cover types declared above in this header. See enums.cc
 600    for the definitions.
 601 */
 602
 603 std::istream& operator>>(std::istream& o, ARDOUR::SampleFormat& sf);
 604 std::istream& operator>>(std::istream& o, ARDOUR::HeaderFormat& sf);
 605 std::istream& operator>>(std::istream& o, ARDOUR::AutoConnectOption& sf);
 606 std::istream& operator>>(std::istream& o, ARDOUR::EditMode& sf);
 607 std::istream& operator>>(std::istream& o, ARDOUR::MonitorModel& sf);
 608 std::istream& operator>>(std::istream& o, ARDOUR::VUMeterStandard& sf);
 609 std::istream& operator>>(std::istream& o, ARDOUR::MeterLineUp& sf);
 610 std::istream& operator>>(std::istream& o, ARDOUR::PFLPosition& sf);
 611 std::istream& operator>>(std::istream& o, ARDOUR::AFLPosition& sf);
 612 std::istream& operator>>(std::istream& o, ARDOUR::RemoteModel& sf);
 613 std::istream& operator>>(std::istream& o, ARDOUR::ListenPosition& sf);
 614 std::istream& operator>>(std::istream& o, ARDOUR::InsertMergePolicy& sf);
 615 std::istream& operator>>(std::istream& o, ARDOUR::SyncSource& sf);
 616 std::istream& operator>>(std::istream& o, ARDOUR::ShuttleBehaviour& sf);
 617 std::istream& operator>>(std::istream& o, ARDOUR::ShuttleUnits& sf);
 618 std::istream& operator>>(std::istream& o, Timecode::TimecodeFormat& sf);
 619 std::istream& operator>>(std::istream& o, ARDOUR::DenormalModel& sf);
 620 std::istream& operator>>(std::istream& o, ARDOUR::WaveformScale& sf);
 621 std::istream& operator>>(std::istream& o, ARDOUR::WaveformShape& sf);
 622 std::istream& operator>>(std::istream& o, ARDOUR::PositionLockStyle& sf);
 623 std::istream& operator>>(std::istream& o, ARDOUR::FadeShape& sf);
 624
 625 std::ostream& operator<<(std::ostream& o, const ARDOUR::SampleFormat& sf);
 626 std::ostream& operator<<(std::ostream& o, const ARDOUR::HeaderFormat& sf);
 627 std::ostream& operator<<(std::ostream& o, const ARDOUR::AutoConnectOption& sf);
 628 std::ostream& operator<<(std::ostream& o, const ARDOUR::EditMode& sf);
 629 std::ostream& operator<<(std::ostream& o, const ARDOUR::MonitorModel& sf);
 630 std::ostream& operator<<(std::ostream& o, const ARDOUR::VUMeterStandard& sf);
 631 std::ostream& operator<<(std::ostream& o, const ARDOUR::MeterLineUp& sf);
 632 std::ostream& operator<<(std::ostream& o, const ARDOUR::PFLPosition& sf);
 633 std::ostream& operator<<(std::ostream& o, const ARDOUR::AFLPosition& sf);
 634 std::ostream& operator<<(std::ostream& o, const ARDOUR::RemoteModel& sf);
 635 std::ostream& operator<<(std::ostream& o, const ARDOUR::ListenPosition& sf);
 636 std::ostream& operator<<(std::ostream& o, const ARDOUR::InsertMergePolicy& sf);
 637 std::ostream& operator<<(std::ostream& o, const ARDOUR::SyncSource& sf);
 638 std::ostream& operator<<(std::ostream& o, const ARDOUR::ShuttleBehaviour& sf);
 639 std::ostream& operator<<(std::ostream& o, const ARDOUR::ShuttleUnits& sf);
 640 std::ostream& operator<<(std::ostream& o, const Timecode::TimecodeFormat& sf);
 641 std::ostream& operator<<(std::ostream& o, const ARDOUR::DenormalModel& sf);
 642 std::ostream& operator<<(std::ostream& o, const ARDOUR::WaveformScale& sf);
 643 std::ostream& operator<<(std::ostream& o, const ARDOUR::WaveformShape& sf);
 644 std::ostream& operator<<(std::ostream& o, const ARDOUR::PositionLockStyle& sf);
 645 std::ostream& operator<<(std::ostream& o, const ARDOUR::FadeShape& sf);
 646
 647 static inline ARDOUR::framepos_t
 648 session_frame_to_track_frame (ARDOUR::framepos_t session_frame, double speed)
 649 {
 650         return (ARDOUR::framepos_t) ((long double) session_frame * (long double) speed);
 651 }
 652
 653 static inline ARDOUR::framepos_t
 654 track_frame_to_session_frame (ARDOUR::framepos_t track_frame, double speed)
 655 {
 656         return (ARDOUR::framepos_t) ((long double) track_frame / (long double) speed);
 657 }
 658
 659 /* for now, break the rules and use "using" to make this "global" */
 660
 661 using ARDOUR::framepos_t;
 662
 663
 664 #endif /* __ardour_types_h__ */
 665