#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/disk_reader.h"
#include "ardour/template_utils.h"
#include "ardour/tempo.h"
#include "ardour/ticker.h"
+#include "ardour/transport_master_manager.h"
#include "ardour/types_convert.h"
#include "ardour/user_bundle.h"
#include "ardour/vca.h"
g_atomic_int_set (&_capture_load, 100);
set_next_event ();
_all_route_group->set_active (true, this);
- interpolation.add_channel ();
if (config.get_use_video_sync()) {
waiting_for_sync_offset = true;
error << string_compose(_("Could not remove session file at path \"%1\" (%2)"),
xml_path, g_strerror (errno)) << endmsg;
}
+
+ StateSaved (snapshot_name); /* EMIT SIGNAL */
}
/** @param snapshot_name Name to save under, without .ardour / .pending prefix */
int
-Session::save_state (string snapshot_name, bool pending, bool switch_to_snapshot, bool template_only)
+Session::save_state (string snapshot_name, bool pending, bool switch_to_snapshot, bool template_only, bool for_archive, bool only_used_assets)
{
DEBUG_TRACE (DEBUG::Locale, string_compose ("Session::save_state locale '%1'\n", setlocale (LC_NUMERIC, NULL)));
/* prevent concurrent saves from different threads */
Glib::Threads::Mutex::Lock lm (save_state_lock);
+ Glib::Threads::Mutex::Lock lx (save_source_lock, Glib::Threads::NOT_LOCK);
+ if (!for_archive) {
+ lx.acquire ();
+ }
if (!_writable || (_state_of_the_state & CannotSave)) {
return 1;
_save_queued = false;
snapshot_t fork_state = NormalSave;
- if (!snapshot_name.empty() && snapshot_name != _current_snapshot_name && !template_only && !pending) {
+ if (!snapshot_name.empty() && snapshot_name != _current_snapshot_name && !template_only && !pending && !for_archive) {
/* snapshot, close midi */
fork_state = switch_to_snapshot ? SwitchToSnapshot : SnapshotKeep;
}
}
}
+ PBD::Unwinder<bool> uw (LV2Plugin::force_state_save, for_archive);
+
SessionSaveUnderway (); /* EMIT SIGNAL */
bool mark_as_clean = true;
-
if (!snapshot_name.empty() && !switch_to_snapshot) {
mark_as_clean = false;
}
mark_as_clean = false;
tree.set_root (&get_template());
} else {
- tree.set_root (&state (true, fork_state));
+ tree.set_root (&state (false, fork_state, only_used_assets));
}
if (snapshot_name.empty()) {
}
}
- if (!pending) {
+ //Mixbus auto-backup mechanism
+ if(Profile->get_mixbus()) {
+ if (pending) { //"pending" save means it's a backup, or some other non-user-initiated save; a good time to make a backup
+ // make a serialized safety backup
+ // (will make one periodically but only one per hour is left on disk)
+ // these backup files go into a separated folder
+ char timebuf[128];
+ time_t n;
+ struct tm local_time;
+ time (&n);
+ localtime_r (&n, &local_time);
+ strftime (timebuf, sizeof(timebuf), "%y-%m-%d.%H", &local_time);
+ std::string save_path(session_directory().backup_path());
+ save_path += G_DIR_SEPARATOR;
+ save_path += legalize_for_path(_current_snapshot_name);
+ save_path += "-";
+ save_path += timebuf;
+ save_path += statefile_suffix;
+ if ( !tree.write (save_path) )
+ error << string_compose(_("Could not save backup file at path \"%1\" (%2)"),
+ save_path, g_strerror (errno)) << endmsg;
+ }
+
+ StateSaved (snapshot_name); /* EMIT SIGNAL */
+ }
+
+ if (!pending && !for_archive) {
save_history (snapshot_name);
}
XMLNode&
-Session::get_state()
+Session::get_state ()
{
- return state(true);
+ /* this is not directly called, but required by PBD::Stateful */
+ assert (0);
+ return state (false, NormalSave);
}
XMLNode&
-Session::get_template()
+Session::get_template ()
{
/* if we don't disable rec-enable, diskstreams
will believe they need to store their capture
disable_record (false);
- return state(false);
+ return state (true, NormalSave);
}
typedef std::set<boost::shared_ptr<Playlist> > PlaylistSet;
return tree.write (sn.c_str());
}
+static void
+merge_all_sources (boost::shared_ptr<const Playlist> pl, std::set<boost::shared_ptr<Source> >* all_sources)
+{
+ pl->deep_sources (*all_sources);
+}
+
namespace
{
struct route_id_compare {
} // anon namespace
XMLNode&
-Session::state (bool full_state, snapshot_t snapshot_type)
+Session::state (bool save_template, snapshot_t snapshot_type, bool only_used_assets)
{
LocaleGuard lg;
XMLNode* node = new XMLNode("Session");
XMLNode* child;
+ PBD::Unwinder<bool> uw (Automatable::skip_saving_automation, save_template);
+
node->set_property("version", CURRENT_SESSION_FILE_VERSION);
child = node->add_child ("ProgramVersion");
/* store configuration settings */
- if (full_state) {
+ if (!save_template) {
node->set_property ("name", _name);
node->set_property ("sample-rate", _base_sample_rate);
}
XMLNode& cfgxml (config.get_variables ());
- if (!full_state) {
+ if (save_template) {
/* exclude search-paths from template */
cfgxml.remove_nodes_and_delete ("name", "audio-search-path");
cfgxml.remove_nodes_and_delete ("name", "midi-search-path");
child = node->add_child ("Sources");
- if (full_state) {
+ if (!save_template) {
Glib::Threads::Mutex::Lock sl (source_lock);
+ set<boost::shared_ptr<Source> > sources_used_by_this_snapshot;
+
+ if (only_used_assets) {
+ playlists->sync_all_regions_with_regions ();
+ playlists->foreach (boost::bind (merge_all_sources, _1, &sources_used_by_this_snapshot), false);
+ }
+
for (SourceMap::iterator siter = sources.begin(); siter != sources.end(); ++siter) {
/* Don't save information about non-file Sources, or
}
}
+ if (only_used_assets) {
+ /* skip only unused audio files */
+ boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> (fs);
+ if (afs && !afs->used()) {
+ continue;
+ }
+ if (afs && sources_used_by_this_snapshot.find (afs) == sources_used_by_this_snapshot.end ()) {
+ continue;
+ }
+ }
+
if (snapshot_type != NormalSave && fs->within_session ()) {
/* copy MIDI sources to new file
*
child = node->add_child ("Regions");
- if (full_state) {
+ if (!save_template) {
Glib::Threads::Mutex::Lock rl (region_lock);
- const RegionFactory::RegionMap& region_map (RegionFactory::all_regions());
- for (RegionFactory::RegionMap::const_iterator i = region_map.begin(); i != region_map.end(); ++i) {
- boost::shared_ptr<Region> r = i->second;
- /* only store regions not attached to playlists */
- if (r->playlist() == 0) {
- if (boost::dynamic_pointer_cast<AudioRegion>(r)) {
- child->add_child_nocopy ((boost::dynamic_pointer_cast<AudioRegion>(r))->get_basic_state ());
- } else {
- child->add_child_nocopy (r->get_state ());
+
+ if (!only_used_assets) {
+ const RegionFactory::RegionMap& region_map (RegionFactory::all_regions());
+ for (RegionFactory::RegionMap::const_iterator i = region_map.begin(); i != region_map.end(); ++i) {
+ boost::shared_ptr<Region> r = i->second;
+ /* only store regions not attached to playlists */
+ if (r->playlist() == 0) {
+ if (boost::dynamic_pointer_cast<AudioRegion>(r)) {
+ child->add_child_nocopy ((boost::dynamic_pointer_cast<AudioRegion>(r))->get_basic_state ());
+ } else {
+ child->add_child_nocopy (r->get_state ());
+ }
}
}
}
XMLNode* ca = node->add_child (X_("CompoundAssociations"));
for (RegionFactory::CompoundAssociations::iterator i = cassocs.begin(); i != cassocs.end(); ++i) {
+ if (i->first->playlist () == 0 && only_used_assets) {
+ continue;
+ }
XMLNode* can = new XMLNode (X_("CompoundAssociation"));
can->set_property (X_("copy"), i->first->id());
can->set_property (X_("original"), i->second->id());
ca->add_child_nocopy (*can);
+ /* see above, child is still "Regions" here */
+ if (i->second->playlist() == 0 && only_used_assets) {
+ if (boost::shared_ptr<AudioRegion> ar = boost::dynamic_pointer_cast<AudioRegion>( i->second)) {
+ child->add_child_nocopy (ar->get_basic_state ());
+ } else {
+ child->add_child_nocopy (ar->get_state ());
+ }
+ }
}
}
}
- if (full_state) {
+ if (!save_template) {
node->add_child_nocopy (_selection->get_state());
for (RouteList::const_iterator i = xml_node_order.begin(); i != xml_node_order.end(); ++i) {
if (!(*i)->is_auditioner()) {
- if (full_state) {
- child->add_child_nocopy ((*i)->get_state());
- } else {
+ if (save_template) {
child->add_child_nocopy ((*i)->get_template());
+ } else {
+ child->add_child_nocopy ((*i)->get_state());
}
}
}
}
- playlists->add_state (node, full_state);
+ playlists->add_state (node, save_template, !only_used_assets);
child = node->add_child ("RouteGroups");
for (list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
if (_click_io) {
XMLNode* gain_child = node->add_child ("Click");
- gain_child->add_child_nocopy (_click_io->state (full_state));
- gain_child->add_child_nocopy (_click_gain->state (full_state));
+ gain_child->add_child_nocopy (_click_io->get_state ());
+ gain_child->add_child_nocopy (_click_gain->get_state ());
}
- if (_ltc_input) {
- XMLNode* ltc_input_child = node->add_child ("LTC-In");
- ltc_input_child->add_child_nocopy (_ltc_input->state (full_state));
- }
-
- if (_ltc_input) {
+ if (_ltc_output) {
XMLNode* ltc_output_child = node->add_child ("LTC-Out");
- ltc_output_child->add_child_nocopy (_ltc_output->state (full_state));
+ ltc_output_child->add_child_nocopy (_ltc_output->get_state ());
}
node->add_child_nocopy (_speakers->get_state());
XMLNode&
Session::get_control_protocol_state ()
{
- ControlProtocolManager& cpm (ControlProtocolManager::instance());
- return cpm.get_state();
+ return ControlProtocolManager::instance().get_state ();
}
int
}
if ((child = find_named_node (node, ControlProtocolManager::state_node_name)) != 0) {
- ControlProtocolManager::instance().set_state (*child, version);
+ ControlProtocolManager::instance().set_state (*child, 1 /* here: session-specific state */);
}
if ((child = find_named_node (node, "Script"))) {
return 0;
}
-static void
-merge_all_sources (boost::shared_ptr<const Playlist> pl, std::set<boost::shared_ptr<Source> >* all_sources)
-{
- pl->deep_sources (*all_sources);
-}
-
int
Session::cleanup_sources (CleanupReport& rep)
{
}
/* never mark session dirty during loading */
- if (_state_of_the_state & Loading) {
+ if (_state_of_the_state & (Loading | Deletion)) {
return;
}
return boost::dynamic_pointer_cast<AutomationControl> (controllable_by_id (id));
}
-boost::shared_ptr<Controllable>
-Session::controllable_by_descriptor (const ControllableDescriptor& desc)
-{
- boost::shared_ptr<Controllable> c;
- boost::shared_ptr<Stripable> s;
- boost::shared_ptr<Route> r;
-
- switch (desc.top_level_type()) {
- case ControllableDescriptor::NamedRoute:
- {
- std::string str = desc.top_level_name();
-
- if (str == "Master" || str == "master") {
- s = _master_out;
- } else if (str == "control" || str == "listen" || str == "monitor" || str == "Monitor") {
- s = _monitor_out;
- } else if (str == "auditioner") {
- s = auditioner;
- } else {
- s = route_by_name (desc.top_level_name());
- }
-
- break;
- }
-
- 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:
- s = route_by_selected_count (desc.selection_id());
- break;
- }
-
- if (!s) {
- return c;
- }
-
- r = boost::dynamic_pointer_cast<Route> (s);
-
- switch (desc.subtype()) {
- case ControllableDescriptor::Gain:
- c = s->gain_control ();
- break;
-
- case ControllableDescriptor::Trim:
- c = s->trim_control ();
- break;
-
- case ControllableDescriptor::Solo:
- c = s->solo_control();
- break;
-
- case ControllableDescriptor::Mute:
- c = s->mute_control();
- break;
-
- case ControllableDescriptor::Recenable:
- c = s->rec_enable_control ();
- break;
-
- case ControllableDescriptor::PanDirection:
- c = s->pan_azimuth_control();
- break;
-
- case ControllableDescriptor::PanWidth:
- c = s->pan_width_control();
- break;
-
- case ControllableDescriptor::PanElevation:
- c = s->pan_elevation_control();
- break;
-
- case ControllableDescriptor::Balance:
- /* XXX simple pan control */
- break;
-
- case ControllableDescriptor::PluginParameter:
- {
- uint32_t plugin = desc.target (0);
- uint32_t parameter_index = desc.target (1);
-
- /* revert to zero based counting */
-
- if (plugin > 0) {
- --plugin;
- }
-
- if (parameter_index > 0) {
- --parameter_index;
- }
-
- if (!r) {
- return c;
- }
-
- boost::shared_ptr<Processor> p = r->nth_plugin (plugin);
-
- if (p) {
- c = boost::dynamic_pointer_cast<ARDOUR::AutomationControl>(
- p->control(Evoral::Parameter(PluginAutomation, 0, parameter_index)));
- }
- break;
- }
-
- case ControllableDescriptor::SendGain: {
- uint32_t send = desc.target (0);
- if (send > 0) {
- --send;
- }
- if (!r) {
- return c;
- }
- c = r->send_level_controllable (send);
- break;
- }
-
- default:
- /* relax and return a null pointer */
- break;
- }
-
- return c;
-}
-
void
Session::add_instant_xml (XMLNode& node, bool write_to_config)
{
for (XMLNodeConstIterator it = tree.root()->children().begin(); it != tree.root()->children().end(); ++it) {
XMLNode *t = *it;
- UndoTransaction* ut = new UndoTransaction ();
std::string name;
int64_t tv_sec;
continue;
}
+ UndoTransaction* ut = new UndoTransaction ();
ut->set_name (name);
struct timeval tv;
set_dirty ();
}
- if (p == "seamless-loop") {
-
- } else if (p == "rf-speed") {
-
- } else if (p == "auto-loop") {
+ if (p == "auto-loop") {
} else if (p == "session-monitoring") {
first_file_data_format_reset = false;
} else if (p == "external-sync") {
- if (!config.get_external_sync()) {
- drop_sync_source ();
- } else {
- switch_to_sync_source (Config->get_sync_source());
- }
+ request_sync_source (TransportMasterManager::instance().current());
} else if (p == "denormal-model") {
setup_fpu ();
} else if (p == "history-depth") {
last_timecode_valid = false;
} else if (p == "playback-buffer-seconds") {
AudioSource::allocate_working_buffers (sample_rate());
- } else if (p == "ltc-source-port") {
- reconnect_ltc_input ();
} else if (p == "ltc-sink-port") {
reconnect_ltc_output ();
} else if (p == "timecode-generator-offset") {
*/
instant_xml ("LastUsedSnapshot");
- XMLNode* last_used_snapshot = new XMLNode ("LastUsedSnapshot");
- last_used_snapshot->set_property ("name", n);
- add_instant_xml (*last_used_snapshot, false);
+ XMLNode last_used_snapshot ("LastUsedSnapshot");
+ last_used_snapshot.set_property ("name", n);
+ add_instant_xml (last_used_snapshot, false);
}
void
}
static string
-make_new_media_path (string old_path, string new_session_folder, string new_session_path)
+make_new_media_path (string old_path, string new_session_folder, string new_session_name)
{
- /* typedir is the "midifiles" or "audiofiles" etc. part of the path. */
-
+ // old_path must be in within_session ()
string typedir = Glib::path_get_basename (Glib::path_get_dirname (old_path));
vector<string> v;
v.push_back (new_session_folder); /* full path */
v.push_back (interchange_dir_name);
- v.push_back (new_session_path); /* just one directory/folder */
+ v.push_back (new_session_name); /* just one directory/folder */
v.push_back (typedir);
v.push_back (Glib::path_get_basename (old_path));
return Glib::build_filename (v);
}
+static string
+make_new_audio_path (string filename, string new_session_folder, string new_session_name)
+{
+ vector<string> v;
+ v.push_back (new_session_folder); /* full path */
+ v.push_back (interchange_dir_name);
+ v.push_back (new_session_name);
+ v.push_back (ARDOUR::sound_dir_name);
+ v.push_back (filename);
+
+ return Glib::build_filename (v);
+}
+
int
Session::save_as (SaveAs& saveas)
{
return -1;
}
+ /* We are going to temporarily change some source properties,
+ * don't allow any concurrent saves (periodic or otherwise */
+ Glib::Threads::Mutex::Lock lm (save_source_lock);
+
+ disable_record (false);
+
/* save current values */
- bool was_dirty = dirty ();
string old_path = _path;
string old_name = _name;
string old_snapshot = _current_snapshot_name;
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>, std::string> orig_origin;
std::map<boost::shared_ptr<AudioFileSource>, float> orig_gain;
set<boost::shared_ptr<Source> > sources_used_by_this_snapshot;
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)
+ /* 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);
+
+ /* build a list of used names */
+ std::set<std::string> audio_file_names;
+ 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;
+ }
+ }
+ audio_file_names.insert (Glib::path_get_basename (afs->path()));
+ }
+
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) {
if (compress_audio != NO_ENCODE) {
total_size += afs->readable_length ();
} else {
- if (afs->within_session()) {
- filemap[from] = make_new_media_path (from, name, name);
+ /* copy files as-is */
+ if (!afs->within_session()) {
+ string to = Glib::path_get_basename (from);
+
+ /* avoid name collitions, see also new_audio_source_path_for_embedded ()
+ * - avoid conflict with files existing in interchange
+ * - avoid conflict with other embedded sources
+ */
+ if (audio_file_names.find (to) == audio_file_names.end ()) {
+ // we need a new name, add a '-<num>' before the '.<ext>'
+ string bn = to.substr (0, to.find_last_of ('.'));
+ string ext = to.find_last_of ('.') == string::npos ? "" : to.substr (to.find_last_of ('.'));
+ to = bn + "-1" + ext;
+ }
+ while (audio_file_names.find (to) == audio_file_names.end ()) {
+ to = bump_name_once (to, '-');
+ }
+
+ audio_file_names.insert (to);
+ filemap[from] = make_new_audio_path (to, name, name);
+
+ remove_dir_from_search_path (Glib::path_get_dirname (from), DataType::AUDIO);
+
+ orig_origin[afs] = afs->origin ();
+ afs->set_origin ("");
+
} else {
filemap[from] = make_new_media_path (from, name, name);
- remove_dir_from_search_path (Glib::path_get_dirname (from), DataType::AUDIO);
}
}
}
new_path = Glib::build_filename (Glib::path_get_dirname (new_path), PBD::basename_nosuffix (new_path) + channelsuffix + ".flac");
g_mkdir_with_parents (Glib::path_get_dirname (new_path).c_str (), 0755);
+ /* avoid name collisions of external files with same name */
+ if (Glib::file_test (new_path, Glib::FILE_TEST_EXISTS)) {
+ new_path = Glib::build_filename (Glib::path_get_dirname (new_path), PBD::basename_nosuffix (new_path) + channelsuffix + "-1.flac");
+ }
+ while (Glib::file_test (new_path, Glib::FILE_TEST_EXISTS)) {
+ new_path = bump_name_once (new_path, '-');
+ }
if (progress) {
progress->descend ((float)afs->readable_length () / total_size);
/* 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, /*pending, don't fork MIDI, don't mark clean */ true);
-
-#ifndef NDEBUG
- cerr << "archiving state from "
- << Glib::build_filename (to_dir, legalize_for_path (name) + pending_suffix)
- << " to "
- << Glib::build_filename (to_dir, legalize_for_path (name) + statefile_suffix)
- << endl;
-#endif
- ::g_rename (
- Glib::build_filename (to_dir, legalize_for_path (name) + pending_suffix).c_str(),
- Glib::build_filename (to_dir, legalize_for_path (name) + statefile_suffix).c_str());
+ save_state (name, false, false, false, true, only_used_sources);
save_default_options ();
_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_origin.begin (); i != orig_origin.end (); ++i) {
+ i->first->set_origin (i->second);
+ }
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);
}
projects / ardour.git / blobdiff