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 AlignChoice {
 172                 UseCaptureTime,
 173                 UseExistingMaterial,
 174                 Automatic
 175         };
 176
 177         enum MeterPoint {
 178                 MeterInput,
 179                 MeterPreFader,
 180                 MeterPostFader,
 181                 MeterOutput,
 182                 MeterCustom
 183         };
 184
 185         enum TrackMode {
 186                 Normal,
 187                 NonLayered,
 188                 Destructive
 189         };
 190
 191         enum NoteMode {
 192                 Sustained,
 193                 Percussive
 194         };
 195
 196         enum ChannelMode {
 197                 AllChannels = 0, ///< Pass through all channel information unmodified
 198                 FilterChannels,  ///< Ignore events on certain channels
 199                 ForceChannel     ///< Force all events to a certain channel
 200         };
 201
 202         enum ColorMode {
 203                 MeterColors = 0,
 204                 ChannelColors,
 205                 TrackColor
 206         };
 207
 208         enum TimecodeFormat {
 209                 timecode_23976,
 210                 timecode_24,
 211                 timecode_24976,
 212                 timecode_25,
 213                 timecode_2997,
 214                 timecode_2997drop,
 215                 timecode_30,
 216                 timecode_30drop,
 217                 timecode_5994,
 218                 timecode_60
 219         };
 220
 221         struct AnyTime {
 222                 enum Type {
 223                         Timecode,
 224                         BBT,
 225                         Frames,
 226                         Seconds
 227                 };
 228
 229                 Type type;
 230
 231                 Timecode::Time     timecode;
 232                 Timecode::BBT_Time bbt;
 233
 234                 union {
 235                         framecnt_t     frames;
 236                         double         seconds;
 237                 };
 238
 239                 AnyTime() { type = Frames; frames = 0; }
 240
 241                 bool operator== (AnyTime const & other) const {
 242                         if (type != other.type) { return false; }
 243
 244                         switch (type) {
 245                           case Timecode:
 246                                 return timecode == other.timecode;
 247                           case BBT:
 248                                 return bbt == other.bbt;
 249                           case Frames:
 250                                 return frames == other.frames;
 251                           case Seconds:
 252                                 return seconds == other.seconds;
 253                         }
 254                         return false; // get rid of warning
 255                 }
 256
 257                 bool not_zero() const
 258                 {
 259                         switch (type) {
 260                           case Timecode:
 261                                 return timecode.hours != 0 || timecode.minutes != 0 ||
 262                                        timecode.seconds != 0 || timecode.frames != 0;
 263                           case BBT:
 264                                 return bbt.bars != 0 || bbt.beats != 0 || bbt.ticks != 0;
 265                           case Frames:
 266                                 return frames != 0;
 267                           case Seconds:
 268                                 return seconds != 0;
 269                         }
 270
 271                         /* NOTREACHED */
 272                         assert (false);
 273                         return false;
 274                 }
 275         };
 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                 OverlapType coverage (framepos_t s, framepos_t e) const {
 295                         return ARDOUR::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                 MeterFalloffMedium = 3,
 326                 MeterFalloffFast = 4,
 327                 MeterFalloffFaster = 5,
 328                 MeterFalloffFastest = 6
 329         };
 330
 331         enum MeterHold {
 332                 MeterHoldOff = 0,
 333                 MeterHoldShort = 40,
 334                 MeterHoldMedium = 100,
 335                 MeterHoldLong = 200
 336         };
 337
 338         enum EditMode {
 339                 Slide,
 340                 Splice,
 341                 Lock
 342         };
 343
 344         enum RegionPoint {
 345                 Start,
 346                 End,
 347                 SyncPoint
 348         };
 349
 350         enum Placement {
 351                 PreFader,
 352                 PostFader
 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 PFLPosition {
 375                 /** PFL signals come from before pre-fader processors */
 376                 PFLFromBeforeProcessors,
 377                 /** PFL signals come pre-fader but after pre-fader processors */
 378                 PFLFromAfterProcessors
 379         };
 380
 381         enum AFLPosition {
 382                 /** AFL signals come post-fader and before post-fader processors */
 383                 AFLFromBeforeProcessors,
 384                 /** AFL signals come post-fader but after post-fader processors */
 385                 AFLFromAfterProcessors
 386         };
 387
 388         enum DenormalModel {
 389                 DenormalNone,
 390                 DenormalFTZ,
 391                 DenormalDAZ,
 392                 DenormalFTZDAZ
 393         };
 394
 395         enum RemoteModel {
 396                 UserOrdered,
 397                 MixerOrdered,
 398                 EditorOrdered
 399         };
 400
 401         enum CrossfadeModel {
 402                 FullCrossfade,
 403                 ShortCrossfade
 404         };
 405
 406         enum LayerModel {
 407                 LaterHigher,
 408                 MoveAddHigher,
 409                 AddHigher
 410         };
 411
 412         enum ListenPosition {
 413                 AfterFaderListen,
 414                 PreFaderListen
 415         };
 416
 417         enum AutoConnectOption {
 418                 ManualConnect = 0x0,
 419                 AutoConnectPhysical = 0x1,
 420                 AutoConnectMaster = 0x2
 421         };
 422
 423         struct InterThreadInfo {
 424                 InterThreadInfo () : done (false), cancel (false), progress (0), thread (0) {}
 425
 426                 volatile bool  done;
 427                 volatile bool  cancel;
 428                 volatile float progress;
 429                 pthread_t      thread;
 430         };
 431
 432         enum SampleFormat {
 433                 FormatFloat = 0,
 434                 FormatInt24,
 435                 FormatInt16
 436         };
 437
 438         enum CDMarkerFormat {
 439                 CDMarkerNone,
 440                 CDMarkerCUE,
 441                 CDMarkerTOC
 442         };
 443
 444         enum HeaderFormat {
 445                 BWF,
 446                 WAVE,
 447                 WAVE64,
 448                 CAF,
 449                 AIFF,
 450                 iXML,
 451                 RF64
 452         };
 453
 454         struct PeakData {
 455                 typedef Sample PeakDatum;
 456
 457                 PeakDatum min;
 458                 PeakDatum max;
 459         };
 460
 461         enum PluginType {
 462                 AudioUnit,
 463                 LADSPA,
 464                 LV2,
 465                 Windows_VST,
 466                 LXVST,
 467         };
 468
 469         enum RunContext {
 470                 ButlerContext = 0,
 471                 TransportContext,
 472                 ExportContext
 473         };
 474
 475         enum SyncSource {
 476                 JACK,
 477                 MTC,
 478                 MIDIClock
 479         };
 480
 481         enum ShuttleBehaviour {
 482                 Sprung,
 483                 Wheel
 484         };
 485
 486         enum ShuttleUnits {
 487                 Percentage,
 488                 Semitones
 489         };
 490
 491         typedef std::vector<boost::shared_ptr<Source> > SourceList;
 492
 493         enum SrcQuality {
 494                 SrcBest,
 495                 SrcGood,
 496                 SrcQuick,
 497                 SrcFast,
 498                 SrcFastest
 499         };
 500
 501         struct TimeFXRequest : public InterThreadInfo {
 502                 TimeFXRequest()
 503                         : time_fraction(0), pitch_fraction(0),
 504                         quick_seek(false), antialias(false),  opts(0) {}
 505                 float time_fraction;
 506                 float pitch_fraction;
 507                 /* SoundTouch */
 508                 bool  quick_seek;
 509                 bool  antialias;
 510                 /* RubberBand */
 511                 int   opts; // really RubberBandStretcher::Options
 512         };
 513
 514         typedef std::list<framepos_t> AnalysisFeatureList;
 515
 516         typedef std::list<boost::shared_ptr<Route> > RouteList;
 517         typedef std::list<boost::weak_ptr  <Route> > WeakRouteList;
 518
 519         class Bundle;
 520         typedef std::vector<boost::shared_ptr<Bundle> > BundleList;
 521
 522         enum WaveformScale {
 523                 Linear,
 524                 Logarithmic
 525         };
 526
 527         enum WaveformShape {
 528                 Traditional,
 529                 Rectified
 530         };
 531
 532         enum QuantizeType {
 533                 Plain,
 534                 Legato,
 535                 Groove
 536         };
 537
 538         struct CleanupReport {
 539                 std::vector<std::string> paths;
 540                 size_t                   space;
 541         };
 542
 543         enum PositionLockStyle {
 544                 AudioTime,
 545                 MusicTime
 546         };
 547
 548         /** A struct used to describe changes to processors in a route.
 549          *  This is useful because objects that respond to a change in processors
 550          *  can optimise what work they do based on details of what has changed.
 551         */
 552         struct RouteProcessorChange {
 553                 enum Type {
 554                         GeneralChange = 0x0,
 555                         MeterPointChange = 0x1
 556                 };
 557
 558                 RouteProcessorChange () : type (GeneralChange), meter_visibly_changed (true)
 559                 {}
 560
 561                 RouteProcessorChange (Type t) : type (t), meter_visibly_changed (true)
 562                 {}
 563
 564                 RouteProcessorChange (Type t, bool m) : type (t), meter_visibly_changed (m)
 565                 {}
 566
 567                 /** type of change; "GeneralChange" means anything could have changed */
 568                 Type type;
 569                 /** true if, when a MeterPointChange has occurred, the change is visible to the user */
 570                 bool meter_visibly_changed;
 571         };
 572
 573         struct BusProfile {
 574                 AutoConnectOption input_ac;      /* override the RC config for input auto-connection */
 575                 AutoConnectOption output_ac;     /* override the RC config for output auto-connection */
 576                 uint32_t master_out_channels;    /* how many channels for the master bus */
 577                 uint32_t requested_physical_in;  /* now many of the available physical inputs to consider usable */
 578                 uint32_t requested_physical_out; /* now many of the available physical inputs to consider usable */
 579         };
 580
 581         enum FadeShape {
 582                 FadeLinear,
 583                 FadeFast,
 584                 FadeSlow,
 585                 FadeLogA,
 586                 FadeLogB
 587         };
 588
 589 } // namespace ARDOUR
 590
 591
 592 /* these cover types declared above in this header. See enums.cc
 593    for the definitions.
 594 */
 595
 596 std::istream& operator>>(std::istream& o, ARDOUR::SampleFormat& sf);
 597 std::istream& operator>>(std::istream& o, ARDOUR::HeaderFormat& sf);
 598 std::istream& operator>>(std::istream& o, ARDOUR::AutoConnectOption& sf);
 599 std::istream& operator>>(std::istream& o, ARDOUR::EditMode& sf);
 600 std::istream& operator>>(std::istream& o, ARDOUR::MonitorModel& sf);
 601 std::istream& operator>>(std::istream& o, ARDOUR::PFLPosition& sf);
 602 std::istream& operator>>(std::istream& o, ARDOUR::AFLPosition& sf);
 603 std::istream& operator>>(std::istream& o, ARDOUR::RemoteModel& sf);
 604 std::istream& operator>>(std::istream& o, ARDOUR::ListenPosition& sf);
 605 std::istream& operator>>(std::istream& o, ARDOUR::LayerModel& 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::SyncSource& sf);
 609 std::istream& operator>>(std::istream& o, ARDOUR::ShuttleBehaviour& sf);
 610 std::istream& operator>>(std::istream& o, ARDOUR::ShuttleUnits& sf);
 611 std::istream& operator>>(std::istream& o, ARDOUR::TimecodeFormat& sf);
 612 std::istream& operator>>(std::istream& o, ARDOUR::DenormalModel& sf);
 613 std::istream& operator>>(std::istream& o, ARDOUR::WaveformScale& sf);
 614 std::istream& operator>>(std::istream& o, ARDOUR::WaveformShape& sf);
 615 std::istream& operator>>(std::istream& o, ARDOUR::PositionLockStyle& sf);
 616
 617 std::ostream& operator<<(std::ostream& o, const ARDOUR::SampleFormat& sf);
 618 std::ostream& operator<<(std::ostream& o, const ARDOUR::HeaderFormat& sf);
 619 std::ostream& operator<<(std::ostream& o, const ARDOUR::AutoConnectOption& sf);
 620 std::ostream& operator<<(std::ostream& o, const ARDOUR::EditMode& sf);
 621 std::ostream& operator<<(std::ostream& o, const ARDOUR::MonitorModel& sf);
 622 std::ostream& operator<<(std::ostream& o, const ARDOUR::PFLPosition& sf);
 623 std::ostream& operator<<(std::ostream& o, const ARDOUR::AFLPosition& sf);
 624 std::ostream& operator<<(std::ostream& o, const ARDOUR::RemoteModel& sf);
 625 std::ostream& operator<<(std::ostream& o, const ARDOUR::ListenPosition& sf);
 626 std::ostream& operator<<(std::ostream& o, const ARDOUR::LayerModel& sf);
 627 std::ostream& operator<<(std::ostream& o, const ARDOUR::InsertMergePolicy& sf);
 628 std::ostream& operator<<(std::ostream& o, const ARDOUR::CrossfadeModel& sf);
 629 std::ostream& operator<<(std::ostream& o, const ARDOUR::SyncSource& sf);
 630 std::ostream& operator<<(std::ostream& o, const ARDOUR::ShuttleBehaviour& sf);
 631 std::ostream& operator<<(std::ostream& o, const ARDOUR::ShuttleUnits& sf);
 632 std::ostream& operator<<(std::ostream& o, const ARDOUR::TimecodeFormat& sf);
 633 std::ostream& operator<<(std::ostream& o, const ARDOUR::DenormalModel& sf);
 634 std::ostream& operator<<(std::ostream& o, const ARDOUR::WaveformScale& sf);
 635 std::ostream& operator<<(std::ostream& o, const ARDOUR::WaveformShape& sf);
 636 std::ostream& operator<<(std::ostream& o, const ARDOUR::PositionLockStyle& sf);
 637
 638 static inline ARDOUR::framepos_t
 639 session_frame_to_track_frame (ARDOUR::framepos_t session_frame, double speed)
 640 {
 641         return (ARDOUR::framepos_t) ((long double) session_frame * (long double) speed);
 642 }
 643
 644 static inline ARDOUR::framepos_t
 645 track_frame_to_session_frame (ARDOUR::framepos_t track_frame, double speed)
 646 {
 647         return (ARDOUR::framepos_t) ((long double) track_frame / (long double) speed);
 648 }
 649
 650 /* for now, break the rules and use "using" to make this "global" */
 651
 652 using ARDOUR::framepos_t;
 653
 654
 655 #endif /* __ardour_types_h__ */
 656