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 "ardour/chan_count.h"
  40
  41 #include <map>
  42
  43 #if __GNUC__ < 3
  44 typedef int intptr_t;
  45 #endif
  46
  47 namespace ARDOUR {
  48
  49         class Source;
  50         class AudioSource;
  51         class Route;
  52         class Region;
  53
  54         typedef jack_default_audio_sample_t Sample;
  55         typedef float                       pan_t;
  56         typedef float                       gain_t;
  57         typedef uint32_t                    layer_t;
  58         typedef uint64_t                    microseconds_t;
  59         typedef jack_nframes_t              pframes_t;
  60
  61         /* Any position measured in audio frames.
  62            Assumed to be non-negative but not enforced.
  63         */
  64         typedef int64_t framepos_t;
  65
  66         /* Any distance from a given framepos_t.
  67            Maybe positive or negative.
  68         */
  69         typedef int64_t frameoffset_t;
  70
  71         /* Any count of audio frames.
  72            Assumed to be positive but not enforced.
  73         */
  74         typedef int64_t framecnt_t;
  75
  76         static const framepos_t max_framepos = INT64_MAX;
  77         static const framecnt_t max_framecnt = INT64_MAX;
  78
  79         // a set of (time) intervals: first of pair is the offset of the start within the region, second is the offset of the end
  80         typedef std::list<std::pair<frameoffset_t, frameoffset_t> > AudioIntervalResult;
  81         // associate a set of intervals with regions (e.g. for silence detection)
  82         typedef std::map<boost::shared_ptr<ARDOUR::Region>,AudioIntervalResult> AudioIntervalMap;
  83
  84         struct IOChange {
  85
  86                 enum Type {
  87                         NoChange = 0,
  88                         ConfigurationChanged = 0x1,
  89                         ConnectionsChanged = 0x2
  90                 } type;
  91
  92                 IOChange () : type (NoChange) {}
  93                 IOChange (Type t) : type (t) {}
  94
  95                 /** channel count of IO before a ConfigurationChanged, if appropriate */
  96                 ARDOUR::ChanCount before;
  97                 /** channel count of IO after a ConfigurationChanged, if appropriate */
  98                 ARDOUR::ChanCount after;
  99         };
 100
 101         enum OverlapType {
 102                 OverlapNone,      // no overlap
 103                 OverlapInternal,  // the overlap is 100% with the object
 104                 OverlapStart,     // overlap covers start, but ends within
 105                 OverlapEnd,       // overlap begins within and covers end
 106                 OverlapExternal   // overlap extends to (at least) begin+end
 107         };
 108
 109         ARDOUR::OverlapType coverage (framepos_t sa, framepos_t ea,
 110                                       framepos_t sb, framepos_t eb);
 111
 112         /* policies for inserting/pasting material where overlaps
 113            might be an issue.
 114         */
 115
 116         enum InsertMergePolicy {
 117                 InsertMergeReject,  // no overlaps allowed
 118                 InsertMergeRelax,   // we just don't care about overlaps
 119                 InsertMergeReplace, // replace old with new
 120                 InsertMergeTruncateExisting, // shorten existing to avoid overlap
 121                 InsertMergeTruncateAddition, // shorten new to avoid overlap
 122                 InsertMergeExtend   // extend new (or old) to the range of old+new
 123         };
 124
 125         /** See evoral/Parameter.hpp
 126          */
 127         enum AutomationType {
 128                 NullAutomation,
 129                 GainAutomation,
 130                 PanAzimuthAutomation,
 131                 PanElevationAutomation,
 132                 PanWidthAutomation,
 133                 PanFrontBackAutomation,
 134                 PanLFEAutomation,
 135                 PluginAutomation,
 136                 SoloAutomation,
 137                 MuteAutomation,
 138                 MidiCCAutomation,
 139                 MidiPgmChangeAutomation,
 140                 MidiPitchBenderAutomation,
 141                 MidiChannelPressureAutomation,
 142                 MidiSystemExclusiveAutomation,
 143                 FadeInAutomation,
 144                 FadeOutAutomation,
 145                 EnvelopeAutomation
 146         };
 147
 148         enum AutoState {
 149                 Off = 0x0,
 150                 Write = 0x1,
 151                 Touch = 0x2,
 152                 Play = 0x4
 153         };
 154
 155         std::string auto_state_to_string (AutoState);
 156         AutoState string_to_auto_state (std::string);
 157
 158         enum AutoStyle {
 159                 Absolute = 0x1,
 160                 Trim = 0x2
 161         };
 162
 163         std::string auto_style_to_string (AutoStyle);
 164         AutoStyle string_to_auto_style (std::string);
 165
 166         enum AlignStyle {
 167                 CaptureTime,
 168                 ExistingMaterial
 169         };
 170
 171         enum MeterPoint {
 172                 MeterInput,
 173                 MeterPreFader,
 174                 MeterPostFader,
 175                 MeterOutput,
 176                 MeterCustom
 177         };
 178
 179         enum TrackMode {
 180                 Normal,
 181                 NonLayered,
 182                 Destructive
 183         };
 184
 185         enum NoteMode {
 186                 Sustained,
 187                 Percussive
 188         };
 189
 190         enum ChannelMode {
 191                 AllChannels = 0, ///< Pass through all channel information unmodified
 192                 FilterChannels,  ///< Ignore events on certain channels
 193                 ForceChannel     ///< Force all events to a certain channel
 194         };
 195
 196         enum ColorMode {
 197                 MeterColors = 0,
 198                 ChannelColors,
 199                 TrackColor
 200         };
 201
 202         enum TimecodeFormat {
 203                 timecode_23976,
 204                 timecode_24,
 205                 timecode_24976,
 206                 timecode_25,
 207                 timecode_2997,
 208                 timecode_2997drop,
 209                 timecode_30,
 210                 timecode_30drop,
 211                 timecode_5994,
 212                 timecode_60
 213         };
 214
 215         struct AnyTime {
 216                 enum Type {
 217                         Timecode,
 218                         BBT,
 219                         Frames,
 220                         Seconds
 221                 };
 222
 223                 Type type;
 224
 225                 Timecode::Time     timecode;
 226                 Timecode::BBT_Time bbt;
 227
 228                 union {
 229                         framecnt_t     frames;
 230                         double         seconds;
 231                 };
 232
 233                 AnyTime() { type = Frames; frames = 0; }
 234
 235                 bool operator== (AnyTime const & other) const {
 236                         if (type != other.type) { return false; }
 237
 238                         switch (type) {
 239                           case Timecode:
 240                                 return timecode == other.timecode;
 241                           case BBT:
 242                                 return bbt == other.bbt;
 243                           case Frames:
 244                                 return frames == other.frames;
 245                           case Seconds:
 246                                 return seconds == other.seconds;
 247                         }
 248                 }
 249
 250                 bool not_zero() const
 251                 {
 252                         switch (type) {
 253                           case Timecode:
 254                                 return timecode.hours != 0 || timecode.minutes != 0 ||
 255                                        timecode.seconds != 0 || timecode.frames != 0;
 256                           case BBT:
 257                                 return bbt.bars != 0 || bbt.beats != 0 || bbt.ticks != 0;
 258                           case Frames:
 259                                 return frames != 0;
 260                           case Seconds:
 261                                 return seconds != 0;
 262                         }
 263                 }
 264         };
 265
 266         struct AudioRange {
 267                 framepos_t start;
 268                 framepos_t end;
 269                 uint32_t id;
 270
 271                 AudioRange (framepos_t s, framepos_t e, uint32_t i) : start (s), end (e) , id (i) {}
 272
 273                 framecnt_t length() { return end - start + 1; }
 274
 275                 bool operator== (const AudioRange& other) const {
 276                         return start == other.start && end == other.end && id == other.id;
 277                 }
 278
 279                 bool equal (const AudioRange& other) const {
 280                         return start == other.start && end == other.end;
 281                 }
 282
 283                 OverlapType coverage (framepos_t s, framepos_t e) const {
 284                         return ARDOUR::coverage (start, end, s, e);
 285                 }
 286         };
 287
 288         struct MusicRange {
 289                 Timecode::BBT_Time start;
 290                 Timecode::BBT_Time end;
 291                 uint32_t id;
 292
 293                 MusicRange (Timecode::BBT_Time& s, Timecode::BBT_Time& e, uint32_t i)
 294                         : start (s), end (e), id (i) {}
 295
 296                 bool operator== (const MusicRange& other) const {
 297                         return start == other.start && end == other.end && id == other.id;
 298                 }
 299
 300                 bool equal (const MusicRange& other) const {
 301                         return start == other.start && end == other.end;
 302                 }
 303         };
 304
 305         /*
 306             Slowest = 6.6dB/sec falloff at update rate of 40ms
 307             Slow    = 6.8dB/sec falloff at update rate of 40ms
 308         */
 309
 310         enum MeterFalloff {
 311                 MeterFalloffOff = 0,
 312                 MeterFalloffSlowest = 1,
 313                 MeterFalloffSlow = 2,
 314                 MeterFalloffMedium = 3,
 315                 MeterFalloffFast = 4,
 316                 MeterFalloffFaster = 5,
 317                 MeterFalloffFastest = 6
 318         };
 319
 320         enum MeterHold {
 321                 MeterHoldOff = 0,
 322                 MeterHoldShort = 40,
 323                 MeterHoldMedium = 100,
 324                 MeterHoldLong = 200
 325         };
 326
 327         enum EditMode {
 328                 Slide,
 329                 Splice,
 330                 Lock
 331         };
 332
 333         enum RegionPoint {
 334                 Start,
 335                 End,
 336                 SyncPoint
 337         };
 338
 339         enum Placement {
 340                 PreFader,
 341                 PostFader
 342         };
 343
 344         enum MonitorModel {
 345                 HardwareMonitoring,
 346                 SoftwareMonitoring,
 347                 ExternalMonitoring
 348         };
 349
 350         enum PFLPosition {
 351                 /** PFL signals come from before pre-fader processors */
 352                 PFLFromBeforeProcessors,
 353                 /** PFL signals come pre-fader but after pre-fader processors */
 354                 PFLFromAfterProcessors
 355         };
 356
 357         enum AFLPosition {
 358                 /** AFL signals come post-fader and before post-fader processors */
 359                 AFLFromBeforeProcessors,
 360                 /** AFL signals come post-fader but after post-fader processors */
 361                 AFLFromAfterProcessors
 362         };
 363
 364         enum DenormalModel {
 365                 DenormalNone,
 366                 DenormalFTZ,
 367                 DenormalDAZ,
 368                 DenormalFTZDAZ
 369         };
 370
 371         enum RemoteModel {
 372                 UserOrdered,
 373                 MixerOrdered,
 374                 EditorOrdered
 375         };
 376
 377         enum CrossfadeModel {
 378                 FullCrossfade,
 379                 ShortCrossfade
 380         };
 381
 382         enum LayerModel {
 383                 LaterHigher,
 384                 MoveAddHigher,
 385                 AddHigher
 386         };
 387
 388         enum ListenPosition {
 389                 AfterFaderListen,
 390                 PreFaderListen
 391         };
 392
 393         enum AutoConnectOption {
 394                 ManualConnect = 0x0,
 395                 AutoConnectPhysical = 0x1,
 396                 AutoConnectMaster = 0x2
 397         };
 398
 399         struct InterThreadInfo {
 400                 InterThreadInfo () : done (false), cancel (false), progress (0), thread (0) {}
 401
 402                 volatile bool  done;
 403                 volatile bool  cancel;
 404                 volatile float progress;
 405                 pthread_t      thread;
 406         };
 407
 408         enum SampleFormat {
 409                 FormatFloat = 0,
 410                 FormatInt24,
 411                 FormatInt16
 412         };
 413
 414         enum CDMarkerFormat {
 415                 CDMarkerNone,
 416                 CDMarkerCUE,
 417                 CDMarkerTOC
 418         };
 419
 420         enum HeaderFormat {
 421                 BWF,
 422                 WAVE,
 423                 WAVE64,
 424                 CAF,
 425                 AIFF,
 426                 iXML,
 427                 RF64
 428         };
 429
 430         struct PeakData {
 431                 typedef Sample PeakDatum;
 432
 433                 PeakDatum min;
 434                 PeakDatum max;
 435         };
 436
 437         enum PluginType {
 438                 AudioUnit,
 439                 LADSPA,
 440                 LV2,
 441                 VST
 442         };
 443
 444         enum RunContext {
 445                 ButlerContext = 0,
 446                 TransportContext,
 447                 ExportContext
 448         };
 449
 450         enum SyncSource {
 451                 JACK,
 452                 MTC,
 453                 MIDIClock
 454         };
 455
 456         enum ShuttleBehaviour {
 457                 Sprung,
 458                 Wheel
 459         };
 460
 461         enum ShuttleUnits {
 462                 Percentage,
 463                 Semitones
 464         };
 465
 466         typedef std::vector<boost::shared_ptr<Source> > SourceList;
 467
 468         enum SrcQuality {
 469                 SrcBest,
 470                 SrcGood,
 471                 SrcQuick,
 472                 SrcFast,
 473                 SrcFastest
 474         };
 475
 476         struct TimeFXRequest : public InterThreadInfo {
 477                 TimeFXRequest()
 478                         : time_fraction(0), pitch_fraction(0),
 479                         quick_seek(false), antialias(false),  opts(0) {}
 480                 float time_fraction;
 481                 float pitch_fraction;
 482                 /* SoundTouch */
 483                 bool  quick_seek;
 484                 bool  antialias;
 485                 /* RubberBand */
 486                 int   opts; // really RubberBandStretcher::Options
 487         };
 488
 489         typedef std::list<framepos_t> AnalysisFeatureList;
 490
 491         typedef std::list<boost::shared_ptr<Route> >      RouteList;
 492
 493         class Bundle;
 494         typedef std::vector<boost::shared_ptr<Bundle> > BundleList;
 495
 496         enum WaveformScale {
 497                 Linear,
 498                 Logarithmic
 499         };
 500
 501         enum WaveformShape {
 502                 Traditional,
 503                 Rectified
 504         };
 505
 506         enum QuantizeType {
 507                 Plain,
 508                 Legato,
 509                 Groove
 510         };
 511
 512         struct CleanupReport {
 513                 std::vector<std::string> paths;
 514                 size_t                   space;
 515         };
 516
 517         enum PositionLockStyle {
 518                 AudioTime,
 519                 MusicTime
 520         };
 521
 522         /** A struct used to describe changes to processors in a route.
 523          *  This is useful because objects that respond to a change in processors
 524          *  can optimise what work they do based on details of what has changed.
 525         */
 526         struct RouteProcessorChange {
 527                 enum Type {
 528                         GeneralChange = 0x0,
 529                         MeterPointChange = 0x1
 530                 };
 531
 532                 RouteProcessorChange () : type (GeneralChange), meter_visibly_changed (true)
 533                 {}
 534
 535                 RouteProcessorChange (Type t) : type (t), meter_visibly_changed (true)
 536                 {}
 537
 538                 RouteProcessorChange (Type t, bool m) : type (t), meter_visibly_changed (m)
 539                 {}
 540
 541                 /** type of change; "GeneralChange" means anything could have changed */
 542                 Type type;
 543                 /** true if, when a MeterPointChange has occurred, the change is visible to the user */
 544                 bool meter_visibly_changed;
 545         };
 546
 547         struct BusProfile {
 548             AutoConnectOption input_ac;      /* override the RC config for input auto-connection */
 549             AutoConnectOption output_ac;     /* override the RC config for output auto-connection */
 550             uint32_t master_out_channels;    /* how many channels for the master bus */
 551             uint32_t requested_physical_in;  /* now many of the available physical inputs to consider usable */
 552             uint32_t requested_physical_out; /* now many of the available physical inputs to consider usable */
 553         };
 554
 555         enum FadeShape {
 556                 FadeLinear,
 557                 FadeFast,
 558                 FadeSlow,
 559                 FadeLogA,
 560                 FadeLogB
 561         };
 562
 563 } // namespace ARDOUR
 564
 565
 566 /* these cover types declared above in this header. See enums.cc
 567    for the definitions.
 568 */
 569
 570 std::istream& operator>>(std::istream& o, ARDOUR::SampleFormat& sf);
 571 std::istream& operator>>(std::istream& o, ARDOUR::HeaderFormat& sf);
 572 std::istream& operator>>(std::istream& o, ARDOUR::AutoConnectOption& sf);
 573 std::istream& operator>>(std::istream& o, ARDOUR::EditMode& sf);
 574 std::istream& operator>>(std::istream& o, ARDOUR::MonitorModel& sf);
 575 std::istream& operator>>(std::istream& o, ARDOUR::PFLPosition& sf);
 576 std::istream& operator>>(std::istream& o, ARDOUR::AFLPosition& sf);
 577 std::istream& operator>>(std::istream& o, ARDOUR::RemoteModel& sf);
 578 std::istream& operator>>(std::istream& o, ARDOUR::ListenPosition& sf);
 579 std::istream& operator>>(std::istream& o, ARDOUR::LayerModel& sf);
 580 std::istream& operator>>(std::istream& o, ARDOUR::InsertMergePolicy& sf);
 581 std::istream& operator>>(std::istream& o, ARDOUR::CrossfadeModel& sf);
 582 std::istream& operator>>(std::istream& o, ARDOUR::SyncSource& sf);
 583 std::istream& operator>>(std::istream& o, ARDOUR::ShuttleBehaviour& sf);
 584 std::istream& operator>>(std::istream& o, ARDOUR::ShuttleUnits& sf);
 585 std::istream& operator>>(std::istream& o, ARDOUR::TimecodeFormat& sf);
 586 std::istream& operator>>(std::istream& o, ARDOUR::DenormalModel& sf);
 587 std::istream& operator>>(std::istream& o, ARDOUR::WaveformScale& sf);
 588 std::istream& operator>>(std::istream& o, ARDOUR::WaveformShape& sf);
 589 std::istream& operator>>(std::istream& o, ARDOUR::PositionLockStyle& sf);
 590
 591 std::ostream& operator<<(std::ostream& o, const ARDOUR::SampleFormat& sf);
 592 std::ostream& operator<<(std::ostream& o, const ARDOUR::HeaderFormat& sf);
 593 std::ostream& operator<<(std::ostream& o, const ARDOUR::AutoConnectOption& sf);
 594 std::ostream& operator<<(std::ostream& o, const ARDOUR::EditMode& sf);
 595 std::ostream& operator<<(std::ostream& o, const ARDOUR::MonitorModel& sf);
 596 std::ostream& operator<<(std::ostream& o, const ARDOUR::PFLPosition& sf);
 597 std::ostream& operator<<(std::ostream& o, const ARDOUR::AFLPosition& sf);
 598 std::ostream& operator<<(std::ostream& o, const ARDOUR::RemoteModel& sf);
 599 std::ostream& operator<<(std::ostream& o, const ARDOUR::ListenPosition& sf);
 600 std::ostream& operator<<(std::ostream& o, const ARDOUR::LayerModel& sf);
 601 std::ostream& operator<<(std::ostream& o, const ARDOUR::InsertMergePolicy& sf);
 602 std::ostream& operator<<(std::ostream& o, const ARDOUR::CrossfadeModel& sf);
 603 std::ostream& operator<<(std::ostream& o, const ARDOUR::SyncSource& sf);
 604 std::ostream& operator<<(std::ostream& o, const ARDOUR::ShuttleBehaviour& sf);
 605 std::ostream& operator<<(std::ostream& o, const ARDOUR::ShuttleUnits& sf);
 606 std::ostream& operator<<(std::ostream& o, const ARDOUR::TimecodeFormat& sf);
 607 std::ostream& operator<<(std::ostream& o, const ARDOUR::DenormalModel& sf);
 608 std::ostream& operator<<(std::ostream& o, const ARDOUR::WaveformScale& sf);
 609 std::ostream& operator<<(std::ostream& o, const ARDOUR::WaveformShape& sf);
 610 std::ostream& operator<<(std::ostream& o, const ARDOUR::PositionLockStyle& sf);
 611
 612 static inline ARDOUR::framepos_t
 613 session_frame_to_track_frame (ARDOUR::framepos_t session_frame, double speed)
 614 {
 615         return (ARDOUR::framepos_t)( (double)session_frame * speed );
 616 }
 617
 618 static inline ARDOUR::framepos_t
 619 track_frame_to_session_frame (ARDOUR::framepos_t track_frame, double speed)
 620 {
 621         return (ARDOUR::framepos_t)( (double)track_frame / speed );
 622 }
 623
 624 /* for now, break the rules and use "using" to make this "global" */
 625
 626 using ARDOUR::framepos_t;
 627
 628
 629 #endif /* __ardour_types_h__ */
 630