X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fsession_directory.cc;h=3a4d049e3a1b38ab322e50232d72ce1512268989;hb=428c82b1bc4dd527f8c65e94170c55f4291f7a45;hp=09c2154c30c0e4e269d7925dd9926a2fb925bf98;hpb=bb9cc45cd22af67ac275a5e73accbe14fee664d8;p=ardour.git diff --git a/libs/ardour/session_directory.cc b/libs/ardour/session_directory.cc index 09c2154c30..3a4d049e3a 100644 --- a/libs/ardour/session_directory.cc +++ b/libs/ardour/session_directory.cc @@ -16,9 +16,15 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ +#include + +#include +#include + #include "pbd/error.h" #include "pbd/compose.h" -#include "pbd/filesystem.h" +#include "pbd/file_utils.h" +#include "pbd/openuri.h" #include "ardour/directory_names.h" #include "ardour/session_directory.h" @@ -31,123 +37,225 @@ namespace ARDOUR { using namespace std; using namespace PBD::sys; -SessionDirectory::SessionDirectory (const path& session_path) + +/* keep a static cache because SessionDirectory is used in various places. */ +std::map SessionDirectory::root_cache; + +SessionDirectory::SessionDirectory (const std::string& session_path) : m_root_path(session_path) { } +SessionDirectory& +SessionDirectory::operator= (const std::string& newpath) +{ + m_root_path = newpath; + root_cache.clear (); + return *this; +} + bool SessionDirectory::create () { - bool is_new = false; - - vector sub_dirs = sub_directories (); - for (vector::const_iterator i = sub_dirs.begin(); i != sub_dirs.end(); ++i) + vector sub_dirs = sub_directories (); + for (vector::const_iterator i = sub_dirs.begin(); i != sub_dirs.end(); ++i) { - try - { - if(create_directories(*i)) is_new = true; - } - catch (PBD::sys::filesystem_error& ex) - { - // log the error - PBD::error << string_compose(_("Cannot create Session directory at path %1 Error: %2"), (*i).to_string(), ex.what()) << endmsg; - - // and rethrow - throw ex; + if (g_mkdir_with_parents (i->c_str(), 0755) != 0) { + PBD::error << string_compose(_("Cannot create Session directory at path %1 Error: %2"), *i, g_strerror(errno)) << endmsg; + return false; } } - return is_new; + return true; } bool SessionDirectory::is_valid () const { - if (!is_directory (m_root_path)) return false; + if (!Glib::file_test (m_root_path, Glib::FILE_TEST_IS_DIR)) return false; - vector sub_dirs = sub_directories (); + vector sub_dirs = sub_directories (); - for (vector::iterator i = sub_dirs.begin(); i != sub_dirs.end(); ++i) { - if (!is_directory (*i)) { - PBD::warning << string_compose(_("Session subdirectory does not exist at path %1"), (*i).to_string()) << endmsg; + for (vector::iterator i = sub_dirs.begin(); i != sub_dirs.end(); ++i) { + if (!Glib::file_test (*i, Glib::FILE_TEST_IS_DIR)) { + PBD::warning << string_compose(_("Session subdirectory does not exist at path %1"), *i) << endmsg; return false; } } return true; } -const path +const std::string SessionDirectory::old_sound_path () const { - return m_root_path / old_sound_dir_name; + return Glib::build_filename (m_root_path, old_sound_dir_name); } -const path +const std::string SessionDirectory::sources_root () const { - const string legalized_root(legalize_for_path(m_root_path.leaf())); + if (root_cache.find (m_root_path) != root_cache.end()) { + return root_cache[m_root_path]; + } + + root_cache.clear (); + + std::string p = m_root_path; + + // TODO ideally we'd use the session's name() here, and not the containing folder's name. + std::string filename = Glib::path_get_basename(p); + + if (filename == ".") { + p = PBD::get_absolute_path (m_root_path); + } + + const string legalized_root (legalize_for_path (Glib::path_get_basename(p))); + + std::string sources_root_path = Glib::build_filename (m_root_path, interchange_dir_name); + + /* check the interchange folder: + * + * 1) if a single subdir exists, use it, regardless of the name + * 2) if more than one dir is in interchange: abort, blame the user + * 3) if interchange does not exist or no subdir is present, + * use the session-name to create one. + * + * We use the name of the containing folder, not the actual + * session name. The latter would require some API changes and + * careful libardour updates: + * + * The session object is created with the "snapshot-name", only + * when loading the .ardour session file, the actual name is set. + * + * SessionDirectory is created with the session itself + * and picks up the wrong inital name. + * + * SessionDirectory is also used directly by the AudioRegionImporter, + * and the peak-file background thread (session.cc). + * + * There is no actual benefit to use the session-name instead of + * the folder-name. Under normal circumstances they are always + * identical. But it would be consistent to prefer the name. + */ + try { + Glib::Dir dir(sources_root_path); + + std::list entries; + + for (Glib::DirIterator di = dir.begin(); di != dir.end(); di++) { + // ignore hidden files (eg. OS X ".DS_Store") + if ((*di).at(0) == '.') { + continue; + } + // and skip regular files (eg. Win Thumbs.db) + string fullpath = Glib::build_filename (sources_root_path, *di); + if (!Glib::file_test (fullpath, Glib::FILE_TEST_IS_DIR)) { + continue; + } + entries.push_back(*di); + } - return m_root_path / interchange_dir_name / legalized_root; + if (entries.size() == 1) { + if (entries.front() != legalized_root) { + PBD::info << _("session-dir and session-name mismatch. Please use 'Menu > Session > Rename' in the future to rename sessions.") << endmsg; + } + root_cache[m_root_path] = Glib::build_filename (sources_root_path, entries.front()); + } + else if (entries.size() > 1) { + PBD::open_folder (sources_root_path); + PBD::fatal << string_compose (_("The session's interchange dir is tainted.\nThere is more than one folder in '%1'.\nPlease remove extra subdirs to reduce possible filename ambiguties."), sources_root_path) << endmsg; + assert (0); // not reached + } + } catch (Glib::FileError) { + ; + } + + if (root_cache.find (m_root_path) == root_cache.end()) { + root_cache[m_root_path] = Glib::build_filename (sources_root_path, legalized_root); + } + + return root_cache[m_root_path]; } -const path +const std::string +SessionDirectory::sources_root_2X () const +{ + std::string p = m_root_path; + std::string filename = Glib::path_get_basename(p); + + if (filename == ".") { + p = PBD::get_absolute_path (m_root_path); + } + + const string legalized_root (legalize_for_path_2X (Glib::path_get_basename(p))); + + std::string sources_root_path = Glib::build_filename (m_root_path, interchange_dir_name); + return Glib::build_filename (sources_root_path, legalized_root); +} + +const std::string SessionDirectory::sound_path () const { - if(is_directory (old_sound_path ())) return old_sound_path(); + if (Glib::file_test (old_sound_path (), Glib::FILE_TEST_IS_DIR)) return old_sound_path(); // the new style sound directory - return sources_root() / sound_dir_name; + return Glib::build_filename (sources_root(), sound_dir_name); } -const path +const std::string +SessionDirectory::sound_path_2X () const +{ + return Glib::build_filename (sources_root_2X(), sound_dir_name); +} + +const std::string SessionDirectory::midi_path () const { - return sources_root() / midi_dir_name; + return Glib::build_filename (sources_root(), midi_dir_name); } -const path +const std::string SessionDirectory::midi_patch_path () const { - return sources_root() / midi_patch_dir_name; + return Glib::build_filename (sources_root(), midi_patch_dir_name); } -const path -SessionDirectory::peak_path () const +const std::string +SessionDirectory::video_path () const { - return m_root_path / peak_dir_name; + return Glib::build_filename (sources_root(), video_dir_name); } -const path -SessionDirectory::dead_sound_path () const +const std::string +SessionDirectory::peak_path () const { - return m_root_path / dead_sound_dir_name; + return Glib::build_filename (m_root_path, peak_dir_name); } -const path -SessionDirectory::dead_midi_path () const +const std::string +SessionDirectory::dead_path () const { - return m_root_path / dead_midi_dir_name; + return Glib::build_filename (m_root_path, dead_dir_name); } -const path +const std::string SessionDirectory::export_path () const { - return m_root_path / export_dir_name; + return Glib::build_filename (m_root_path, export_dir_name); } -const vector +const vector SessionDirectory::sub_directories () const { - vector tmp_paths; - - tmp_paths.push_back ( sound_path () ); - tmp_paths.push_back ( midi_path () ); - tmp_paths.push_back ( peak_path () ); - tmp_paths.push_back ( dead_sound_path () ); - tmp_paths.push_back ( dead_midi_path () ); - tmp_paths.push_back ( export_path () ); + vector tmp_paths; + + tmp_paths.push_back (sound_path ()); + tmp_paths.push_back (midi_path ()); + tmp_paths.push_back (video_path ()); + tmp_paths.push_back (peak_path ()); + tmp_paths.push_back (dead_path ()); + tmp_paths.push_back (export_path ()); return tmp_paths; }