#include "ardour/filename_extensions.h"
#include "ardour/graph.h"
#include "ardour/location.h"
+#ifdef LV2_SUPPORT
#include "ardour/lv2_plugin.h"
+#endif
#include "ardour/midi_model.h"
#include "ardour/midi_patch_manager.h"
#include "ardour/midi_region.h"
setup_midi_machine_control ();
if (_butler->start_thread()) {
+ error << _("Butler did not start") << endmsg;
return -1;
}
if (start_midi_thread ()) {
+ error << _("MIDI I/O thread did not start") << endmsg;
return -1;
}
delete _tempo_map;
_tempo_map = new TempoMap (_current_frame_rate);
_tempo_map->PropertyChanged.connect_same_thread (*this, boost::bind (&Session::tempo_map_changed, this, _1));
- _tempo_map->MetricPositionChanged.connect_same_thread (*this, boost::bind (&Session::gui_tempo_map_changed, this));
+ _tempo_map->MetricPositionChanged.connect_same_thread (*this, boost::bind (&Session::tempo_map_changed, this, _1));
/* MidiClock requires a tempo map */
SndFileSource::setup_standard_crossfades (*this, frame_rate());
_engine.GraphReordered.connect_same_thread (*this, boost::bind (&Session::graph_reordered, this));
+ _engine.MidiSelectionPortsChanged.connect_same_thread (*this, boost::bind (&Session::rewire_midi_selection_ports, this));
AudioDiskstream::allocate_working_buffers();
refresh_disk_space ();
if (state_tree) {
if (set_state (*state_tree->root(), Stateful::loading_state_version)) {
+ error << _("Could not set session state from XML") << endmsg;
return -1;
}
} else {
/* handle this one in a different way than all others, so that its clear what happened */
error << err.what() << endmsg;
return -1;
+ } catch (std::exception const & e) {
+ error << _("Unexpected exception during session setup: ") << e.what() << endmsg;
+ return -1;
} catch (...) {
+ error << _("Unknown exception during session setup") << endmsg;
return -1;
}
/* Initial loop location, from absolute zero, length 10 seconds */
- Location* loc = new Location (*this, 0, 10.0 * _engine.sample_rate(), _("Loop"), Location::IsAutoLoop);
+ Location* loc = new Location (*this, 0, 10.0 * _engine.sample_rate(), _("Loop"), Location::IsAutoLoop, 0);
_locations->add (loc, true);
set_auto_loop_location (loc);
}
return -1;
}
}
- } else {
- XMLNode* child;
- if ((child = find_named_node (root, "ProgramVersion")) != 0) {
- if ((prop = child->property ("modified-with")) != 0) {
- std::string modified_with = prop->value ();
-
- const double modified_with_version = atof (modified_with.substr ( modified_with.find(" ", 0) + 1, string::npos).c_str());
- const int modified_with_revision = atoi (modified_with.substr (modified_with.find("-", 0) + 1, string::npos).c_str());
-
- if (modified_with_version <= 5.3 && !(modified_with_version == 5.3 && modified_with_revision > 42)) {
- _midi_regions_use_bbt_beats = true;
- }
- }
- }
}
save_snapshot_name (snapshot_name);
return state(false);
}
+typedef std::set<boost::shared_ptr<Playlist> > PlaylistSet;
+typedef std::set<boost::shared_ptr<Source> > SourceSet;
+
+bool
+Session::export_track_state (boost::shared_ptr<RouteList> rl, const string& path)
+{
+ if (Glib::file_test (path, Glib::FILE_TEST_EXISTS)) {
+ return false;
+ }
+ if (g_mkdir_with_parents (path.c_str(), 0755) != 0) {
+ return false;
+ }
+
+ PBD::Unwinder<std::string> uw (_template_state_dir, path);
+
+ LocaleGuard lg;
+ XMLNode* node = new XMLNode("TrackState"); // XXX
+ XMLNode* child;
+
+ PlaylistSet playlists; // SessionPlaylists
+ SourceSet sources;
+
+ // these will work with new_route_from_template()
+ // TODO: LV2 plugin-state-dir needs to be relative (on load?)
+ child = node->add_child ("Routes");
+ for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
+ if ((*i)->is_auditioner()) {
+ continue;
+ }
+ if ((*i)->is_master() || (*i)->is_monitor()) {
+ continue;
+ }
+ child->add_child_nocopy ((*i)->get_state());
+ boost::shared_ptr<Track> track = boost::dynamic_pointer_cast<Track> (*i);
+ if (track) {
+ playlists.insert (track->playlist ());
+ }
+ }
+
+ // on load, Regions in the playlists need to resolve and map Source-IDs
+ // also playlist needs to be merged or created with new-name..
+ // ... and Diskstream in tracks adjusted to use the correct playlist
+ child = node->add_child ("Playlists"); // SessionPlaylists::add_state
+ for (PlaylistSet::const_iterator i = playlists.begin(); i != playlists.end(); ++i) {
+ child->add_child_nocopy ((*i)->get_state ());
+ boost::shared_ptr<RegionList> prl = (*i)->region_list ();
+ for (RegionList::const_iterator s = prl->begin(); s != prl->end(); ++s) {
+ const Region::SourceList& sl = (*s)->sources ();
+ for (Region::SourceList::const_iterator sli = sl.begin(); sli != sl.end(); ++sli) {
+ sources.insert (*sli);
+ }
+ }
+ }
+
+ child = node->add_child ("Sources");
+ for (SourceSet::const_iterator i = sources.begin(); i != sources.end(); ++i) {
+ child->add_child_nocopy ((*i)->get_state ());
+ boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (*i);
+ if (fs) {
+#ifdef PLATFORM_WINDOWS
+ fs->close ();
+#endif
+ string p = fs->path ();
+ PBD::copy_file (p, Glib::build_filename (path, Glib::path_get_basename (p)));
+ }
+ }
+
+ std::string sn = Glib::build_filename (path, "share.axml");
+
+ XMLTree tree;
+ tree.set_root (node);
+ return tree.write (sn.c_str());
+}
+
XMLNode&
Session::state (bool full_state)
{
node->add_child_nocopy (*midi_port_stuff);
}
- node->add_child_nocopy (config.get_variables ());
+ XMLNode& cfgxml (config.get_variables ());
+ if (!full_state) {
+ /* exclude search-paths from template */
+ cfgxml.remove_nodes_and_delete ("name", "audio-search-path");
+ cfgxml.remove_nodes_and_delete ("name", "midi-search-path");
+ cfgxml.remove_nodes_and_delete ("name", "raid-path");
+ }
+ node->add_child_nocopy (cfgxml);
node->add_child_nocopy (ARDOUR::SessionMetadata::Metadata()->get_state());
}
} else {
Locations loc (*this);
+ const bool was_dirty = dirty();
// for a template, just create a new Locations, populate it
// with the default start and end, and get the state for that.
- Location* range = new Location (*this, 0, 0, _("session"), Location::IsSessionRange);
+ Location* range = new Location (*this, 0, 0, _("session"), Location::IsSessionRange, 0);
range->set (max_framepos, 0);
loc.add (range);
XMLNode& locations_state = loc.get_state();
}
}
node->add_child_nocopy (locations_state);
+
+ /* adding a location above will have marked the session
+ * dirty. This is an artifact, so fix it if the session wasn't
+ * already dirty
+ */
+
+ if (!was_dirty) {
+ _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
+ }
}
child = node->add_child ("Bundles");
{
XMLNodeList nlist;
XMLNodeConstIterator niter;
- boost::shared_ptr<Source> source; /* don't need this but it stops some
- * versions of gcc complaining about
- * discarded return values.
- */
+ /* don't need this but it stops some
+ * versions of gcc complaining about
+ * discarded return values.
+ */
+ boost::shared_ptr<Source> source;
nlist = node.children();
set_dirty();
+ std::map<std::string, std::string> relocation;
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
- retry:
+#ifdef PLATFORM_WINDOWS
+ int old_mode = 0;
+#endif
+
+ XMLNode srcnode (**niter);
+ bool try_replace_abspath = true;
+
+retry:
try {
- if ((source = XMLSourceFactory (**niter)) == 0) {
+#ifdef PLATFORM_WINDOWS
+ // do not show "insert media" popups (files embedded from removable media).
+ old_mode = SetErrorMode(SEM_FAILCRITICALERRORS);
+#endif
+ if ((source = XMLSourceFactory (srcnode)) == 0) {
error << _("Session: cannot create Source from XML description.") << endmsg;
}
+#ifdef PLATFORM_WINDOWS
+ SetErrorMode(old_mode);
+#endif
} catch (MissingSource& err) {
+#ifdef PLATFORM_WINDOWS
+ SetErrorMode(old_mode);
+#endif
+
+ /* try previous abs path replacements first */
+ if (try_replace_abspath && Glib::path_is_absolute (err.path)) {
+ std::string dir = Glib::path_get_dirname (err.path);
+ std::map<std::string, std::string>::const_iterator rl = relocation.find (dir);
+ if (rl != relocation.end ()) {
+ std::string newpath = Glib::build_filename (rl->second, Glib::path_get_basename (err.path));
+ if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
+ srcnode.add_property ("origin", newpath);
+ try_replace_abspath = false;
+ goto retry;
+ }
+ }
+ }
- int user_choice;
+ int user_choice;
+ _missing_file_replacement = "";
if (err.type == DataType::MIDI && Glib::path_is_absolute (err.path)) {
- error << string_compose (_("A external MIDI file is missing. %1 cannot currently recover from missing external MIDI files"),
- PROGRAM_NAME) << endmsg;
+ error << string_compose (_("An external MIDI file is missing. %1 cannot currently recover from missing external MIDI files"),
+ PROGRAM_NAME) << endmsg;
return -1;
}
- if (!no_questions_about_missing_files) {
+ if (!no_questions_about_missing_files) {
user_choice = MissingFile (this, err.path, err.type).get_value_or (-1);
} else {
- user_choice = -2;
- }
+ user_choice = -2;
+ }
- switch (user_choice) {
- case 0:
- /* user added a new search location, so try again */
- goto retry;
+ switch (user_choice) {
+ case 0:
+ /* user added a new search location
+ * or selected a new absolute path,
+ * so try again */
+ if (Glib::path_is_absolute (err.path)) {
+ if (!_missing_file_replacement.empty ()) {
+ /* replace origin, in XML */
+ std::string newpath = Glib::build_filename (
+ _missing_file_replacement, Glib::path_get_basename (err.path));
+ srcnode.add_property ("origin", newpath);
+ relocation[Glib::path_get_dirname (err.path)] = _missing_file_replacement;
+ _missing_file_replacement = "";
+ }
+ }
+ goto retry;
- case 1:
- /* user asked to quit the entire session load
- */
- return -1;
+ case 1:
+ /* user asked to quit the entire session load */
+ return -1;
- case 2:
- no_questions_about_missing_files = true;
- goto retry;
+ case 2:
+ no_questions_about_missing_files = true;
+ goto retry;
- case 3:
- no_questions_about_missing_files = true;
- /* fallthru */
+ case 3:
+ no_questions_about_missing_files = true;
+ /* fallthru */
- case -1:
- default:
- switch (err.type) {
+ case -1:
+ default:
+ switch (err.type) {
- case DataType::AUDIO:
- source = SourceFactory::createSilent (*this, **niter, max_framecnt, _current_frame_rate);
- break;
+ case DataType::AUDIO:
+ source = SourceFactory::createSilent (*this, **niter, max_framecnt, _current_frame_rate);
+ break;
- case DataType::MIDI:
- /* The MIDI file is actually missing so
- * just create a new one in the same
- * location. Do not announce its
- */
- string fullpath;
-
- if (!Glib::path_is_absolute (err.path)) {
- fullpath = Glib::build_filename (source_search_path (DataType::MIDI).front(), err.path);
- } else {
- /* this should be an unrecoverable error: we would be creating a MIDI file outside
- the session tree.
- */
- return -1;
+ case DataType::MIDI:
+ /* The MIDI file is actually missing so
+ * just create a new one in the same
+ * location. Do not announce its
+ */
+ string fullpath;
+
+ if (!Glib::path_is_absolute (err.path)) {
+ fullpath = Glib::build_filename (source_search_path (DataType::MIDI).front(), err.path);
+ } else {
+ /* this should be an unrecoverable error: we would be creating a MIDI file outside
+ * the session tree.
+ */
+ return -1;
+ }
+ /* Note that we do not announce the source just yet - we need to reset its ID before we do that */
+ source = SourceFactory::createWritable (DataType::MIDI, *this, fullpath, false, _current_frame_rate, false, false);
+ /* reset ID to match the missing one */
+ source->set_id (**niter);
+ /* Now we can announce it */
+ SourceFactory::SourceCreated (source);
+ break;
}
- /* Note that we do not announce the source just yet - we need to reset its ID before we do that */
- source = SourceFactory::createWritable (DataType::MIDI, *this, fullpath, false, _current_frame_rate, false, false);
- /* reset ID to match the missing one */
- source->set_id (**niter);
- /* Now we can announce it */
- SourceFactory::SourceCreated (source);
break;
- }
- break;
- }
+ }
}
}
void
Session::refresh_disk_space ()
{
-#if __APPLE__ || __FreeBSD__ || (HAVE_SYS_VFS_H && HAVE_SYS_STATVFS_H)
+#if __APPLE__ || __FreeBSD__ || __NetBSD__ || (HAVE_SYS_VFS_H && HAVE_SYS_STATVFS_H)
Glib::Threads::Mutex::Lock lm (space_lock);
_total_free_4k_blocks_uncertain = false;
for (vector<space_and_path>::iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
+#if defined(__NetBSD__)
+ struct statvfs statfsbuf;
+ statvfs (i->path.c_str(), &statfsbuf);
+#else
struct statfs statfsbuf;
- statfs (i->path.c_str(), &statfsbuf);
+ statfs (i->path.c_str(), &statfsbuf);
+#endif
double const scale = statfsbuf.f_bsize / 4096.0;
/* See if this filesystem is read-only */
return possible_states(_path);
}
+RouteGroup*
+Session::new_route_group (const std::string& name)
+{
+ RouteGroup* rg = NULL;
+
+ for (std::list<RouteGroup*>::const_iterator i = _route_groups.begin (); i != _route_groups.end (); ++i) {
+ if ((*i)->name () == name) {
+ rg = *i;
+ break;
+ }
+ }
+
+ if (!rg) {
+ rg = new RouteGroup (*this, name);
+ add_route_group (rg);
+ }
+ return (rg);
+}
+
void
Session::add_route_group (RouteGroup* g)
{
capture files.
*/
- if (!i->second->used() && (i->second->length(i->second->timeline_position() > 0))) {
+ if (!i->second->used() && (i->second->length(i->second->timeline_position()) > 0)) {
dead_sources.push_back (i->second);
i->second->drop_references ();
}
_state_of_the_state = StateOfTheState (_state_of_the_state | Dirty);
-
if (!was_dirty) {
DirtyChanged(); /* EMIT SIGNAL */
}
}
-
void
Session::set_clean ()
{
_state_of_the_state = Clean;
-
if (was_dirty) {
DirtyChanged(); /* EMIT SIGNAL */
}
XMLNode*
Session::instant_xml (const string& node_name)
{
+#ifdef MIXBUS // "Safe Mode" (shift + click open) -> also ignore instant.xml
+ if (get_disable_all_loaded_plugins ()) {
+ return NULL;
+ }
+#endif
return Stateful::instant_xml (node_name, _path);
}
// replace history
_history.clear();
- for (XMLNodeConstIterator it = tree.root()->children().begin(); it != tree.root()->children().end(); it++) {
+ for (XMLNodeConstIterator it = tree.root()->children().begin(); it != tree.root()->children().end(); ++it) {
XMLNode *t = *it;
UndoTransaction* ut = new UndoTransaction ();
} else if (p == "auto-loop") {
+ } else if (p == "session-monitoring") {
+
} else if (p == "auto-input") {
if (Config->get_monitoring_model() == HardwareMonitoring && transport_rolling()) {
/* auto-input only makes a difference if we're rolling */
- set_track_monitor_input_status (!config.get_auto_input());
+ set_track_monitor_input_status (!config.get_auto_input());
}
} else if (p == "punch-in") {
_mmc->enable_send (Config->get_send_mmc ());
- } else if (p == "midi-feedback") {
-
- session_midi_feedback = Config->get_midi_feedback();
-
} else if (p == "jack-time-master") {
engine().reset_timebase ();
}
int
-Session::get_session_info_from_path (XMLTree& tree, const string& xmlpath)
+Session::get_info_from_path (const string& xmlpath, float& sample_rate, SampleFormat& data_format, std::string& program_version)
{
+ bool found_sr = false;
+ bool found_data_format = false;
+ program_version = "";
+
if (!Glib::file_test (xmlpath, Glib::FILE_TEST_EXISTS)) {
return -1;
- }
+ }
- if (!tree.read (xmlpath)) {
+ xmlParserCtxtPtr ctxt = xmlNewParserCtxt();
+ if (ctxt == NULL) {
return -1;
}
+ xmlDocPtr doc = xmlCtxtReadFile (ctxt, xmlpath.c_str(), NULL, XML_PARSE_HUGE);
- return 0;
-}
-
-int
-Session::get_info_from_path (const string& xmlpath, float& sample_rate, SampleFormat& data_format)
-{
- XMLTree tree;
- bool found_sr = false;
- bool found_data_format = false;
-
- if (get_session_info_from_path (tree, xmlpath)) {
+ if (doc == NULL) {
+ xmlFreeParserCtxt(ctxt);
return -1;
}
- /* sample rate */
-
- XMLProperty const * prop;
- XMLNode const * root (tree.root());
+ xmlNodePtr node = xmlDocGetRootElement(doc);
- if ((prop = root->property (X_("sample-rate"))) != 0) {
- sample_rate = atoi (prop->value());
- found_sr = true;
+ if (node == NULL) {
+ xmlFreeParserCtxt(ctxt);
+ xmlFreeDoc (doc);
+ return -1;
}
- const XMLNodeList& children (root->children());
- for (XMLNodeList::const_iterator c = children.begin(); c != children.end(); ++c) {
- const XMLNode* child = *c;
- if (child->name() == "Config") {
- const XMLNodeList& options (child->children());
- for (XMLNodeList::const_iterator oc = options.begin(); oc != options.end(); ++oc) {
- XMLNode const * option = *oc;
- XMLProperty const * name = option->property("name");
-
- if (!name) {
- continue;
- }
+ /* sample rate */
- if (name->value() == "native-file-data-format") {
- XMLProperty const * value = option->property ("value");
- if (value) {
- SampleFormat fmt = (SampleFormat) string_2_enum (option->property ("value")->value(), fmt);
- data_format = fmt;
- found_data_format = true;
- break;
- }
- }
- }
- }
- if (found_data_format) {
- break;
- }
- }
+ xmlAttrPtr attr;
+ for (attr = node->properties; attr; attr = attr->next) {
+ if (!strcmp ((const char*)attr->name, "sample-rate") && attr->children) {
+ sample_rate = atoi ((char*)attr->children->content);
+ found_sr = true;
+ }
+ }
+
+ node = node->children;
+ while (node != NULL) {
+ if (!strcmp((const char*) node->name, "ProgramVersion")) {
+ xmlChar* val = xmlGetProp (node, (const xmlChar*)"modified-with");
+ if (val) {
+ program_version = string ((const char*)val);
+ size_t sep = program_version.find_first_of("-");
+ if (sep != string::npos) {
+ program_version = program_version.substr (0, sep);
+ }
+ }
+ xmlFree (val);
+ }
+ if (strcmp((const char*) node->name, "Config")) {
+ node = node->next;
+ continue;
+ }
+ for (node = node->children; node; node = node->next) {
+ xmlChar* pv = xmlGetProp (node, (const xmlChar*)"name");
+ if (pv && !strcmp ((const char*)pv, "native-file-data-format")) {
+ xmlFree (pv);
+ xmlChar* val = xmlGetProp (node, (const xmlChar*)"value");
+ if (val) {
+ SampleFormat fmt = (SampleFormat) string_2_enum (string ((const char*)val), fmt);
+ data_format = fmt;
+ found_data_format = true;
+ }
+ xmlFree (val);
+ break;
+ }
+ xmlFree (pv);
+ }
+ break;
+ }
+
+ xmlFreeParserCtxt(ctxt);
+ xmlFreeDoc (doc);
return !(found_sr && found_data_format); // zero if they are both found
}
}
}
-
_path = to_dir;
set_snapshot_name (saveas.new_name);
_name = saveas.new_name;
bool was_dirty = dirty ();
- save_state ("", false, false, !saveas.include_media);
save_default_options ();
if (saveas.copy_media && saveas.copy_external) {
if (!saveas.switch_to) {
+ /* save the new state */
+
+ save_state ("", false, false, !saveas.include_media);
+
/* switch back to the way things were */
_path = old_path;
*/
reset_write_sources (true, true);
+ /* creating new write sources marks the session as
+ dirty. If the new session is empty, then
+ save_state() thinks we're saving a template and will
+ not mark the session as clean. So do that here,
+ before we save state.
+ */
+
+ if (!saveas.include_media) {
+ _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
+ }
+
+ save_state ("", false, false, !saveas.include_media);
+
/* the copying above was based on actually discovering files, not just iterating over the sources list.
But if we're going to switch to the new (copied) session, we need to change the paths in the sources also.
*/
}
int
-Session::archive_session (const std::string& dest, const std::string& name, ArchiveEncode compress_audio, Progress* progress)
+Session::archive_session (const std::string& dest,
+ const std::string& name,
+ ArchiveEncode compress_audio,
+ bool only_used_sources,
+ Progress* progress)
{
if (dest.empty () || name.empty ()) {
return -1;
/* prepare archive */
string archive = Glib::build_filename (dest, name + ".tar.xz");
-#ifndef NDEBUG
- cout << "ARCHIVE: " << archive << "\n";
-#endif
-
PBD::ScopedConnectionList progress_connection;
PBD::FileArchive ar (archive);
if (progress) {
blacklist_dirs.push_back (string (plugins_dir_name) + G_DIR_SEPARATOR);
std::map<boost::shared_ptr<AudioFileSource>, std::string> orig_sources;
+ std::map<boost::shared_ptr<AudioFileSource>, float> orig_gain;
- if (compress_audio != NO_ENCODE) {
+ set<boost::shared_ptr<Source> > sources_used_by_this_snapshot;
+ if (only_used_sources) {
+ playlists->sync_all_regions_with_regions ();
+ playlists->foreach (boost::bind (merge_all_sources, _1, &sources_used_by_this_snapshot), false);
+ }
+
+ // collect audio sources for this session, calc total size for encoding
+ // add option to only include *used* sources (see Session::cleanup_sources)
+ size_t total_size = 0;
+ {
Glib::Threads::Mutex::Lock lm (source_lock);
for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> (i->second);
- if (!afs) {
+ if (!afs || afs->readable_length () == 0) {
continue;
}
- if (afs->readable_length () == 0) {
+
+ if (only_used_sources) {
+ if (!afs->used()) {
+ continue;
+ }
+ if (sources_used_by_this_snapshot.find (afs) == sources_used_by_this_snapshot.end ()) {
+ continue;
+ }
+ }
+
+ std::string from = afs->path();
+
+ if (compress_audio != NO_ENCODE) {
+ total_size += afs->readable_length ();
+ } else {
+ if (afs->within_session()) {
+ filemap[from] = make_new_media_path (from, name, name);
+ } else {
+ filemap[from] = make_new_media_path (from, name, name);
+ remove_dir_from_search_path (Glib::path_get_dirname (from), DataType::AUDIO);
+ }
+ }
+ }
+ }
+
+ /* encode audio */
+ if (compress_audio != NO_ENCODE) {
+ if (progress) {
+ progress->set_progress (2); // set to "encoding"
+ progress->set_progress (0);
+ }
+
+ Glib::Threads::Mutex::Lock lm (source_lock);
+ for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
+ boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> (i->second);
+ if (!afs || afs->readable_length () == 0) {
continue;
}
+ if (only_used_sources) {
+ if (!afs->used()) {
+ continue;
+ }
+ if (sources_used_by_this_snapshot.find (afs) == sources_used_by_this_snapshot.end ()) {
+ continue;
+ }
+ }
+
orig_sources[afs] = afs->path();
+ orig_gain[afs] = afs->gain();
std::string new_path = make_new_media_path (afs->path (), to_dir, name);
new_path = Glib::build_filename (Glib::path_get_dirname (new_path), PBD::basename_nosuffix (new_path) + ".flac");
g_mkdir_with_parents (Glib::path_get_dirname (new_path).c_str (), 0755);
- // TODO: set progress to "encoding", use total readable_length () somehow.
- // .. or a custom progress report like save-as.
+ if (progress) {
+ progress->descend ((float)afs->readable_length () / total_size);
+ }
+
try {
- SndFileSource* ns = new SndFileSource (*this, *(afs.get()), new_path, compress_audio == FLAC_16BIT, NULL /*progress*/);
+ SndFileSource* ns = new SndFileSource (*this, *(afs.get()), new_path, compress_audio == FLAC_16BIT, progress);
afs->replace_file (new_path);
+ afs->set_gain (ns->gain(), true);
delete ns;
} catch (...) {
cerr << "failed to encode " << afs->path() << " to " << new_path << "\n";
}
+
+ if (progress) {
+ progress->ascend ();
+ }
}
}
+ if (progress) {
+ progress->set_progress (-1); // set to "archiving"
+ progress->set_progress (0);
+ }
+
/* index files relevant for this session */
for (vector<space_and_path>::const_iterator sd = session_dirs.begin(); sd != session_dirs.end(); ++sd) {
vector<string> files;
#endif
if (from.find (audiofile_dir_string) != string::npos) {
- if (!compress_audio != NO_ENCODE) {
- filemap[from] = make_new_media_path (from, name, name);
- }
+ ; // handled above
} else if (from.find (midifile_dir_string) != string::npos) {
filemap[from] = make_new_media_path (from, name, name);
} else if (from.find (videofile_dir_string) != string::npos) {
}
}
- /* include external media */
- {
- Glib::Threads::Mutex::Lock lm (source_lock);
- for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
- boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (i->second);
- if (!fs) {
- continue;
- }
- if (fs->within_session()) {
- continue;
- }
-
- if (fs->type () != DataType::AUDIO) {
- continue;
- }
-
- std::string from = fs->path();
- filemap[from] = make_new_media_path (from, name, name);
- remove_dir_from_search_path (Glib::path_get_dirname (from), DataType::AUDIO);
- }
- }
-
/* write session file */
_path = to_dir;
g_mkdir_with_parents (externals_dir ().c_str (), 0755);
-
+#ifdef LV2_SUPPORT
PBD::Unwinder<bool> uw (LV2Plugin::force_state_save, true);
+#endif
save_state (name);
save_default_options ();
for (std::map<boost::shared_ptr<AudioFileSource>, std::string>::iterator i = orig_sources.begin (); i != orig_sources.end (); ++i) {
i->first->replace_file (i->second);
}
-
-#ifndef NDEBUG
- /* done -- now zip */
- for (std::map<string,string>::const_iterator i = filemap.begin(); i != filemap.end (); ++i) {
- cout << "archive " << (*i).first << " as " << (*i).second << "\n";
+ for (std::map<boost::shared_ptr<AudioFileSource>, float>::iterator i = orig_gain.begin (); i != orig_gain.end (); ++i) {
+ i->first->set_gain (i->second, true);
}
-#endif
int rv = ar.create (filemap);
remove_directory (to_dir);
projects / ardour.git / blobdiff