libs/ardour/ardour/export_profile_manager.h

   1 /*
   2     Copyright (C) 2008 Paul Davis
   3     Author: Sakari Bergen
   4
   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.
   9
  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.
  14
  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.
  18
  19 */
  20
  21 #ifndef __ardour_export_profile_manager_h__
  22 #define __ardour_export_profile_manager_h__
  23
  24 #include <list>
  25 #include <vector>
  26 #include <map>
  27 #include <set>
  28
  29 #include <boost/shared_ptr.hpp>
  30 #include <boost/weak_ptr.hpp>
  31 #include <sigc++/signal.h>
  32 #include <glibmm/ustring.h>
  33
  34 #include <pbd/uuid.h>
  35 #include <pbd/file_utils.h>
  36 #include <pbd/xml++.h>
  37
  38 #include <ardour/filesystem_paths.h>
  39 #include <ardour/location.h>
  40 #include <ardour/types.h>
  41
  42 using std::string;
  43 using std::list;
  44 using std::set;
  45
  46 namespace ARDOUR
  47 {
  48
  49 class ExportHandler;
  50 class ExportTimespan;
  51 class ExportChannelConfiguration;
  52 class ExportFormatSpecification;
  53 class ExportFilename;
  54 class ExportPreset;
  55 class Location;
  56 class Session;
  57
  58 /// Manages (de)serialization of export profiles and related classes
  59 class ExportProfileManager
  60 {
  61   public:
  62
  63         ExportProfileManager (Session & s);
  64         ~ExportProfileManager ();
  65
  66         void load_profile ();
  67         void prepare_for_export ();
  68
  69         typedef boost::shared_ptr<ExportPreset> PresetPtr;
  70         typedef std::list<PresetPtr> PresetList;
  71
  72         PresetList const & get_presets () { return preset_list; }
  73         bool load_preset (PresetPtr preset);
  74         PresetPtr save_preset (string const & name);
  75         void remove_preset ();
  76
  77   private:
  78         typedef boost::shared_ptr<ExportHandler> HandlerPtr;
  79
  80         typedef std::pair<PBD::UUID, PBD::sys::path> FilePair;
  81         typedef std::map<PBD::UUID, PBD::sys::path> FileMap;
  82
  83         HandlerPtr  handler;
  84         Session &   session;
  85
  86         void load_presets ();
  87         void load_preset_from_disk (PBD::sys::path const & path);
  88
  89         bool set_state (XMLNode const & root);
  90         bool set_global_state (XMLNode const & root);
  91         bool set_local_state (XMLNode const & root);
  92
  93         void serialize_profile (XMLNode & root);
  94         void serialize_global_profile (XMLNode & root);
  95         void serialize_local_profile (XMLNode & root);
  96
  97         PresetList preset_list;
  98         PresetPtr  current_preset;
  99         FileMap    preset_file_map;
 100
 101         std::vector<PBD::sys::path> find_file (std::string const & pattern);
 102
 103         PBD::sys::path  export_config_dir;
 104         PBD::SearchPath search_path;
 105
 106 /* Timespans */
 107   public:
 108
 109         typedef boost::shared_ptr<ExportTimespan> TimespanPtr;
 110         typedef std::list<TimespanPtr> TimespanList;
 111         typedef boost::shared_ptr<TimespanList> TimespanListPtr;
 112         typedef std::list<Location *> LocationList;
 113
 114         enum TimeFormat {
 115                 SMPTE,
 116                 BBT,
 117                 MinSec,
 118                 Frames,
 119                 Off
 120         };
 121
 122         struct TimespanState {
 123                 TimespanListPtr timespans;
 124                 TimeFormat      time_format;
 125
 126                 boost::shared_ptr<Location> session_range;
 127                 boost::shared_ptr<Location> selection_range;
 128                 boost::shared_ptr<LocationList> ranges;
 129
 130                 TimespanState (boost::shared_ptr<Location> session_range,
 131                                boost::shared_ptr<Location> selection_range,
 132                                boost::shared_ptr<LocationList> ranges) :
 133                   timespans (new TimespanList ()),
 134                   time_format (SMPTE),
 135
 136                   session_range (session_range),
 137                   selection_range (selection_range),
 138                   ranges (ranges)
 139                 {}
 140         };
 141
 142         typedef boost::shared_ptr<TimespanState> TimespanStatePtr;
 143         typedef std::list<TimespanStatePtr> TimespanStateList;
 144
 145         void set_selection_range (nframes_t start = 0, nframes_t end = 0);
 146         TimespanStateList const & get_timespans () { return timespans; }
 147
 148   private:
 149
 150         TimespanStateList timespans;
 151
 152         bool init_timespans (XMLNodeList nodes);
 153
 154         TimespanStatePtr deserialize_timespan (XMLNode & root);
 155         XMLNode & serialize_timespan (TimespanStatePtr state);
 156
 157         /* Locations */
 158
 159         void update_ranges ();
 160
 161         boost::shared_ptr<Location>     session_range;
 162         boost::shared_ptr<Location>     selection_range;
 163         boost::shared_ptr<LocationList> ranges;
 164
 165 /* Channel Configs */
 166   public:
 167
 168         typedef boost::shared_ptr<ExportChannelConfiguration> ChannelConfigPtr;
 169
 170         struct ChannelConfigState {
 171                 ChannelConfigPtr config;
 172
 173                 ChannelConfigState (ChannelConfigPtr ptr) : config (ptr) {}
 174         };
 175         typedef boost::shared_ptr<ChannelConfigState> ChannelConfigStatePtr;
 176         typedef std::list<ChannelConfigStatePtr> ChannelConfigStateList;
 177
 178         ChannelConfigStateList const & get_channel_configs () { return channel_configs; }
 179
 180   private:
 181
 182         ChannelConfigStateList channel_configs;
 183
 184         bool init_channel_configs (XMLNodeList nodes);
 185
 186 /* Formats */
 187   public:
 188
 189         typedef boost::shared_ptr<ExportFormatSpecification> FormatPtr;
 190         typedef std::list<FormatPtr> FormatList;
 191
 192         struct FormatState {
 193                 boost::shared_ptr<FormatList const> list;
 194                 FormatPtr                           format;
 195
 196                 FormatState (boost::shared_ptr<FormatList const> list, FormatPtr format) :
 197                   list (list), format (format) {}
 198         };
 199         typedef boost::shared_ptr<FormatState> FormatStatePtr;
 200         typedef std::list<FormatStatePtr> FormatStateList;
 201
 202         FormatStateList const & get_formats () { return formats; }
 203         FormatStatePtr duplicate_format_state (FormatStatePtr state);
 204         void remove_format_state (FormatStatePtr state);
 205
 206         PBD::sys::path save_format_to_disk (FormatPtr format);
 207         void remove_format_profile (FormatPtr format);
 208         FormatPtr get_new_format (FormatPtr original);
 209
 210         sigc::signal<void> FormatListChanged;
 211
 212   private:
 213
 214         FormatStateList formats;
 215
 216         bool init_formats (XMLNodeList nodes);
 217         FormatStatePtr deserialize_format (XMLNode & root);
 218         XMLNode & serialize_format (FormatStatePtr state);
 219
 220         void load_formats ();
 221
 222         FormatPtr load_format (XMLNode & node);
 223         void load_format_from_disk (PBD::sys::path const & path);
 224
 225         boost::shared_ptr<FormatList> format_list;
 226         FileMap                       format_file_map;
 227
 228 /* Filenames */
 229   public:
 230
 231         typedef boost::shared_ptr<ExportFilename> FilenamePtr;
 232
 233         struct FilenameState {
 234                 FilenamePtr  filename;
 235
 236                 FilenameState (FilenamePtr ptr) : filename (ptr) {}
 237         };
 238         typedef boost::shared_ptr<FilenameState> FilenameStatePtr;
 239         typedef std::list<FilenameStatePtr> FilenameStateList;
 240
 241         FilenameStateList const & get_filenames () { return filenames; }
 242         FilenameStatePtr duplicate_filename_state (FilenameStatePtr state);
 243         void remove_filename_state (FilenameStatePtr state);
 244
 245   private:
 246
 247         FilenameStateList filenames;
 248
 249         bool init_filenames (XMLNodeList nodes);
 250         FilenamePtr load_filename (XMLNode & node);
 251
 252 /* Warnings */
 253   public:
 254         struct Warnings {
 255                 std::list<Glib::ustring> errors;
 256                 std::list<Glib::ustring> warnings;
 257                 std::list<Glib::ustring> conflicting_filenames;
 258         };
 259
 260         boost::shared_ptr<Warnings> get_warnings ();
 261
 262   private:
 263         void check_config (boost::shared_ptr<Warnings> warnings,
 264                            TimespanStatePtr timespan_state,
 265                            ChannelConfigStatePtr channel_config_state,
 266                            FormatStatePtr format_state,
 267                            FilenameStatePtr filename_state);
 268 };
 269
 270
 271 } // namespace ARDOUR
 272
 273 #endif /* __ardour_export_profile_manager_h__ */