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 #include <pthread.h>
  30
  31 #include <inttypes.h>
  32
  33 #include "timecode/bbt_time.h"
  34 #include "timecode/time.h"
  35
  36 #include "pbd/id.h"
  37
  38 #include "evoral/Range.hpp"
  39
  40 #include "ardour/chan_count.h"
  41 #include "ardour/plugin_types.h"
  42
  43 #include <map>
  44
  45 #if __GNUC__ < 3
  46 typedef int intptr_t;
  47 #endif
  48
  49 namespace ARDOUR {
  50
  51         class Source;
  52         class AudioSource;
  53         class Route;
  54         class Region;
  55         class Stripable;
  56         class VCA;
  57         class AutomationControl;
  58
  59         typedef float    Sample;
  60         typedef float    pan_t;
  61         typedef float    gain_t;
  62         typedef uint32_t layer_t;
  63         typedef uint64_t microseconds_t;
  64         typedef uint32_t pframes_t;
  65
  66         /* Any position measured in audio frames.
  67            Assumed to be non-negative but not enforced.
  68         */
  69         typedef int64_t framepos_t;
  70
  71         /* Any distance from a given framepos_t.
  72            Maybe positive or negative.
  73         */
  74         typedef int64_t frameoffset_t;
  75
  76         /* Any count of audio frames.
  77            Assumed to be positive but not enforced.
  78         */
  79         typedef int64_t framecnt_t;
  80
  81         static const framepos_t max_framepos = INT64_MAX;
  82         static const framecnt_t max_framecnt = INT64_MAX;
  83         static const layer_t    max_layer    = UINT32_MAX;
  84
  85         // a set of (time) intervals: first of pair is the offset of the start within the region, second is the offset of the end
  86         typedef std::list<std::pair<frameoffset_t, frameoffset_t> > AudioIntervalResult;
  87         // associate a set of intervals with regions (e.g. for silence detection)
  88         typedef std::map<boost::shared_ptr<ARDOUR::Region>,AudioIntervalResult> AudioIntervalMap;
  89
  90         typedef std::list<boost::shared_ptr<Region> > RegionList;
  91
  92         struct IOChange {
  93
  94                 enum Type {
  95                         NoChange = 0,
  96                         ConfigurationChanged = 0x1,
  97                         ConnectionsChanged = 0x2
  98                 } type;
  99
 100                 IOChange () : type (NoChange) {}
 101                 IOChange (Type t) : type (t) {}
 102
 103                 /** channel count of IO before a ConfigurationChanged, if appropriate */
 104                 ARDOUR::ChanCount before;
 105                 /** channel count of IO after a ConfigurationChanged, if appropriate */
 106                 ARDOUR::ChanCount after;
 107         };
 108
 109         /* policies for inserting/pasting material where overlaps
 110            might be an issue.
 111         */
 112
 113         enum InsertMergePolicy {
 114                 InsertMergeReject,  ///< no overlaps allowed
 115                 InsertMergeRelax,   ///< we just don't care about overlaps
 116                 InsertMergeReplace, ///< replace old with new
 117                 InsertMergeTruncateExisting, ///< shorten existing to avoid overlap
 118                 InsertMergeTruncateAddition, ///< shorten new to avoid overlap
 119                 InsertMergeExtend   ///< extend new (or old) to the range of old+new
 120         };
 121
 122         /** See evoral/Parameter.hpp
 123          *
 124          * When you add things here, you REALLY SHOULD add a case clause to
 125          * the constructor of ParameterDescriptor, unless the Controllables
 126          * that the enum refers to are completely standard (0-1.0 range, 0.0 as
 127          * normal, non-toggled, non-enumerated). Anything else needs to be
 128          * added there so that things that try to represent them can do so
 129          * with as much information as possible.
 130          */
 131         enum AutomationType {
 132                 NullAutomation,
 133                 GainAutomation,
 134                 PanAzimuthAutomation,
 135                 PanElevationAutomation,
 136                 PanWidthAutomation,
 137                 PanFrontBackAutomation,
 138                 PanLFEAutomation,
 139                 PluginAutomation,
 140                 PluginPropertyAutomation,
 141                 SoloAutomation,
 142                 SoloIsolateAutomation,
 143                 SoloSafeAutomation,
 144                 MuteAutomation,
 145                 MidiCCAutomation,
 146                 MidiPgmChangeAutomation,
 147                 MidiPitchBenderAutomation,
 148                 MidiChannelPressureAutomation,
 149                 MidiNotePressureAutomation,
 150                 MidiSystemExclusiveAutomation,
 151                 FadeInAutomation,
 152                 FadeOutAutomation,
 153                 EnvelopeAutomation,
 154                 RecEnableAutomation,
 155                 RecSafeAutomation,
 156                 TrimAutomation,
 157                 PhaseAutomation,
 158                 MonitoringAutomation,
 159                 EQGain,
 160                 EQFrequency,
 161                 EQQ,
 162                 EQShape,
 163                 EQEnable,
 164                 EQHPF,
 165                 EQLPF,
 166                 EQFilterEnable,
 167                 CompThreshold,
 168                 CompSpeed,
 169                 CompMode,
 170                 CompMakeup,
 171                 CompRedux,
 172                 CompEnable,
 173                 BusSendLevel,
 174                 BusSendEnable,
 175         };
 176
 177         enum AutoState {
 178                 Off = 0x0,
 179                 Write = 0x1,
 180                 Touch = 0x2,
 181                 Play = 0x4
 182         };
 183
 184         std::string auto_state_to_string (AutoState);
 185         AutoState string_to_auto_state (std::string);
 186
 187         enum AlignStyle {
 188                 CaptureTime,
 189                 ExistingMaterial
 190         };
 191
 192         enum AlignChoice {
 193                 UseCaptureTime,
 194                 UseExistingMaterial,
 195                 Automatic
 196         };
 197
 198         enum MeterPoint {
 199                 MeterInput,
 200                 MeterPreFader,
 201                 MeterPostFader,
 202                 MeterOutput,
 203                 MeterCustom
 204         };
 205
 206         enum MeterType {
 207                 MeterMaxSignal = 0x0001,
 208                 MeterMaxPeak   = 0x0002,
 209                 MeterPeak      = 0x0004,
 210                 MeterKrms      = 0x0008,
 211                 MeterK20       = 0x0010,
 212                 MeterK14       = 0x0020,
 213                 MeterIEC1DIN   = 0x0040,
 214                 MeterIEC1NOR   = 0x0080,
 215                 MeterIEC2BBC   = 0x0100,
 216                 MeterIEC2EBU   = 0x0200,
 217                 MeterVU        = 0x0400,
 218                 MeterK12       = 0x0800,
 219                 MeterPeak0dB   = 0x1000,
 220                 MeterMCP       = 0x2000
 221         };
 222
 223         enum TrackMode {
 224                 Normal,
 225                 NonLayered,
 226                 Destructive
 227         };
 228
 229         enum NoteMode {
 230                 Sustained,
 231                 Percussive
 232         };
 233
 234         enum ChannelMode {
 235                 AllChannels = 0, ///< Pass through all channel information unmodified
 236                 FilterChannels,  ///< Ignore events on certain channels
 237                 ForceChannel     ///< Force all events to a certain channel
 238         };
 239
 240         enum ColorMode {
 241                 MeterColors = 0,
 242                 ChannelColors,
 243                 TrackColor
 244         };
 245
 246         enum RoundMode {
 247                 RoundDownMaybe  = -2,  ///< Round down only if necessary
 248                 RoundDownAlways = -1,  ///< Always round down, even if on a division
 249                 RoundNearest    = 0,   ///< Round to nearest
 250                 RoundUpAlways   = 1,   ///< Always round up, even if on a division
 251                 RoundUpMaybe    = 2    ///< Round up only if necessary
 252         };
 253
 254         class AnyTime {
 255         public:
 256                 enum Type {
 257                         Timecode,
 258                         BBT,
 259                         Frames,
 260                         Seconds
 261                 };
 262
 263                 Type type;
 264
 265                 Timecode::Time     timecode;
 266                 Timecode::BBT_Time bbt;
 267
 268                 union {
 269                         framecnt_t     frames;
 270                         double         seconds;
 271                 };
 272
 273                 AnyTime() { type = Frames; frames = 0; }
 274
 275                 bool operator== (AnyTime const & other) const {
 276                         if (type != other.type) { return false; }
 277
 278                         switch (type) {
 279                           case Timecode:
 280                                 return timecode == other.timecode;
 281                           case BBT:
 282                                 return bbt == other.bbt;
 283                           case Frames:
 284                                 return frames == other.frames;
 285                           case Seconds:
 286                                 return seconds == other.seconds;
 287                         }
 288                         return false; // get rid of warning
 289                 }
 290
 291                 bool not_zero() const
 292                 {
 293                         switch (type) {
 294                           case Timecode:
 295                                 return timecode.hours != 0 || timecode.minutes != 0 ||
 296                                        timecode.seconds != 0 || timecode.frames != 0;
 297                           case BBT:
 298                                 return bbt.bars != 0 || bbt.beats != 0 || bbt.ticks != 0;
 299                           case Frames:
 300                                 return frames != 0;
 301                           case Seconds:
 302                                 return seconds != 0;
 303                         }
 304
 305                         abort(); /* NOTREACHED */
 306                         return false;
 307                 }
 308         };
 309
 310         /* used for translating audio frames to an exact musical position using a note divisor.
 311            an exact musical position almost never falls exactly on an audio frame, but for sub-sample
 312            musical accuracy we need to derive exact musical locations from a frame position
 313            the division follows TempoMap::exact_beat_at_frame().
 314            division
 315            -1       musical location is the bar closest to frame
 316             0       musical location is the musical position of the frame
 317             1       musical location is the BBT beat closest to frame
 318             n       musical location is the quarter-note division n closest to frame
 319         */
 320         struct MusicFrame {
 321                 framepos_t frame;
 322                 int32_t    division;
 323
 324                 MusicFrame (framepos_t f, int32_t d) : frame (f), division (d) {}
 325
 326                 void set (framepos_t f, int32_t d) {frame = f; division = d; }
 327
 328                 MusicFrame operator- (MusicFrame other) { return MusicFrame (frame - other.frame, 0); }
 329         };
 330
 331         /* XXX: slightly unfortunate that there is this and Evoral::Range<>,
 332            but this has a uint32_t id which Evoral::Range<> does not.
 333         */
 334         struct AudioRange {
 335                 framepos_t start;
 336                 framepos_t end;
 337                 uint32_t id;
 338
 339                 AudioRange (framepos_t s, framepos_t e, uint32_t i) : start (s), end (e) , id (i) {}
 340
 341                 framecnt_t length() const { return end - start + 1; }
 342
 343                 bool operator== (const AudioRange& other) const {
 344                         return start == other.start && end == other.end && id == other.id;
 345                 }
 346
 347                 bool equal (const AudioRange& other) const {
 348                         return start == other.start && end == other.end;
 349                 }
 350
 351                 Evoral::OverlapType coverage (framepos_t s, framepos_t e) const {
 352                         return Evoral::coverage (start, end, s, e);
 353                 }
 354         };
 355
 356         struct MusicRange {
 357                 Timecode::BBT_Time start;
 358                 Timecode::BBT_Time end;
 359                 uint32_t id;
 360
 361                 MusicRange (Timecode::BBT_Time& s, Timecode::BBT_Time& e, uint32_t i)
 362                         : start (s), end (e), id (i) {}
 363
 364                 bool operator== (const MusicRange& other) const {
 365                         return start == other.start && end == other.end && id == other.id;
 366                 }
 367
 368                 bool equal (const MusicRange& other) const {
 369                         return start == other.start && end == other.end;
 370                 }
 371         };
 372
 373         /*
 374             Slowest = 6.6dB/sec falloff at update rate of 40ms
 375             Slow    = 6.8dB/sec falloff at update rate of 40ms
 376         */
 377
 378         enum MeterFalloff {
 379                 MeterFalloffOff = 0,
 380                 MeterFalloffSlowest = 1,
 381                 MeterFalloffSlow = 2,
 382                 MeterFalloffSlowish = 3,
 383                 MeterFalloffModerate = 4,
 384                 MeterFalloffMedium = 5,
 385                 MeterFalloffFast = 6,
 386                 MeterFalloffFaster = 7,
 387                 MeterFalloffFastest = 8,
 388         };
 389
 390         enum MeterHold {
 391                 MeterHoldOff = 0,
 392                 MeterHoldShort = 40,
 393                 MeterHoldMedium = 100,
 394                 MeterHoldLong = 200
 395         };
 396
 397         enum EditMode {
 398                 Slide,
 399                 Splice,
 400                 Ripple,
 401                 Lock
 402         };
 403
 404         enum RegionSelectionAfterSplit {
 405                 None = 0,
 406                 NewlyCreatedLeft = 1,  // bit 0
 407                 NewlyCreatedRight = 2, // bit 1
 408                 NewlyCreatedBoth = 3,
 409                 Existing = 4,          // bit 2
 410                 ExistingNewlyCreatedLeft = 5,
 411                 ExistingNewlyCreatedRight = 6,
 412                 ExistingNewlyCreatedBoth = 7
 413         };
 414
 415         enum RegionPoint {
 416                 Start,
 417                 End,
 418                 SyncPoint
 419         };
 420
 421         enum Placement {
 422                 PreFader,
 423                 PostFader
 424         };
 425
 426         enum MonitorModel {
 427                 HardwareMonitoring, ///< JACK does monitoring
 428                 SoftwareMonitoring, ///< Ardour does monitoring
 429                 ExternalMonitoring  ///< we leave monitoring to the audio hardware
 430         };
 431
 432         enum MonitorChoice {
 433                 MonitorAuto = 0,
 434                 MonitorInput = 0x1,
 435                 MonitorDisk = 0x2,
 436                 MonitorCue = 0x4,
 437         };
 438
 439         enum MonitorState {
 440                 MonitoringSilence = 0x1,
 441                 MonitoringInput = 0x2,
 442                 MonitoringDisk = 0x4,
 443         };
 444
 445         enum MeterState {
 446                 MeteringInput, ///< meter the input IO, regardless of what is going through the route
 447                 MeteringRoute  ///< meter what is going through the route
 448         };
 449
 450         enum VUMeterStandard {
 451                 MeteringVUfrench,   // 0VU = -2dBu
 452                 MeteringVUamerican, // 0VU =  0dBu
 453                 MeteringVUstandard, // 0VU = +4dBu
 454                 MeteringVUeight     // 0VU = +8dBu
 455         };
 456
 457         enum MeterLineUp {
 458                 MeteringLineUp24,
 459                 MeteringLineUp20,
 460                 MeteringLineUp18,
 461                 MeteringLineUp15
 462         };
 463
 464         enum PFLPosition {
 465                 /** PFL signals come from before pre-fader processors */
 466                 PFLFromBeforeProcessors,
 467                 /** PFL signals come pre-fader but after pre-fader processors */
 468                 PFLFromAfterProcessors
 469         };
 470
 471         enum AFLPosition {
 472                 /** AFL signals come post-fader and before post-fader processors */
 473                 AFLFromBeforeProcessors,
 474                 /** AFL signals come post-fader but after post-fader processors */
 475                 AFLFromAfterProcessors
 476         };
 477
 478         enum DenormalModel {
 479                 DenormalNone,
 480                 DenormalFTZ,
 481                 DenormalDAZ,
 482                 DenormalFTZDAZ
 483         };
 484
 485         enum LayerModel {
 486                 LaterHigher,
 487                 Manual
 488         };
 489
 490         enum ListenPosition {
 491                 AfterFaderListen,
 492                 PreFaderListen
 493         };
 494
 495         enum AutoConnectOption {
 496                 ManualConnect = 0x0,
 497                 AutoConnectPhysical = 0x1,
 498                 AutoConnectMaster = 0x2
 499         };
 500
 501     enum TracksAutoNamingRule {
 502         UseDefaultNames = 0x1,
 503         NameAfterDriver = 0x2
 504     };
 505
 506         enum SampleFormat {
 507                 FormatFloat = 0,
 508                 FormatInt24,
 509                 FormatInt16
 510         };
 511
 512         int format_data_width (ARDOUR::SampleFormat);
 513
 514         enum CDMarkerFormat {
 515                 CDMarkerNone,
 516                 CDMarkerCUE,
 517                 CDMarkerTOC,
 518                 MP4Chaps
 519         };
 520
 521         enum HeaderFormat {
 522                 BWF,
 523                 WAVE,
 524                 WAVE64,
 525                 CAF,
 526                 AIFF,
 527                 iXML,
 528                 RF64,
 529                 RF64_WAV,
 530                 MBWF,
 531         };
 532
 533         struct PeakData {
 534                 typedef Sample PeakDatum;
 535
 536                 PeakDatum min;
 537                 PeakDatum max;
 538         };
 539
 540         enum RunContext {
 541                 ButlerContext = 0,
 542                 TransportContext,
 543                 ExportContext
 544         };
 545
 546         enum SyncSource {
 547                 /* These are "synonyms". It is important for JACK to be first
 548                    both here and in enums.cc, so that the string "JACK" is
 549                    correctly recognized in older session and preference files.
 550                 */
 551                 JACK = 0,
 552                 Engine = 0,
 553                 MTC,
 554                 MIDIClock,
 555                 LTC
 556         };
 557
 558         enum ShuttleBehaviour {
 559                 Sprung,
 560                 Wheel
 561         };
 562
 563         enum ShuttleUnits {
 564                 Percentage,
 565                 Semitones
 566         };
 567
 568         typedef std::vector<boost::shared_ptr<Source> > SourceList;
 569
 570         enum SrcQuality {
 571                 SrcBest,
 572                 SrcGood,
 573                 SrcQuick,
 574                 SrcFast,
 575                 SrcFastest
 576         };
 577
 578         typedef std::list<framepos_t> AnalysisFeatureList;
 579
 580         typedef std::list<boost::shared_ptr<Route> > RouteList;
 581         typedef std::list<boost::shared_ptr<Stripable> > StripableList;
 582         typedef std::list<boost::weak_ptr  <Route> > WeakRouteList;
 583         typedef std::list<boost::weak_ptr  <Stripable> > WeakStripableList;
 584         typedef std::list<boost::shared_ptr<AutomationControl> > ControlList;
 585
 586         typedef std::list<boost::shared_ptr<VCA> > VCAList;
 587
 588         class Bundle;
 589         typedef std::vector<boost::shared_ptr<Bundle> > BundleList;
 590
 591         enum WaveformScale {
 592                 Linear,
 593                 Logarithmic
 594         };
 595
 596         enum WaveformShape {
 597                 Traditional,
 598                 Rectified
 599         };
 600
 601         struct CleanupReport {
 602                 std::vector<std::string> paths;
 603                 size_t                   space;
 604         };
 605
 606         enum PositionLockStyle {
 607                 AudioTime,
 608                 MusicTime
 609         };
 610
 611         /** A struct used to describe changes to processors in a route.
 612          *  This is useful because objects that respond to a change in processors
 613          *  can optimise what work they do based on details of what has changed.
 614         */
 615         struct RouteProcessorChange {
 616                 enum Type {
 617                         GeneralChange = 0x0,
 618                         MeterPointChange = 0x1,
 619                         RealTimeChange = 0x2
 620                 };
 621
 622                 RouteProcessorChange () : type (GeneralChange), meter_visibly_changed (true)
 623                 {}
 624
 625                 RouteProcessorChange (Type t) : type (t), meter_visibly_changed (true)
 626                 {}
 627
 628                 RouteProcessorChange (Type t, bool m) : type (t), meter_visibly_changed (m)
 629                 {}
 630
 631                 /** type of change; "GeneralChange" means anything could have changed */
 632                 Type type;
 633                 /** true if, when a MeterPointChange has occurred, the change is visible to the user */
 634                 bool meter_visibly_changed;
 635         };
 636
 637         struct BusProfile {
 638                 AutoConnectOption input_ac;      /* override the RC config for input auto-connection */
 639                 AutoConnectOption output_ac;     /* override the RC config for output auto-connection */
 640                 uint32_t master_out_channels;    /* how many channels for the master bus */
 641                 uint32_t requested_physical_in;  /* now many of the available physical inputs to consider usable */
 642                 uint32_t requested_physical_out; /* now many of the available physical inputs to consider usable */
 643         };
 644
 645         enum FadeShape {
 646                 FadeLinear,
 647                 FadeFast,
 648                 FadeSlow,
 649                 FadeConstantPower,
 650                 FadeSymmetric,
 651         };
 652
 653         enum TransportState {
 654                 /* these values happen to match the constants used by JACK but
 655                    this equality cannot be assumed.
 656                 */
 657                 TransportStopped = 0,
 658                 TransportRolling = 1,
 659                 TransportLooping = 2,
 660                 TransportStarting = 3,
 661         };
 662
 663         enum PortFlags {
 664                 /* these values happen to match the constants used by JACK but
 665                    this equality cannot be assumed.
 666                 */
 667                 IsInput = 0x1,
 668                 IsOutput = 0x2,
 669                 IsPhysical = 0x4,
 670                 CanMonitor = 0x8,
 671                 IsTerminal = 0x10,
 672
 673                 /* non-JACK related flags */
 674                 Hidden = 0x20,
 675                 Shadow = 0x40
 676         };
 677
 678         enum MidiPortFlags {
 679                 MidiPortMusic = 0x1,
 680                 MidiPortControl = 0x2,
 681                 MidiPortSelection = 0x4,
 682                 MidiPortVirtual = 0x8
 683         };
 684
 685         struct LatencyRange {
 686             uint32_t min; //< samples
 687             uint32_t max; //< samples
 688         };
 689
 690         enum BufferingPreset {
 691                 Small,
 692                 Medium,
 693                 Large,
 694                 Custom,
 695         };
 696
 697         enum AutoReturnTarget {
 698                 LastLocate = 0x1,
 699                 RangeSelectionStart = 0x2,
 700                 Loop = 0x4,
 701                 RegionSelectionStart = 0x8,
 702         };
 703
 704         enum PlaylistDisposition {
 705                 CopyPlaylist,
 706                 NewPlaylist,
 707                 SharePlaylist
 708         };
 709
 710         enum MidiTrackNameSource {
 711                 SMFTrackNumber,
 712                 SMFTrackName,
 713                 SMFInstrumentName
 714         };
 715
 716         enum MidiTempoMapDisposition {
 717                 SMFTempoIgnore,
 718                 SMFTempoUse,
 719         };
 720
 721 } // namespace ARDOUR
 722
 723 static inline ARDOUR::framepos_t
 724 session_frame_to_track_frame (ARDOUR::framepos_t session_frame, double speed)
 725 {
 726         long double result = (long double) session_frame * (long double) speed;
 727
 728         if (result >= (long double) ARDOUR::max_framepos) {
 729                 return ARDOUR::max_framepos;
 730         } else if (result <= (long double) (ARDOUR::max_framepos) * (ARDOUR::framepos_t)(-1)) {
 731                 return (ARDOUR::max_framepos * (ARDOUR::framepos_t)(-1));
 732         } else {
 733                 return result;
 734         }
 735 }
 736
 737 static inline ARDOUR::framepos_t
 738 track_frame_to_session_frame (ARDOUR::framepos_t track_frame, double speed)
 739 {
 740         /* NB - do we need a check for speed == 0 ??? */
 741         long double result = (long double) track_frame / (long double) speed;
 742
 743         if (result >= (long double) ARDOUR::max_framepos) {
 744                 return ARDOUR::max_framepos;
 745         } else if (result <= (long double) (ARDOUR::max_framepos) * (ARDOUR::framepos_t)(-1)) {
 746                 return (ARDOUR::max_framepos * (ARDOUR::framepos_t)(-1));
 747         } else {
 748                 return result;
 749         }
 750 }
 751
 752 /* for now, break the rules and use "using" to make this "global" */
 753
 754 using ARDOUR::framepos_t;
 755
 756
 757 #endif /* __ardour_types_h__ */