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