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
  30 #include <inttypes.h>
  31 #include <jack/types.h>
  32 #include <jack/midiport.h>
  33
  34 #include "timecode/bbt_time.h"
  35 #include "timecode/time.h"
  36
  37 #include "pbd/id.h"
  38
  39 #include "evoral/Range.hpp"
  40
  41 #include "ardour/chan_count.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 jack_default_audio_sample_t 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 jack_nframes_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 TrackMode {
 181                 Normal,
 182                 NonLayered,
 183                 Destructive
 184         };
 185
 186         enum NoteMode {
 187                 Sustained,
 188                 Percussive
 189         };
 190
 191         enum ChannelMode {
 192                 AllChannels = 0, ///< Pass through all channel information unmodified
 193                 FilterChannels,  ///< Ignore events on certain channels
 194                 ForceChannel     ///< Force all events to a certain channel
 195         };
 196
 197         enum ColorMode {
 198                 MeterColors = 0,
 199                 ChannelColors,
 200                 TrackColor
 201         };
 202
 203         enum TimecodeFormat {
 204                 timecode_23976,
 205                 timecode_24,
 206                 timecode_24976,
 207                 timecode_25,
 208                 timecode_2997,
 209                 timecode_2997drop,
 210                 timecode_30,
 211                 timecode_30drop,
 212                 timecode_5994,
 213                 timecode_60
 214         };
 215
 216         class AnyTime {
 217         public:
 218                 enum Type {
 219                         Timecode,
 220                         BBT,
 221                         Frames,
 222                         Seconds
 223                 };
 224
 225                 Type type;
 226
 227                 Timecode::Time     timecode;
 228                 Timecode::BBT_Time bbt;
 229
 230                 union {
 231                         framecnt_t     frames;
 232                         double         seconds;
 233                 };
 234
 235                 AnyTime() { type = Frames; frames = 0; }
 236
 237                 bool operator== (AnyTime const & other) const {
 238                         if (type != other.type) { return false; }
 239
 240                         switch (type) {
 241                           case Timecode:
 242                                 return timecode == other.timecode;
 243                           case BBT:
 244                                 return bbt == other.bbt;
 245                           case Frames:
 246                                 return frames == other.frames;
 247                           case Seconds:
 248                                 return seconds == other.seconds;
 249                         }
 250                         return false; // get rid of warning
 251                 }
 252
 253                 bool not_zero() const
 254                 {
 255                         switch (type) {
 256                           case Timecode:
 257                                 return timecode.hours != 0 || timecode.minutes != 0 ||
 258                                        timecode.seconds != 0 || timecode.frames != 0;
 259                           case BBT:
 260                                 return bbt.bars != 0 || bbt.beats != 0 || bbt.ticks != 0;
 261                           case Frames:
 262                                 return frames != 0;
 263                           case Seconds:
 264                                 return seconds != 0;
 265                         }
 266
 267                         /* NOTREACHED */
 268                         assert (false);
 269                         return false;
 270                 }
 271         };
 272
 273         /* XXX: slightly unfortunate that there is this and Evoral::Range<>,
 274            but this has a uint32_t id which Evoral::Range<> does not.
 275         */
 276         struct AudioRange {
 277                 framepos_t start;
 278                 framepos_t end;
 279                 uint32_t id;
 280
 281                 AudioRange (framepos_t s, framepos_t e, uint32_t i) : start (s), end (e) , id (i) {}
 282
 283                 framecnt_t length() { return end - start + 1; }
 284
 285                 bool operator== (const AudioRange& other) const {
 286                         return start == other.start && end == other.end && id == other.id;
 287                 }
 288
 289                 bool equal (const AudioRange& other) const {
 290                         return start == other.start && end == other.end;
 291                 }
 292
 293                 Evoral::OverlapType coverage (framepos_t s, framepos_t e) const {
 294                         return Evoral::coverage (start, end, s, e);
 295                 }
 296         };
 297
 298         struct MusicRange {
 299                 Timecode::BBT_Time start;
 300                 Timecode::BBT_Time end;
 301                 uint32_t id;
 302
 303                 MusicRange (Timecode::BBT_Time& s, Timecode::BBT_Time& e, uint32_t i)
 304                         : start (s), end (e), id (i) {}
 305
 306                 bool operator== (const MusicRange& other) const {
 307                         return start == other.start && end == other.end && id == other.id;
 308                 }
 309
 310                 bool equal (const MusicRange& other) const {
 311                         return start == other.start && end == other.end;
 312                 }
 313         };
 314
 315         /*
 316             Slowest = 6.6dB/sec falloff at update rate of 40ms
 317             Slow    = 6.8dB/sec falloff at update rate of 40ms
 318         */
 319
 320         enum MeterFalloff {
 321                 MeterFalloffOff = 0,
 322                 MeterFalloffSlowest = 1,
 323                 MeterFalloffSlow = 2,
 324                 MeterFalloffMedium = 3,
 325                 MeterFalloffFast = 4,
 326                 MeterFalloffFaster = 5,
 327                 MeterFalloffFastest = 6
 328         };
 329
 330         enum MeterHold {
 331                 MeterHoldOff = 0,
 332                 MeterHoldShort = 40,
 333                 MeterHoldMedium = 100,
 334                 MeterHoldLong = 200
 335         };
 336
 337         enum EditMode {
 338                 Slide,
 339                 Splice,
 340                 Lock
 341         };
 342
 343         enum RegionPoint {
 344                 Start,
 345                 End,
 346                 SyncPoint
 347         };
 348
 349         enum Placement {
 350                 PreFader,
 351                 PostFader
 352         };
 353
 354         enum RouteSortOrderKey {
 355                 UndefinedSort,
 356                 EditorSort,
 357                 MixerSort
 358         };
 359
 360         enum MonitorModel {
 361                 HardwareMonitoring, ///< JACK does monitoring
 362                 SoftwareMonitoring, ///< Ardour does monitoring
 363                 ExternalMonitoring  ///< we leave monitoring to the audio hardware
 364         };
 365
 366         enum MonitorChoice {
 367                 MonitorAuto = 0,
 368                 MonitorInput = 0x1,
 369                 MonitorDisk = 0x2,
 370                 MonitorCue = 0x4,
 371         };
 372
 373         enum MonitorState {
 374                 MonitoringSilence = 0x1,
 375                 MonitoringInput = 0x2,
 376                 MonitoringDisk = 0x4,
 377         };
 378
 379         enum MeterState {
 380                 MeteringInput, ///< meter the input IO, regardless of what is going through the route
 381                 MeteringRoute  ///< meter what is going through the route
 382         };
 383
 384         enum PFLPosition {
 385                 /** PFL signals come from before pre-fader processors */
 386                 PFLFromBeforeProcessors,
 387                 /** PFL signals come pre-fader but after pre-fader processors */
 388                 PFLFromAfterProcessors
 389         };
 390
 391         enum AFLPosition {
 392                 /** AFL signals come post-fader and before post-fader processors */
 393                 AFLFromBeforeProcessors,
 394                 /** AFL signals come post-fader but after post-fader processors */
 395                 AFLFromAfterProcessors
 396         };
 397
 398         enum DenormalModel {
 399                 DenormalNone,
 400                 DenormalFTZ,
 401                 DenormalDAZ,
 402                 DenormalFTZDAZ
 403         };
 404
 405         enum RemoteModel {
 406                 UserOrdered,
 407                 MixerOrdered,
 408                 EditorOrdered
 409         };
 410
 411         enum CrossfadeModel {
 412                 FullCrossfade,
 413                 ShortCrossfade
 414         };
 415
 416         enum CrossfadeChoice {
 417                 RegionFades,
 418                 ConstantPowerMinus3dB,
 419                 ConstantPowerMinus6dB,
 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 PluginType {
 463                 AudioUnit,
 464                 LADSPA,
 465                 LV2,
 466                 Windows_VST,
 467                 LXVST,
 468         };
 469
 470         enum RunContext {
 471                 ButlerContext = 0,
 472                 TransportContext,
 473                 ExportContext
 474         };
 475
 476         enum SyncSource {
 477                 JACK,
 478                 MTC,
 479                 MIDIClock
 480         };
 481
 482         enum ShuttleBehaviour {
 483                 Sprung,
 484                 Wheel
 485         };
 486
 487         enum ShuttleUnits {
 488                 Percentage,
 489                 Semitones
 490         };
 491
 492         typedef std::vector<boost::shared_ptr<Source> > SourceList;
 493
 494         enum SrcQuality {
 495                 SrcBest,
 496                 SrcGood,
 497                 SrcQuick,
 498                 SrcFast,
 499                 SrcFastest
 500         };
 501
 502         typedef std::list<framepos_t> AnalysisFeatureList;
 503
 504         typedef std::list<boost::shared_ptr<Route> > RouteList;
 505         typedef std::list<boost::weak_ptr  <Route> > WeakRouteList;
 506
 507         class Bundle;
 508         typedef std::vector<boost::shared_ptr<Bundle> > BundleList;
 509
 510         enum WaveformScale {
 511                 Linear,
 512                 Logarithmic
 513         };
 514
 515         enum WaveformShape {
 516                 Traditional,
 517                 Rectified
 518         };
 519
 520         struct CleanupReport {
 521                 std::vector<std::string> paths;
 522                 size_t                   space;
 523         };
 524
 525         enum PositionLockStyle {
 526                 AudioTime,
 527                 MusicTime
 528         };
 529
 530         /** A struct used to describe changes to processors in a route.
 531          *  This is useful because objects that respond to a change in processors
 532          *  can optimise what work they do based on details of what has changed.
 533         */
 534         struct RouteProcessorChange {
 535                 enum Type {
 536                         GeneralChange = 0x0,
 537                         MeterPointChange = 0x1
 538                 };
 539
 540                 RouteProcessorChange () : type (GeneralChange), meter_visibly_changed (true)
 541                 {}
 542
 543                 RouteProcessorChange (Type t) : type (t), meter_visibly_changed (true)
 544                 {}
 545
 546                 RouteProcessorChange (Type t, bool m) : type (t), meter_visibly_changed (m)
 547                 {}
 548
 549                 /** type of change; "GeneralChange" means anything could have changed */
 550                 Type type;
 551                 /** true if, when a MeterPointChange has occurred, the change is visible to the user */
 552                 bool meter_visibly_changed;
 553         };
 554
 555         struct BusProfile {
 556                 AutoConnectOption input_ac;      /* override the RC config for input auto-connection */
 557                 AutoConnectOption output_ac;     /* override the RC config for output auto-connection */
 558                 uint32_t master_out_channels;    /* how many channels for the master bus */
 559                 uint32_t requested_physical_in;  /* now many of the available physical inputs to consider usable */
 560                 uint32_t requested_physical_out; /* now many of the available physical inputs to consider usable */
 561         };
 562
 563         enum FadeShape {
 564                 FadeLinear,
 565                 FadeFast,
 566                 FadeSlow,
 567                 FadeConstantPower,
 568                 FadeSymmetric,
 569         };
 570
 571 } // namespace ARDOUR
 572
 573
 574 /* these cover types declared above in this header. See enums.cc
 575    for the definitions.
 576 */
 577
 578 std::istream& operator>>(std::istream& o, ARDOUR::SampleFormat& sf);
 579 std::istream& operator>>(std::istream& o, ARDOUR::HeaderFormat& sf);
 580 std::istream& operator>>(std::istream& o, ARDOUR::AutoConnectOption& sf);
 581 std::istream& operator>>(std::istream& o, ARDOUR::EditMode& sf);
 582 std::istream& operator>>(std::istream& o, ARDOUR::MonitorModel& sf);
 583 std::istream& operator>>(std::istream& o, ARDOUR::PFLPosition& sf);
 584 std::istream& operator>>(std::istream& o, ARDOUR::AFLPosition& sf);
 585 std::istream& operator>>(std::istream& o, ARDOUR::RemoteModel& sf);
 586 std::istream& operator>>(std::istream& o, ARDOUR::ListenPosition& sf);
 587 std::istream& operator>>(std::istream& o, ARDOUR::InsertMergePolicy& sf);
 588 std::istream& operator>>(std::istream& o, ARDOUR::CrossfadeModel& sf);
 589 std::istream& operator>>(std::istream& o, ARDOUR::CrossfadeChoice& sf);
 590 std::istream& operator>>(std::istream& o, ARDOUR::SyncSource& sf);
 591 std::istream& operator>>(std::istream& o, ARDOUR::ShuttleBehaviour& sf);
 592 std::istream& operator>>(std::istream& o, ARDOUR::ShuttleUnits& sf);
 593 std::istream& operator>>(std::istream& o, ARDOUR::TimecodeFormat& sf);
 594 std::istream& operator>>(std::istream& o, ARDOUR::DenormalModel& sf);
 595 std::istream& operator>>(std::istream& o, ARDOUR::WaveformScale& sf);
 596 std::istream& operator>>(std::istream& o, ARDOUR::WaveformShape& sf);
 597 std::istream& operator>>(std::istream& o, ARDOUR::PositionLockStyle& sf);
 598
 599 std::ostream& operator<<(std::ostream& o, const ARDOUR::SampleFormat& sf);
 600 std::ostream& operator<<(std::ostream& o, const ARDOUR::HeaderFormat& sf);
 601 std::ostream& operator<<(std::ostream& o, const ARDOUR::AutoConnectOption& sf);
 602 std::ostream& operator<<(std::ostream& o, const ARDOUR::EditMode& sf);
 603 std::ostream& operator<<(std::ostream& o, const ARDOUR::MonitorModel& sf);
 604 std::ostream& operator<<(std::ostream& o, const ARDOUR::PFLPosition& sf);
 605 std::ostream& operator<<(std::ostream& o, const ARDOUR::AFLPosition& sf);
 606 std::ostream& operator<<(std::ostream& o, const ARDOUR::RemoteModel& sf);
 607 std::ostream& operator<<(std::ostream& o, const ARDOUR::ListenPosition& sf);
 608 std::ostream& operator<<(std::ostream& o, const ARDOUR::InsertMergePolicy& sf);
 609 std::ostream& operator<<(std::ostream& o, const ARDOUR::CrossfadeModel& sf);
 610 std::ostream& operator<<(std::ostream& o, const ARDOUR::CrossfadeChoice& sf);
 611 std::ostream& operator<<(std::ostream& o, const ARDOUR::SyncSource& sf);
 612 std::ostream& operator<<(std::ostream& o, const ARDOUR::ShuttleBehaviour& sf);
 613 std::ostream& operator<<(std::ostream& o, const ARDOUR::ShuttleUnits& sf);
 614 std::ostream& operator<<(std::ostream& o, const ARDOUR::TimecodeFormat& sf);
 615 std::ostream& operator<<(std::ostream& o, const ARDOUR::DenormalModel& sf);
 616 std::ostream& operator<<(std::ostream& o, const ARDOUR::WaveformScale& sf);
 617 std::ostream& operator<<(std::ostream& o, const ARDOUR::WaveformShape& sf);
 618 std::ostream& operator<<(std::ostream& o, const ARDOUR::PositionLockStyle& sf);
 619
 620 static inline ARDOUR::framepos_t
 621 session_frame_to_track_frame (ARDOUR::framepos_t session_frame, double speed)
 622 {
 623         return (ARDOUR::framepos_t) ((long double) session_frame * (long double) speed);
 624 }
 625
 626 static inline ARDOUR::framepos_t
 627 track_frame_to_session_frame (ARDOUR::framepos_t track_frame, double speed)
 628 {
 629         return (ARDOUR::framepos_t) ((long double) track_frame / (long double) speed);
 630 }
 631
 632 /* for now, break the rules and use "using" to make this "global" */
 633
 634 using ARDOUR::framepos_t;
 635
 636
 637 #endif /* __ardour_types_h__ */
 638