merge with master and fix 4 conflicts by hand
[ardour.git] / 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
56         typedef float    Sample;
57         typedef float    pan_t;
58         typedef float    gain_t;
59         typedef uint32_t layer_t;
60         typedef uint64_t microseconds_t;
61         typedef uint32_t pframes_t;
62
63         /* Any position measured in audio frames.
64            Assumed to be non-negative but not enforced.
65         */
66         typedef int64_t framepos_t;
67
68         /* Any distance from a given framepos_t.
69            Maybe positive or negative.
70         */
71         typedef int64_t frameoffset_t;
72
73         /* Any count of audio frames.
74            Assumed to be positive but not enforced.
75         */
76         typedef int64_t framecnt_t;
77
78         static const framepos_t max_framepos = INT64_MAX;
79         static const framecnt_t max_framecnt = INT64_MAX;
80         static const layer_t    max_layer    = UINT32_MAX;
81
82         // a set of (time) intervals: first of pair is the offset of the start within the region, second is the offset of the end
83         typedef std::list<std::pair<frameoffset_t, frameoffset_t> > AudioIntervalResult;
84         // associate a set of intervals with regions (e.g. for silence detection)
85         typedef std::map<boost::shared_ptr<ARDOUR::Region>,AudioIntervalResult> AudioIntervalMap;
86
87         typedef std::list<boost::shared_ptr<Region> > RegionList;
88
89         struct IOChange {
90
91                 enum Type {
92                         NoChange = 0,
93                         ConfigurationChanged = 0x1,
94                         ConnectionsChanged = 0x2
95                 } type;
96
97                 IOChange () : type (NoChange) {}
98                 IOChange (Type t) : type (t) {}
99
100                 /** channel count of IO before a ConfigurationChanged, if appropriate */
101                 ARDOUR::ChanCount before;
102                 /** channel count of IO after a ConfigurationChanged, if appropriate */
103                 ARDOUR::ChanCount after;
104         };
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 evoral/Parameter.hpp
120          */
121         enum AutomationType {
122                 NullAutomation,
123                 GainAutomation,
124                 PanAzimuthAutomation,
125                 PanElevationAutomation,
126                 PanWidthAutomation,
127                 PanFrontBackAutomation,
128                 PanLFEAutomation,
129                 PluginAutomation,
130                 SoloAutomation,
131                 MuteAutomation,
132                 MidiCCAutomation,
133                 MidiPgmChangeAutomation,
134                 MidiPitchBenderAutomation,
135                 MidiChannelPressureAutomation,
136                 MidiSystemExclusiveAutomation,
137                 FadeInAutomation,
138                 FadeOutAutomation,
139                 EnvelopeAutomation,
140                 RecEnableAutomation
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 AlignChoice {
167                 UseCaptureTime,
168                 UseExistingMaterial,
169                 Automatic
170         };
171
172         enum MeterPoint {
173                 MeterInput,
174                 MeterPreFader,
175                 MeterPostFader,
176                 MeterOutput,
177                 MeterCustom
178         };
179
180         enum MeterType {
181                 MeterMaxSignal = 0x001,
182                 MeterMaxPeak   = 0x002,
183                 MeterPeak      = 0x004,
184                 MeterKrms      = 0x008,
185                 MeterK20       = 0x010,
186                 MeterK14       = 0x020,
187                 MeterIEC1DIN   = 0x040,
188                 MeterIEC1NOR   = 0x080,
189                 MeterIEC2BBC   = 0x100,
190                 MeterIEC2EBU   = 0x200,
191                 MeterVU        = 0x400,
192                 MeterK12       = 0x800
193         };
194
195         enum TrackMode {
196                 Normal,
197                 NonLayered,
198                 Destructive
199         };
200
201         enum NoteMode {
202                 Sustained,
203                 Percussive
204         };
205
206         enum ChannelMode {
207                 AllChannels = 0, ///< Pass through all channel information unmodified
208                 FilterChannels,  ///< Ignore events on certain channels
209                 ForceChannel     ///< Force all events to a certain channel
210         };
211
212         enum ColorMode {
213                 MeterColors = 0,
214                 ChannelColors,
215                 TrackColor
216         };
217
218         class AnyTime {
219         public:
220                 enum Type {
221                         Timecode,
222                         BBT,
223                         Frames,
224                         Seconds
225                 };
226
227                 Type type;
228
229                 Timecode::Time     timecode;
230                 Timecode::BBT_Time bbt;
231
232                 union {
233                         framecnt_t     frames;
234                         double         seconds;
235                 };
236
237                 AnyTime() { type = Frames; frames = 0; }
238
239                 bool operator== (AnyTime const & other) const {
240                         if (type != other.type) { return false; }
241
242                         switch (type) {
243                           case Timecode:
244                                 return timecode == other.timecode;
245                           case BBT:
246                                 return bbt == other.bbt;
247                           case Frames:
248                                 return frames == other.frames;
249                           case Seconds:
250                                 return seconds == other.seconds;
251                         }
252                         return false; // get rid of warning
253                 }
254
255                 bool not_zero() const
256                 {
257                         switch (type) {
258                           case Timecode:
259                                 return timecode.hours != 0 || timecode.minutes != 0 ||
260                                        timecode.seconds != 0 || timecode.frames != 0;
261                           case BBT:
262                                 return bbt.bars != 0 || bbt.beats != 0 || bbt.ticks != 0;
263                           case Frames:
264                                 return frames != 0;
265                           case Seconds:
266                                 return seconds != 0;
267                         }
268
269                         /* NOTREACHED */
270                         assert (false);
271                         return false;
272                 }
273         };
274
275         /* XXX: slightly unfortunate that there is this and Evoral::Range<>,
276            but this has a uint32_t id which Evoral::Range<> does not.
277         */
278         struct AudioRange {
279                 framepos_t start;
280                 framepos_t end;
281                 uint32_t id;
282
283                 AudioRange (framepos_t s, framepos_t e, uint32_t i) : start (s), end (e) , id (i) {}
284
285                 framecnt_t length() { return end - start + 1; }
286
287                 bool operator== (const AudioRange& other) const {
288                         return start == other.start && end == other.end && id == other.id;
289                 }
290
291                 bool equal (const AudioRange& other) const {
292                         return start == other.start && end == other.end;
293                 }
294
295                 Evoral::OverlapType coverage (framepos_t s, framepos_t e) const {
296                         return Evoral::coverage (start, end, s, e);
297                 }
298         };
299
300         struct MusicRange {
301                 Timecode::BBT_Time start;
302                 Timecode::BBT_Time end;
303                 uint32_t id;
304
305                 MusicRange (Timecode::BBT_Time& s, Timecode::BBT_Time& e, uint32_t i)
306                         : start (s), end (e), id (i) {}
307
308                 bool operator== (const MusicRange& other) const {
309                         return start == other.start && end == other.end && id == other.id;
310                 }
311
312                 bool equal (const MusicRange& other) const {
313                         return start == other.start && end == other.end;
314                 }
315         };
316
317         /*
318             Slowest = 6.6dB/sec falloff at update rate of 40ms
319             Slow    = 6.8dB/sec falloff at update rate of 40ms
320         */
321
322         enum MeterFalloff {
323                 MeterFalloffOff = 0,
324                 MeterFalloffSlowest = 1,
325                 MeterFalloffSlow = 2,
326                 MeterFalloffSlowish = 3,
327                 MeterFalloffModerate = 4,
328                 MeterFalloffMedium = 5,
329                 MeterFalloffFast = 6,
330                 MeterFalloffFaster = 7,
331                 MeterFalloffFastest = 8,
332         };
333
334         enum MeterHold {
335                 MeterHoldOff = 0,
336                 MeterHoldShort = 40,
337                 MeterHoldMedium = 100,
338                 MeterHoldLong = 200
339         };
340
341         enum EditMode {
342                 Slide,
343                 Splice,
344                 Lock
345         };
346
347         enum RegionPoint {
348                 Start,
349                 End,
350                 SyncPoint
351         };
352
353         enum Placement {
354                 PreFader,
355                 PostFader
356         };
357
358         enum MonitorModel {
359                 HardwareMonitoring, ///< JACK does monitoring
360                 SoftwareMonitoring, ///< Ardour does monitoring
361                 ExternalMonitoring  ///< we leave monitoring to the audio hardware
362         };
363
364         enum MonitorChoice {
365                 MonitorAuto = 0,
366                 MonitorInput = 0x1,
367                 MonitorDisk = 0x2,
368                 MonitorCue = 0x4,
369         };
370
371         enum MonitorState {
372                 MonitoringSilence = 0x1,
373                 MonitoringInput = 0x2,
374                 MonitoringDisk = 0x4,
375         };
376
377         enum MeterState {
378                 MeteringInput, ///< meter the input IO, regardless of what is going through the route
379                 MeteringRoute  ///< meter what is going through the route
380         };
381
382         enum VUMeterStandard {
383                 MeteringVUfrench,   // 0VU = -2dBu
384                 MeteringVUamerican, // 0VU =  0dBu
385                 MeteringVUstandard, // 0VU = +4dBu
386                 MeteringVUeight     // 0VU = +8dBu
387         };
388
389         enum MeterLineUp {
390                 MeteringLineUp24,
391                 MeteringLineUp20,
392                 MeteringLineUp18,
393                 MeteringLineUp15
394         };
395
396         enum PFLPosition {
397                 /** PFL signals come from before pre-fader processors */
398                 PFLFromBeforeProcessors,
399                 /** PFL signals come pre-fader but after pre-fader processors */
400                 PFLFromAfterProcessors
401         };
402
403         enum AFLPosition {
404                 /** AFL signals come post-fader and before post-fader processors */
405                 AFLFromBeforeProcessors,
406                 /** AFL signals come post-fader but after post-fader processors */
407                 AFLFromAfterProcessors
408         };
409
410         enum DenormalModel {
411                 DenormalNone,
412                 DenormalFTZ,
413                 DenormalDAZ,
414                 DenormalFTZDAZ
415         };
416
417         enum RemoteModel {
418                 UserOrdered,
419                 MixerOrdered
420         };
421
422         enum CrossfadeModel {
423                 FullCrossfade,
424                 ShortCrossfade
425         };
426
427         enum CrossfadeChoice {
428                 RegionFades,
429                 ConstantPowerMinus3dB,
430                 ConstantPowerMinus6dB,
431         };
432
433         enum ListenPosition {
434                 AfterFaderListen,
435                 PreFaderListen
436         };
437
438         enum AutoConnectOption {
439                 ManualConnect = 0x0,
440                 AutoConnectPhysical = 0x1,
441                 AutoConnectMaster = 0x2
442         };
443
444         enum SampleFormat {
445                 FormatFloat = 0,
446                 FormatInt24,
447                 FormatInt16
448         };
449
450         enum CDMarkerFormat {
451                 CDMarkerNone,
452                 CDMarkerCUE,
453                 CDMarkerTOC
454         };
455
456         enum HeaderFormat {
457                 BWF,
458                 WAVE,
459                 WAVE64,
460                 CAF,
461                 AIFF,
462                 iXML,
463                 RF64
464         };
465
466         struct PeakData {
467                 typedef Sample PeakDatum;
468
469                 PeakDatum min;
470                 PeakDatum max;
471         };
472
473         enum RunContext {
474                 ButlerContext = 0,
475                 TransportContext,
476                 ExportContext
477         };
478
479         enum SyncSource {
480                 /* These are "synonyms". It is important for JACK to be first
481                    both here and in enums.cc, so that the string "JACK" is
482                    correctly recognized in older session and preference files.
483                 */
484                 JACK = 0,
485                 Engine = 0,
486                 MTC,
487                 MIDIClock,
488                 LTC
489         };
490
491         enum ShuttleBehaviour {
492                 Sprung,
493                 Wheel
494         };
495
496         enum ShuttleUnits {
497                 Percentage,
498                 Semitones
499         };
500
501         typedef std::vector<boost::shared_ptr<Source> > SourceList;
502
503         enum SrcQuality {
504                 SrcBest,
505                 SrcGood,
506                 SrcQuick,
507                 SrcFast,
508                 SrcFastest
509         };
510
511         typedef std::list<framepos_t> AnalysisFeatureList;
512
513         typedef std::list<boost::shared_ptr<Route> > RouteList;
514         typedef std::list<boost::weak_ptr  <Route> > WeakRouteList;
515
516         class Bundle;
517         typedef std::vector<boost::shared_ptr<Bundle> > BundleList;
518
519         enum WaveformScale {
520                 Linear,
521                 Logarithmic
522         };
523
524         enum WaveformShape {
525                 Traditional,
526                 Rectified
527         };
528
529         struct CleanupReport {
530                 std::vector<std::string> paths;
531                 size_t                   space;
532         };
533
534         enum PositionLockStyle {
535                 AudioTime,
536                 MusicTime
537         };
538
539         /** A struct used to describe changes to processors in a route.
540          *  This is useful because objects that respond to a change in processors
541          *  can optimise what work they do based on details of what has changed.
542         */
543         struct RouteProcessorChange {
544                 enum Type {
545                         GeneralChange = 0x0,
546                         MeterPointChange = 0x1
547                 };
548
549                 RouteProcessorChange () : type (GeneralChange), meter_visibly_changed (true)
550                 {}
551
552                 RouteProcessorChange (Type t) : type (t), meter_visibly_changed (true)
553                 {}
554
555                 RouteProcessorChange (Type t, bool m) : type (t), meter_visibly_changed (m)
556                 {}
557
558                 /** type of change; "GeneralChange" means anything could have changed */
559                 Type type;
560                 /** true if, when a MeterPointChange has occurred, the change is visible to the user */
561                 bool meter_visibly_changed;
562         };
563
564         struct BusProfile {
565                 AutoConnectOption input_ac;      /* override the RC config for input auto-connection */
566                 AutoConnectOption output_ac;     /* override the RC config for output auto-connection */
567                 uint32_t master_out_channels;    /* how many channels for the master bus */
568                 uint32_t requested_physical_in;  /* now many of the available physical inputs to consider usable */
569                 uint32_t requested_physical_out; /* now many of the available physical inputs to consider usable */
570         };
571
572         enum FadeShape {
573                 FadeLinear,
574                 FadeFast,
575                 FadeSlow,
576                 FadeConstantPower,
577                 FadeSymmetric,
578         };
579
580         enum TransportState {
581                 /* these values happen to match the constants used by JACK but
582                    this equality cannot be assumed.
583                 */
584                 TransportStopped = 0,
585                 TransportRolling = 1, 
586                 TransportLooping = 2, 
587                 TransportStarting = 3,
588         };
589
590         enum PortFlags {
591                 /* these values happen to match the constants used by JACK but
592                    this equality cannot be assumed.
593                 */
594                 IsInput = 0x1, 
595                 IsOutput = 0x2,
596                 IsPhysical = 0x4,
597                 CanMonitor = 0x8,
598                 IsTerminal = 0x10
599         };
600
601         struct LatencyRange {
602             uint32_t min; //< samples
603             uint32_t max; //< samples
604         };
605
606 } // namespace ARDOUR
607
608
609 /* these cover types declared above in this header. See enums.cc
610    for the definitions.
611 */
612
613 std::istream& operator>>(std::istream& o, ARDOUR::SampleFormat& sf);
614 std::istream& operator>>(std::istream& o, ARDOUR::HeaderFormat& sf);
615 std::istream& operator>>(std::istream& o, ARDOUR::AutoConnectOption& sf);
616 std::istream& operator>>(std::istream& o, ARDOUR::EditMode& sf);
617 std::istream& operator>>(std::istream& o, ARDOUR::MonitorModel& sf);
618 std::istream& operator>>(std::istream& o, ARDOUR::VUMeterStandard& sf);
619 std::istream& operator>>(std::istream& o, ARDOUR::MeterLineUp& sf);
620 std::istream& operator>>(std::istream& o, ARDOUR::PFLPosition& sf);
621 std::istream& operator>>(std::istream& o, ARDOUR::AFLPosition& sf);
622 std::istream& operator>>(std::istream& o, ARDOUR::RemoteModel& sf);
623 std::istream& operator>>(std::istream& o, ARDOUR::ListenPosition& sf);
624 std::istream& operator>>(std::istream& o, ARDOUR::InsertMergePolicy& sf);
625 std::istream& operator>>(std::istream& o, ARDOUR::CrossfadeModel& sf);
626 std::istream& operator>>(std::istream& o, ARDOUR::CrossfadeChoice& sf);
627 std::istream& operator>>(std::istream& o, ARDOUR::SyncSource& sf);
628 std::istream& operator>>(std::istream& o, ARDOUR::ShuttleBehaviour& sf);
629 std::istream& operator>>(std::istream& o, ARDOUR::ShuttleUnits& sf);
630 std::istream& operator>>(std::istream& o, Timecode::TimecodeFormat& sf);
631 std::istream& operator>>(std::istream& o, ARDOUR::DenormalModel& sf);
632 std::istream& operator>>(std::istream& o, ARDOUR::WaveformScale& sf);
633 std::istream& operator>>(std::istream& o, ARDOUR::WaveformShape& sf);
634 std::istream& operator>>(std::istream& o, ARDOUR::PositionLockStyle& sf);
635 std::istream& operator>>(std::istream& o, ARDOUR::FadeShape& sf);
636
637 std::ostream& operator<<(std::ostream& o, const ARDOUR::SampleFormat& sf);
638 std::ostream& operator<<(std::ostream& o, const ARDOUR::HeaderFormat& sf);
639 std::ostream& operator<<(std::ostream& o, const ARDOUR::AutoConnectOption& sf);
640 std::ostream& operator<<(std::ostream& o, const ARDOUR::EditMode& sf);
641 std::ostream& operator<<(std::ostream& o, const ARDOUR::MonitorModel& sf);
642 std::ostream& operator<<(std::ostream& o, const ARDOUR::VUMeterStandard& sf);
643 std::ostream& operator<<(std::ostream& o, const ARDOUR::MeterLineUp& sf);
644 std::ostream& operator<<(std::ostream& o, const ARDOUR::PFLPosition& sf);
645 std::ostream& operator<<(std::ostream& o, const ARDOUR::AFLPosition& sf);
646 std::ostream& operator<<(std::ostream& o, const ARDOUR::RemoteModel& sf);
647 std::ostream& operator<<(std::ostream& o, const ARDOUR::ListenPosition& sf);
648 std::ostream& operator<<(std::ostream& o, const ARDOUR::InsertMergePolicy& sf);
649 std::ostream& operator<<(std::ostream& o, const ARDOUR::CrossfadeModel& sf);
650 std::ostream& operator<<(std::ostream& o, const ARDOUR::CrossfadeChoice& sf);
651 std::ostream& operator<<(std::ostream& o, const ARDOUR::SyncSource& sf);
652 std::ostream& operator<<(std::ostream& o, const ARDOUR::ShuttleBehaviour& sf);
653 std::ostream& operator<<(std::ostream& o, const ARDOUR::ShuttleUnits& sf);
654 std::ostream& operator<<(std::ostream& o, const Timecode::TimecodeFormat& sf);
655 std::ostream& operator<<(std::ostream& o, const ARDOUR::DenormalModel& sf);
656 std::ostream& operator<<(std::ostream& o, const ARDOUR::WaveformScale& sf);
657 std::ostream& operator<<(std::ostream& o, const ARDOUR::WaveformShape& sf);
658 std::ostream& operator<<(std::ostream& o, const ARDOUR::PositionLockStyle& sf);
659 std::ostream& operator<<(std::ostream& o, const ARDOUR::FadeShape& sf);
660
661 static inline ARDOUR::framepos_t
662 session_frame_to_track_frame (ARDOUR::framepos_t session_frame, double speed)
663 {
664         return (ARDOUR::framepos_t) ((long double) session_frame * (long double) speed);
665 }
666
667 static inline ARDOUR::framepos_t
668 track_frame_to_session_frame (ARDOUR::framepos_t track_frame, double speed)
669 {
670         return (ARDOUR::framepos_t) ((long double) track_frame / (long double) speed);
671 }
672
673 /* for now, break the rules and use "using" to make this "global" */
674
675 using ARDOUR::framepos_t;
676
677
678 #endif /* __ardour_types_h__ */
679