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