2 Copyright (C) 2008 Paul Davis
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 #include "ardour/export_format_specification.h"
23 #include "ardour/export_format_compatibility.h"
24 #include "ardour/export_formats.h"
25 #include "ardour/session.h"
26 #include "ardour/types_convert.h"
28 #include "pbd/error.h"
29 #include "pbd/xml++.h"
30 #include "pbd/enumwriter.h"
31 #include "pbd/enum_convert.h"
32 #include "pbd/string_convert.h"
33 #include "pbd/types_convert.h"
38 DEFINE_ENUM_CONVERT (ARDOUR::ExportFormatBase::FormatId)
39 DEFINE_ENUM_CONVERT (ARDOUR::ExportFormatBase::SampleRate)
40 DEFINE_ENUM_CONVERT (ARDOUR::ExportFormatBase::SampleFormat)
41 DEFINE_ENUM_CONVERT (ARDOUR::ExportFormatBase::DitherType)
42 DEFINE_ENUM_CONVERT (ARDOUR::ExportFormatBase::SRCQuality)
43 DEFINE_ENUM_CONVERT (ARDOUR::ExportFormatBase::Type)
53 ExportFormatSpecification::Time &
54 ExportFormatSpecification::Time::operator= (AnyTime const & other)
56 static_cast<AnyTime &>(*this) = other;
61 ExportFormatSpecification::Time::get_samples_at (samplepos_t position, samplecnt_t target_rate) const
63 samplecnt_t duration = session.any_duration_to_samples (position, *this);
64 return ((double) target_rate / session.sample_rate()) * duration + 0.5;
68 ExportFormatSpecification::Time::get_state ()
71 XMLNode * node = new XMLNode ("Duration");
73 node->set_property ("format", type);
77 node->set_property ("hours", timecode.hours);
78 node->set_property ("minutes", timecode.minutes);
79 node->set_property ("seconds", timecode.seconds);
80 node->set_property ("frames", timecode.frames);
83 node->set_property ("bars", bbt.bars);
84 node->set_property ("beats", bbt.beats);
85 node->set_property ("ticks", bbt.ticks);
88 node->set_property ("samples", samples);
91 node->set_property ("seconds", seconds);
99 ExportFormatSpecification::Time::set_state (const XMLNode & node)
101 if (!node.get_property ("format", type)) {
107 node.get_property ("hours", timecode.hours);
108 node.get_property ("minutes", timecode.minutes);
109 node.get_property ("seconds", timecode.seconds);
110 node.get_property ("frames", timecode.frames);
114 node.get_property ("bars", bbt.bars);
115 node.get_property ("beats", bbt.beats);
116 node.get_property ("ticks", bbt.ticks);
120 node.get_property ("samples", samples);
124 node.get_property ("seconds", seconds);
132 ExportFormatSpecification::ExportFormatSpecification (Session & s)
134 , has_sample_format (false)
135 , supports_tagging (false)
136 , _has_codec_quality (false)
137 , _has_broadcast_info (false)
139 , _dither_type (D_None)
140 , _src_quality (SRC_SincBest)
143 , _trim_beginning (false)
144 , _silence_beginning (s)
149 , _normalize_loudness (false)
150 , _normalize_dbfs (GAIN_COEFF_UNITY)
151 , _normalize_lufs (-23)
152 , _normalize_dbtp (-1)
155 , _with_mp4chaps (false)
156 , _soundcloud_upload (false)
161 format_ids.insert (F_None);
162 endiannesses.insert (E_FileDefault);
163 sample_formats.insert (SF_None);
164 sample_rates.insert (SR_None);
165 qualities.insert (Q_None);
168 ExportFormatSpecification::ExportFormatSpecification (Session & s, XMLNode const & state)
170 , has_sample_format (false)
171 , supports_tagging (false)
172 , _has_codec_quality (false)
173 , _has_broadcast_info (false)
175 , _dither_type (D_None)
176 , _src_quality (SRC_SincBest)
179 , _trim_beginning (false)
180 , _silence_beginning (s)
185 , _normalize_loudness (false)
186 , _normalize_dbfs (GAIN_COEFF_UNITY)
187 , _normalize_lufs (-23)
188 , _normalize_dbtp (-1)
191 , _with_mp4chaps (false)
192 , _soundcloud_upload (false)
197 _silence_beginning.type = Time::Timecode;
198 _silence_end.type = Time::Timecode;
203 ExportFormatSpecification::ExportFormatSpecification (ExportFormatSpecification const & other, bool modify_name)
204 : ExportFormatBase(other)
205 , session (other.session)
206 , _silence_beginning (other.session)
207 , _silence_end (other.session)
208 , _with_toc (other._with_toc)
209 , _with_cue (other._with_cue)
210 , _with_mp4chaps (other._with_mp4chaps)
211 , _soundcloud_upload (false)
212 , _command (other._command)
213 , _analyse (other._analyse)
214 , _codec_quality (other._codec_quality)
217 set_name (other.name() + " (copy)");
219 set_name (other.name());
222 _format_name = other._format_name;
223 has_sample_format = other.has_sample_format;
224 supports_tagging = other.supports_tagging;
225 _has_codec_quality = other._has_codec_quality;
226 _has_broadcast_info = other._has_broadcast_info;
227 _channel_limit = other._channel_limit;
229 set_type (other.type());
230 set_format_id (other.format_id());
231 set_endianness (other.endianness());
232 set_sample_format (other.sample_format());
233 set_sample_rate (other.sample_rate());
234 set_quality (other.quality());
236 set_dither_type (other.dither_type());
237 set_src_quality (other.src_quality());
238 set_trim_beginning (other.trim_beginning());
239 set_trim_end (other.trim_end());
240 set_normalize (other.normalize());
241 set_normalize_loudness (other.normalize_loudness());
242 set_normalize_dbfs (other.normalize_dbfs());
243 set_normalize_lufs (other.normalize_lufs());
244 set_normalize_dbtp (other.normalize_dbtp());
246 set_tag (other.tag());
248 set_silence_beginning (other.silence_beginning_time());
249 set_silence_end (other.silence_end_time());
251 set_extension(other.extension());
254 ExportFormatSpecification::~ExportFormatSpecification ()
259 ExportFormatSpecification::get_state ()
262 XMLNode * root = new XMLNode ("ExportFormatSpecification");
264 root->set_property ("name", _name);
265 root->set_property ("id", _id.to_s());
266 root->set_property ("with-cue", _with_cue);
267 root->set_property ("with-toc", _with_toc);
268 root->set_property ("with-mp4chaps", _with_mp4chaps);
269 root->set_property ("command", _command);
270 root->set_property ("analyse", _analyse);
271 root->set_property ("soundcloud-upload", _soundcloud_upload);
273 node = root->add_child ("Encoding");
274 node->set_property ("id", format_id());
275 node->set_property ("type", type());
276 node->set_property ("extension", extension());
277 node->set_property ("name", _format_name);
278 node->set_property ("has-sample-format", has_sample_format);
279 node->set_property ("channel-limit", _channel_limit);
281 node = root->add_child ("SampleRate");
282 node->set_property ("rate", sample_rate());
284 node = root->add_child ("SRCQuality");
285 node->set_property ("quality", src_quality());
287 if (_has_codec_quality) {
288 node = root->add_child ("CodecQuality");
289 node->set_property ("quality", codec_quality());
292 XMLNode * enc_opts = root->add_child ("EncodingOptions");
294 add_option (enc_opts, "sample-format", to_string(sample_format()));
295 add_option (enc_opts, "dithering", to_string (dither_type()));
296 add_option (enc_opts, "tag-metadata", to_string (_tag));
297 add_option (enc_opts, "tag-support", to_string (supports_tagging));
298 add_option (enc_opts, "broadcast-info", to_string (_has_broadcast_info));
300 XMLNode * processing = root->add_child ("Processing");
302 node = processing->add_child ("Normalize");
303 node->set_property ("enabled", normalize());
304 node->set_property ("loudness", normalize_loudness());
305 node->set_property ("dbfs", normalize_dbfs());
306 node->set_property ("lufs", normalize_lufs());
307 node->set_property ("dbtp", normalize_dbtp());
309 XMLNode * silence = processing->add_child ("Silence");
310 XMLNode * start = silence->add_child ("Start");
311 XMLNode * end = silence->add_child ("End");
313 node = start->add_child ("Trim");
314 node->set_property ("enabled", trim_beginning());
316 node = start->add_child ("Add");
317 node->set_property ("enabled", _silence_beginning.not_zero());
318 node->add_child_nocopy (_silence_beginning.get_state());
320 node = end->add_child ("Trim");
321 node->set_property ("enabled", trim_end());
323 node = end->add_child ("Add");
324 node->set_property ("enabled", _silence_end.not_zero());
325 node->add_child_nocopy (_silence_end.get_state());
331 ExportFormatSpecification::set_state (const XMLNode & root)
333 XMLNode const * child;
336 root.get_property ("name", _name);
338 if (root.get_property ("id", str)) {
342 if (!root.get_property ("with-cue", _with_cue)) {
346 if (!root.get_property ("with-toc", _with_toc)) {
350 if (!root.get_property ("with-mp4chaps", _with_mp4chaps)) {
351 _with_mp4chaps = false;
354 if (!root.get_property ("command", _command)) {
358 if (!root.get_property ("analyse", _analyse)) {
362 if (!root.get_property ("soundcloud-upload", _soundcloud_upload)) {
363 _soundcloud_upload = false;
366 /* Encoding and SRC */
368 if ((child = root.child ("Encoding"))) {
370 if (child->get_property ("id", fid)) {
374 ExportFormatBase::Type type;
375 if (child->get_property ("type", type)) {
379 if (child->get_property ("extension", str)) {
383 child->get_property ("name", _format_name);
384 child->get_property ("has-sample-format", has_sample_format);
385 child->get_property ("channel-limit", _channel_limit);
388 if ((child = root.child ("SampleRate"))) {
390 if (child->get_property ("rate", rate)) {
391 set_sample_rate (rate);
395 if ((child = root.child ("SRCQuality"))) {
396 child->get_property ("quality", _src_quality);
399 if ((child = root.child ("CodecQuality"))) {
400 child->get_property ("quality", _codec_quality);
401 _has_codec_quality = true;
403 _has_codec_quality = false;
406 /* fixup codec quality for old states */
407 if (!_has_codec_quality) {
408 /* We'd need an instance of ExportFormatManager to look up
409 * defaults for a given type -- in the future there may even be
410 * difference qualities depending on sub-type, so we just
411 * hardcode them here for the time being.
413 if (format_id() == F_FFMPEG) {
414 _codec_quality = -2; // ExportFormatOggVorbis::default_codec_quality();
416 else if (format_id() == F_Ogg) {
417 _codec_quality = 40; // ExportFormatFFMPEG::default_codec_quality();
421 /* Encoding options */
423 if ((child = root.child ("EncodingOptions"))) {
424 set_sample_format ((SampleFormat) string_2_enum (get_option (child, "sample-format"), SampleFormat));
425 set_dither_type ((DitherType) string_2_enum (get_option (child, "dithering"), DitherType));
426 set_tag (string_to<bool>(get_option (child, "tag-metadata")));
427 supports_tagging = string_to<bool>(get_option (child, "tag-support"));
428 _has_broadcast_info = string_to<bool>(get_option (child, "broadcast-info"));
433 XMLNode const * proc = root.child ("Processing");
434 if (!proc) { std::cerr << X_("Could not load processing for export format") << std::endl; return -1; }
436 if ((child = proc->child ("Normalize"))) {
437 child->get_property ("enabled", _normalize);
438 // old formats before ~ 4.7-930ish
439 child->get_property ("target", _normalize_dbfs);
440 child->get_property ("loudness", _normalize_loudness);
441 child->get_property ("dbfs", _normalize_dbfs);
442 child->get_property ("lufs", _normalize_lufs);
443 child->get_property ("dbtp", _normalize_dbtp);
446 XMLNode const * silence = proc->child ("Silence");
447 if (!silence) { std::cerr << X_("Could not load silence for export format") << std::endl; return -1; }
449 XMLNode const * start = silence->child ("Start");
450 XMLNode const * end = silence->child ("End");
451 if (!start || !end) { std::cerr << X_("Could not load end or start silence for export format") << std::endl; return -1; }
455 if ((child = start->child ("Trim"))) {
456 child->get_property ("enabled", _trim_beginning);
460 if ((child = start->child ("Add"))) {
461 if (child->get_property ("enabled", enabled) && enabled) {
462 if ((child = child->child ("Duration"))) {
463 _silence_beginning.set_state (*child);
466 _silence_beginning.type = Time::Timecode;
472 if ((child = end->child ("Trim"))) {
473 child->get_property ("enabled", _trim_end);
476 if ((child = end->child ("Add"))) {
477 if (child->get_property ("enabled", enabled) && enabled) {
478 if ((child = child->child ("Duration"))) {
479 _silence_end.set_state (*child);
482 _silence_end.type = Time::Timecode;
490 ExportFormatSpecification::is_compatible_with (ExportFormatCompatibility const & compatibility) const
492 boost::shared_ptr<ExportFormatBase> intersection = get_intersection (compatibility);
494 if (intersection->formats_empty() && format_id() != 0) {
498 if (intersection->endiannesses_empty() && endianness() != E_FileDefault) {
502 if (intersection->sample_rates_empty() && sample_rate() != SR_None) {
506 if (intersection->sample_formats_empty() && sample_format() != SF_None) {
510 if (intersection->qualities_empty() && quality() != Q_None) {
518 ExportFormatSpecification::is_complete () const
520 if (type() == T_None) {
528 if (!sample_rate()) {
532 if (has_sample_format) {
533 if (sample_format() == SF_None) {
542 ExportFormatSpecification::set_format (boost::shared_ptr<ExportFormat> format)
545 FormatId new_fmt = format->get_format_id ();
546 bool fmt_changed = format_id() != new_fmt;
547 set_format_id (new_fmt);
549 set_type (format->get_type());
550 set_extension (format->extension());
552 if (format->get_explicit_sample_format()) {
553 set_sample_format (format->get_explicit_sample_format());
556 if (format->has_sample_format()) {
557 has_sample_format = true;
560 if (format->has_broadcast_info()) {
561 _has_broadcast_info = true;
564 _has_codec_quality = format->has_codec_quality();
565 if (!_has_codec_quality) {
567 } else if (fmt_changed) {
568 _codec_quality = boost::dynamic_pointer_cast<HasCodecQuality> (format)->default_codec_quality();
571 supports_tagging = format->supports_tagging ();
572 _channel_limit = format->get_channel_limit();
574 _format_name = format->name();
576 set_format_id (F_None);
579 _has_broadcast_info = false;
580 has_sample_format = false;
581 supports_tagging = false;
589 ExportFormatSpecification::description (bool include_name)
591 list<string> components;
594 if (_normalize_loudness) {
595 components.push_back (_("normalize loudness"));
597 components.push_back (_("normalize peak"));
601 if (_trim_beginning && _trim_end) {
602 components.push_back ( _("trim"));
603 } else if (_trim_beginning) {
604 components.push_back (_("trim start"));
605 } else if (_trim_end) {
606 components.push_back (_("trim end"));
609 if (_format_name != "") {
610 components.push_back (_format_name);
613 if (has_sample_format) {
614 components.push_back (HasSampleFormat::get_sample_format_name (sample_format()));
617 switch (sample_rate()) {
619 components.push_back ("8 kHz");
622 components.push_back ("22,5 kHz");
625 components.push_back ("44,1 kHz");
628 components.push_back ("48 kHz");
631 components.push_back ("88,2 kHz");
634 components.push_back ("96 kHz");
637 components.push_back ("176.4 kHz");
640 components.push_back ("192 kHz");
643 components.push_back (_("Session rate"));
650 components.push_back ("TOC");
654 components.push_back ("CUE");
657 if (_with_mp4chaps) {
658 components.push_back ("MP4ch");
661 if (!_command.empty()) {
662 components.push_back ("+");
670 for (list<string>::const_iterator it = components.begin(); it != components.end(); ++it) {
671 if (it != components.begin()) { desc += ", "; }
678 ExportFormatSpecification::add_option (XMLNode * node, std::string const & name, std::string const & value)
680 node = node->add_child ("Option");
681 node->set_property ("name", name);
682 node->set_property ("value", value);
686 ExportFormatSpecification::get_option (XMLNode const * node, std::string const & name)
688 XMLNodeList list (node->children ("Option"));
690 for (XMLNodeList::iterator it = list.begin(); it != list.end(); ++it) {
692 if ((*it)->get_property ("name", str) && name == str) {
693 if ((*it)->get_property ("value", str)) {
699 std::cerr << "Could not load encoding option \"" << name << "\" for export format" << std::endl;
704 }; // namespace ARDOUR