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