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         };
 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                 OverlapType coverage (framepos_t s, framepos_t e) const {
 291                         return ARDOUR::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                 MeterFalloffMedium = 3,
 322                 MeterFalloffFast = 4,
 323                 MeterFalloffFaster = 5,
 324                 MeterFalloffFastest = 6
 325         };
 326
 327         enum MeterHold {
 328                 MeterHoldOff = 0,
 329                 MeterHoldShort = 40,
 330                 MeterHoldMedium = 100,
 331                 MeterHoldLong = 200
 332         };
 333
 334         enum EditMode {
 335                 Slide,
 336                 Splice,
 337                 Lock
 338         };
 339
 340         enum RegionPoint {
 341                 Start,
 342                 End,
 343                 SyncPoint
 344         };
 345
 346         enum Placement {
 347                 PreFader,
 348                 PostFader
 349         };
 350
 351         enum MonitorModel {
 352                 HardwareMonitoring,
 353                 SoftwareMonitoring,
 354                 ExternalMonitoring
 355         };
 356
 357         enum PFLPosition {
 358                 /** PFL signals come from before pre-fader processors */
 359                 PFLFromBeforeProcessors,
 360                 /** PFL signals come pre-fader but after pre-fader processors */
 361                 PFLFromAfterProcessors
 362         };
 363
 364         enum AFLPosition {
 365                 /** AFL signals come post-fader and before post-fader processors */
 366                 AFLFromBeforeProcessors,
 367                 /** AFL signals come post-fader but after post-fader processors */
 368                 AFLFromAfterProcessors
 369         };
 370
 371         enum DenormalModel {
 372                 DenormalNone,
 373                 DenormalFTZ,
 374                 DenormalDAZ,
 375                 DenormalFTZDAZ
 376         };
 377
 378         enum RemoteModel {
 379                 UserOrdered,
 380                 MixerOrdered,
 381                 EditorOrdered
 382         };
 383
 384         enum CrossfadeModel {
 385                 FullCrossfade,
 386                 ShortCrossfade
 387         };
 388
 389         enum LayerModel {
 390                 LaterHigher,
 391                 MoveAddHigher,
 392                 AddHigher
 393         };
 394
 395         enum ListenPosition {
 396                 AfterFaderListen,
 397                 PreFaderListen
 398         };
 399
 400         enum AutoConnectOption {
 401                 ManualConnect = 0x0,
 402                 AutoConnectPhysical = 0x1,
 403                 AutoConnectMaster = 0x2
 404         };
 405
 406         struct InterThreadInfo {
 407                 InterThreadInfo () : done (false), cancel (false), progress (0), thread (0) {}
 408
 409                 volatile bool  done;
 410                 volatile bool  cancel;
 411                 volatile float progress;
 412                 pthread_t      thread;
 413         };
 414
 415         enum SampleFormat {
 416                 FormatFloat = 0,
 417                 FormatInt24,
 418                 FormatInt16
 419         };
 420
 421         enum CDMarkerFormat {
 422                 CDMarkerNone,
 423                 CDMarkerCUE,
 424                 CDMarkerTOC
 425         };
 426
 427         enum HeaderFormat {
 428                 BWF,
 429                 WAVE,
 430                 WAVE64,
 431                 CAF,
 432                 AIFF,
 433                 iXML,
 434                 RF64
 435         };
 436
 437         struct PeakData {
 438                 typedef Sample PeakDatum;
 439
 440                 PeakDatum min;
 441                 PeakDatum max;
 442         };
 443
 444         enum PluginType {
 445                 AudioUnit,
 446                 LADSPA,
 447                 LV2,
 448                 VST
 449         };
 450
 451         enum RunContext {
 452                 ButlerContext = 0,
 453                 TransportContext,
 454                 ExportContext
 455         };
 456
 457         enum SyncSource {
 458                 JACK,
 459                 MTC,
 460                 MIDIClock
 461         };
 462
 463         enum ShuttleBehaviour {
 464                 Sprung,
 465                 Wheel
 466         };
 467
 468         enum ShuttleUnits {
 469                 Percentage,
 470                 Semitones
 471         };
 472
 473         typedef std::vector<boost::shared_ptr<Source> > SourceList;
 474
 475         enum SrcQuality {
 476                 SrcBest,
 477                 SrcGood,
 478                 SrcQuick,
 479                 SrcFast,
 480                 SrcFastest
 481         };
 482
 483         struct TimeFXRequest : public InterThreadInfo {
 484                 TimeFXRequest()
 485                         : time_fraction(0), pitch_fraction(0),
 486                         quick_seek(false), antialias(false),  opts(0) {}
 487                 float time_fraction;
 488                 float pitch_fraction;
 489                 /* SoundTouch */
 490                 bool  quick_seek;
 491                 bool  antialias;
 492                 /* RubberBand */
 493                 int   opts; // really RubberBandStretcher::Options
 494         };
 495
 496         typedef std::list<framepos_t> AnalysisFeatureList;
 497
 498         typedef std::list<boost::shared_ptr<Route> > RouteList;
 499         typedef std::list<boost::weak_ptr  <Route> > WeakRouteList;
 500
 501         class Bundle;
 502         typedef std::vector<boost::shared_ptr<Bundle> > BundleList;
 503
 504         enum WaveformScale {
 505                 Linear,
 506                 Logarithmic
 507         };
 508
 509         enum WaveformShape {
 510                 Traditional,
 511                 Rectified
 512         };
 513
 514         enum QuantizeType {
 515                 Plain,
 516                 Legato,
 517                 Groove
 518         };
 519
 520         struct CleanupReport {
 521                 std::vector<std::string> paths;
 522                 size_t                   space;
 523         };
 524
 525         enum PositionLockStyle {
 526                 AudioTime,
 527                 MusicTime
 528         };
 529
 530         /** A struct used to describe changes to processors in a route.
 531          *  This is useful because objects that respond to a change in processors
 532          *  can optimise what work they do based on details of what has changed.
 533         */
 534         struct RouteProcessorChange {
 535                 enum Type {
 536                         GeneralChange = 0x0,
 537                         MeterPointChange = 0x1
 538                 };
 539
 540                 RouteProcessorChange () : type (GeneralChange), meter_visibly_changed (true)
 541                 {}
 542
 543                 RouteProcessorChange (Type t) : type (t), meter_visibly_changed (true)
 544                 {}
 545
 546                 RouteProcessorChange (Type t, bool m) : type (t), meter_visibly_changed (m)
 547                 {}
 548
 549                 /** type of change; "GeneralChange" means anything could have changed */
 550                 Type type;
 551                 /** true if, when a MeterPointChange has occurred, the change is visible to the user */
 552                 bool meter_visibly_changed;
 553         };
 554
 555         struct BusProfile {
 556                 AutoConnectOption input_ac;      /* override the RC config for input auto-connection */
 557                 AutoConnectOption output_ac;     /* override the RC config for output auto-connection */
 558                 uint32_t master_out_channels;    /* how many channels for the master bus */
 559                 uint32_t requested_physical_in;  /* now many of the available physical inputs to consider usable */
 560                 uint32_t requested_physical_out; /* now many of the available physical inputs to consider usable */
 561         };
 562
 563         enum FadeShape {
 564                 FadeLinear,
 565                 FadeFast,
 566                 FadeSlow,
 567                 FadeLogA,
 568                 FadeLogB
 569         };
 570
 571 } // namespace ARDOUR
 572
 573
 574 /* these cover types declared above in this header. See enums.cc
 575    for the definitions.
 576 */
 577
 578 std::istream& operator>>(std::istream& o, ARDOUR::SampleFormat& sf);
 579 std::istream& operator>>(std::istream& o, ARDOUR::HeaderFormat& sf);
 580 std::istream& operator>>(std::istream& o, ARDOUR::AutoConnectOption& sf);
 581 std::istream& operator>>(std::istream& o, ARDOUR::EditMode& sf);
 582 std::istream& operator>>(std::istream& o, ARDOUR::MonitorModel& sf);
 583 std::istream& operator>>(std::istream& o, ARDOUR::PFLPosition& sf);
 584 std::istream& operator>>(std::istream& o, ARDOUR::AFLPosition& sf);
 585 std::istream& operator>>(std::istream& o, ARDOUR::RemoteModel& sf);
 586 std::istream& operator>>(std::istream& o, ARDOUR::ListenPosition& sf);
 587 std::istream& operator>>(std::istream& o, ARDOUR::LayerModel& sf);
 588 std::istream& operator>>(std::istream& o, ARDOUR::InsertMergePolicy& sf);
 589 std::istream& operator>>(std::istream& o, ARDOUR::CrossfadeModel& sf);
 590 std::istream& operator>>(std::istream& o, ARDOUR::SyncSource& sf);
 591 std::istream& operator>>(std::istream& o, ARDOUR::ShuttleBehaviour& sf);
 592 std::istream& operator>>(std::istream& o, ARDOUR::ShuttleUnits& sf);
 593 std::istream& operator>>(std::istream& o, ARDOUR::TimecodeFormat& sf);
 594 std::istream& operator>>(std::istream& o, ARDOUR::DenormalModel& sf);
 595 std::istream& operator>>(std::istream& o, ARDOUR::WaveformScale& sf);
 596 std::istream& operator>>(std::istream& o, ARDOUR::WaveformShape& sf);
 597 std::istream& operator>>(std::istream& o, ARDOUR::PositionLockStyle& sf);
 598
 599 std::ostream& operator<<(std::ostream& o, const ARDOUR::SampleFormat& sf);
 600 std::ostream& operator<<(std::ostream& o, const ARDOUR::HeaderFormat& sf);
 601 std::ostream& operator<<(std::ostream& o, const ARDOUR::AutoConnectOption& sf);
 602 std::ostream& operator<<(std::ostream& o, const ARDOUR::EditMode& sf);
 603 std::ostream& operator<<(std::ostream& o, const ARDOUR::MonitorModel& sf);
 604 std::ostream& operator<<(std::ostream& o, const ARDOUR::PFLPosition& sf);
 605 std::ostream& operator<<(std::ostream& o, const ARDOUR::AFLPosition& sf);
 606 std::ostream& operator<<(std::ostream& o, const ARDOUR::RemoteModel& sf);
 607 std::ostream& operator<<(std::ostream& o, const ARDOUR::ListenPosition& sf);
 608 std::ostream& operator<<(std::ostream& o, const ARDOUR::LayerModel& sf);
 609 std::ostream& operator<<(std::ostream& o, const ARDOUR::InsertMergePolicy& sf);
 610 std::ostream& operator<<(std::ostream& o, const ARDOUR::CrossfadeModel& sf);
 611 std::ostream& operator<<(std::ostream& o, const ARDOUR::SyncSource& sf);
 612 std::ostream& operator<<(std::ostream& o, const ARDOUR::ShuttleBehaviour& sf);
 613 std::ostream& operator<<(std::ostream& o, const ARDOUR::ShuttleUnits& sf);
 614 std::ostream& operator<<(std::ostream& o, const ARDOUR::TimecodeFormat& sf);
 615 std::ostream& operator<<(std::ostream& o, const ARDOUR::DenormalModel& sf);
 616 std::ostream& operator<<(std::ostream& o, const ARDOUR::WaveformScale& sf);
 617 std::ostream& operator<<(std::ostream& o, const ARDOUR::WaveformShape& sf);
 618 std::ostream& operator<<(std::ostream& o, const ARDOUR::PositionLockStyle& sf);
 619
 620 static inline ARDOUR::framepos_t
 621 session_frame_to_track_frame (ARDOUR::framepos_t session_frame, double speed)
 622 {
 623         return (ARDOUR::framepos_t) ((long double) session_frame * (long double) speed);
 624 }
 625
 626 static inline ARDOUR::framepos_t
 627 track_frame_to_session_frame (ARDOUR::framepos_t track_frame, double speed)
 628 {
 629         return (ARDOUR::framepos_t) ((long double) track_frame / (long double) speed);
 630 }
 631
 632 /* for now, break the rules and use "using" to make this "global" */
 633
 634 using ARDOUR::framepos_t;
 635
 636
 637 #endif /* __ardour_types_h__ */
 638