libs/ardour/ardour/types.h

   1 /*
   2     Copyright (C) 2002 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #ifndef __ardour_types_h__
  21 #define __ardour_types_h__
  22
  23 #include <istream>
  24 #include <vector>
  25 #include <map>
  26 #include <boost/shared_ptr.hpp>
  27 #include <sys/types.h>
  28 #include <stdint.h>
  29
  30 #include <inttypes.h>
  31 #include <jack/types.h>
  32 #include <jack/midiport.h>
  33
  34 #include "timecode/bbt_time.h"
  35 #include "timecode/time.h"
  36
  37 #include "pbd/id.h"
  38
  39 #include "evoral/Range.hpp"
  40
  41 #include "ardour/chan_count.h"
  42
  43 #include <map>
  44
  45 #if __GNUC__ < 3
  46 typedef int intptr_t;
  47 #endif
  48
  49 namespace ARDOUR {
  50
  51         class Source;
  52         class AudioSource;
  53         class Route;
  54         class Region;
  55
  56         typedef jack_default_audio_sample_t Sample;
  57         typedef float                       pan_t;
  58         typedef float                       gain_t;
  59         typedef uint32_t                    layer_t;
  60         typedef uint64_t                    microseconds_t;
  61         typedef jack_nframes_t              pframes_t;
  62
  63         /* Any position measured in audio frames.
  64            Assumed to be non-negative but not enforced.
  65         */
  66         typedef int64_t framepos_t;
  67
  68         /* Any distance from a given framepos_t.
  69            Maybe positive or negative.
  70         */
  71         typedef int64_t frameoffset_t;
  72
  73         /* Any count of audio frames.
  74            Assumed to be positive but not enforced.
  75         */
  76         typedef int64_t framecnt_t;
  77
  78         static const framepos_t max_framepos = INT64_MAX;
  79         static const framecnt_t max_framecnt = INT64_MAX;
  80         static const layer_t    max_layer    = UINT32_MAX;
  81
  82         // a set of (time) intervals: first of pair is the offset of the start within the region, second is the offset of the end
  83         typedef std::list<std::pair<frameoffset_t, frameoffset_t> > AudioIntervalResult;
  84         // associate a set of intervals with regions (e.g. for silence detection)
  85         typedef std::map<boost::shared_ptr<ARDOUR::Region>,AudioIntervalResult> AudioIntervalMap;
  86
  87         typedef std::list<boost::shared_ptr<Region> > RegionList;
  88
  89         struct IOChange {
  90
  91                 enum Type {
  92                         NoChange = 0,
  93                         ConfigurationChanged = 0x1,
  94                         ConnectionsChanged = 0x2
  95                 } type;
  96
  97                 IOChange () : type (NoChange) {}
  98                 IOChange (Type t) : type (t) {}
  99
 100                 /** channel count of IO before a ConfigurationChanged, if appropriate */
 101                 ARDOUR::ChanCount before;
 102                 /** channel count of IO after a ConfigurationChanged, if appropriate */
 103                 ARDOUR::ChanCount after;
 104         };
 105
 106         /* policies for inserting/pasting material where overlaps
 107            might be an issue.
 108         */
 109
 110         enum InsertMergePolicy {
 111                 InsertMergeReject,  // no overlaps allowed
 112                 InsertMergeRelax,   // we just don't care about overlaps
 113                 InsertMergeReplace, // replace old with new
 114                 InsertMergeTruncateExisting, // shorten existing to avoid overlap
 115                 InsertMergeTruncateAddition, // shorten new to avoid overlap
 116                 InsertMergeExtend   // extend new (or old) to the range of old+new
 117         };
 118
 119         /** See evoral/Parameter.hpp
 120          */
 121         enum AutomationType {
 122                 NullAutomation,
 123                 GainAutomation,
 124                 PanAzimuthAutomation,
 125                 PanElevationAutomation,
 126                 PanWidthAutomation,
 127                 PanFrontBackAutomation,
 128                 PanLFEAutomation,
 129                 PluginAutomation,
 130                 SoloAutomation,
 131                 MuteAutomation,
 132                 MidiCCAutomation,
 133                 MidiPgmChangeAutomation,
 134                 MidiPitchBenderAutomation,
 135                 MidiChannelPressureAutomation,
 136                 MidiSystemExclusiveAutomation,
 137                 FadeInAutomation,
 138                 FadeOutAutomation,
 139                 EnvelopeAutomation,
 140                 RecEnableAutomation
 141         };
 142
 143         enum AutoState {
 144                 Off = 0x0,
 145                 Write = 0x1,
 146                 Touch = 0x2,
 147                 Play = 0x4
 148         };
 149
 150         std::string auto_state_to_string (AutoState);
 151         AutoState string_to_auto_state (std::string);
 152
 153         enum AutoStyle {
 154                 Absolute = 0x1,
 155                 Trim = 0x2
 156         };
 157
 158         std::string auto_style_to_string (AutoStyle);
 159         AutoStyle string_to_auto_style (std::string);
 160
 161         enum AlignStyle {
 162                 CaptureTime,
 163                 ExistingMaterial
 164         };
 165
 166         enum AlignChoice {
 167                 UseCaptureTime,
 168                 UseExistingMaterial,
 169                 Automatic
 170         };
 171
 172         enum MeterPoint {
 173                 MeterInput,
 174                 MeterPreFader,
 175                 MeterPostFader,
 176                 MeterOutput,
 177                 MeterCustom
 178         };
 179
 180         enum MeterType {
 181                 MeterMaxSignal = 0x01,
 182                 MeterMaxPeak   = 0x02,
 183                 MeterPeak      = 0x04,
 184                 MeterKrms      = 0x08,
 185                 MeterIEC1      = 0x10,
 186                 MeterIEC2      = 0x20,
 187                 MeterVU        = 0x40
 188         };
 189
 190         enum TrackMode {
 191                 Normal,
 192                 NonLayered,
 193                 Destructive
 194         };
 195
 196         enum NoteMode {
 197                 Sustained,
 198                 Percussive
 199         };
 200
 201         enum ChannelMode {
 202                 AllChannels = 0, ///< Pass through all channel information unmodified
 203                 FilterChannels,  ///< Ignore events on certain channels
 204                 ForceChannel     ///< Force all events to a certain channel
 205         };
 206
 207         enum ColorMode {
 208                 MeterColors = 0,
 209                 ChannelColors,
 210                 TrackColor
 211         };
 212
 213         class AnyTime {
 214         public:
 215                 enum Type {
 216                         Timecode,
 217                         BBT,
 218                         Frames,
 219                         Seconds
 220                 };
 221
 222                 Type type;
 223
 224                 Timecode::Time     timecode;
 225                 Timecode::BBT_Time bbt;
 226
 227                 union {
 228                         framecnt_t     frames;
 229                         double         seconds;
 230                 };
 231
 232                 AnyTime() { type = Frames; frames = 0; }
 233
 234                 bool operator== (AnyTime const & other) const {
 235                         if (type != other.type) { return false; }
 236
 237                         switch (type) {
 238                           case Timecode:
 239                                 return timecode == other.timecode;
 240                           case BBT:
 241                                 return bbt == other.bbt;
 242                           case Frames:
 243                                 return frames == other.frames;
 244                           case Seconds:
 245                                 return seconds == other.seconds;
 246                         }
 247                         return false; // get rid of warning
 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                         /* NOTREACHED */
 265                         assert (false);
 266                         return false;
 267                 }
 268         };
 269
 270         /* XXX: slightly unfortunate that there is this and Evoral::Range<>,
 271            but this has a uint32_t id which Evoral::Range<> does not.
 272         */
 273         struct AudioRange {
 274                 framepos_t start;
 275                 framepos_t end;
 276                 uint32_t id;
 277
 278                 AudioRange (framepos_t s, framepos_t e, uint32_t i) : start (s), end (e) , id (i) {}
 279
 280                 framecnt_t length() { return end - start + 1; }
 281
 282                 bool operator== (const AudioRange& other) const {
 283                         return start == other.start && end == other.end && id == other.id;
 284                 }
 285
 286                 bool equal (const AudioRange& other) const {
 287                         return start == other.start && end == other.end;
 288                 }
 289
 290                 Evoral::OverlapType coverage (framepos_t s, framepos_t e) const {
 291                         return Evoral::coverage (start, end, s, e);
 292                 }
 293         };
 294
 295         struct MusicRange {
 296                 Timecode::BBT_Time start;
 297                 Timecode::BBT_Time end;
 298                 uint32_t id;
 299
 300                 MusicRange (Timecode::BBT_Time& s, Timecode::BBT_Time& e, uint32_t i)
 301                         : start (s), end (e), id (i) {}
 302
 303                 bool operator== (const MusicRange& other) const {
 304                         return start == other.start && end == other.end && id == other.id;
 305                 }
 306
 307                 bool equal (const MusicRange& other) const {
 308                         return start == other.start && end == other.end;
 309                 }
 310         };
 311
 312         /*
 313             Slowest = 6.6dB/sec falloff at update rate of 40ms
 314             Slow    = 6.8dB/sec falloff at update rate of 40ms
 315         */
 316
 317         enum MeterFalloff {
 318                 MeterFalloffOff = 0,
 319                 MeterFalloffSlowest = 1,
 320                 MeterFalloffSlow = 2,
 321                 MeterFalloffSlowish = 3,
 322                 MeterFalloffModerate = 4,
 323                 MeterFalloffMedium = 5,
 324                 MeterFalloffFast = 6,
 325                 MeterFalloffFaster = 7,
 326                 MeterFalloffFastest = 8,
 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 RouteSortOrderKey {
 354                 EditorSort,
 355                 MixerSort
 356         };
 357
 358         enum MonitorModel {
 359                 HardwareMonitoring, ///< JACK does monitoring
 360                 SoftwareMonitoring, ///< Ardour does monitoring
 361                 ExternalMonitoring  ///< we leave monitoring to the audio hardware
 362         };
 363
 364         enum MonitorChoice {
 365                 MonitorAuto = 0,
 366                 MonitorInput = 0x1,
 367                 MonitorDisk = 0x2,
 368                 MonitorCue = 0x4,
 369         };
 370
 371         enum MonitorState {
 372                 MonitoringSilence = 0x1,
 373                 MonitoringInput = 0x2,
 374                 MonitoringDisk = 0x4,
 375         };
 376
 377         enum MeterState {
 378                 MeteringInput, ///< meter the input IO, regardless of what is going through the route
 379                 MeteringRoute  ///< meter what is going through the route
 380         };
 381
 382         enum MeterLineUp {
 383                 MeteringLineUp24,
 384                 MeteringLineUp20,
 385                 MeteringLineUp18,
 386                 MeteringLineUp15
 387         };
 388
 389         enum PFLPosition {
 390                 /** PFL signals come from before pre-fader processors */
 391                 PFLFromBeforeProcessors,
 392                 /** PFL signals come pre-fader but after pre-fader processors */
 393                 PFLFromAfterProcessors
 394         };
 395
 396         enum AFLPosition {
 397                 /** AFL signals come post-fader and before post-fader processors */
 398                 AFLFromBeforeProcessors,
 399                 /** AFL signals come post-fader but after post-fader processors */
 400                 AFLFromAfterProcessors
 401         };
 402
 403         enum DenormalModel {
 404                 DenormalNone,
 405                 DenormalFTZ,
 406                 DenormalDAZ,
 407                 DenormalFTZDAZ
 408         };
 409
 410         enum RemoteModel {
 411                 UserOrdered,
 412                 MixerOrdered,
 413                 EditorOrdered
 414         };
 415
 416         enum CrossfadeModel {
 417                 FullCrossfade,
 418                 ShortCrossfade
 419         };
 420
 421         enum CrossfadeChoice {
 422                 RegionFades,
 423                 ConstantPowerMinus3dB,
 424                 ConstantPowerMinus6dB,
 425         };
 426
 427         enum ListenPosition {
 428                 AfterFaderListen,
 429                 PreFaderListen
 430         };
 431
 432         enum AutoConnectOption {
 433                 ManualConnect = 0x0,
 434                 AutoConnectPhysical = 0x1,
 435                 AutoConnectMaster = 0x2
 436         };
 437
 438         enum SampleFormat {
 439                 FormatFloat = 0,
 440                 FormatInt24,
 441                 FormatInt16
 442         };
 443
 444         enum CDMarkerFormat {
 445                 CDMarkerNone,
 446                 CDMarkerCUE,
 447                 CDMarkerTOC
 448         };
 449
 450         enum HeaderFormat {
 451                 BWF,
 452                 WAVE,
 453                 WAVE64,
 454                 CAF,
 455                 AIFF,
 456                 iXML,
 457                 RF64
 458         };
 459
 460         struct PeakData {
 461                 typedef Sample PeakDatum;
 462
 463                 PeakDatum min;
 464                 PeakDatum max;
 465         };
 466
 467         enum PluginType {
 468                 AudioUnit,
 469                 LADSPA,
 470                 LV2,
 471                 Windows_VST,
 472                 LXVST,
 473         };
 474
 475         enum RunContext {
 476                 ButlerContext = 0,
 477                 TransportContext,
 478                 ExportContext
 479         };
 480
 481         enum SyncSource {
 482                 JACK,
 483                 MTC,
 484                 MIDIClock,
 485                 LTC
 486         };
 487
 488         enum ShuttleBehaviour {
 489                 Sprung,
 490                 Wheel
 491         };
 492
 493         enum ShuttleUnits {
 494                 Percentage,
 495                 Semitones
 496         };
 497
 498         typedef std::vector<boost::shared_ptr<Source> > SourceList;
 499
 500         enum SrcQuality {
 501                 SrcBest,
 502                 SrcGood,
 503                 SrcQuick,
 504                 SrcFast,
 505                 SrcFastest
 506         };
 507
 508         typedef std::list<framepos_t> AnalysisFeatureList;
 509
 510         typedef std::list<boost::shared_ptr<Route> > RouteList;
 511         typedef std::list<boost::weak_ptr  <Route> > WeakRouteList;
 512
 513         class Bundle;
 514         typedef std::vector<boost::shared_ptr<Bundle> > BundleList;
 515
 516         enum WaveformScale {
 517                 Linear,
 518                 Logarithmic
 519         };
 520
 521         enum WaveformShape {
 522                 Traditional,
 523                 Rectified
 524         };
 525
 526         struct CleanupReport {
 527                 std::vector<std::string> paths;
 528                 size_t                   space;
 529         };
 530
 531         enum PositionLockStyle {
 532                 AudioTime,
 533                 MusicTime
 534         };
 535
 536         /** A struct used to describe changes to processors in a route.
 537          *  This is useful because objects that respond to a change in processors
 538          *  can optimise what work they do based on details of what has changed.
 539         */
 540         struct RouteProcessorChange {
 541                 enum Type {
 542                         GeneralChange = 0x0,
 543                         MeterPointChange = 0x1
 544                 };
 545
 546                 RouteProcessorChange () : type (GeneralChange), meter_visibly_changed (true)
 547                 {}
 548
 549                 RouteProcessorChange (Type t) : type (t), meter_visibly_changed (true)
 550                 {}
 551
 552                 RouteProcessorChange (Type t, bool m) : type (t), meter_visibly_changed (m)
 553                 {}
 554
 555                 /** type of change; "GeneralChange" means anything could have changed */
 556                 Type type;
 557                 /** true if, when a MeterPointChange has occurred, the change is visible to the user */
 558                 bool meter_visibly_changed;
 559         };
 560
 561         struct BusProfile {
 562                 AutoConnectOption input_ac;      /* override the RC config for input auto-connection */
 563                 AutoConnectOption output_ac;     /* override the RC config for output auto-connection */
 564                 uint32_t master_out_channels;    /* how many channels for the master bus */
 565                 uint32_t requested_physical_in;  /* now many of the available physical inputs to consider usable */
 566                 uint32_t requested_physical_out; /* now many of the available physical inputs to consider usable */
 567         };
 568
 569         enum FadeShape {
 570                 FadeLinear,
 571                 FadeFast,
 572                 FadeSlow,
 573                 FadeConstantPower,
 574                 FadeSymmetric,
 575         };
 576
 577 } // namespace ARDOUR
 578
 579
 580 /* these cover types declared above in this header. See enums.cc
 581    for the definitions.
 582 */
 583
 584 std::istream& operator>>(std::istream& o, ARDOUR::SampleFormat& sf);
 585 std::istream& operator>>(std::istream& o, ARDOUR::HeaderFormat& sf);
 586 std::istream& operator>>(std::istream& o, ARDOUR::AutoConnectOption& sf);
 587 std::istream& operator>>(std::istream& o, ARDOUR::EditMode& sf);
 588 std::istream& operator>>(std::istream& o, ARDOUR::MonitorModel& sf);
 589 std::istream& operator>>(std::istream& o, ARDOUR::MeterLineUp& sf);
 590 std::istream& operator>>(std::istream& o, ARDOUR::PFLPosition& sf);
 591 std::istream& operator>>(std::istream& o, ARDOUR::AFLPosition& sf);
 592 std::istream& operator>>(std::istream& o, ARDOUR::RemoteModel& sf);
 593 std::istream& operator>>(std::istream& o, ARDOUR::ListenPosition& sf);
 594 std::istream& operator>>(std::istream& o, ARDOUR::InsertMergePolicy& sf);
 595 std::istream& operator>>(std::istream& o, ARDOUR::CrossfadeModel& sf);
 596 std::istream& operator>>(std::istream& o, ARDOUR::CrossfadeChoice& sf);
 597 std::istream& operator>>(std::istream& o, ARDOUR::SyncSource& sf);
 598 std::istream& operator>>(std::istream& o, ARDOUR::ShuttleBehaviour& sf);
 599 std::istream& operator>>(std::istream& o, ARDOUR::ShuttleUnits& sf);
 600 std::istream& operator>>(std::istream& o, Timecode::TimecodeFormat& sf);
 601 std::istream& operator>>(std::istream& o, ARDOUR::DenormalModel& sf);
 602 std::istream& operator>>(std::istream& o, ARDOUR::WaveformScale& sf);
 603 std::istream& operator>>(std::istream& o, ARDOUR::WaveformShape& sf);
 604 std::istream& operator>>(std::istream& o, ARDOUR::PositionLockStyle& sf);
 605
 606 std::ostream& operator<<(std::ostream& o, const ARDOUR::SampleFormat& sf);
 607 std::ostream& operator<<(std::ostream& o, const ARDOUR::HeaderFormat& sf);
 608 std::ostream& operator<<(std::ostream& o, const ARDOUR::AutoConnectOption& sf);
 609 std::ostream& operator<<(std::ostream& o, const ARDOUR::EditMode& sf);
 610 std::ostream& operator<<(std::ostream& o, const ARDOUR::MonitorModel& sf);
 611 std::ostream& operator<<(std::ostream& o, const ARDOUR::MeterLineUp& sf);
 612 std::ostream& operator<<(std::ostream& o, const ARDOUR::PFLPosition& sf);
 613 std::ostream& operator<<(std::ostream& o, const ARDOUR::AFLPosition& sf);
 614 std::ostream& operator<<(std::ostream& o, const ARDOUR::RemoteModel& sf);
 615 std::ostream& operator<<(std::ostream& o, const ARDOUR::ListenPosition& sf);
 616 std::ostream& operator<<(std::ostream& o, const ARDOUR::InsertMergePolicy& sf);
 617 std::ostream& operator<<(std::ostream& o, const ARDOUR::CrossfadeModel& sf);
 618 std::ostream& operator<<(std::ostream& o, const ARDOUR::CrossfadeChoice& sf);
 619 std::ostream& operator<<(std::ostream& o, const ARDOUR::SyncSource& sf);
 620 std::ostream& operator<<(std::ostream& o, const ARDOUR::ShuttleBehaviour& sf);
 621 std::ostream& operator<<(std::ostream& o, const ARDOUR::ShuttleUnits& sf);
 622 std::ostream& operator<<(std::ostream& o, const Timecode::TimecodeFormat& sf);
 623 std::ostream& operator<<(std::ostream& o, const ARDOUR::DenormalModel& sf);
 624 std::ostream& operator<<(std::ostream& o, const ARDOUR::WaveformScale& sf);
 625 std::ostream& operator<<(std::ostream& o, const ARDOUR::WaveformShape& sf);
 626 std::ostream& operator<<(std::ostream& o, const ARDOUR::PositionLockStyle& sf);
 627
 628 static inline ARDOUR::framepos_t
 629 session_frame_to_track_frame (ARDOUR::framepos_t session_frame, double speed)
 630 {
 631         return (ARDOUR::framepos_t) ((long double) session_frame * (long double) speed);
 632 }
 633
 634 static inline ARDOUR::framepos_t
 635 track_frame_to_session_frame (ARDOUR::framepos_t track_frame, double speed)
 636 {
 637         return (ARDOUR::framepos_t) ((long double) track_frame / (long double) speed);
 638 }
 639
 640 /* for now, break the rules and use "using" to make this "global" */
 641
 642 using ARDOUR::framepos_t;
 643
 644
 645 #endif /* __ardour_types_h__ */
 646