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