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