#include "pbd/debug.h"
#include "pbd/enumwriter.h"
#include "pbd/error.h"
+#include "pbd/file_archive.h"
#include "pbd/file_utils.h"
#include "pbd/pathexpand.h"
#include "pbd/pthread_utils.h"
#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"
#include "ardour/playlist_source.h"
#include "ardour/port.h"
#include "ardour/processor.h"
+#include "ardour/progress.h"
#include "ardour/profile.h"
#include "ardour/proxy_controllable.h"
#include "ardour/recent_sessions.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;
}
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());
Locations loc (*this);
// 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();
set_dirty();
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
+#ifdef PLATFORM_WINDOWS
+ int old_mode = 0;
+#endif
+
retry:
try {
+#ifdef PLATFORM_WINDOWS
+ // do not show "insert media" popups (files embedded from removable media).
+ old_mode = SetErrorMode(SEM_FAILCRITICALERRORS);
+#endif
if ((source = XMLSourceFactory (**niter)) == 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
int user_choice;
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 ();
}
}
- g_stat ((*x).c_str(), &statbuf);
-
- if (::rename ((*x).c_str(), newpath.c_str()) != 0) {
- error << string_compose (_("cannot rename unused file source from %1 to %2 (%3)"), (*x), newpath, strerror (errno)) << endmsg;
+ if ((g_stat ((*x).c_str(), &statbuf) != 0) || (::g_rename ((*x).c_str(), newpath.c_str()) != 0)) {
+ error << string_compose (_("cannot rename unused file source from %1 to %2 (%3)"), (*x),
+ newpath, g_strerror (errno)) << endmsg;
continue;
}
/* see if there an easy to find peakfile for this file, and remove it.
*/
- string base = Glib::path_get_basename (*x);
- base += "%A"; /* this is what we add for the channel suffix of all native files,
- or for the first channel of embedded files. it will miss
- some peakfiles for other channels
- */
+ string base = Glib::path_get_basename (*x);
+ base += "%A"; /* this is what we add for the channel suffix of all native files,
+ or for the first channel of embedded files. it will miss
+ some peakfiles for other channels
+ */
string peakpath = construct_peak_filepath (base);
- if (Glib::file_test (peakpath.c_str(), Glib::FILE_TEST_EXISTS)) {
- if (::g_unlink (peakpath.c_str()) != 0) {
- error << string_compose (_("cannot remove peakfile %1 for %2 (%3)"),
- peakpath, _path, strerror (errno))
- << endmsg;
+ if (Glib::file_test (peakpath.c_str (), Glib::FILE_TEST_EXISTS)) {
+ if (::g_unlink (peakpath.c_str ()) != 0) {
+ error << string_compose (_("cannot remove peakfile %1 for %2 (%3)"), peakpath, _path,
+ g_strerror (errno)) << endmsg;
/* try to back out */
- ::rename (newpath.c_str(), _path.c_str());
+ ::g_rename (newpath.c_str (), _path.c_str ());
goto out;
}
}
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)
{
+ bool found_sr = false;
+ bool found_data_format = false;
+
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, "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
}
return 0;
}
+static void set_progress (Progress* p, size_t n, size_t t)
+{
+ p->set_progress (float (n) / float(t));
+}
+
+int
+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;
+ }
+
+ /* save current values */
+ bool was_dirty = dirty ();
+ string old_path = _path;
+ string old_name = _name;
+ string old_snapshot = _current_snapshot_name;
+ string old_sd = _session_dir->root_path();
+ string old_config_search_path[DataType::num_types];
+ old_config_search_path[DataType::AUDIO] = config.get_audio_search_path ();
+ old_config_search_path[DataType::MIDI] = config.get_midi_search_path ();
+
+ /* ensure that session-path is included in search-path */
+ bool ok = false;
+ for (vector<space_and_path>::const_iterator sd = session_dirs.begin(); sd != session_dirs.end(); ++sd) {
+ if ((*sd).path == old_path) {
+ ok = true;
+ }
+ }
+ if (!ok) {
+ return -1;
+ }
+
+ /* create temporary dir to save session to */
+#ifdef PLATFORM_WINDOWS
+ char tmp[256] = "C:\\TEMP\\";
+ GetTempPath (sizeof (tmp), tmp);
+#else
+ char const* tmp = getenv("TMPDIR");
+ if (!tmp) {
+ tmp = "/tmp/";
+ }
+#endif
+ if ((strlen (tmp) + 21) > 1024) {
+ return -1;
+ }
+
+ char tmptpl[1024];
+ strcpy (tmptpl, tmp);
+ strcat (tmptpl, "ardourarchive-XXXXXX");
+ char* tmpdir = g_mkdtemp (tmptpl);
+
+ if (!tmpdir) {
+ return -1;
+ }
+
+ std::string to_dir = std::string (tmpdir);
+
+ /* switch session directory temporarily */
+ (*_session_dir) = to_dir;
+
+ if (!_session_dir->create()) {
+ (*_session_dir) = old_sd;
+ remove_directory (to_dir);
+ return -1;
+ }
+
+ /* prepare archive */
+ string archive = Glib::build_filename (dest, name + ".tar.xz");
+
+ PBD::ScopedConnectionList progress_connection;
+ PBD::FileArchive ar (archive);
+ if (progress) {
+ ar.progress.connect_same_thread (progress_connection, boost::bind (&set_progress, progress, _1, _2));
+ }
+
+ /* collect files to archive */
+ std::map<string,string> filemap;
+
+ vector<string> do_not_copy_extensions;
+ do_not_copy_extensions.push_back (statefile_suffix);
+ do_not_copy_extensions.push_back (pending_suffix);
+ do_not_copy_extensions.push_back (backup_suffix);
+ do_not_copy_extensions.push_back (temp_suffix);
+ do_not_copy_extensions.push_back (history_suffix);
+
+ vector<string> blacklist_dirs;
+ blacklist_dirs.push_back (string (peak_dir_name) + G_DIR_SEPARATOR);
+ blacklist_dirs.push_back (string (analysis_dir_name) + G_DIR_SEPARATOR);
+ blacklist_dirs.push_back (string (dead_dir_name) + G_DIR_SEPARATOR);
+ blacklist_dirs.push_back (string (export_dir_name) + G_DIR_SEPARATOR);
+ blacklist_dirs.push_back (string (externals_dir_name) + G_DIR_SEPARATOR);
+ 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;
+
+ 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 || 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;
+ }
+ }
+
+ 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);
+
+ if (progress) {
+ progress->descend ((float)afs->readable_length () / total_size);
+ }
+
+ try {
+ 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;
+
+ size_t prefix_len = (*sd).path.size();
+ if (prefix_len > 0 && (*sd).path.at (prefix_len - 1) != G_DIR_SEPARATOR) {
+ ++prefix_len;
+ }
+
+ find_files_matching_filter (files, (*sd).path, accept_all_files, 0, false, true, true);
+
+ static const std::string audiofile_dir_string = string (sound_dir_name) + G_DIR_SEPARATOR;
+ static const std::string videofile_dir_string = string (video_dir_name) + G_DIR_SEPARATOR;
+ static const std::string midifile_dir_string = string (midi_dir_name) + G_DIR_SEPARATOR;
+
+ for (vector<string>::const_iterator i = files.begin (); i != files.end (); ++i) {
+ std::string from = *i;
+
+#ifdef __APPLE__
+ string filename = Glib::path_get_basename (from);
+ std::transform (filename.begin(), filename.end(), filename.begin(), ::toupper);
+ if (filename == ".DS_STORE") {
+ continue;
+ }
+#endif
+
+ if (from.find (audiofile_dir_string) != string::npos) {
+ ; // 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) {
+ filemap[from] = make_new_media_path (from, name, name);
+ } else {
+ bool do_copy = true;
+ for (vector<string>::iterator v = blacklist_dirs.begin(); v != blacklist_dirs.end(); ++v) {
+ if (from.find (*v) != string::npos) {
+ do_copy = false;
+ break;
+ }
+ }
+ for (vector<string>::iterator v = do_not_copy_extensions.begin(); v != do_not_copy_extensions.end(); ++v) {
+ if ((from.length() > (*v).length()) && (from.find (*v) == from.length() - (*v).length())) {
+ do_copy = false;
+ break;
+ }
+ }
+
+ if (do_copy) {
+ filemap[from] = name + G_DIR_SEPARATOR + from.substr (prefix_len);
+ }
+ }
+ }
+ }
+
+ /* 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 ();
+
+ size_t prefix_len = _path.size();
+ if (prefix_len > 0 && _path.at (prefix_len - 1) != G_DIR_SEPARATOR) {
+ ++prefix_len;
+ }
+
+ /* collect session-state files */
+ vector<string> files;
+ do_not_copy_extensions.clear ();
+ do_not_copy_extensions.push_back (history_suffix);
+
+ blacklist_dirs.clear ();
+ blacklist_dirs.push_back (string (externals_dir_name) + G_DIR_SEPARATOR);
+
+ find_files_matching_filter (files, to_dir, accept_all_files, 0, false, true, true);
+ for (vector<string>::const_iterator i = files.begin (); i != files.end (); ++i) {
+ std::string from = *i;
+ bool do_copy = true;
+ for (vector<string>::iterator v = blacklist_dirs.begin(); v != blacklist_dirs.end(); ++v) {
+ if (from.find (*v) != string::npos) {
+ do_copy = false;
+ break;
+ }
+ }
+ for (vector<string>::iterator v = do_not_copy_extensions.begin(); v != do_not_copy_extensions.end(); ++v) {
+ if ((from.length() > (*v).length()) && (from.find (*v) == from.length() - (*v).length())) {
+ do_copy = false;
+ break;
+ }
+ }
+ if (do_copy) {
+ filemap[from] = name + G_DIR_SEPARATOR + from.substr (prefix_len);
+ }
+ }
+
+ /* restore original values */
+ _path = old_path;
+ _name = old_name;
+ set_snapshot_name (old_snapshot);
+ (*_session_dir) = old_sd;
+ if (was_dirty) {
+ set_dirty ();
+ }
+ config.set_audio_search_path (old_config_search_path[DataType::AUDIO]);
+ config.set_midi_search_path (old_config_search_path[DataType::MIDI]);
+
+ 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);
+ }
+ 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);
+ }
+
+ int rv = ar.create (filemap);
+ remove_directory (to_dir);
+
+ return rv;
+}
+
void
Session::undo (uint32_t n)
{