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