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 = 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         };
 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 RouteSortOrderKey {
 358                 EditorSort,
 359                 MixerSort
 360         };
 361
 362         enum MonitorModel {
 363                 HardwareMonitoring, ///< JACK does monitoring
 364                 SoftwareMonitoring, ///< Ardour does monitoring
 365                 ExternalMonitoring  ///< we leave monitoring to the audio hardware
 366         };
 367
 368         enum MonitorChoice {
 369                 MonitorAuto = 0,
 370                 MonitorInput = 0x1,
 371                 MonitorDisk = 0x2,
 372                 MonitorCue = 0x4,
 373         };
 374
 375         enum MonitorState {
 376                 MonitoringSilence = 0x1,
 377                 MonitoringInput = 0x2,
 378                 MonitoringDisk = 0x4,
 379         };
 380
 381         enum MeterState {
 382                 MeteringInput, ///< meter the input IO, regardless of what is going through the route
 383                 MeteringRoute  ///< meter what is going through the route
 384         };
 385
 386         enum VUMeterStandard {
 387                 MeteringVUfrench,   // 0VU = -2dBu
 388                 MeteringVUamerican, // 0VU =  0dBu
 389                 MeteringVUstandard, // 0VU = +4dBu
 390                 MeteringVUeight     // 0VU = +8dBu
 391         };
 392
 393         enum MeterLineUp {
 394                 MeteringLineUp24,
 395                 MeteringLineUp20,
 396                 MeteringLineUp18,
 397                 MeteringLineUp15
 398         };
 399
 400         enum PFLPosition {
 401                 /** PFL signals come from before pre-fader processors */
 402                 PFLFromBeforeProcessors,
 403                 /** PFL signals come pre-fader but after pre-fader processors */
 404                 PFLFromAfterProcessors
 405         };
 406
 407         enum AFLPosition {
 408                 /** AFL signals come post-fader and before post-fader processors */
 409                 AFLFromBeforeProcessors,
 410                 /** AFL signals come post-fader but after post-fader processors */
 411                 AFLFromAfterProcessors
 412         };
 413
 414         enum DenormalModel {
 415                 DenormalNone,
 416                 DenormalFTZ,
 417                 DenormalDAZ,
 418                 DenormalFTZDAZ
 419         };
 420
 421         enum RemoteModel {
 422                 UserOrdered,
 423                 MixerOrdered,
 424                 EditorOrdered
 425         };
 426
 427         enum CrossfadeModel {
 428                 FullCrossfade,
 429                 ShortCrossfade
 430         };
 431
 432         enum CrossfadeChoice {
 433                 RegionFades,
 434                 ConstantPowerMinus3dB,
 435                 ConstantPowerMinus6dB,
 436         };
 437
 438         enum ListenPosition {
 439                 AfterFaderListen,
 440                 PreFaderListen
 441         };
 442
 443         enum AutoConnectOption {
 444                 ManualConnect = 0x0,
 445                 AutoConnectPhysical = 0x1,
 446                 AutoConnectMaster = 0x2
 447         };
 448
 449         enum SampleFormat {
 450                 FormatFloat = 0,
 451                 FormatInt24,
 452                 FormatInt16
 453         };
 454
 455         enum CDMarkerFormat {
 456                 CDMarkerNone,
 457                 CDMarkerCUE,
 458                 CDMarkerTOC
 459         };
 460
 461         enum HeaderFormat {
 462                 BWF,
 463                 WAVE,
 464                 WAVE64,
 465                 CAF,
 466                 AIFF,
 467                 iXML,
 468                 RF64
 469         };
 470
 471         struct PeakData {
 472                 typedef Sample PeakDatum;
 473
 474                 PeakDatum min;
 475                 PeakDatum max;
 476         };
 477
 478         enum PluginType {
 479                 AudioUnit,
 480                 LADSPA,
 481                 LV2,
 482                 Windows_VST,
 483                 LXVST,
 484         };
 485
 486         enum RunContext {
 487                 ButlerContext = 0,
 488                 TransportContext,
 489                 ExportContext
 490         };
 491
 492         enum SyncSource {
 493                 JACK,
 494                 MTC,
 495                 MIDIClock,
 496                 LTC
 497         };
 498
 499         enum ShuttleBehaviour {
 500                 Sprung,
 501                 Wheel
 502         };
 503
 504         enum ShuttleUnits {
 505                 Percentage,
 506                 Semitones
 507         };
 508
 509         typedef std::vector<boost::shared_ptr<Source> > SourceList;
 510
 511         enum SrcQuality {
 512                 SrcBest,
 513                 SrcGood,
 514                 SrcQuick,
 515                 SrcFast,
 516                 SrcFastest
 517         };
 518
 519         typedef std::list<framepos_t> AnalysisFeatureList;
 520
 521         typedef std::list<boost::shared_ptr<Route> > RouteList;
 522         typedef std::list<boost::weak_ptr  <Route> > WeakRouteList;
 523
 524         class Bundle;
 525         typedef std::vector<boost::shared_ptr<Bundle> > BundleList;
 526
 527         enum WaveformScale {
 528                 Linear,
 529                 Logarithmic
 530         };
 531
 532         enum WaveformShape {
 533                 Traditional,
 534                 Rectified
 535         };
 536
 537         struct CleanupReport {
 538                 std::vector<std::string> paths;
 539                 size_t                   space;
 540         };
 541
 542         enum PositionLockStyle {
 543                 AudioTime,
 544                 MusicTime
 545         };
 546
 547         /** A struct used to describe changes to processors in a route.
 548          *  This is useful because objects that respond to a change in processors
 549          *  can optimise what work they do based on details of what has changed.
 550         */
 551         struct RouteProcessorChange {
 552                 enum Type {
 553                         GeneralChange = 0x0,
 554                         MeterPointChange = 0x1
 555                 };
 556
 557                 RouteProcessorChange () : type (GeneralChange), meter_visibly_changed (true)
 558                 {}
 559
 560                 RouteProcessorChange (Type t) : type (t), meter_visibly_changed (true)
 561                 {}
 562
 563                 RouteProcessorChange (Type t, bool m) : type (t), meter_visibly_changed (m)
 564                 {}
 565
 566                 /** type of change; "GeneralChange" means anything could have changed */
 567                 Type type;
 568                 /** true if, when a MeterPointChange has occurred, the change is visible to the user */
 569                 bool meter_visibly_changed;
 570         };
 571
 572         struct BusProfile {
 573                 AutoConnectOption input_ac;      /* override the RC config for input auto-connection */
 574                 AutoConnectOption output_ac;     /* override the RC config for output auto-connection */
 575                 uint32_t master_out_channels;    /* how many channels for the master bus */
 576                 uint32_t requested_physical_in;  /* now many of the available physical inputs to consider usable */
 577                 uint32_t requested_physical_out; /* now many of the available physical inputs to consider usable */
 578         };
 579
 580         enum FadeShape {
 581                 FadeLinear,
 582                 FadeFast,
 583                 FadeSlow,
 584                 FadeConstantPower,
 585                 FadeSymmetric,
 586         };
 587
 588 } // namespace ARDOUR
 589
 590
 591 /* these cover types declared above in this header. See enums.cc
 592    for the definitions.
 593 */
 594
 595 std::istream& operator>>(std::istream& o, ARDOUR::SampleFormat& sf);
 596 std::istream& operator>>(std::istream& o, ARDOUR::HeaderFormat& sf);
 597 std::istream& operator>>(std::istream& o, ARDOUR::AutoConnectOption& sf);
 598 std::istream& operator>>(std::istream& o, ARDOUR::EditMode& sf);
 599 std::istream& operator>>(std::istream& o, ARDOUR::MonitorModel& sf);
 600 std::istream& operator>>(std::istream& o, ARDOUR::VUMeterStandard& sf);
 601 std::istream& operator>>(std::istream& o, ARDOUR::MeterLineUp& sf);
 602 std::istream& operator>>(std::istream& o, ARDOUR::PFLPosition& sf);
 603 std::istream& operator>>(std::istream& o, ARDOUR::AFLPosition& sf);
 604 std::istream& operator>>(std::istream& o, ARDOUR::RemoteModel& sf);
 605 std::istream& operator>>(std::istream& o, ARDOUR::ListenPosition& sf);
 606 std::istream& operator>>(std::istream& o, ARDOUR::InsertMergePolicy& sf);
 607 std::istream& operator>>(std::istream& o, ARDOUR::CrossfadeModel& sf);
 608 std::istream& operator>>(std::istream& o, ARDOUR::CrossfadeChoice& sf);
 609 std::istream& operator>>(std::istream& o, ARDOUR::SyncSource& sf);
 610 std::istream& operator>>(std::istream& o, ARDOUR::ShuttleBehaviour& sf);
 611 std::istream& operator>>(std::istream& o, ARDOUR::ShuttleUnits& sf);
 612 std::istream& operator>>(std::istream& o, Timecode::TimecodeFormat& sf);
 613 std::istream& operator>>(std::istream& o, ARDOUR::DenormalModel& sf);
 614 std::istream& operator>>(std::istream& o, ARDOUR::WaveformScale& sf);
 615 std::istream& operator>>(std::istream& o, ARDOUR::WaveformShape& sf);
 616 std::istream& operator>>(std::istream& o, ARDOUR::PositionLockStyle& sf);
 617
 618 std::ostream& operator<<(std::ostream& o, const ARDOUR::SampleFormat& sf);
 619 std::ostream& operator<<(std::ostream& o, const ARDOUR::HeaderFormat& sf);
 620 std::ostream& operator<<(std::ostream& o, const ARDOUR::AutoConnectOption& sf);
 621 std::ostream& operator<<(std::ostream& o, const ARDOUR::EditMode& sf);
 622 std::ostream& operator<<(std::ostream& o, const ARDOUR::MonitorModel& sf);
 623 std::ostream& operator<<(std::ostream& o, const ARDOUR::VUMeterStandard& sf);
 624 std::ostream& operator<<(std::ostream& o, const ARDOUR::MeterLineUp& sf);
 625 std::ostream& operator<<(std::ostream& o, const ARDOUR::PFLPosition& sf);
 626 std::ostream& operator<<(std::ostream& o, const ARDOUR::AFLPosition& sf);
 627 std::ostream& operator<<(std::ostream& o, const ARDOUR::RemoteModel& sf);
 628 std::ostream& operator<<(std::ostream& o, const ARDOUR::ListenPosition& sf);
 629 std::ostream& operator<<(std::ostream& o, const ARDOUR::InsertMergePolicy& sf);
 630 std::ostream& operator<<(std::ostream& o, const ARDOUR::CrossfadeModel& sf);
 631 std::ostream& operator<<(std::ostream& o, const ARDOUR::CrossfadeChoice& sf);
 632 std::ostream& operator<<(std::ostream& o, const ARDOUR::SyncSource& sf);
 633 std::ostream& operator<<(std::ostream& o, const ARDOUR::ShuttleBehaviour& sf);
 634 std::ostream& operator<<(std::ostream& o, const ARDOUR::ShuttleUnits& sf);
 635 std::ostream& operator<<(std::ostream& o, const Timecode::TimecodeFormat& sf);
 636 std::ostream& operator<<(std::ostream& o, const ARDOUR::DenormalModel& sf);
 637 std::ostream& operator<<(std::ostream& o, const ARDOUR::WaveformScale& sf);
 638 std::ostream& operator<<(std::ostream& o, const ARDOUR::WaveformShape& sf);
 639 std::ostream& operator<<(std::ostream& o, const ARDOUR::PositionLockStyle& sf);
 640
 641 static inline ARDOUR::framepos_t
 642 session_frame_to_track_frame (ARDOUR::framepos_t session_frame, double speed)
 643 {
 644         return (ARDOUR::framepos_t) ((long double) session_frame * (long double) speed);
 645 }
 646
 647 static inline ARDOUR::framepos_t
 648 track_frame_to_session_frame (ARDOUR::framepos_t track_frame, double speed)
 649 {
 650         return (ARDOUR::framepos_t) ((long double) track_frame / (long double) speed);
 651 }
 652
 653 /* for now, break the rules and use "using" to make this "global" */
 654
 655 using ARDOUR::framepos_t;
 656
 657
 658 #endif /* __ardour_types_h__ */
 659