X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fsession_state.cc;h=ee86a40e09d08f4b0c9cf24560d2c03b3d43d67c;hb=bbe62da55a5fb06ba39e02c9671a94ab6e24bb08;hp=decff17f1e517f91ad0015f6d473637064514f3c;hpb=0dca11cb470700399c2e284649ece2ff23332660;p=ardour.git diff --git a/libs/ardour/session_state.cc b/libs/ardour/session_state.cc index decff17f1e..ee86a40e09 100644 --- a/libs/ardour/session_state.cc +++ b/libs/ardour/session_state.cc @@ -29,6 +29,7 @@ #include #include /* snprintf(3) ... grrr */ #include + #include #include #include @@ -38,7 +39,7 @@ #include #endif -#ifdef __APPLE__ +#if defined(__APPLE__) || defined(__FreeBSD__) #include #include #endif @@ -62,10 +63,10 @@ #include "evoral/SMF.hpp" #include "pbd/basename.h" -#include "pbd/controllable_descriptor.h" #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" @@ -81,14 +82,19 @@ #include "ardour/audioengine.h" #include "ardour/audiofilesource.h" #include "ardour/audioregion.h" +#include "ardour/auditioner.h" #include "ardour/automation_control.h" #include "ardour/boost_debug.h" #include "ardour/butler.h" +#include "ardour/controllable_descriptor.h" #include "ardour/control_protocol_manager.h" #include "ardour/directory_names.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" @@ -100,10 +106,12 @@ #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" #include "ardour/region_factory.h" +#include "ardour/revision.h" #include "ardour/route_group.h" #include "ardour/send.h" #include "ardour/session.h" @@ -119,13 +127,14 @@ #include "ardour/tempo.h" #include "ardour/ticker.h" #include "ardour/user_bundle.h" +#include "ardour/vca.h" #include "ardour/vca_manager.h" #include "control_protocol/control_protocol.h" #include "LuaBridge/LuaBridge.h" -#include "i18n.h" +#include "pbd/i18n.h" #include using namespace std; @@ -172,7 +181,6 @@ Session::pre_engine_init (string fullpath) set_next_event (); _all_route_group->set_active (true, this); interpolation.add_channel_to (0, 0); - _vca_manager = new VCAManager (*this); if (config.get_use_video_sync()) { waiting_for_sync_offset = true; @@ -231,10 +239,12 @@ Session::post_engine_init () 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; } @@ -262,6 +272,7 @@ Session::post_engine_init () 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 (); @@ -272,6 +283,7 @@ Session::post_engine_init () 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 { @@ -338,7 +350,11 @@ Session::post_engine_init () /* 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; } @@ -620,14 +636,14 @@ Session::create (const string& session_template, BusProfile* bus_profile) /* 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); } _state_of_the_state = Clean; - /* set up Master Out and Control Out if necessary */ + /* set up Master Out and Monitor Out if necessary */ if (bus_profile) { @@ -636,7 +652,7 @@ Session::create (const string& session_template, BusProfile* bus_profile) // Waves Tracks: always create master bus for Tracks if (ARDOUR::Profile->get_trx() || bus_profile->master_out_channels) { - boost::shared_ptr r (new Route (*this, _("Master"), Route::MasterOut, DataType::AUDIO)); + boost::shared_ptr r (new Route (*this, _("Master"), PresentationInfo::MasterOut, DataType::AUDIO)); if (r->init ()) { return -1; } @@ -657,7 +673,7 @@ Session::create (const string& session_template, BusProfile* bus_profile) } if (!rl.empty()) { - add_routes (rl, false, false, false); + add_routes (rl, false, false, false, PresentationInfo::max_order); } // Waves Tracks: Skip this. Always use autoconnection for Tracks @@ -1037,6 +1053,80 @@ Session::get_template() return state(false); } +typedef std::set > PlaylistSet; +typedef std::set > SourceSet; + +bool +Session::export_track_state (boost::shared_ptr 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 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 = boost::dynamic_pointer_cast (*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 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 fs = boost::dynamic_pointer_cast (*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) { @@ -1048,6 +1138,12 @@ Session::state (bool full_state) snprintf(buf, sizeof(buf), "%d", CURRENT_SESSION_FILE_VERSION); node->add_property("version", buf); + child = node->add_child ("ProgramVersion"); + child->add_property("created-with", created_with); + + std::string modified_with = string_compose ("%1 %2", PROGRAM_NAME, revision); + child->add_property("modified-with", modified_with); + /* store configuration settings */ if (full_state) { @@ -1086,6 +1182,8 @@ Session::state (bool full_state) } } + node->add_property ("end-is-free", _session_range_end_is_free ? X_("yes") : X_("no")); + /* save the ID counter */ snprintf (buf, sizeof (buf), "%" PRIu64, ID::counter()); @@ -1101,7 +1199,7 @@ Session::state (bool full_state) /* save the VCA counter */ - snprintf (buf, sizeof (buf), "%" PRIu32, VCA::next_vca_number()); + snprintf (buf, sizeof (buf), "%" PRIu32, VCA::get_next_vca_number()); node->add_property ("vca-counter", buf); /* various options */ @@ -1115,7 +1213,14 @@ 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()); @@ -1191,7 +1296,7 @@ Session::state (bool full_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(); @@ -1228,7 +1333,7 @@ Session::state (bool full_state) RouteList public_order (*r); public_order.sort (cmp); - /* the sort should have put control outs first */ + /* the sort should have put the monitor out first */ if (_monitor_out) { assert (_monitor_out == public_order.front()); @@ -1340,8 +1445,19 @@ Session::set_state (const XMLNode& node, int version) } } + created_with = "unknown"; + if ((child = find_named_node (node, "ProgramVersion")) != 0) { + if ((prop = child->property (X_("created-with"))) != 0) { + created_with = prop->value (); + } + } + setup_raid_path(_session_dir->root_path()); + if ((prop = node.property (X_("end-is-free"))) != 0) { + _session_range_end_is_free = string_is_affirmative (prop->value()); + } + if ((prop = node.property (X_("id-counter"))) != 0) { uint64_t x; sscanf (prop->value().c_str(), "%" PRIu64, &x); @@ -1485,6 +1601,10 @@ Session::set_state (const XMLNode& node, int version) goto out; } + /* Now that we have Routes and masters loaded, connect them if appropriate */ + + Slavable::Assign (_vca_manager); /* EMIT SIGNAL */ + /* our diskstreams list is no longer needed as they are now all owned by their Route */ _diskstreams_2X.clear (); @@ -1588,7 +1708,7 @@ Session::load_routes (const XMLNode& node, int version) BootMessage (_("Tracks/busses loaded; Adding to Session")); - add_routes (new_routes, false, false, false); + add_routes (new_routes, false, false, false, PresentationInfo::max_order); BootMessage (_("Finished adding tracks/busses")); @@ -1637,12 +1757,7 @@ Session::XMLRouteFactory (const XMLNode& node, int version) ret = track; } else { - enum Route::Flag flags = Route::Flag(0); - XMLProperty const * prop = node.property("flags"); - if (prop) { - flags = Route::Flag (string_2_enum (prop->value(), flags)); - } - + PresentationInfo::Flag flags = PresentationInfo::get_flags (node); boost::shared_ptr r (new Route (*this, X_("toBeResetFroXML"), flags)); if (r->init () == 0 && r->set_state (node, version) == 0) { @@ -1711,12 +1826,7 @@ Session::XMLRouteFactory_2X (const XMLNode& node, int version) ret = track; } else { - enum Route::Flag flags = Route::Flag(0); - XMLProperty const * prop = node.property("flags"); - if (prop) { - flags = Route::Flag (string_2_enum (prop->value(), flags)); - } - + PresentationInfo::Flag flags = PresentationInfo::get_flags (node); boost::shared_ptr r (new Route (*this, X_("toBeResetFroXML"), flags)); if (r->init () == 0 && r->set_state (node, version) == 0) { @@ -2079,13 +2189,27 @@ Session::load_sources (const XMLNode& node) 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; @@ -2252,7 +2376,7 @@ Session::save_template (string template_name, bool replace_existing) void Session::refresh_disk_space () { -#if __APPLE__ || (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); @@ -2262,10 +2386,15 @@ Session::refresh_disk_space () _total_free_4k_blocks_uncertain = false; for (vector::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 */ @@ -2565,6 +2694,25 @@ Session::possible_states () const return possible_states(_path); } +RouteGroup* +Session::new_route_group (const std::string& name) +{ + RouteGroup* rg = NULL; + + for (std::list::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) { @@ -2862,14 +3010,17 @@ Session::find_all_sources_across_snapshots (set& result, bool exclude_th return 0; } - this_snapshot_path = _path; - this_snapshot_path += legalize_for_path (_current_snapshot_name); + this_snapshot_path = Glib::build_filename (_path, legalize_for_path (_current_snapshot_name)); this_snapshot_path += statefile_suffix; for (vector::iterator i = state_files.begin(); i != state_files.end(); ++i) { + cerr << "Looking at snapshot " << (*i) << " ( with this = [" << this_snapshot_path << "])\n"; + if (exclude_this_snapshot && *i == this_snapshot_path) { + cerr << "\texcluded\n"; continue; + } if (find_all_sources (*i, result) < 0) { @@ -3000,6 +3151,12 @@ Session::cleanup_peakfiles () return 0; } +static void +merge_all_sources (boost::shared_ptr pl, std::set >* all_sources) +{ + pl->deep_sources (*all_sources); +} + int Session::cleanup_sources (CleanupReport& rep) { @@ -3010,14 +3167,14 @@ Session::cleanup_sources (CleanupReport& rep) string midi_path; vector candidates; vector unused; - set all_sources; - bool used; + set sources_used_by_all_snapshots; string spath; int ret = -1; string tmppath1; string tmppath2; Searchpath asp; Searchpath msp; + set > sources_used_by_this_snapshot; _state_of_the_state = (StateOfTheState) (_state_of_the_state | InCleanup); @@ -3060,7 +3217,7 @@ Session::cleanup_sources (CleanupReport& rep) 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 (); } @@ -3088,12 +3245,21 @@ Session::cleanup_sources (CleanupReport& rep) find_files_matching_filter (candidates, audio_path, accept_all_audio_files, (void *) 0, true, true); find_files_matching_filter (candidates, midi_path, accept_all_midi_files, (void *) 0, true, true); - /* find all sources, but don't use this snapshot because the - state file on disk still references sources we may have already - dropped. + /* add sources from all other snapshots as "used", but don't use this + snapshot because the state file on disk still references sources we + may have already dropped. */ - find_all_sources_across_snapshots (all_sources, true); + find_all_sources_across_snapshots (sources_used_by_all_snapshots, true); + + /* Although the region factory has a list of all regions ever created + * for this session, we're only interested in regions actually in + * playlists right now. So merge all playlist regions lists together. + * + * This will include the playlists used within compound regions. + */ + + playlists->foreach (boost::bind (merge_all_sources, _1, &sources_used_by_this_snapshot)); /* add our current source list */ @@ -3103,59 +3269,76 @@ Session::cleanup_sources (CleanupReport& rep) SourceMap::iterator tmp = i; ++tmp; - if ((fs = boost::dynamic_pointer_cast (i->second)) != 0) { + if ((fs = boost::dynamic_pointer_cast (i->second)) == 0) { + /* not a file */ + i = tmp; + continue; + } - /* this is mostly for windows which doesn't allow file - * renaming if the file is in use. But we don't special - * case it because we need to know if this causes - * problems, and the easiest way to notice that is to - * keep it in place for all platforms. - */ + /* this is mostly for windows which doesn't allow file + * renaming if the file is in use. But we do not special + * case it because we need to know if this causes + * problems, and the easiest way to notice that is to + * keep it in place for all platforms. + */ - fs->close (); + fs->close (); - if (!fs->is_stub()) { + if (!fs->is_stub()) { - if (playlists->source_use_count (fs) != 0) { - all_sources.insert (fs->path()); - } else { + /* Note that we're checking a list of all + * sources across all snapshots with the list + * of sources used by this snapshot. + */ - /* we might not remove this source from disk, because it may be used - by other snapshots, but its not being used in this version - so lets get rid of it now, along with any representative regions - in the region list. - */ + if (sources_used_by_this_snapshot.find (i->second) != sources_used_by_this_snapshot.end()) { + /* this source is in use by this snapshot */ + sources_used_by_all_snapshots.insert (fs->path()); + cerr << "Source from source list found in used_by_this_snapshot (" << fs->path() << ")\n"; + } else { + cerr << "Source from source list NOT found in used_by_this_snapshot (" << fs->path() << ")\n"; + /* this source is NOT in use by this snapshot + */ - RegionFactory::remove_regions_using_source (i->second); + /* remove all related regions from RegionFactory master list + */ - // also remove source from all_sources + RegionFactory::remove_regions_using_source (i->second); - for (set::iterator j = all_sources.begin(); j != all_sources.end(); ++j) { - spath = Glib::path_get_basename (*j); - if (spath == i->second->name()) { - all_sources.erase (j); - break; - } - } + /* remove from our current source list + * also. We may not remove it from + * disk, because it may be used by + * other snapshots, but it isn't used inside this + * snapshot anymore, so we don't need a + * reference to it. + */ - sources.erase (i); - } + sources.erase (i); } } i = tmp; } + /* now check each candidate source to see if it exists in the list of + sources_used_by_all_snapshots. If it doesn't, put it into "unused". + */ + + cerr << "Candidates: " << candidates.size() << endl; + cerr << "Used by others: " << sources_used_by_all_snapshots.size() << endl; + for (vector::iterator x = candidates.begin(); x != candidates.end(); ++x) { - used = false; + bool used = false; spath = *x; - for (set::iterator i = all_sources.begin(); i != all_sources.end(); ++i) { + for (set::iterator i = sources_used_by_all_snapshots.begin(); i != sources_used_by_all_snapshots.end(); ++i) { tmppath1 = canonical_path (spath); tmppath2 = canonical_path ((*i)); + cerr << "\t => " << tmppath2 << endl; + if (tmppath1 == tmppath2) { used = true; break; @@ -3167,6 +3350,14 @@ Session::cleanup_sources (CleanupReport& rep) } } + cerr << "Actually unused: " << unused.size() << endl; + + if (unused.empty()) { + /* Nothing to do */ + ret = 0; + goto out; + } + /* now try to move all unused files into the "dead" directory(ies) */ for (vector::iterator x = unused.begin(); x != unused.end(); ++x) { @@ -3229,38 +3420,30 @@ Session::cleanup_sources (CleanupReport& rep) newpath = newpath_v; } - } else { - - /* it doesn't exist, or we can't read it or something */ - } - 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; - goto out; + 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; } } @@ -3401,72 +3584,85 @@ boost::shared_ptr Session::controllable_by_descriptor (const ControllableDescriptor& desc) { boost::shared_ptr c; + boost::shared_ptr s; boost::shared_ptr r; switch (desc.top_level_type()) { case ControllableDescriptor::NamedRoute: { std::string str = desc.top_level_name(); + if (str == "Master" || str == "master") { - r = _master_out; - } else if (str == "control" || str == "listen") { - r = _monitor_out; + s = _master_out; + } else if (str == "control" || str == "listen" || str == "monitor" || str == "Monitor") { + s = _monitor_out; + } else if (str == "auditioner") { + s = auditioner; } else { - r = route_by_name (desc.top_level_name()); + s = route_by_name (desc.top_level_name()); } + break; } - case ControllableDescriptor::RemoteControlID: - r = route_by_remote_id (desc.rid()); + case ControllableDescriptor::PresentationOrderRoute: + s = get_remote_nth_stripable (desc.presentation_order(), PresentationInfo::Route); + break; + + case ControllableDescriptor::PresentationOrderTrack: + s = get_remote_nth_stripable (desc.presentation_order(), PresentationInfo::Track); + break; + + case ControllableDescriptor::PresentationOrderBus: + s = get_remote_nth_stripable (desc.presentation_order(), PresentationInfo::Bus); + break; + + case ControllableDescriptor::PresentationOrderVCA: + s = get_remote_nth_stripable (desc.presentation_order(), PresentationInfo::VCA); break; case ControllableDescriptor::SelectionCount: - r = route_by_selected_count (desc.selection_id()); + s = route_by_selected_count (desc.selection_id()); break; } - if (!r) { + if (!s) { return c; } + r = boost::dynamic_pointer_cast (s); + switch (desc.subtype()) { case ControllableDescriptor::Gain: - c = r->gain_control (); + c = s->gain_control (); break; case ControllableDescriptor::Trim: - c = r->trim()->gain_control (); + c = s->trim_control (); break; case ControllableDescriptor::Solo: - c = r->solo_control(); + c = s->solo_control(); break; case ControllableDescriptor::Mute: - c = r->mute_control(); + c = s->mute_control(); break; case ControllableDescriptor::Recenable: - { - boost::shared_ptr t = boost::dynamic_pointer_cast(r); - - if (t) { - c = t->rec_enable_control (); - } + c = s->rec_enable_control (); break; - } case ControllableDescriptor::PanDirection: - c = r->pan_azimuth_control(); + c = s->pan_azimuth_control(); break; case ControllableDescriptor::PanWidth: - c = r->pan_width_control(); + c = s->pan_width_control(); break; case ControllableDescriptor::PanElevation: - c = r->pan_elevation_control(); + c = s->pan_elevation_control(); break; case ControllableDescriptor::Balance: @@ -3488,6 +3684,10 @@ Session::controllable_by_descriptor (const ControllableDescriptor& desc) --parameter_index; } + if (!r) { + return c; + } + boost::shared_ptr p = r->nth_plugin (plugin); if (p) { @@ -3502,6 +3702,9 @@ Session::controllable_by_descriptor (const ControllableDescriptor& desc) if (send > 0) { --send; } + if (!r) { + return c; + } c = r->send_level_controllable (send); break; } @@ -3529,6 +3732,11 @@ Session::add_instant_xml (XMLNode& node, bool write_to_config) 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); } @@ -3612,7 +3820,7 @@ Session::restore_history (string snapshot_name) // 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 (); @@ -3699,11 +3907,13 @@ Session::config_changed (std::string p, bool ours) } 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") { @@ -3819,10 +4029,6 @@ Session::config_changed (std::string p, bool ours) _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 (); @@ -3874,7 +4080,7 @@ Session::config_changed (std::string p, bool ours) } else if (p == "solo-control-is-listen-control") { solo_control_mode_changed (); } else if (p == "solo-mute-gain") { - _solo_cut_control->Changed(); + _solo_cut_control->Changed (true, Controllable::NoGroup); } else if (p == "timecode-offset" || p == "timecode-offset-negative") { last_timecode_valid = false; } else if (p == "playback-buffer-seconds") { @@ -4222,68 +4428,78 @@ Session::rename (const std::string& new_name) } 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& created_version) { + bool found_sr = false; + bool found_data_format = false; + created_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 */ + xmlNodePtr node = xmlDocGetRootElement(doc); - XMLProperty const * prop; - XMLNode const * root (tree.root()); - - 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*)"created-with"); + if (val) { + created_version = string ((const char*)val); + } + 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 } @@ -4843,3 +5059,340 @@ Session::save_as (SaveAs& saveas) 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::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 filemap; + + vector 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 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, std::string> orig_sources; + std::map, float> orig_gain; + + set > 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 afs = boost::dynamic_pointer_cast (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 afs = boost::dynamic_pointer_cast (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::const_iterator sd = session_dirs.begin(); sd != session_dirs.end(); ++sd) { + vector 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::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::iterator v = blacklist_dirs.begin(); v != blacklist_dirs.end(); ++v) { + if (from.find (*v) != string::npos) { + do_copy = false; + break; + } + } + for (vector::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 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 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::const_iterator i = files.begin (); i != files.end (); ++i) { + std::string from = *i; + bool do_copy = true; + for (vector::iterator v = blacklist_dirs.begin(); v != blacklist_dirs.end(); ++v) { + if (from.find (*v) != string::npos) { + do_copy = false; + break; + } + } + for (vector::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, std::string>::iterator i = orig_sources.begin (); i != orig_sources.end (); ++i) { + i->first->replace_file (i->second); + } + for (std::map, 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) +{ + if (actively_recording()) { + return; + } + + _history.undo (n); +} + +void +Session::redo (uint32_t n) +{ + if (actively_recording()) { + return; + } + + _history.redo (n); +}