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