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.
24 #include <glibmm/fileutils.h>
26 #include "pbd/enumwriter.h"
27 #include "pbd/xml++.h"
28 #include "pbd/convert.h"
30 #include "ardour/export_profile_manager.h"
31 #include "ardour/export_format_specification.h"
32 #include "ardour/export_timespan.h"
33 #include "ardour/export_channel_configuration.h"
34 #include "ardour/export_filename.h"
35 #include "ardour/export_preset.h"
36 #include "ardour/export_handler.h"
37 #include "ardour/export_failed.h"
38 #include "ardour/filename_extensions.h"
39 #include "ardour/route.h"
40 #include "ardour/session.h"
41 #include "ardour/broadcast_info.h"
52 ExportProfileManager::ExportProfileManager (Session
& s
, std::string xml_node_name
)
53 : xml_node_name (xml_node_name
)
54 , handler (s
.get_export_handler())
57 , session_range (new Location (s
))
58 , ranges (new LocationList ())
59 , single_range_mode (false)
61 , format_list (new FormatList ())
64 /* Initialize path variables */
66 export_config_dir
= user_config_directory();
67 export_config_dir
/= "export";
68 search_path
+= export_config_dir
;
70 search_path
+= ardour_search_path().add_subdirectory_to_paths("export");
72 sys::path sys_export
= ardour_module_directory();
73 sys_export
/= "export";
75 search_path
+= sys_export
;
77 info
<< string_compose (_("Searching for export formats in %1"), search_path
.to_string()) << endmsg
;
78 cerr
<< string_compose (_("Searching for export formats in %1"), search_path
.to_string()) << endl
;
80 /* create export config directory if necessary */
82 if (!sys::exists (export_config_dir
)) {
83 sys::create_directory (export_config_dir
);
89 /* Initialize all lists with an empty config */
92 init_timespans (dummy
);
93 init_channel_configs (dummy
);
95 init_filenames (dummy
);
98 ExportProfileManager::~ExportProfileManager ()
100 if (single_range_mode
) { return; }
102 XMLNode
* instant_xml (new XMLNode (xml_node_name
));
103 serialize_profile (*instant_xml
);
104 session
.add_instant_xml (*instant_xml
, false);
108 ExportProfileManager::load_profile ()
110 XMLNode
* instant_node
= session
.instant_xml (xml_node_name
);
112 set_state (*instant_node
);
114 XMLNode
empty_node (xml_node_name
);
115 set_state (empty_node
);
120 ExportProfileManager::prepare_for_export ()
122 TimespanListPtr ts_list
= timespans
.front()->timespans
;
124 FormatStateList::const_iterator format_it
;
125 FilenameStateList::const_iterator filename_it
;
128 for (TimespanList::iterator ts_it
= ts_list
->begin(); ts_it
!= ts_list
->end(); ++ts_it
) {
129 // ..., each format-filename pair
130 for (format_it
= formats
.begin(), filename_it
= filenames
.begin();
131 format_it
!= formats
.end() && filename_it
!= filenames
.end();
132 ++format_it
, ++filename_it
) {
134 FilenamePtr filename
= (*filename_it
)->filename
;
135 // filename->include_timespan = (ts_list->size() > 1); Disabled for now...
137 boost::shared_ptr
<BroadcastInfo
> b
;
138 if ((*format_it
)->format
->has_broadcast_info()) {
139 b
.reset (new BroadcastInfo
);
140 b
->set_from_session (session
, (*ts_it
)->get_start());
143 // ...and each channel config
144 filename
->include_channel_config
= (channel_configs
.size() > 1);
145 for(ChannelConfigStateList::iterator cc_it
= channel_configs
.begin(); cc_it
!= channel_configs
.end(); ++cc_it
) {
146 handler
->add_export_config (*ts_it
, (*cc_it
)->config
, (*format_it
)->format
, filename
, b
);
153 ExportProfileManager::load_preset (PresetPtr preset
)
157 current_preset
= preset
;
158 if (!preset
) { return false; }
160 XMLNode
const * state
;
161 if ((state
= preset
->get_local_state())) {
162 set_local_state (*state
);
163 } else { ok
= false; }
165 if ((state
= preset
->get_global_state())) {
166 if (!set_global_state (*state
)) {
169 } else { ok
= false; }
175 ExportProfileManager::load_presets ()
177 vector
<sys::path
> found
= find_file (string_compose (X_("*%1"),export_preset_suffix
));
179 for (vector
<sys::path
>::iterator it
= found
.begin(); it
!= found
.end(); ++it
) {
180 load_preset_from_disk (*it
);
184 ExportProfileManager::PresetPtr
185 ExportProfileManager::save_preset (string
const & name
)
187 string safe_name
= legalize_for_path (name
);
188 string filename
= export_config_dir
.to_string() + "/" + safe_name
+ export_preset_suffix
;
190 if (!current_preset
) {
191 current_preset
.reset (new ExportPreset (filename
, session
));
192 preset_list
.push_back (current_preset
);
195 XMLNode
* global_preset
= new XMLNode ("ExportPreset");
196 XMLNode
* local_preset
= new XMLNode ("ExportPreset");
198 serialize_global_profile (*global_preset
);
199 serialize_local_profile (*local_preset
);
201 current_preset
->set_name (name
);
202 current_preset
->set_global_state (*global_preset
);
203 current_preset
->set_local_state (*local_preset
);
205 current_preset
->save (filename
);
207 return current_preset
;
211 ExportProfileManager::remove_preset ()
213 if (!current_preset
) { return; }
215 for (PresetList::iterator it
= preset_list
.begin(); it
!= preset_list
.end(); ++it
) {
216 if (*it
== current_preset
) {
217 preset_list
.erase (it
);
222 FileMap::iterator it
= preset_file_map
.find (current_preset
->id());
223 if (it
!= preset_file_map
.end()) {
224 sys::remove (it
->second
);
225 preset_file_map
.erase (it
);
228 current_preset
->remove_local();
229 current_preset
.reset();
233 ExportProfileManager::load_preset_from_disk (PBD::sys::path
const & path
)
235 PresetPtr
preset (new ExportPreset (path
.to_string(), session
));
237 /* Handle id to filename mapping and don't add duplicates to list */
239 FilePair
pair (preset
->id(), path
);
240 if (preset_file_map
.insert (pair
).second
) {
241 preset_list
.push_back (preset
);
246 ExportProfileManager::set_state (XMLNode
const & root
)
248 return set_global_state (root
) & set_local_state (root
);
252 ExportProfileManager::set_global_state (XMLNode
const & root
)
254 return init_filenames (root
.children ("ExportFilename")) &
255 init_formats (root
.children ("ExportFormat"));
259 ExportProfileManager::set_local_state (XMLNode
const & root
)
261 return init_timespans (root
.children ("ExportTimespan")) &
262 init_channel_configs (root
.children ("ExportChannelConfiguration"));
266 ExportProfileManager::serialize_profile (XMLNode
& root
)
268 serialize_local_profile (root
);
269 serialize_global_profile (root
);
273 ExportProfileManager::serialize_global_profile (XMLNode
& root
)
275 for (FormatStateList::iterator it
= formats
.begin(); it
!= formats
.end(); ++it
) {
276 root
.add_child_nocopy (serialize_format (*it
));
279 for (FilenameStateList::iterator it
= filenames
.begin(); it
!= filenames
.end(); ++it
) {
280 root
.add_child_nocopy ((*it
)->filename
->get_state());
285 ExportProfileManager::serialize_local_profile (XMLNode
& root
)
287 for (TimespanStateList::iterator it
= timespans
.begin(); it
!= timespans
.end(); ++it
) {
288 root
.add_child_nocopy (serialize_timespan (*it
));
291 for (ChannelConfigStateList::iterator it
= channel_configs
.begin(); it
!= channel_configs
.end(); ++it
) {
292 root
.add_child_nocopy ((*it
)->config
->get_state());
296 std::vector
<sys::path
>
297 ExportProfileManager::find_file (std::string
const & pattern
)
299 vector
<sys::path
> found
;
301 Glib::PatternSpec
pattern_spec (pattern
);
302 find_matching_files_in_search_path (search_path
, pattern_spec
, found
);
308 ExportProfileManager::set_selection_range (framepos_t start
, framepos_t end
)
312 selection_range
.reset (new Location (session
));
313 selection_range
->set_name (_("Selection"));
314 selection_range
->set (start
, end
);
316 selection_range
.reset();
319 for (TimespanStateList::iterator it
= timespans
.begin(); it
!= timespans
.end(); ++it
) {
320 (*it
)->selection_range
= selection_range
;
325 ExportProfileManager::set_single_range (framepos_t start
, framepos_t end
, string name
)
327 single_range_mode
= true;
329 single_range
.reset (new Location (session
));
330 single_range
->set_name (name
);
331 single_range
->set (start
, end
);
335 return single_range
->id().to_s();
339 ExportProfileManager::init_timespans (XMLNodeList nodes
)
345 for (XMLNodeList::const_iterator it
= nodes
.begin(); it
!= nodes
.end(); ++it
) {
346 TimespanStatePtr span
= deserialize_timespan (**it
);
348 timespans
.push_back (span
);
349 } else { ok
= false; }
352 if (timespans
.empty()) {
353 TimespanStatePtr
state (new TimespanState (session_range
, selection_range
, ranges
));
354 timespans
.push_back (state
);
356 // Add session as default selection
357 TimespanPtr timespan
= handler
->add_timespan();
358 timespan
->set_name (session_range
->name());
359 timespan
->set_range_id ("session");
360 timespan
->set_range (session_range
->start(), session_range
->end());
361 state
->timespans
->push_back (timespan
);
368 ExportProfileManager::TimespanStatePtr
369 ExportProfileManager::deserialize_timespan (XMLNode
& root
)
371 TimespanStatePtr
state (new TimespanState (session_range
, selection_range
, ranges
));
372 XMLProperty
const * prop
;
374 XMLNodeList spans
= root
.children ("Range");
375 for (XMLNodeList::iterator node_it
= spans
.begin(); node_it
!= spans
.end(); ++node_it
) {
377 prop
= (*node_it
)->property ("id");
378 if (!prop
) { continue; }
379 string id
= prop
->value();
381 for (LocationList::iterator it
= ranges
->begin(); it
!= ranges
->end(); ++it
) {
382 if ((!id
.compare ("session") && *it
== session_range
.get()) ||
383 (!id
.compare ("selection") && *it
== selection_range
.get()) ||
384 (!id
.compare ((*it
)->id().to_s()))) {
385 TimespanPtr timespan
= handler
->add_timespan();
386 timespan
->set_name ((*it
)->name());
387 timespan
->set_range_id (id
);
388 timespan
->set_range ((*it
)->start(), (*it
)->end());
389 state
->timespans
->push_back (timespan
);
394 if ((prop
= root
.property ("format"))) {
395 state
->time_format
= (TimeFormat
) string_2_enum (prop
->value(), TimeFormat
);
402 ExportProfileManager::serialize_timespan (TimespanStatePtr state
)
404 XMLNode
& root
= *(new XMLNode ("ExportTimespan"));
409 for (TimespanList::iterator it
= state
->timespans
->begin(); it
!= state
->timespans
->end(); ++it
) {
410 if ((span
= root
.add_child ("Range"))) {
411 span
->add_property ("id", (*it
)->range_id());
415 root
.add_property ("format", enum_2_string (state
->time_format
));
421 ExportProfileManager::update_ranges () {
424 if (single_range_mode
) {
425 ranges
->push_back (single_range
.get());
431 session_range
->set_name (_("Session"));
432 session_range
->set (session
.current_start_frame(), session
.current_end_frame());
433 ranges
->push_back (session_range
.get());
437 if (selection_range
) {
438 ranges
->push_back (selection_range
.get());
443 LocationList
const & list (session
.locations()->list());
444 for (LocationList::const_iterator it
= list
.begin(); it
!= list
.end(); ++it
) {
445 if ((*it
)->is_range_marker()) {
446 ranges
->push_back (*it
);
451 ExportProfileManager::ChannelConfigStatePtr
452 ExportProfileManager::add_channel_config ()
454 ChannelConfigStatePtr
ptr(new ChannelConfigState(handler
->add_channel_config()));
455 channel_configs
.push_back(ptr
);
460 ExportProfileManager::init_channel_configs (XMLNodeList nodes
)
462 channel_configs
.clear();
465 ChannelConfigStatePtr
config (new ChannelConfigState (handler
->add_channel_config()));
466 channel_configs
.push_back (config
);
468 // Add master outs as default
469 IO
* master_out
= session
.master_out()->output().get();
470 if (!master_out
) { return false; }
472 for (uint32_t n
= 0; n
< master_out
->n_ports().n_audio(); ++n
) {
473 PortExportChannel
* channel
= new PortExportChannel ();
474 channel
->add_port (master_out
->audio (n
));
476 ExportChannelPtr
chan_ptr (channel
);
477 config
->config
->register_channel (chan_ptr
);
482 for (XMLNodeList::const_iterator it
= nodes
.begin(); it
!= nodes
.end(); ++it
) {
483 ChannelConfigStatePtr
config (new ChannelConfigState (handler
->add_channel_config()));
484 config
->config
->set_state (**it
);
485 channel_configs
.push_back (config
);
491 ExportProfileManager::FormatStatePtr
492 ExportProfileManager::duplicate_format_state (FormatStatePtr state
)
494 /* Note: The pointer in the new FormatState should point to the same format spec
495 as the original state's pointer. The spec itself should not be copied! */
497 FormatStatePtr
format (new FormatState (format_list
, state
->format
));
498 formats
.push_back (format
);
503 ExportProfileManager::remove_format_state (FormatStatePtr state
)
505 for (FormatStateList::iterator it
= formats
.begin(); it
!= formats
.end(); ++it
) {
514 ExportProfileManager::save_format_to_disk (FormatPtr format
)
516 // TODO filename character stripping
518 /* Get filename for file */
520 string new_name
= format
->name();
521 new_name
+= export_format_suffix
;
523 /* make sure its legal for the filesystem */
525 new_name
= legalize_for_path (new_name
);
527 sys::path
new_path (export_config_dir
);
528 new_path
/= new_name
;
530 /* Check if format is on disk already */
531 FileMap::iterator it
;
532 if ((it
= format_file_map
.find (format
->id())) != format_file_map
.end()) {
534 /* Check if config is not in user config dir */
535 if (it
->second
.branch_path().to_string().compare (export_config_dir
.to_string())) {
539 XMLTree
tree (new_path
.to_string());
540 tree
.set_root (&format
->get_state());
545 /* Update file and rename if necessary */
547 XMLTree
tree (it
->second
.to_string());
548 tree
.set_root (&format
->get_state());
551 if (new_name
.compare (it
->second
.leaf())) {
552 sys::rename (it
->second
, new_path
);
556 it
->second
= new_path
;
561 XMLTree
tree (new_path
.to_string());
562 tree
.set_root (&format
->get_state());
566 FormatListChanged ();
571 ExportProfileManager::remove_format_profile (FormatPtr format
)
573 for (FormatList::iterator it
= format_list
->begin(); it
!= format_list
->end(); ++it
) {
575 format_list
->erase (it
);
580 FileMap::iterator it
= format_file_map
.find (format
->id());
581 if (it
!= format_file_map
.end()) {
582 sys::remove (it
->second
);
583 format_file_map
.erase (it
);
586 FormatListChanged ();
589 ExportProfileManager::FormatPtr
590 ExportProfileManager::get_new_format (FormatPtr original
)
594 format
.reset (new ExportFormatSpecification (*original
));
596 format
= handler
->add_format();
597 format
->set_name ("empty format");
600 sys::path path
= save_format_to_disk (format
);
601 FilePair
pair (format
->id(), path
);
602 format_file_map
.insert (pair
);
604 format_list
->push_back (format
);
605 FormatListChanged ();
611 ExportProfileManager::init_formats (XMLNodeList nodes
)
616 for (XMLNodeList::const_iterator it
= nodes
.begin(); it
!= nodes
.end(); ++it
) {
617 FormatStatePtr format
= deserialize_format (**it
);
619 formats
.push_back (format
);
620 } else { ok
= false; }
623 if (formats
.empty ()) {
624 FormatStatePtr
format (new FormatState (format_list
, FormatPtr ()));
625 formats
.push_back (format
);
632 ExportProfileManager::FormatStatePtr
633 ExportProfileManager::deserialize_format (XMLNode
& root
)
638 if ((prop
= root
.property ("id"))) {
642 for (FormatList::iterator it
= format_list
->begin(); it
!= format_list
->end(); ++it
) {
643 if ((*it
)->id() == id
) {
644 return FormatStatePtr (new FormatState (format_list
, *it
));
648 return FormatStatePtr ();
652 ExportProfileManager::serialize_format (FormatStatePtr state
)
654 XMLNode
* root
= new XMLNode ("ExportFormat");
656 string id
= state
->format
? state
->format
->id().to_s() : "";
657 root
->add_property ("id", id
);
663 ExportProfileManager::load_formats ()
665 vector
<sys::path
> found
= find_file (string_compose ("*%1", export_format_suffix
));
667 for (vector
<sys::path
>::iterator it
= found
.begin(); it
!= found
.end(); ++it
) {
668 load_format_from_disk (*it
);
673 ExportProfileManager::load_format_from_disk (PBD::sys::path
const & path
)
675 XMLTree
const tree (path
.to_string());
676 FormatPtr format
= handler
->add_format (*tree
.root());
678 /* Handle id to filename mapping and don't add duplicates to list */
680 FilePair
pair (format
->id(), path
);
681 if (format_file_map
.insert (pair
).second
) {
682 format_list
->push_back (format
);
685 FormatListChanged ();
688 ExportProfileManager::FilenameStatePtr
689 ExportProfileManager::duplicate_filename_state (FilenameStatePtr state
)
691 FilenameStatePtr
filename (new FilenameState (handler
->add_filename_copy (state
->filename
)));
692 filenames
.push_back (filename
);
697 ExportProfileManager::remove_filename_state (FilenameStatePtr state
)
699 for (FilenameStateList::iterator it
= filenames
.begin(); it
!= filenames
.end(); ++it
) {
701 filenames
.erase (it
);
708 ExportProfileManager::init_filenames (XMLNodeList nodes
)
712 for (XMLNodeList::const_iterator it
= nodes
.begin(); it
!= nodes
.end(); ++it
) {
713 FilenamePtr filename
= handler
->add_filename();
714 filename
->set_state (**it
);
715 filenames
.push_back (FilenameStatePtr (new FilenameState (filename
)));
718 if (filenames
.empty()) {
719 FilenameStatePtr
filename (new FilenameState (handler
->add_filename()));
720 filenames
.push_back (filename
);
727 boost::shared_ptr
<ExportProfileManager::Warnings
>
728 ExportProfileManager::get_warnings ()
730 boost::shared_ptr
<Warnings
> warnings (new Warnings ());
732 assert (!channel_configs
.empty ());
734 ChannelConfigStatePtr channel_config_state
= channel_configs
.front();
735 TimespanStatePtr timespan_state
= timespans
.front();
737 /*** Check "global" config ***/
739 TimespanListPtr timespans
= timespan_state
->timespans
;
740 ChannelConfigPtr channel_config
= channel_config_state
->config
;
742 /* Check Timespans are not empty */
744 if (timespans
->empty()) {
745 warnings
->errors
.push_back (_("No timespan has been selected!"));
748 /* Check channel config ports */
750 if (!channel_config
->all_channels_have_ports ()) {
751 warnings
->warnings
.push_back (_("Some channels are empty"));
754 /*** Check files ***/
756 FormatStateList::const_iterator format_it
;
757 FilenameStateList::const_iterator filename_it
;
758 for (format_it
= formats
.begin(), filename_it
= filenames
.begin();
759 format_it
!= formats
.end() && filename_it
!= filenames
.end();
760 ++format_it
, ++filename_it
) {
761 check_config (warnings
, timespan_state
, channel_config_state
, *format_it
, *filename_it
);
768 ExportProfileManager::check_config (boost::shared_ptr
<Warnings
> warnings
,
769 TimespanStatePtr timespan_state
,
770 ChannelConfigStatePtr channel_config_state
,
771 FormatStatePtr format_state
,
772 FilenameStatePtr filename_state
)
774 TimespanListPtr timespans
= timespan_state
->timespans
;
775 ChannelConfigPtr channel_config
= channel_config_state
->config
;
776 FormatPtr format
= format_state
->format
;
777 FilenamePtr filename
= filename_state
->filename
;
779 /* Check format and maximum channel count */
780 if (!format
|| !format
->type()) {
781 warnings
->errors
.push_back (_("No format selected!"));
782 } else if (!channel_config
->get_n_chans()) {
783 warnings
->errors
.push_back (_("All channels are empty!"));
784 } else if (!check_format (format
, channel_config
->get_n_chans())) {
785 warnings
->errors
.push_back (_("One or more of the selected formats is not compatible with this system!"));
786 } else if (format
->channel_limit() < channel_config
->get_n_chans()) {
787 warnings
->errors
.push_back
788 (string_compose (_("%1 supports only %2 channels, but you have %3 channels in your channel configuration"),
789 format
->format_name(),
790 format
->channel_limit(),
791 channel_config
->get_n_chans()));
794 if (!warnings
->errors
.empty()) { return; }
796 /* Check filenames */
798 // filename->include_timespan = (timespans->size() > 1); Disabled for now...
800 for (std::list
<TimespanPtr
>::iterator timespan_it
= timespans
->begin(); timespan_it
!= timespans
->end(); ++timespan_it
) {
801 filename
->set_timespan (*timespan_it
);
803 if (channel_config
->get_split()) {
804 filename
->include_channel
= true;
806 for (uint32_t chan
= 1; chan
<= channel_config
->get_n_chans(); ++chan
) {
807 filename
->set_channel (chan
);
809 string path
= filename
->get_path (format
);
811 if (sys::exists (sys::path (path
))) {
812 warnings
->conflicting_filenames
.push_back (path
);
817 string path
= filename
->get_path (format
);
819 if (sys::exists (sys::path (path
))) {
820 warnings
->conflicting_filenames
.push_back (path
);
827 ExportProfileManager::check_format (FormatPtr format
, uint32_t channels
)
829 switch (format
->type()) {
830 case ExportFormatBase::T_Sndfile
:
831 return check_sndfile_format (format
, channels
);
834 throw ExportFailed (X_("Invalid format given for ExportFileFactory::check!"));
839 ExportProfileManager::check_sndfile_format (FormatPtr format
, unsigned int channels
)
842 sf_info
.channels
= channels
;
843 sf_info
.samplerate
= format
->sample_rate ();
844 sf_info
.format
= format
->format_id () | format
->sample_format ();
846 return (sf_format_check (&sf_info
) == SF_TRUE
? true : false);
849 }; // namespace ARDOUR