#include <list>
#include <vector>
#include <map>
-#include <set>
#include <stdexcept>
+#include <string>
#include <boost/shared_ptr.hpp>
-#include <boost/weak_ptr.hpp>
-#include <sigc++/signal.h>
-#include <glibmm/ustring.h>
-#include <pbd/uuid.h>
-#include <pbd/file_utils.h>
-#include <pbd/xml++.h>
+#include "pbd/uuid.h"
+#include "pbd/file_utils.h"
+#include "pbd/xml++.h"
-#include <ardour/filesystem_paths.h>
-#include <ardour/location.h>
-#include <ardour/types.h>
-
-using std::string;
-using std::list;
-using std::set;
+#include "ardour/filesystem_paths.h"
+#include "ardour/location.h"
+#include "ardour/libardour_visibility.h"
+#include "ardour/types.h"
+#include "ardour/export_handler.h"
namespace ARDOUR
{
class ExportHandler;
-class ExportTimespan;
-class ExportChannelConfiguration;
-class ExportFormatSpecification;
-class ExportFilename;
-class ExportPreset;
class Location;
class Session;
/// Manages (de)serialization of export profiles and related classes
-class ExportProfileManager
+class LIBARDOUR_API ExportProfileManager
{
public:
- ExportProfileManager (Session & s);
+ enum ExportType {
+ RegularExport,
+ RangeExport,
+ SelectionExport,
+ RegionExport,
+ StemExport
+ };
+
+ ExportProfileManager (Session & s, ExportType type);
~ExportProfileManager ();
void load_profile ();
void prepare_for_export ();
-
- typedef boost::shared_ptr<ExportPreset> PresetPtr;
- typedef std::list<PresetPtr> PresetList;
-
+
+ ExportType type () const { return _type; }
+
+ typedef std::list<ExportPresetPtr> PresetList;
+
PresetList const & get_presets () { return preset_list; }
- bool load_preset (PresetPtr preset);
- PresetPtr save_preset (string const & name);
+ bool load_preset (ExportPresetPtr preset);
+ ExportPresetPtr new_preset (std::string const & name);
+ ExportPresetPtr save_preset (std::string const & name);
void remove_preset ();
private:
typedef boost::shared_ptr<ExportHandler> HandlerPtr;
- typedef std::pair<PBD::UUID, PBD::sys::path> FilePair;
- typedef std::map<PBD::UUID, PBD::sys::path> FileMap;
-
+ typedef std::pair<PBD::UUID, std::string> FilePair;
+ typedef std::map<PBD::UUID, std::string> FileMap;
+
+ ExportType _type;
+ std::string xml_node_name;
HandlerPtr handler;
Session & session;
-
+
+ std::string preset_filename (std::string const & preset_name);
void load_presets ();
- void load_preset_from_disk (PBD::sys::path const & path);
-
+ void load_preset_from_disk (std::string const & path);
+
bool set_state (XMLNode const & root);
bool set_global_state (XMLNode const & root);
bool set_local_state (XMLNode const & root);
-
+
void serialize_profile (XMLNode & root);
void serialize_global_profile (XMLNode & root);
void serialize_local_profile (XMLNode & root);
-
- PresetList preset_list;
- PresetPtr current_preset;
- FileMap preset_file_map;
-
- std::vector<PBD::sys::path> find_file (std::string const & pattern);
-
- PBD::sys::path export_config_dir;
- PBD::SearchPath search_path;
+
+ PresetList preset_list;
+ ExportPresetPtr current_preset;
+ FileMap preset_file_map;
+
+ std::vector<std::string> find_file (std::string const & pattern);
+
+ std::string export_config_dir;
+ PBD::Searchpath search_path;
/* Timespans */
public:
- typedef boost::shared_ptr<ExportTimespan> TimespanPtr;
- typedef std::list<TimespanPtr> TimespanList;
+ typedef std::list<ExportTimespanPtr> TimespanList;
typedef boost::shared_ptr<TimespanList> TimespanListPtr;
typedef std::list<Location *> LocationList;
enum TimeFormat {
- SMPTE,
+ Timecode,
BBT,
MinSec,
Frames,
- Off
};
struct TimespanState {
TimespanListPtr timespans;
TimeFormat time_format;
-
- boost::shared_ptr<Location> session_range;
+
boost::shared_ptr<Location> selection_range;
boost::shared_ptr<LocationList> ranges;
-
- TimespanState (boost::shared_ptr<Location> session_range,
- boost::shared_ptr<Location> selection_range,
- boost::shared_ptr<LocationList> ranges) :
- timespans (new TimespanList ()),
- time_format (SMPTE),
-
- session_range (session_range),
- selection_range (selection_range),
- ranges (ranges)
+
+ TimespanState (boost::shared_ptr<Location> selection_range,
+ boost::shared_ptr<LocationList> ranges)
+ : timespans (new TimespanList ())
+ , time_format (Timecode)
+ , selection_range (selection_range)
+ , ranges (ranges)
{}
};
-
+
typedef boost::shared_ptr<TimespanState> TimespanStatePtr;
typedef std::list<TimespanStatePtr> TimespanStateList;
-
- void set_selection_range (nframes_t start = 0, nframes_t end = 0);
- std::string set_single_range (nframes_t start, nframes_t end, Glib::ustring name);
+
+ void set_selection_range (framepos_t start = 0, framepos_t end = 0);
+ std::string set_single_range (framepos_t start, framepos_t end, std::string name);
TimespanStateList const & get_timespans () { return check_list (timespans); }
-
+
private:
TimespanStateList timespans;
bool init_timespans (XMLNodeList nodes);
-
+
TimespanStatePtr deserialize_timespan (XMLNode & root);
XMLNode & serialize_timespan (TimespanStatePtr state);
-
+
/* Locations */
-
+
void update_ranges ();
-
- boost::shared_ptr<Location> session_range;
+
boost::shared_ptr<Location> selection_range;
boost::shared_ptr<LocationList> ranges;
-
+
bool single_range_mode;
boost::shared_ptr<Location> single_range;
/* Channel Configs */
public:
- typedef boost::shared_ptr<ExportChannelConfiguration> ChannelConfigPtr;
-
struct ChannelConfigState {
- ChannelConfigPtr config;
-
- ChannelConfigState (ChannelConfigPtr ptr) : config (ptr) {}
+ ExportChannelConfigPtr config;
+
+ ChannelConfigState (ExportChannelConfigPtr ptr) : config (ptr) {}
};
typedef boost::shared_ptr<ChannelConfigState> ChannelConfigStatePtr;
typedef std::list<ChannelConfigStatePtr> ChannelConfigStateList;
-
+
ChannelConfigStateList const & get_channel_configs () { return check_list (channel_configs); }
+ void clear_channel_configs () { channel_configs.clear(); }
+ ChannelConfigStatePtr add_channel_config ();
private:
/* Formats */
public:
- typedef boost::shared_ptr<ExportFormatSpecification> FormatPtr;
- typedef std::list<FormatPtr> FormatList;
+ typedef std::list<ExportFormatSpecPtr> FormatList;
struct FormatState {
boost::shared_ptr<FormatList const> list;
- FormatPtr format;
-
- FormatState (boost::shared_ptr<FormatList const> list, FormatPtr format) :
+ ExportFormatSpecPtr format;
+
+ FormatState (boost::shared_ptr<FormatList const> list, ExportFormatSpecPtr format) :
list (list), format (format) {}
};
typedef boost::shared_ptr<FormatState> FormatStatePtr;
typedef std::list<FormatStatePtr> FormatStateList;
-
+
FormatStateList const & get_formats () { return check_list (formats); }
FormatStatePtr duplicate_format_state (FormatStatePtr state);
void remove_format_state (FormatStatePtr state);
-
- PBD::sys::path save_format_to_disk (FormatPtr format);
- void remove_format_profile (FormatPtr format);
- FormatPtr get_new_format (FormatPtr original);
-
- sigc::signal<void> FormatListChanged;
+
+ std::string save_format_to_disk (ExportFormatSpecPtr format);
+ void remove_format_profile (ExportFormatSpecPtr format);
+ ExportFormatSpecPtr get_new_format (ExportFormatSpecPtr original);
+
+ PBD::Signal0<void> FormatListChanged;
private:
XMLNode & serialize_format (FormatStatePtr state);
void load_formats ();
-
- FormatPtr load_format (XMLNode & node);
- void load_format_from_disk (PBD::sys::path const & path);
+
+ ExportFormatSpecPtr load_format (XMLNode & node);
+ void load_format_from_disk (std::string const & path);
boost::shared_ptr<FormatList> format_list;
FileMap format_file_map;
-
+
/* Filenames */
public:
-
- typedef boost::shared_ptr<ExportFilename> FilenamePtr;
-
+
struct FilenameState {
- FilenamePtr filename;
-
- FilenameState (FilenamePtr ptr) : filename (ptr) {}
+ ExportFilenamePtr filename;
+
+ FilenameState (ExportFilenamePtr ptr) : filename (ptr) {}
};
typedef boost::shared_ptr<FilenameState> FilenameStatePtr;
typedef std::list<FilenameStatePtr> FilenameStateList;
-
+
FilenameStateList const & get_filenames () { return check_list (filenames); }
FilenameStatePtr duplicate_filename_state (FilenameStatePtr state);
void remove_filename_state (FilenameStatePtr state);
+ std::string get_sample_filename_for_format (ExportFilenamePtr filename, ExportFormatSpecPtr format);
+
private:
FilenameStateList filenames;
-
+
bool init_filenames (XMLNodeList nodes);
- FilenamePtr load_filename (XMLNode & node);
+ ExportFilenamePtr load_filename (XMLNode & node);
/* Warnings */
public:
struct Warnings {
- std::list<Glib::ustring> errors;
- std::list<Glib::ustring> warnings;
- std::list<Glib::ustring> conflicting_filenames;
+ std::list<std::string> errors;
+ std::list<std::string> warnings;
+ std::list<std::string> conflicting_filenames;
};
-
+
boost::shared_ptr<Warnings> get_warnings ();
-
+
private:
void check_config (boost::shared_ptr<Warnings> warnings,
TimespanStatePtr timespan_state,
FormatStatePtr format_state,
FilenameStatePtr filename_state);
+ bool check_format (ExportFormatSpecPtr format, uint32_t channels);
+ bool check_sndfile_format (ExportFormatSpecPtr format, unsigned int channels);
+
/* Utilities */
+ void build_filenames(std::list<std::string> & result, ExportFilenamePtr filename,
+ TimespanListPtr timespans, ExportChannelConfigPtr channel_config,
+ ExportFormatSpecPtr format);
+
/* Element state lists should never be empty, this is used to check them */
template<typename T>
std::list<T> const &
projects / ardour.git / blobdiff