1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
|
/*
Copyright (C) 2008 Paul Davis
Author: Sakari Bergen
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef __ardour_export_format_specification_h__
#define __ardour_export_format_specification_h__
#include <string>
#include "pbd/uuid.h"
#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/export_format_base.h"
class XMLNode;
namespace ARDOUR
{
class ExportFormat;
class ExportFormatCompatibility;
class Session;
class LIBARDOUR_API ExportFormatSpecification : public ExportFormatBase {
private:
/* Time struct for keeping time formats as close as possible to what was requested */
struct Time : public AnyTime {
Time (Session & session) : AnyTime (), session (session) {}
Time & operator= (AnyTime const & other);
framecnt_t get_frames_at (framepos_t position, framecnt_t target_rate) const;
/* Serialization */
XMLNode & get_state ();
int set_state (const XMLNode & node);
private:
Session & session;
};
private:
friend class ExportElementFactory;
explicit ExportFormatSpecification (Session & s);
ExportFormatSpecification (Session & s, XMLNode const & state);
public:
ExportFormatSpecification (ExportFormatSpecification const & other, bool modify_name = true);
~ExportFormatSpecification ();
/* compatibility */
bool is_compatible_with (ExportFormatCompatibility const & compatibility) const;
bool is_complete () const;
/* Modifying functions */
void set_format (boost::shared_ptr<ExportFormat> format);
void set_name (std::string const & name) { _name = name; }
void set_type (Type type) { _type = type; }
void set_format_id (FormatId value) { format_ids.clear(); format_ids.insert (value); }
void set_endianness (Endianness value) { endiannesses.clear(); endiannesses.insert (value); }
void set_sample_format (SampleFormat value) { sample_formats.clear(); sample_formats.insert (value); }
void set_sample_rate (SampleRate value) { sample_rates.clear(); sample_rates.insert (value); }
void set_quality (Quality value) { qualities.clear(); qualities.insert (value); }
void set_dither_type (DitherType value) { _dither_type = value; }
void set_src_quality (SRCQuality value) { _src_quality = value; }
void set_trim_beginning (bool value) { _trim_beginning = value; }
void set_trim_end (bool value) { _trim_end = value; }
void set_normalize (bool value) { _normalize = value; }
void set_normalize_loudness (bool value) { _normalize_loudness = value; }
void set_normalize_dbfs (float value) { _normalize_dbfs = value; }
void set_normalize_lufs (float value) { _normalize_lufs = value; }
void set_normalize_dbtp (float value) { _normalize_dbtp = value; }
void set_tag (bool tag_it) { _tag = tag_it; }
void set_with_cue (bool yn) { _with_cue = yn; }
void set_with_toc (bool yn) { _with_toc = yn; }
void set_with_mp4chaps (bool yn) { _with_mp4chaps = yn; }
void set_soundcloud_upload (bool yn) { _soundcloud_upload = yn; }
void set_command (std::string command) { _command = command; }
void set_analyse (bool yn) { _analyse = yn; }
void set_silence_beginning (AnyTime const & value) { _silence_beginning = value; }
void set_silence_end (AnyTime const & value) { _silence_end = value; }
/* Accessing functions */
PBD::UUID const & id () { return _id; }
std::string const & name () const { return _name; }
std::string description (bool include_name = true);
bool has_broadcast_info () const { return _has_broadcast_info; }
uint32_t channel_limit () const { return _channel_limit; }
std::string format_name () const { return _format_name; }
Type type () const { return _type; }
FormatId format_id () const {
if (!format_ids.empty() )
return *format_ids.begin();
else
return FormatId(0);
}
Endianness endianness () const {
if (!endiannesses.empty() )
return *endiannesses.begin();
else
return Endianness(0);
}
SampleFormat sample_format () const {
if (!sample_formats.empty() )
return *sample_formats.begin();
else
return SampleFormat(0);
}
SampleRate sample_rate () const {
if (!sample_rates.empty() )
return *sample_rates.begin();
else
return SampleRate(0);
}
Quality quality () const {
if (!qualities.empty() )
return *qualities.begin();
else
return Quality(0);
}
DitherType dither_type () const { return _dither_type; }
SRCQuality src_quality () const { return _src_quality; }
bool trim_beginning () const { return _trim_beginning; }
bool trim_end () const { return _trim_end; }
bool normalize () const { return _normalize; }
bool normalize_loudness () const { return _normalize_loudness; }
float normalize_dbfs () const { return _normalize_dbfs; }
float normalize_lufs () const { return _normalize_lufs; }
float normalize_dbtp () const { return _normalize_dbtp; }
bool with_toc() const { return _with_toc; }
bool with_cue() const { return _with_cue; }
bool with_mp4chaps() const { return _with_mp4chaps; }
bool soundcloud_upload() const { return _soundcloud_upload; }
std::string command() const { return _command; }
bool analyse() const { return _analyse; }
bool tag () const { return _tag && supports_tagging; }
framecnt_t silence_beginning_at (framepos_t position, framecnt_t samplerate) const
{ return _silence_beginning.get_frames_at (position, samplerate); }
framecnt_t silence_end_at (framepos_t position, framecnt_t samplerate) const
{ return _silence_end.get_frames_at (position, samplerate); }
AnyTime silence_beginning_time () const { return _silence_beginning; }
AnyTime silence_end_time () const { return _silence_end; }
/* Serialization */
XMLNode & get_state ();
int set_state (const XMLNode & root);
private:
Session & session;
/* The variables below do not have setters (usually set via set_format) */
std::string _format_name;
bool has_sample_format;
bool supports_tagging;
bool _has_broadcast_info;
uint32_t _channel_limit;
/* The variables below have getters and setters */
std::string _name;
PBD::UUID _id;
Type _type;
DitherType _dither_type;
SRCQuality _src_quality;
bool _tag;
bool _trim_beginning;
Time _silence_beginning;
bool _trim_end;
Time _silence_end;
bool _normalize;
bool _normalize_loudness;
float _normalize_dbfs;
float _normalize_lufs;
float _normalize_dbtp;
bool _with_toc;
bool _with_cue;
bool _with_mp4chaps;
bool _soundcloud_upload;
std::string _command;
bool _analyse;
/* serialization helpers */
void add_option (XMLNode * node, std::string const & name, std::string const & value);
std::string get_option (XMLNode const * node, std::string const & name);
};
} // namespace ARDOUR
#endif /* __ardour_export_format_specification_h__ */
|
