the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
- This program is distributed in the hope that it will be useful,
+ This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
#include <sys/mount.h>
#endif
+#include <glib.h>
+
#include <glibmm.h>
#include <glibmm/thread.h>
#include "midi++/manager.h"
#include "pbd/boost_debug.h"
+#include "pbd/basename.h"
#include "pbd/controllable_descriptor.h"
#include "pbd/enumwriter.h"
#include "pbd/error.h"
#include "ardour/amp.h"
#include "ardour/audio_diskstream.h"
+#include "ardour/audio_playlist_source.h"
#include "ardour/audio_track.h"
#include "ardour/audioengine.h"
#include "ardour/audiofilesource.h"
#include "ardour/processor.h"
#include "ardour/port.h"
#include "ardour/proxy_controllable.h"
+#include "ardour/recent_sessions.h"
#include "ardour/region_factory.h"
#include "ardour/route_group.h"
#include "ardour/send.h"
using namespace ARDOUR;
using namespace PBD;
+
void
Session::first_stage_init (string fullpath, string snapshot_name)
{
_path = string(buf);
- if (_path[_path.length()-1] != '/') {
+ if (_path[_path.length()-1] != G_DIR_SEPARATOR) {
_path += G_DIR_SEPARATOR;
}
- if (Glib::file_test (_path, Glib::FILE_TEST_EXISTS) && ::access (_path.c_str(), W_OK)) {
- _writable = false;
- } else {
- _writable = true;
- }
-
/* these two are just provisional settings. set_state()
will likely override them.
*/
if (load_state (_current_snapshot_name)) {
return -1;
}
- cleanup_stubfiles ();
}
if (_butler->start_thread()) {
/* initial program change will be delivered later; see ::config_changed() */
- BootMessage (_("Reset Control Protocols"));
-
- ControlProtocolManager::instance().set_session (this);
-
_state_of_the_state = Clean;
Port::set_connecting_blocked (false);
return -1;
}
- dir = session_directory().sound_stub_path().to_string();
-
- if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
- error << string_compose(_("Session: cannot create session stub sounds dir \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
- return -1;
- }
-
dir = session_directory().midi_path().to_string();
if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
return -1;
}
- dir = session_directory().midi_stub_path().to_string();
-
- if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
- error << string_compose(_("Session: cannot create session stub midi dir \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
- return -1;
- }
-
- dir = session_directory().dead_sound_path().to_string();
+ dir = session_directory().dead_path().to_string();
if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
error << string_compose(_("Session: cannot create session dead sounds folder \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
return -1;
}
+ _writable = exists_and_writable (sys::path (_path));
+
if (!mix_template.empty()) {
std::string in_path = mix_template;
/* set initial start + end point */
_state_of_the_state = Clean;
-
+
/* set up Master Out and Control Out if necessary */
if (bus_profile) {
ChanCount count(DataType::AUDIO, bus_profile->master_out_channels);
if (bus_profile->master_out_channels) {
- Route* rt = new Route (*this, _("master"), Route::MasterOut, DataType::AUDIO);
- if (rt->init ()) {
- delete rt;
+ boost::shared_ptr<Route> r (new Route (*this, _("master"), Route::MasterOut, DataType::AUDIO));
+ if (r->init ()) {
return -1;
}
#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
- boost_debug_shared_ptr_mark_interesting (rt, "Route");
+ boost_debug_shared_ptr_mark_interesting (r.get(), "Route");
#endif
- boost::shared_ptr<Route> r (rt);
{
Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
r->input()->ensure_io (count, false, this);
rl.push_back (r);
if (Config->get_use_monitor_bus()) {
- Route* rt = new Route (*this, _("monitor"), Route::MonitorOut, DataType::AUDIO);
- if (rt->init ()) {
- delete rt;
+ boost::shared_ptr<Route> r (new Route (*this, _("monitor"), Route::MonitorOut, DataType::AUDIO));
+ if (r->init ()) {
return -1;
}
#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
- boost_debug_shared_ptr_mark_interesting (rt, "Route");
+ boost_debug_shared_ptr_mark_interesting (r.get(), "Route");
#endif
- boost::shared_ptr<Route> r (rt);
{
Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
r->input()->ensure_io (count, false, this);
r->output()->ensure_io (count, false, this);
}
r->set_remote_control_id (control_id);
-
+
rl.push_back (r);
}
}
if (!rl.empty()) {
- add_routes (rl, false);
+ add_routes (rl, false, false);
}
/* this allows the user to override settings with an environment variable.
bus_profile->input_ac = AutoConnectOption (0);
bus_profile->output_ac = AutoConnectOption (0);
}
-
+
Config->set_input_auto_connect (bus_profile->input_ac);
Config->set_output_auto_connect (bus_profile->output_ac);
}
}
/** Rename a state file.
- * @param snapshot_name Snapshot name.
+ * @param old_name Old snapshot name.
+ * @param new_name New snapshot name.
*/
void
Session::rename_state (string old_name, string new_name)
}
/** Remove a state file.
- * @param snapshot_name Snapshot name.
+ * @param snapshot_name Snapshot name.
*/
void
Session::remove_state (string snapshot_name)
if (event->type == JackSessionSaveTemplate)
{
if (save_template( timebuf )) {
- event->flags = JackSessionSaveError;
+ event->flags = JackSessionSaveError;
} else {
string cmd ("ardour3 -P -U ");
cmd += event->client_uuid;
else
{
if (save_state (timebuf)) {
- event->flags = JackSessionSaveError;
+ event->flags = JackSessionSaveError;
} else {
sys::path xml_path (_session_dir->root_path());
xml_path /= legalize_for_path (timebuf) + statefile_suffix;
}
#endif
+/** @param snapshot_name Name to save under, without .ardour / .pending prefix */
int
Session::save_state (string snapshot_name, bool pending, bool switch_to_snapshot)
{
} else {
- if (rename (tmp_path.to_string().c_str(), xml_path.to_string().c_str()) != 0) {
+ if (::rename (tmp_path.to_string().c_str(), xml_path.to_string().c_str()) != 0) {
error << string_compose (_("could not rename temporary session file %1 to %2"),
tmp_path.to_string(), xml_path.to_string()) << endmsg;
sys::remove (tmp_path);
set_dirty();
- /* writable() really reflects the whole folder, but if for any
- reason the session state file can't be written to, still
- make us unwritable.
- */
-
- if (::access (xmlpath.to_string().c_str(), W_OK) != 0) {
- _writable = false;
- }
+ _writable = exists_and_writable (xmlpath);
if (!state_tree->read (xmlpath.to_string())) {
error << string_compose(_("Could not understand ardour file %1"), xmlpath.to_string()) << endmsg;
sscanf (prop->value().c_str(), "%d.%d.%d", &major, &minor, µ);
Stateful::loading_state_version = (major * 1000) + minor;
}
-
+
if (Stateful::loading_state_version < CURRENT_SESSION_FILE_VERSION) {
sys::path backup_path(_session_dir->root_path());
for (SourceMap::iterator siter = sources.begin(); siter != sources.end(); ++siter) {
- /* Don't save information about non-destructive file sources that are empty
- and unused by any regions.
+ /* Don't save information about non-file Sources, or
+ * about non-destructive file sources that are empty
+ * and unused by any regions.
*/
boost::shared_ptr<FileSource> fs;
+
if ((fs = boost::dynamic_pointer_cast<FileSource> (siter->second)) != 0) {
+
if (!fs->destructive()) {
if (fs->empty() && !fs->used()) {
continue;
}
}
- }
- child->add_child_nocopy (siter->second->get_state());
+ child->add_child_nocopy (siter->second->get_state());
+ }
}
}
child->add_child_nocopy (r->state ());
}
}
+
+ RegionFactory::CompoundAssociations& cassocs (RegionFactory::compound_associations());
+
+ if (!cassocs.empty()) {
+ XMLNode* ca = node->add_child (X_("CompoundAssociations"));
+
+ for (RegionFactory::CompoundAssociations::iterator i = cassocs.begin(); i != cassocs.end(); ++i) {
+ char buf[64];
+ XMLNode* can = new XMLNode (X_("CompoundAssociation"));
+ i->first->id().print (buf, sizeof (buf));
+ can->add_property (X_("copy"), buf);
+ i->second->id().print (buf, sizeof (buf));
+ can->add_property (X_("original"), buf);
+ ca->add_child_nocopy (*can);
+ }
+ }
}
if (full_state) {
IO::disable_connecting ();
- /* Object loading order:
-
- Path
- Extra
- Options/Config
- MIDI Control // relies on data from Options/Config
- Metadata
- Locations
- Sources
- AudioRegions
- Connections
- Routes
- RouteGroups
- MixGroups
- Click
- ControlProtocols
- */
-
- if ((child = find_named_node (node, "Extra")) != 0) {
- _extra_xml = new XMLNode (*child);
- }
+ Stateful::save_extra_xml (node);
if (((child = find_named_node (node, "Options")) != 0)) { /* old style */
load_options (*child);
}
}
+ if ((child = find_named_node (node, X_("Speakers"))) != 0) {
+ _speakers->set_state (*child, version);
+ }
+
+ if ((child = find_named_node (node, "Sources")) == 0) {
+ error << _("Session: XML state has no sources section") << endmsg;
+ goto out;
+ } else if (load_sources (*child)) {
+ goto out;
+ }
+
+ if ((child = find_named_node (node, "TempoMap")) == 0) {
+ error << _("Session: XML state has no Tempo Map section") << endmsg;
+ goto out;
+ } else if (_tempo_map->set_state (*child, version)) {
+ goto out;
+ }
+
if ((child = find_named_node (node, "Locations")) == 0) {
error << _("Session: XML state has no locations section") << endmsg;
goto out;
goto out;
}
- if ((child = find_named_node (node, X_("Speakers"))) != 0) {
- _speakers->set_state (*child, version);
- }
-
Location* location;
if ((location = _locations->auto_loop_location()) != 0) {
AudioFileSource::set_header_position_offset (_session_range_location->start());
}
- if ((child = find_named_node (node, "Sources")) == 0) {
- error << _("Session: XML state has no sources section") << endmsg;
- goto out;
- } else if (load_sources (*child)) {
- goto out;
- }
-
if ((child = find_named_node (node, "Regions")) == 0) {
error << _("Session: XML state has no Regions section") << endmsg;
goto out;
} else if (playlists->load_unused (*this, *child)) {
goto out;
}
-
+
+ if ((child = find_named_node (node, "CompoundAssociations")) != 0) {
+ if (load_compounds (*child)) {
+ goto out;
+ }
+ }
+
if ((child = find_named_node (node, "NamedSelections")) != 0) {
if (load_named_selections (*child)) {
goto out;
_bundle_xml_node = new XMLNode (*child);
}
}
-
- if ((child = find_named_node (node, "TempoMap")) == 0) {
- error << _("Session: XML state has no Tempo Map section") << endmsg;
- goto out;
- } else if (_tempo_map->set_state (*child, version)) {
- goto out;
- }
if (version < 3000) {
if ((child = find_named_node (node, X_("DiskStreams"))) == 0) {
_diskstreams_2X.clear ();
if (version >= 3000) {
-
+
if ((child = find_named_node (node, "RouteGroups")) == 0) {
error << _("Session: XML state has no route groups section") << endmsg;
goto out;
} else if (load_route_groups (*child, version)) {
goto out;
}
-
+
} else if (version < 3000) {
-
+
if ((child = find_named_node (node, "EditGroups")) == 0) {
error << _("Session: XML state has no edit groups section") << endmsg;
goto out;
} else {
route = XMLRouteFactory (**niter, version);
}
-
+
if (route == 0) {
error << _("Session: cannot create Route from XML description.") << endmsg;
return -1;
new_routes.push_back (route);
}
- add_routes (new_routes, false);
+ add_routes (new_routes, false, false);
return 0;
}
if (ds_child) {
- Track* track;
-
+ boost::shared_ptr<Track> track;
+
if (type == DataType::AUDIO) {
- track = new AudioTrack (*this, X_("toBeResetFroXML"));
-
+ track.reset (new AudioTrack (*this, X_("toBeResetFroXML")));
} else {
- track = new MidiTrack (*this, X_("toBeResetFroXML"));
+ track.reset (new MidiTrack (*this, X_("toBeResetFroXML")));
}
-
+
if (track->init()) {
- delete track;
return ret;
}
-
+
if (track->set_state (node, version)) {
- delete track;
return ret;
}
-
+
#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
- boost_debug_shared_ptr_mark_interesting (track, "Track");
+ boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
#endif
- ret.reset (track);
-
+ ret = track;
+
} else {
- Route* rt = new Route (*this, X_("toBeResetFroXML"));
+ boost::shared_ptr<Route> r (new Route (*this, X_("toBeResetFroXML")));
- if (rt->init () == 0 && rt->set_state (node, version) == 0) {
+ if (r->init () == 0 && r->set_state (node, version) == 0) {
#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
- boost_debug_shared_ptr_mark_interesting (rt, "Route");
+ boost_debug_shared_ptr_mark_interesting (r.get(), "Route");
#endif
- ret.reset (rt);
- } else {
- delete rt;
+ ret = r;
}
}
return boost::shared_ptr<Route> ();
}
- Track* track;
-
+ boost::shared_ptr<Track> track;
+
if (type == DataType::AUDIO) {
- track = new AudioTrack (*this, X_("toBeResetFroXML"));
-
+ track.reset (new AudioTrack (*this, X_("toBeResetFroXML")));
} else {
- track = new MidiTrack (*this, X_("toBeResetFroXML"));
+ track.reset (new MidiTrack (*this, X_("toBeResetFroXML")));
}
-
+
if (track->init()) {
- delete track;
return ret;
}
-
+
if (track->set_state (node, version)) {
- delete track;
return ret;
}
track->set_diskstream (*i);
-
-#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
- boost_debug_shared_ptr_mark_interesting (track, "Track");
+
+#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
+ boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
#endif
- ret.reset (track);
-
+ ret = track;
+
} else {
- Route* rt = new Route (*this, X_("toBeResetFroXML"));
+ boost::shared_ptr<Route> r (new Route (*this, X_("toBeResetFroXML")));
- if (rt->init () == 0 && rt->set_state (node, version) == 0) {
+ if (r->init () == 0 && r->set_state (node, version) == 0) {
#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
- boost_debug_shared_ptr_mark_interesting (rt, "Route");
+ boost_debug_shared_ptr_mark_interesting (r.get(), "Route");
#endif
- ret.reset (rt);
- } else {
- delete rt;
+ ret = r;
}
}
return 0;
}
+int
+Session::load_compounds (const XMLNode& node)
+{
+ XMLNodeList calist = node.children();
+ XMLNodeConstIterator caiter;
+ XMLProperty *caprop;
+
+ for (caiter = calist.begin(); caiter != calist.end(); ++caiter) {
+ XMLNode* ca = *caiter;
+ ID orig_id;
+ ID copy_id;
+
+ if ((caprop = ca->property (X_("original"))) == 0) {
+ continue;
+ }
+ orig_id = caprop->value();
+
+ if ((caprop = ca->property (X_("copy"))) == 0) {
+ continue;
+ }
+ copy_id = caprop->value();
+
+ boost::shared_ptr<Region> orig = RegionFactory::region_by_id (orig_id);
+ boost::shared_ptr<Region> copy = RegionFactory::region_by_id (copy_id);
+
+ if (!orig || !copy) {
+ warning << string_compose (_("Regions in compound description not found (ID's %1 and %2): ignored"),
+ orig_id, copy_id)
+ << endmsg;
+ continue;
+ }
+
+ RegionFactory::add_compound_association (orig, copy);
+ }
+
+ return 0;
+}
+
+void
+Session::load_nested_sources (const XMLNode& node)
+{
+ XMLNodeList nlist;
+ XMLNodeConstIterator niter;
+
+ nlist = node.children();
+
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
+ if ((*niter)->name() == "Source") {
+
+ /* it may already exist, so don't recreate it unnecessarily
+ */
+
+ XMLProperty* prop = (*niter)->property (X_("id"));
+ if (!prop) {
+ error << _("Nested source has no ID info in session state file! (ignored)") << endmsg;
+ continue;
+ }
+
+ ID source_id (prop->value());
+
+ if (!source_by_id (source_id)) {
+
+ try {
+ SourceFactory::create (*this, **niter, true);
+ }
+ catch (failed_constructor& err) {
+ error << string_compose (_("Cannot reconstruct nested source for region %1"), name()) << endmsg;
+ }
+ }
+ }
+ }
+}
+
boost::shared_ptr<Region>
Session::XMLRegionFactory (const XMLNode& node, bool full)
{
try {
+ const XMLNodeList& nlist = node.children();
+
+ for (XMLNodeConstIterator niter = nlist.begin(); niter != nlist.end(); ++niter) {
+ XMLNode *child = (*niter);
+ if (child->name() == "NestedSource") {
+ load_nested_sources (*child);
+ }
+ }
+
if (!type || type->value() == "audio") {
return boost::shared_ptr<Region>(XMLAudioRegionFactory (node, full));
} else if (type->value() == "midi") {
case 0:
/* user added a new search location, so try again */
goto retry;
-
-
+
+
case 1:
/* user asked to quit the entire session load
*/
set_dirty ();
if (version >= 3000) {
-
+
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
if ((*niter)->name() == "RouteGroup") {
RouteGroup* rg = new RouteGroup (*this, "");
_route_groups.push_back (g);
route_group_added (g); /* EMIT SIGNAL */
- g->MembershipChanged.connect_same_thread (*this, boost::bind (&Session::route_group_changed, this));
- g->PropertyChanged.connect_same_thread (*this, boost::bind (&Session::route_group_changed, this));
-
+ g->RouteAdded.connect_same_thread (*this, boost::bind (&Session::route_added_to_route_group, this, _1, _2));
+ g->RouteRemoved.connect_same_thread (*this, boost::bind (&Session::route_removed_from_route_group, this, _1, _2));
+ g->PropertyChanged.connect_same_thread (*this, boost::bind (&Session::route_group_property_changed, this, g));
+
set_dirty ();
}
route_group_removed (); /* EMIT SIGNAL */
}
+}
+/** Set a new order for our route groups, without adding or removing any.
+ * @param groups Route group list in the new order.
+ */
+void
+Session::reorder_route_groups (list<RouteGroup*> groups)
+{
+ _route_groups = groups;
+
+ route_groups_reordered (); /* EMIT SIGNAL */
+ set_dirty ();
}
+
RouteGroup *
Session::route_group_by_name (string name)
{
to hold all the commands that are committed. This keeps the order of
commands correct in the history.
*/
-
+
if (_current_trans == 0) {
/* start a new transaction */
assert (_current_trans_quarks.empty ());
_current_trans = new UndoTransaction();
_current_trans->set_name (g_quark_to_string (q));
}
-
+
_current_trans_quarks.push_front (q);
}
{
assert (_current_trans);
assert (!_current_trans_quarks.empty ());
-
+
struct timeval now;
if (cmd) {
}
static bool
-accept_all_non_peak_files (const string& path, void */*arg*/)
+accept_all_audio_files (const string& path, void */*arg*/)
{
if (!Glib::file_test (path, Glib::FILE_TEST_IS_REGULAR)) {
return false;
}
- return (path.length() > 5 && path.find (peakfile_suffix) != (path.length() - 5));
+ if (!AudioFileSource::safe_audio_file_extension (path)) {
+ return false;
+ }
+
+ return true;
+}
+
+static bool
+accept_all_midi_files (const string& path, void */*arg*/)
+{
+ if (!Glib::file_test (path, Glib::FILE_TEST_IS_REGULAR)) {
+ return false;
+ }
+
+ return ((path.length() > 4 && path.find (".mid") != (path.length() - 4)) ||
+ (path.length() > 4 && path.find (".smf") != (path.length() - 4)) ||
+ (path.length() > 5 && path.find (".midi") != (path.length() - 5)));
}
static bool
accept_all_state_files (const string& path, void */*arg*/)
{
+ if (!Glib::file_test (path, Glib::FILE_TEST_IS_REGULAR)) {
+ return false;
+ }
+
return (path.length() > 7 && path.find (".ardour") == (path.length() - 7));
}
for (RegionFactory::RegionMap::const_iterator i = regions.begin(); i != regions.end(); ++i) {
boost::shared_ptr<AudioRegion> audio_region = boost::dynamic_pointer_cast<AudioRegion>( i->second);
-
+
if (!audio_region) {
continue;
}
-
+
uint32_t used = playlists->region_use_count (audio_region);
if (used == 0 && !audio_region->automatic()) {
vector<boost::shared_ptr<Source> > dead_sources;
PathScanner scanner;
- string sound_path;
+ string audio_path;
+ string midi_path;
vector<space_and_path>::iterator i;
vector<space_and_path>::iterator nexti;
- vector<string*>* soundfiles;
+ vector<string*>* candidates;
+ vector<string*>* candidates2;
vector<string> unused;
set<string> all_sources;
bool used;
_state_of_the_state = (StateOfTheState) (_state_of_the_state | InCleanup);
- /* step 1: consider deleting all unused playlists */
-
+ /* consider deleting all unused playlists */
+
if (playlists->maybe_delete_unused (boost::bind (Session::ask_about_playlist_deletion, _1))) {
ret = 0;
goto out;
}
- /* step 2: find all un-used sources */
+ /* sync the "all regions" property of each playlist with its current state
+ */
+
+ playlists->sync_all_regions_with_regions ();
+
+ /* find all un-used sources */
rep.paths.clear ();
rep.space = 0;
i = tmp;
}
- /* build a list of all the possible sound directories for the session */
+ /* build a list of all the possible audio directories for the session */
for (i = session_dirs.begin(); i != session_dirs.end(); ) {
++nexti;
SessionDirectory sdir ((*i).path);
- sound_path += sdir.sound_path().to_string();
+ audio_path += sdir.sound_path().to_string();
if (nexti != session_dirs.end()) {
- sound_path += ':';
+ audio_path += ':';
}
i = nexti;
}
- /* now do the same thing for the files that ended up in the sounds dir(s)
- but are not referenced as sources in any snapshot.
- */
- soundfiles = scanner (sound_path, accept_all_non_peak_files, (void *) 0, false, true);
+ /* build a list of all the possible midi directories for the session */
- if (soundfiles == 0) {
- return 0;
+ for (i = session_dirs.begin(); i != session_dirs.end(); ) {
+
+ nexti = i;
+ ++nexti;
+
+ SessionDirectory sdir ((*i).path);
+ midi_path += sdir.midi_path().to_string();
+
+ if (nexti != session_dirs.end()) {
+ midi_path += ':';
+ }
+
+ i = nexti;
}
+ candidates = scanner (audio_path, accept_all_audio_files, (void *) 0, true, true);
+ candidates2 = scanner (midi_path, accept_all_midi_files, (void *) 0, true, true);
+
+ /* merge them */
+
+ if (candidates) {
+ if (candidates2) {
+ for (vector<string*>::iterator i = candidates2->begin(); i != candidates2->end(); ++i) {
+ candidates->push_back (*i);
+ }
+ delete candidates2;
+ }
+ } else {
+ candidates = candidates2; // might still be null
+ }
+
/* find all sources, but don't use this snapshot because the
state file on disk still references sources we may have already
dropped.
/* add our current source list
*/
- for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
+ for (SourceMap::iterator i = sources.begin(); i != sources.end(); ) {
boost::shared_ptr<FileSource> fs;
+ SourceMap::iterator tmp = i;
+ ++tmp;
if ((fs = boost::dynamic_pointer_cast<FileSource> (i->second)) != 0) {
- all_sources.insert (fs->path());
+ if (playlists->source_use_count (fs) != 0) {
+ all_sources.insert (fs->path());
+ } else {
+
+ /* 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.
+ */
+
+ RegionFactory::remove_regions_using_source (i->second);
+ sources.erase (i);
+ }
}
+
+ i = tmp;
}
char tmppath1[PATH_MAX+1];
char tmppath2[PATH_MAX+1];
- for (vector<string*>::iterator x = soundfiles->begin(); x != soundfiles->end(); ++x) {
+ if (candidates) {
+ for (vector<string*>::iterator x = candidates->begin(); x != candidates->end(); ++x) {
- used = false;
- spath = **x;
+ used = false;
+ spath = **x;
- for (set<string>::iterator i = all_sources.begin(); i != all_sources.end(); ++i) {
+ for (set<string>::iterator i = all_sources.begin(); i != all_sources.end(); ++i) {
- if (realpath(spath.c_str(), tmppath1) == 0) {
- error << string_compose (_("Cannot expand path %1 (%2)"),
- spath, strerror (errno)) << endmsg;
- continue;
+ if (realpath(spath.c_str(), tmppath1) == 0) {
+ error << string_compose (_("Cannot expand path %1 (%2)"),
+ spath, strerror (errno)) << endmsg;
+ continue;
+ }
+
+ if (realpath((*i).c_str(), tmppath2) == 0) {
+ error << string_compose (_("Cannot expand path %1 (%2)"),
+ (*i), strerror (errno)) << endmsg;
+ continue;
+ }
+
+ if (strcmp(tmppath1, tmppath2) == 0) {
+ used = true;
+ break;
+ }
}
- if (realpath((*i).c_str(), tmppath2) == 0) {
- error << string_compose (_("Cannot expand path %1 (%2)"),
- (*i), strerror (errno)) << endmsg;
- continue;
+ if (!used) {
+ unused.push_back (spath);
}
- if (strcmp(tmppath1, tmppath2) == 0) {
- used = true;
- break;
- }
- }
+ delete *x;
+ }
- if (!used) {
- unused.push_back (spath);
- }
- }
+ delete candidates;
+ }
- /* now try to move all unused files into the "dead_sounds" directory(ies) */
+ /* now try to move all unused files into the "dead" directory(ies) */
for (vector<string>::iterator x = unused.begin(); x != unused.end(); ++x) {
struct stat statbuf;
- rep.paths.push_back (*x);
- if (stat ((*x).c_str(), &statbuf) == 0) {
- rep.space += statbuf.st_size;
- }
-
string newpath;
/* don't move the file across filesystems, just
- stick it in the `dead_sound_dir_name' directory
+ stick it in the `dead_dir_name' directory
on whichever filesystem it was already on.
*/
/* new school, go up 4 levels */
- newpath = Glib::path_get_dirname (*x); // "audiofiles"
+ newpath = Glib::path_get_dirname (*x); // "audiofiles" or "midifiles"
newpath = Glib::path_get_dirname (newpath); // "session-name"
newpath = Glib::path_get_dirname (newpath); // "interchange"
newpath = Glib::path_get_dirname (newpath); // "session-dir"
}
- newpath = Glib::build_filename (newpath, dead_sound_dir_name);
+ newpath = Glib::build_filename (newpath, dead_dir_name);
if (g_mkdir_with_parents (newpath.c_str(), 0755) < 0) {
- error << string_compose(_("Session: cannot create session peakfile folder \"%1\" (%2)"), newpath, strerror (errno)) << endmsg;
+ error << string_compose(_("Session: cannot create dead file folder \"%1\" (%2)"), newpath, strerror (errno)) << endmsg;
return -1;
}
newpath = Glib::build_filename (newpath, Glib::path_get_basename ((*x)));
-
+
if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
/* the new path already exists, try versioning */
snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), version);
newpath_v = buf;
- while (access (newpath_v.c_str(), F_OK) == 0 && version < 999) {
+ while (Glib::file_test (newpath_v.c_str(), Glib::FILE_TEST_EXISTS) && version < 999) {
snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), ++version);
newpath_v = buf;
}
}
+ stat ((*x).c_str(), &statbuf);
+
if (::rename ((*x).c_str(), newpath.c_str()) != 0) {
- error << string_compose (_("cannot rename audio file source from %1 to %2 (%3)"),
+ error << string_compose (_("cannot rename unused file source from %1 to %2 (%3)"),
(*x), newpath, strerror (errno))
<< endmsg;
goto out;
/* see if there an easy to find peakfile for this file, and remove it.
*/
- string peakpath = (*x).substr (0, (*x).find_last_of ('.'));
- peakpath += peakfile_suffix;
+ string base = basename_nosuffix (*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 = peak_path (base);
- if (access (peakpath.c_str(), W_OK) == 0) {
+ if (Glib::file_test (peakpath.c_str(), Glib::FILE_TEST_EXISTS)) {
if (::unlink (peakpath.c_str()) != 0) {
error << string_compose (_("cannot remove peakfile %1 for %2 (%3)"),
- peakpath, _path, strerror (errno))
+ peakpath, _path, strerror (errno))
<< endmsg;
/* try to back out */
- rename (newpath.c_str(), _path.c_str());
+ ::rename (newpath.c_str(), _path.c_str());
goto out;
}
}
- }
- ret = 0;
+ rep.paths.push_back (*x);
+ rep.space += statbuf.st_size;
+ }
/* dump the history list */
*/
save_state ("");
+ ret = 0;
out:
_state_of_the_state = (StateOfTheState) (_state_of_the_state & ~InCleanup);
// FIXME: needs adaptation for MIDI
vector<space_and_path>::iterator i;
- string dead_sound_dir;
+ string dead_dir;
rep.paths.clear ();
rep.space = 0;
for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
- dead_sound_dir = (*i).path;
- dead_sound_dir += dead_sound_dir_name;
+ dead_dir = Glib::build_filename ((*i).path, dead_dir_name);
- clear_directory (dead_sound_dir, &rep.space, &rep.paths);
+ clear_directory (dead_dir, &rep.space, &rep.paths);
}
return 0;
}
-void
-Session::cleanup_stubfiles ()
-{
- vector<space_and_path>::iterator i;
-
- for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
-
- string dir;
- string lname = legalize_for_path (_name);
-
- vector<string> v;
-
- /* XXX this is a hack caused by semantic conflicts
- between space_and_path and the SessionDirectory concept.
- */
-
- v.push_back ((*i).path);
- v.push_back ("interchange");
- v.push_back (lname);
- v.push_back ("audiofiles");
- v.push_back (stub_dir_name);
-
- dir = Glib::build_filename (v);
-
- clear_directory (dir);
-
- v.clear ();
- v.push_back ((*i).path);
- v.push_back ("interchange");
- v.push_back (lname);
- v.push_back ("midifiles");
- v.push_back (stub_dir_name);
-
- dir = Glib::build_filename (v);
-
- clear_directory (dir);
- }
-}
-
void
Session::set_dirty ()
{
r = route_by_remote_id (desc.rid());
break;
}
-
+
if (!r) {
return c;
}
case ControllableDescriptor::Recenable:
{
boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track>(r);
-
+
if (t) {
c = t->rec_enable_control ();
}
uint32_t parameter_index = desc.target (1);
/* revert to zero based counting */
-
+
if (plugin > 0) {
--plugin;
}
-
+
if (parameter_index > 0) {
--parameter_index;
}
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:
+ case ControllableDescriptor::SendGain:
{
uint32_t send = desc.target (0);
/* revert to zero-based counting */
-
+
if (send > 0) {
--send;
}
-
+
boost::shared_ptr<Processor> p = r->nth_send (send);
-
+
if (p) {
boost::shared_ptr<Send> s = boost::dynamic_pointer_cast<Send>(p);
boost::shared_ptr<Amp> a = s->amp();
} else {
error << _("Failed to downcast MidiSource for SysExDiffCommand") << endmsg;
}
-
+
} else if (n->name() == "PatchChangeDiffCommand") {
PBD::ID id (n->property("midi-source")->value());
if (Config->get_monitoring_model() == HardwareMonitoring && transport_rolling()) {
/* auto-input only makes a difference if we're rolling */
-
- boost::shared_ptr<RouteList> rl = routes.reader ();
- for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
- boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
- if (tr && tr->record_enabled ()) {
- tr->monitor_input (!config.get_auto_input());
- }
- }
+ set_track_monitor_input_status (!config.get_auto_input());
}
} else if (p == "punch-in") {
//poke_midi_thread ();
- } else if (p == "mmc-device-id" || p == "mmc-receive-id") {
+ } else if (p == "mmc-device-id" || p == "mmc-receive-id" || p == "mmc-receive-device-id") {
MIDI::Manager::instance()->mmc()->set_receive_device_id (Config->get_mmc_receive_device_id());
- } else if (p == "mmc-send-id") {
+ } else if (p == "mmc-send-id" || p == "mmc-send-device-id") {
MIDI::Manager::instance()->mmc()->set_send_device_id (Config->get_mmc_send_device_id());
}
} else if (p == "solo-mute-override") {
// catch_up_on_solo_mute_override ();
- } else if (p == "listen-position") {
+ } else if (p == "listen-position" || p == "pfl-position") {
listen_position_changed ();
} else if (p == "solo-control-is-listen-control") {
solo_control_mode_changed ();
} else if (p == "timecode-offset" || p == "timecode-offset-negative") {
last_timecode_valid = false;
+ } else if (p == "playback-buffer-seconds") {
+ AudioSource::allocate_working_buffers (frame_rate());
}
set_dirty ();
Session::setup_midi_machine_control ()
{
MIDI::MachineControl* mmc = MIDI::Manager::instance()->mmc ();
-
+
mmc->Play.connect_same_thread (*this, boost::bind (&Session::mmc_deferred_play, this, _1));
mmc->DeferredPlay.connect_same_thread (*this, boost::bind (&Session::mmc_deferred_play, this, _1));
mmc->Stop.connect_same_thread (*this, boost::bind (&Session::mmc_stop, this, _1));
it up as a Controllable. Changes to the Controllable will just map back to the RCConfiguration
parameter.
*/
-
+
return _solo_cut_control;
}
+
+int
+Session::rename (const std::string& new_name)
+{
+ string legal_name = legalize_for_path (new_name);
+ string newpath;
+ string oldstr;
+ string newstr;
+ bool first = true;
+
+#define RENAME ::rename
+
+ /* Rename:
+
+ * session directory
+ * interchange subdirectory
+ * session file
+ * session history
+
+ * Backup files are left unchanged and not renamed.
+ */
+
+ /* pass one: not 100% safe check that the new directory names don't
+ * already exist ...
+ */
+
+ for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
+ vector<string> v;
+
+ oldstr = (*i).path;
+
+ /* this is a stupid hack because Glib::path_get_dirname() is
+ * lexical-only, and so passing it /a/b/c/ gives a different
+ * result than passing it /a/b/c ...
+ */
+
+ if (oldstr[oldstr.length()-1] == G_DIR_SEPARATOR) {
+ oldstr = oldstr.substr (0, oldstr.length() - 1);
+ }
+
+ string base = Glib::path_get_dirname (oldstr);
+ string p = Glib::path_get_basename (oldstr);
+
+ newstr = Glib::build_filename (base, legal_name);
+
+ if (Glib::file_test (newstr, Glib::FILE_TEST_EXISTS)) {
+ return -1;
+ }
+ }
+
+ /* Session dirs */
+
+ for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
+ vector<string> v;
+
+ oldstr = (*i).path;
+
+ /* this is a stupid hack because Glib::path_get_dirname() is
+ * lexical-only, and so passing it /a/b/c/ gives a different
+ * result than passing it /a/b/c ...
+ */
+
+ if (oldstr[oldstr.length()-1] == G_DIR_SEPARATOR) {
+ oldstr = oldstr.substr (0, oldstr.length() - 1);
+ }
+
+ string base = Glib::path_get_dirname (oldstr);
+ string p = Glib::path_get_basename (oldstr);
+
+ newstr = Glib::build_filename (base, legal_name);
+
+ cerr << "Rename " << oldstr << " => " << newstr << endl;
+
+ if (RENAME (oldstr.c_str(), newstr.c_str()) != 0) {
+ return 1;
+ }
+
+ if (first) {
+ (*_session_dir) = newstr;
+ newpath = newstr;
+ first = 1;
+ }
+
+ /* directory below interchange */
+
+ v.push_back (newstr);
+ v.push_back (interchange_dir_name);
+ v.push_back (p);
+
+ oldstr = Glib::build_filename (v);
+
+ v.clear ();
+ v.push_back (newstr);
+ v.push_back (interchange_dir_name);
+ v.push_back (legal_name);
+
+ newstr = Glib::build_filename (v);
+
+ cerr << "Rename " << oldstr << " => " << newstr << endl;
+
+ if (RENAME (oldstr.c_str(), newstr.c_str()) != 0) {
+ return 1;
+ }
+ }
+
+ /* state file */
+
+ oldstr = Glib::build_filename (newpath, _current_snapshot_name) + statefile_suffix;
+ newstr= Glib::build_filename (newpath, legal_name) + statefile_suffix;
+
+ cerr << "Rename " << oldstr << " => " << newstr << endl;
+
+ if (RENAME (oldstr.c_str(), newstr.c_str()) != 0) {
+ return 1;
+ }
+
+ /* history file */
+
+
+ oldstr = Glib::build_filename (newpath, _current_snapshot_name) + history_suffix;
+
+ if (Glib::file_test (oldstr, Glib::FILE_TEST_EXISTS)) {
+ newstr = Glib::build_filename (newpath, legal_name) + history_suffix;
+
+ cerr << "Rename " << oldstr << " => " << newstr << endl;
+
+ if (RENAME (oldstr.c_str(), newstr.c_str()) != 0) {
+ return 1;
+ }
+ }
+
+ /* remove old name from recent sessions */
+
+ remove_recent_sessions (_path);
+
+ _path = newpath;
+ _current_snapshot_name = new_name;
+ _name = new_name;
+
+ set_dirty ();
+
+ /* save state again to get everything just right */
+
+ save_state (_current_snapshot_name);
+
+
+ /* add to recent sessions */
+
+ store_recent_sessions (new_name, _path);
+
+ return 0;
+
+#undef RENAME
+}
projects / ardour.git / blobdiff