/*
- Copyright (C) 1999-2002 Paul Davis
+ Copyright (C) 1999-2002 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
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.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
+
*/
#include "ardour/audioregion.h"
#include "ardour/auditioner.h"
#include "ardour/buffer.h"
+#include "ardour/butler.h"
#include "ardour/configuration.h"
#include "ardour/control_protocol_manager.h"
#include "ardour/crossfade.h"
_writable = false;
} else {
cerr << "Session writable based on " << _path << endl;
- _writable = true;
+ _writable = true;
}
/* these two are just provisional settings. set_state()
pending_locate_frame = 0;
pending_locate_roll = false;
pending_locate_flush = false;
- audio_dstream_buffer_size = 0;
- midi_dstream_buffer_size = 0;
state_was_pending = false;
set_next_event ();
outbound_mtc_smpte_frame = 0;
session_send_mmc = false;
session_send_mtc = false;
post_transport_work = PostTransportWork (0);
- g_atomic_int_set (&butler_should_do_transport_work, 0);
g_atomic_int_set (&_playback_load, 100);
g_atomic_int_set (&_capture_load, 100);
g_atomic_int_set (&_playback_load_min, 100);
destructive_index = 0;
first_file_data_format_reset = true;
first_file_header_format_reset = true;
- butler_thread = (pthread_t) 0;
//midi_thread = (pthread_t) 0;
AudioDiskstream::allocate_working_buffers();
/* click sounds are unset by default, which causes us to internal
waveforms for clicks.
*/
-
+
click_length = 0;
click_emphasis_length = 0;
_clicking = false;
remove_empty_sounds ();
}
- if (start_butler_thread()) {
+ if (_butler->start_thread()) {
return -1;
}
// to call setup_raid_path() here.
if (state_tree) {
- if (set_state (*state_tree->root())) {
+ if (set_state (*state_tree->root(), Stateful::loading_state_version)) {
return -1;
}
} else {
}
/* handle this one in a different way than all others, so that its clear what happened */
-
+
catch (AudioEngine::PortRegistrationFailure& err) {
error << err.what() << endmsg;
return -1;
_engine.transport_locate (0);
deliver_mmc (MIDI::MachineControl::cmdMmcReset, 0);
deliver_mmc (MIDI::MachineControl::cmdLocate, 0);
-
+
MidiClockTicker::instance().set_session(*this);
MIDI::Name::MidiPatchManager::instance().set_session(*this);
config.set_end_marker_is_free (new_session);
_state_of_the_state = Clean;
-
+
DirtyChanged (); /* EMIT SIGNAL */
if (state_was_pending) {
remove_pending_capture_state ();
state_was_pending = false;
}
-
+
BootMessage (_("Session loading complete"));
return 0;
for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
raid_search_path += sys::path((*i).path);
}
-
+
return raid_search_path.to_string ();
}
if (path.empty()) {
return;
}
-
+
space_and_path sp;
string fspath;
error << string_compose(_("Session: cannot create session 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 0;
} else {
- error << string_compose (_("Could not open %1 for writing mix template"), out_path)
+ error << string_compose (_("Could not open %1 for writing mix template"), out_path)
<< endmsg;
return -1;
}
} else {
- error << string_compose (_("Could not open mix template %1 for reading"), in_path)
+ error << string_compose (_("Could not open mix template %1 for reading"), in_path)
<< endmsg;
return -1;
}
}
-
+
/* Instantiate metadata */
-
+
_metadata = new SessionMetadata ();
/* set initial start + end point */
{
XMLNodeList clist;
XMLNodeConstIterator citer;
-
+
clist = node.children();
for (citer = clist.begin(); citer != clist.end(); ++citer) {
} else {
error << _("Session: unknown diskstream type in XML") << endmsg;
}
- }
-
+ }
+
catch (failed_constructor& err) {
error << _("Session: could not load diskstream via XML state") << endmsg;
return -1;
Session::remove_pending_capture_state ()
{
sys::path pending_state_file_path(_session_dir->root_path());
-
+
pending_state_file_path /= legalize_for_path (_current_snapshot_name) + pending_suffix;
try
if (!pending) {
/* proper save: use statefile_suffix (.ardour in English) */
-
+
xml_path /= legalize_for_path (snapshot_name) + statefile_suffix;
/* make a backup copy of the old file */
bool was_dirty = dirty();
_state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
-
+
if (was_dirty) {
DirtyChanged (); /* EMIT SIGNAL */
}
Session::restore_state (string snapshot_name)
{
if (load_state (snapshot_name) == 0) {
- set_state (*state_tree->root());
+ set_state (*state_tree->root(), Stateful::loading_state_version);
}
-
+
return 0;
}
if (AskAboutPendingState()) {
state_was_pending = true;
- }
- }
+ }
+ }
if (!state_was_pending) {
xmlpath = _session_dir->root_path();
xmlpath /= legalize_for_path (snapshot_name) + statefile_suffix;
}
-
+
if (!sys::exists (xmlpath)) {
error << string_compose(_("%1: session state information file \"%2\" doesn't exist!"), _name, xmlpath.to_string()) << endmsg;
return 1;
}
XMLNode& root (*state_tree->root());
-
+
if (root.name() != X_("Session")) {
error << string_compose (_("Session file %1 is not an Ardour session"), xmlpath.to_string()) << endmsg;
delete state_tree;
}
const XMLProperty* prop;
- bool is_old = false; // session is _very_ old (pre-2.0)
if ((prop = root.property ("version")) == 0) {
/* no version implies very old version of Ardour */
- is_old = true;
+ Stateful::loading_state_version = 1000;
} else {
- int major_version;
- major_version = atoi (prop->value().c_str()); // grab just the first number before the period
- if (major_version < 2) {
- is_old = true;
- }
- }
+ int major;
+ int minor;
+ int micro;
- if (is_old) {
+ 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());
}
info << string_compose (_("Copying old session file %1 to %2\nUse %2 with Ardour versions before 2.0 from now on"),
- xmlpath.to_string(), backup_path.to_string())
+ xmlpath.to_string(), backup_path.to_string())
<< endmsg;
try
config.set_variables (node);
- /* now reset MIDI ports because the session can have its own
+ /* now reset MIDI ports because the session can have its own
MIDI configuration.
*/
{
/* if we don't disable rec-enable, diskstreams
will believe they need to store their capture
- sources in their state node.
+ sources in their state node.
*/
-
+
disable_record (false);
return state(false);
char buf[16];
snprintf(buf, sizeof(buf), "%d.%d.%d", libardour3_major_version, libardour3_minor_version, libardour3_micro_version);
node->add_property("version", string(buf));
-
+
/* store configuration settings */
if (full_state) {
-
+
node->add_property ("name", _name);
snprintf (buf, sizeof (buf), "%" PRId32, _nominal_frame_rate);
node->add_property ("sample-rate", buf);
++next;
++i;
}
-
+
child = node->add_child ("Path");
child->add_content (p);
}
}
/* save the ID counter */
-
+
snprintf (buf, sizeof (buf), "%" PRIu64, ID::counter());
node->add_property ("id-counter", buf);
Glib::Mutex::Lock sl (source_lock);
for (SourceMap::iterator siter = sources.begin(); siter != sources.end(); ++siter) {
-
+
/* Don't save information about non-destructive file sources that are empty */
/* FIXME: MIDI breaks if this is made FileSource like it should be... */
-
+
boost::shared_ptr<AudioFileSource> fs;
if ((fs = boost::dynamic_pointer_cast<AudioFileSource> (siter->second)) != 0) {
if (!fs->destructive()) {
}
}
}
-
+
child->add_child_nocopy (siter->second->get_state());
}
}
child = node->add_child ("Regions");
- if (full_state) {
+ if (full_state) {
Glib::Mutex::Lock rl (region_lock);
for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
-
+
/* only store regions not attached to playlists */
if (i->second->playlist() == 0) {
child = node->add_child ("DiskStreams");
- {
+ {
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if (!(*i)->hidden()) {
loc.add (end);
node->add_child_nocopy (loc.get_state());
}
-
+
child = node->add_child ("Bundles");
{
boost::shared_ptr<BundleList> bundles = _bundles.reader ();
child = node->add_child ("Routes");
{
boost::shared_ptr<RouteList> r = routes.reader ();
-
+
RoutePublicOrderSorter cmp;
RouteList public_order (*r);
public_order.sort (cmp);
-
+
for (RouteList::iterator i = public_order.begin(); i != public_order.end(); ++i) {
if (!(*i)->is_hidden()) {
if (full_state) {
}
}
-
+
child = node->add_child ("RouteGroups");
for (list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
child->add_child_nocopy ((*i)->get_state());
}
}
}
-
-
+
+
if (_click_io) {
child = node->add_child ("Click");
child->add_child_nocopy (_click_io->state (full_state));
for (NamedSelectionList::iterator i = named_selections.begin(); i != named_selections.end(); ++i) {
if (full_state) {
child->add_child_nocopy ((*i)->get_state());
- }
+ }
}
}
}
int
-Session::set_state (const XMLNode& node)
+Session::set_state (const XMLNode& node, int version)
{
XMLNodeList nlist;
XMLNode* child;
int ret = -1;
_state_of_the_state = StateOfTheState (_state_of_the_state|CannotSave);
-
+
if (node.name() != X_("Session")){
fatal << _("programming error: Session: incorrect XML node sent to set_state()") << endmsg;
return -1;
}
+ if ((prop = node.property ("version")) != 0) {
+ version = atoi (prop->value ()) * 1000;
+ }
+
if ((prop = node.property ("name")) != 0) {
_name = prop->value ();
}
ID::init_counter (now);
}
-
+
IO::disable_connecting ();
/* Object loading order:
if (use_config_midi_ports ()) {
}
- if ((child = find_named_node (node, "Metadata")) == 0) {
- warning << _("Session: XML state has no metadata section (2.0 session?)") << endmsg;
- } else if (_metadata->set_state (*child)) {
- goto out;
+ if (version >= 3000) {
+ if ((child = find_named_node (node, "Metadata")) == 0) {
+ warning << _("Session: XML state has no metadata section") << endmsg;
+ } else if (_metadata->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;
- } else if (_locations.set_state (*child)) {
+ } else if (_locations.set_state (*child, version)) {
goto out;
}
goto out;
}
- if ((child = find_named_node (node, "Bundles")) == 0) {
- warning << _("Session: XML state has no bundles section (2.0 session?)") << endmsg;
- //goto out;
- } else {
- /* We can't load Bundles yet as they need to be able
- to convert from port names to Port objects, which can't happen until
- later */
- _bundle_xml_node = new XMLNode (*child);
+ if (version >= 3000) {
+ if ((child = find_named_node (node, "Bundles")) == 0) {
+ warning << _("Session: XML state has no bundles section") << endmsg;
+ //goto out;
+ } else {
+ /* We can't load Bundles yet as they need to be able
+ to convert from port names to Port objects, which can't happen until
+ later */
+ _bundle_xml_node = new XMLNode (*child);
+ }
}
- 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)) {
- goto out;
+ 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 if (load_route_groups (*child, version)) {
+ goto out;
+ }
+
+ if ((child = find_named_node (node, "MixGroups")) == 0) {
+ error << _("Session: XML state has no mix groups section") << endmsg;
+ goto out;
+ } else if (load_route_groups (*child, version)) {
+ 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)) {
+ } else if (_tempo_map->set_state (*child, version)) {
goto out;
}
if ((child = find_named_node (node, "Routes")) == 0) {
error << _("Session: XML state has no routes section") << endmsg;
goto out;
- } else if (load_routes (*child)) {
+ } else if (load_routes (*child, version)) {
goto out;
}
if ((child = find_named_node (node, "Click")) == 0) {
warning << _("Session: XML state has no click section") << endmsg;
} else if (_click_io) {
- _click_io->set_state (*child);
+ _click_io->set_state (*child, version);
}
if ((child = find_named_node (node, "ControlProtocols")) != 0) {
}
int
-Session::load_routes (const XMLNode& node)
+Session::load_routes (const XMLNode& node, int version)
{
XMLNodeList nlist;
XMLNodeConstIterator niter;
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
- boost::shared_ptr<Route> route (XMLRouteFactory (**niter));
+ boost::shared_ptr<Route> route (XMLRouteFactory (**niter, version));
if (route == 0) {
error << _("Session: cannot create Route from XML description.") << endmsg;
}
boost::shared_ptr<Route>
-Session::XMLRouteFactory (const XMLNode& node)
+Session::XMLRouteFactory (const XMLNode& node, int version)
{
if (node.name() != "Route") {
return boost::shared_ptr<Route> ((Route*) 0);
}
bool has_diskstream = (node.property ("diskstream") != 0 || node.property ("diskstream-id") != 0);
-
+
DataType type = DataType::AUDIO;
const XMLProperty* prop = node.property("default-type");
if (prop) {
type = DataType(prop->value());
- }
-
+ }
+
assert(type != DataType::NIL);
if (has_diskstream) {
if (type == DataType::AUDIO) {
- boost::shared_ptr<Route> ret (new AudioTrack (*this, node));
+ boost::shared_ptr<Route> ret (new AudioTrack (*this, node, version));
return ret;
} else {
- boost::shared_ptr<Route> ret (new MidiTrack (*this, node));
+ boost::shared_ptr<Route> ret (new MidiTrack (*this, node, version));
return ret;
}
} else {
const XMLProperty* type = node.property("type");
try {
-
+
if ( !type || type->value() == "audio" ) {
return boost::shared_ptr<Region>(XMLAudioRegionFactory (node, full));
-
+
} else if (type->value() == "midi") {
-
+
return boost::shared_ptr<Region>(XMLMidiRegionFactory (node, full));
}
-
+
} catch (failed_constructor& err) {
return boost::shared_ptr<Region> ();
}
SourceList master_sources;
uint32_t nchans = 1;
char buf[128];
-
+
if (node.name() != X_("Region")) {
return boost::shared_ptr<AudioRegion>();
}
cerr << "no name for this region\n";
abort ();
}
-
+
if ((prop = node.property (X_("source-0"))) == 0) {
if ((prop = node.property ("source")) == 0) {
error << _("Session: XMLNode describing a AudioRegion is incomplete (no source)") << endmsg;
error << string_compose(_("Session: XMLNode describing a AudioRegion references an unknown source id =%1"), s_id) << endmsg;
return boost::shared_ptr<AudioRegion>();
}
-
+
as = boost::dynamic_pointer_cast<AudioSource>(source);
if (!as) {
error << string_compose(_("Session: XMLNode describing a AudioRegion references a non-audio source id =%1"), s_id) << endmsg;
for (uint32_t n=1; n < nchans; ++n) {
snprintf (buf, sizeof(buf), X_("source-%d"), n);
if ((prop = node.property (buf)) != 0) {
-
+
PBD::ID id2 (prop->value());
-
+
if ((source = source_by_id (id2)) == 0) {
error << string_compose(_("Session: XMLNode describing a AudioRegion references an unknown source id =%1"), id2) << endmsg;
return boost::shared_ptr<AudioRegion>();
}
-
+
as = boost::dynamic_pointer_cast<AudioSource>(source);
if (!as) {
error << string_compose(_("Session: XMLNode describing a AudioRegion references a non-audio source id =%1"), id2) << endmsg;
for (uint32_t n = 0; n < nchans; ++n) {
snprintf (buf, sizeof(buf), X_("master-source-%d"), n);
if ((prop = node.property (buf)) != 0) {
-
+
PBD::ID id2 (prop->value());
-
+
if ((source = source_by_id (id2)) == 0) {
error << string_compose(_("Session: XMLNode describing a AudioRegion references an unknown source id =%1"), id2) << endmsg;
return boost::shared_ptr<AudioRegion>();
}
-
+
as = boost::dynamic_pointer_cast<AudioSource>(source);
if (!as) {
error << string_compose(_("Session: XMLNode describing a AudioRegion references a non-audio source id =%1"), id2) << endmsg;
}
return region;
-
+
}
catch (failed_constructor& err) {
boost::shared_ptr<MidiSource> ms;
SourceList sources;
uint32_t nchans = 1;
-
+
if (node.name() != X_("Region")) {
return boost::shared_ptr<MidiRegion>();
}
if ((prop = node.property (X_("channels"))) != 0) {
nchans = atoi (prop->value().c_str());
}
-
+
if ((prop = node.property ("name")) == 0) {
cerr << "no name for this region\n";
abort ();
for (n = 0; n < 999999; ++n) {
if (identifier.length()) {
- snprintf (buf, sizeof(buf), "%s%s%" PRIu32 "%s", name.c_str(),
+ snprintf (buf, sizeof(buf), "%s%s%" PRIu32 "%s", name.c_str(),
identifier.c_str(), n, ext.c_str());
} else {
snprintf (buf, sizeof(buf), "%s-%" PRIu32 "%s", name.c_str(),
return "";
}
-
+
int
Session::load_sources (const XMLNode& node)
}
int
-Session::rename_template (string old_name, string new_name)
+Session::rename_template (string old_name, string new_name)
{
sys::path old_path (user_template_directory());
old_path /= old_name + template_suffix;
}
int
-Session::delete_template (string name)
+Session::delete_template (string name)
{
sys::path path = user_template_directory();
path /= name + template_suffix;
/* get freespace on every FS that is part of the session path */
_total_free_4k_blocks = 0;
-
+
for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
statfs ((*i).path.c_str(), &statfsbuf);
}
/* OK, here's the algorithm we're following here:
-
- We want to select which directory to use for
+
+ We want to select which directory to use for
the next file source to be created. Ideally,
we'd like to use a round-robin process so as to
get maximum performance benefits from splitting
So, we use a user-configurable space threshold. If
there are at least 2 filesystems with more than this
- much space available, we use RR selection between them.
+ much space available, we use RR selection between them.
If not, then we pick the filesystem with the most space.
This gets a good balance between the two
- approaches.
+ approaches.
*/
-
+
refresh_disk_space ();
-
+
int free_enough = 0;
for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
/* pick FS with the most freespace (and that
seems to actually work ...)
*/
-
+
vector<space_and_path> sorted;
space_and_path_ascending_cmp cmp;
sorted = session_dirs;
sort (sorted.begin(), sorted.end(), cmp);
-
+
for (i = sorted.begin(); i != sorted.end(); ++i) {
if (create_session_directory ((*i).path)) {
result = (*i).path;
set_dirty();
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
-
+
if ((playlist = XMLPlaylistFactory (**niter)) == 0) {
error << _("Session: cannot create Playlist from XML description.") << endmsg;
}
set_dirty();
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
-
+
if ((playlist = XMLPlaylistFactory (**niter)) == 0) {
error << _("Session: cannot create Playlist from XML description.") << endmsg;
continue;
set_dirty();
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
-
+
if ((ns = XMLNamedSelectionFactory (**niter)) == 0) {
error << _("Session: cannot create Named Selection from XML description.") << endmsg;
}
int
Session::load_bundles (XMLNode const & node)
{
- XMLNodeList nlist = node.children();
- XMLNodeConstIterator niter;
+ XMLNodeList nlist = node.children();
+ XMLNodeConstIterator niter;
- set_dirty();
+ set_dirty();
- for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
- if ((*niter)->name() == "InputBundle") {
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
+ if ((*niter)->name() == "InputBundle") {
add_bundle (boost::shared_ptr<UserBundle> (new UserBundle (**niter, true)));
- } else if ((*niter)->name() == "OutputBundle") {
- add_bundle (boost::shared_ptr<UserBundle> (new UserBundle (**niter, false)));
- } else {
- error << string_compose(_("Unknown node \"%1\" found in Bundles list from state file"), (*niter)->name()) << endmsg;
- return -1;
- }
- }
+ } else if ((*niter)->name() == "OutputBundle") {
+ add_bundle (boost::shared_ptr<UserBundle> (new UserBundle (**niter, false)));
+ } else {
+ error << string_compose(_("Unknown node \"%1\" found in Bundles list from state file"), (*niter)->name()) << endmsg;
+ return -1;
+ }
+ }
return 0;
-}
+}
int
-Session::load_route_groups (const XMLNode& node)
+Session::load_route_groups (const XMLNode& node, int version)
{
XMLNodeList nlist = node.children();
XMLNodeConstIterator niter;
set_dirty ();
- for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
- if ((*niter)->name() == "RouteGroup") {
- RouteGroup* rg = new RouteGroup (*this, "");
- add_route_group (rg);
- rg->set_state (**niter);
+ if (version >= 3000) {
+
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
+ if ((*niter)->name() == "RouteGroup") {
+ RouteGroup* rg = new RouteGroup (*this, "");
+ add_route_group (rg);
+ rg->set_state (**niter, version);
+ }
+ }
+
+ } else if (version < 3000) {
+
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
+ if ((*niter)->name() == "EditGroup" || (*niter)->name() == "MixGroup") {
+ RouteGroup* rg = new RouteGroup (*this, "");
+ add_route_group (rg);
+ rg->set_state (**niter, version);
+ }
}
}
-
+
return 0;
-}
+}
void
Session::auto_save()
remove_end(string* state)
{
string statename(*state);
-
+
string::size_type start,end;
if ((start = statename.find_last_of ('/')) != string::npos) {
statename = statename.substr (start+1);
}
-
+
if ((end = statename.rfind(".ardour")) == string::npos) {
end = statename.length();
}
}
vector<string *> *
-Session::possible_states (string path)
+Session::possible_states (string path)
{
PathScanner scanner;
vector<string*>* states = scanner (path, state_file_filter, 0, false, false);
-
+
transform(states->begin(), states->end(), states->begin(), remove_end);
-
+
string_cmp cmp;
sort (states->begin(), states->end(), cmp);
-
+
return states;
}
_current_trans.pop();
}
-Session::GlobalRouteBooleanState
+Session::GlobalRouteBooleanState
Session::get_global_route_boolean (bool (Route::*method)(void) const)
{
GlobalRouteBooleanState s;
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
if (!(*i)->is_hidden()) {
RouteBooleanState v;
-
+
v.first =* i;
Route* r = (*i).get();
v.second = (r->*method)();
-
+
s.push_back (v);
}
}
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
if (!(*i)->is_hidden()) {
RouteMeterState v;
-
+
v.first =* i;
v.second = (*i)->meter_point();
-
+
s.push_back (v);
}
}
}
void
-Session::set_global_route_metering (GlobalRouteMeterState s, void* arg)
+Session::set_global_route_metering (GlobalRouteMeterState s, void* arg)
{
for (GlobalRouteMeterState::iterator i = s.begin(); i != s.end(); ++i) {
return (path.length() > 7 && path.find (".ardour") == (path.length() - 7));
}
-int
+int
Session::find_all_sources (string path, set<string>& result)
{
XMLTree tree;
set_dirty();
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
-
+
XMLProperty* prop;
if ((prop = (*niter)->property (X_("type"))) == 0) {
/* external file, ignore */
continue;
}
-
+
Glib::ustring found_path;
bool is_new;
uint16_t chan;
}
state_files = scanner (ripped, accept_all_state_files, (void *) 0, false, true);
-
+
if (state_files == 0) {
/* impossible! */
return 0;
AudioSourceList::iterator iter;
boost::shared_ptr<Region> region;
uint32_t count;
-
+
RegionCounter() : count (0) {}
};
Session::cleanup_sources (Session::cleanup_report& rep)
{
// FIXME: needs adaptation to midi
-
+
vector<boost::shared_ptr<Source> > dead_sources;
vector<boost::shared_ptr<Playlist> > playlists_tbd;
PathScanner scanner;
bool used;
string spath;
int ret = -1;
-
+
_state_of_the_state = (StateOfTheState) (_state_of_the_state | InCleanup);
-
+
/* step 1: consider deleting all unused playlists */
for (PlaylistList::iterator x = unused_playlists.begin(); x != unused_playlists.end(); ++x) {
rep.space = 0;
for (SourceMap::iterator i = sources.begin(); i != sources.end(); ) {
-
+
SourceMap::iterator tmp;
tmp = i;
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->GoingAway();
- }
+ }
i = tmp;
}
i = nexti;
}
- /* now do the same thing for the files that ended up in the sounds dir(s)
+ /* 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.
*/
state file on disk still references sources we may have already
dropped.
*/
-
+
find_all_sources_across_snapshots (all_sources, true);
/* add our current source list
*/
-
+
for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
boost::shared_ptr<FileSource> fs;
-
+
if ((fs = boost::dynamic_pointer_cast<FileSource> (i->second)) != 0) {
all_sources.insert (fs->path());
- }
+ }
}
char tmppath1[PATH_MAX+1];
char tmppath2[PATH_MAX+1];
-
+
for (vector<string*>::iterator x = soundfiles->begin(); x != soundfiles->end(); ++x) {
used = false;
}
string newpath;
-
+
/* don't move the file across filesystems, just
stick it in the `dead_sound_dir_name' directory
on whichever filesystem it was already on.
/* old school, go up 1 level */
- newpath = Glib::path_get_dirname (*x); // "sounds"
+ newpath = Glib::path_get_dirname (*x); // "sounds"
newpath = Glib::path_get_dirname (newpath); // "session-name"
} else {
/* new school, go up 4 levels */
-
- newpath = Glib::path_get_dirname (*x); // "audiofiles"
+
+ newpath = Glib::path_get_dirname (*x); // "audiofiles"
newpath = Glib::path_get_dirname (newpath); // "session-name"
newpath = Glib::path_get_dirname (newpath); // "interchange"
newpath = Glib::path_get_dirname (newpath); // "session-dir"
newpath += '/';
newpath += Glib::path_get_basename ((*x));
-
+
if (access (newpath.c_str(), F_OK) == 0) {
-
+
/* the new path already exists, try versioning */
-
+
char buf[PATH_MAX+1];
int version = 1;
string newpath_v;
-
+
snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), version);
newpath_v = buf;
snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), ++version);
newpath_v = buf;
}
-
+
if (version == 999) {
error << string_compose (_("there are already 1000 files with names like %1; versioning discontinued"),
newpath)
} else {
newpath = newpath_v;
}
-
+
} else {
-
+
/* it doesn't exist, or we can't read it or something */
-
+
}
if (::rename ((*x).c_str(), newpath.c_str()) != 0) {
/* save state so we don't end up a session file
referring to non-existent sources.
*/
-
+
save_state ("");
out:
Session::cleanup_trash_sources (Session::cleanup_report& rep)
{
// FIXME: needs adaptation for MIDI
-
+
vector<space_and_path>::iterator i;
string dead_sound_dir;
struct dirent* dentry;
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;
while ((dentry = readdir (dead)) != 0) {
/* avoid '.' and '..' */
-
- if ((dentry->d_name[0] == '.' && dentry->d_name[1] == '\0') ||
+
+ if ((dentry->d_name[0] == '.' && dentry->d_name[1] == '\0') ||
(dentry->d_name[2] == '\0' && dentry->d_name[0] == '.' && dentry->d_name[1] == '.')) {
continue;
}
}
closedir (dead);
-
+
}
return 0;
Session::set_clean ()
{
bool was_dirty = dirty();
-
+
_state_of_the_state = Clean;
Glib::Mutex::Lock lm (controllables_lock);
controllables.insert (c);
}
-
+
struct null_deleter { void operator()(void const *) const {} };
void
if (x != controllables.end()) {
controllables.erase (x);
}
-}
+}
boost::shared_ptr<Controllable>
Session::controllable_by_id (const PBD::ID& id)
{
Glib::Mutex::Lock lm (controllables_lock);
-
+
for (Controllables::iterator i = controllables.begin(); i != controllables.end(); ++i) {
if ((*i)->id() == id) {
return *i;
return boost::shared_ptr<Controllable>();
}
-void
+void
Session::add_instant_xml (XMLNode& node, bool write_to_config)
{
if (_writable) {
return Stateful::instant_xml (node_name, _path);
}
-int
+int
Session::save_history (string snapshot_name)
{
XMLTree tree;
-
+
if (!_writable) {
return 0;
- }
+ }
- if (snapshot_name.empty()) {
+ if (snapshot_name.empty()) {
snapshot_name = _current_snapshot_name;
}
-
- const string history_filename = legalize_for_path (snapshot_name) + history_suffix;
+
+ const string history_filename = legalize_for_path (snapshot_name) + history_suffix;
const string backup_filename = history_filename + backup_suffix;
- const sys::path xml_path = _session_dir->root_path() / history_filename;
+ const sys::path xml_path = _session_dir->root_path() / history_filename;
const sys::path backup_path = _session_dir->root_path() / backup_filename;
if (sys::exists (xml_path)) {
error << _("could not backup old history file, current history not saved") << endmsg;
return -1;
}
- }
+ }
if (!Config->get_save_history() || Config->get_saved_history_depth() < 0) {
return 0;
}
- tree.set_root (&_history.get_state (Config->get_saved_history_depth()));
+ tree.set_root (&_history.get_state (Config->get_saved_history_depth()));
if (!tree.write (xml_path.to_string()))
{
if (snapshot_name.empty()) {
snapshot_name = _current_snapshot_name;
}
-
+
const string xml_filename = legalize_for_path (snapshot_name) + history_suffix;
const sys::path xml_path = _session_dir->root_path() / xml_filename;
-
- cerr << "Loading history from " << xml_path.to_string() << endmsg;
+
+ info << "Loading history from " << xml_path.to_string() << endmsg;
if (!sys::exists (xml_path)) {
info << string_compose (_("%1: no history file \"%2\" for this session."),
// replace history
_history.clear();
- for (XMLNodeConstIterator it = tree.root()->children().begin(); it != tree.root()->children().end(); it++) {
-
- XMLNode *t = *it;
- UndoTransaction* ut = new UndoTransaction ();
- struct timeval tv;
-
- ut->set_name(t->property("name")->value());
- stringstream ss(t->property("tv-sec")->value());
- ss >> tv.tv_sec;
- ss.str(t->property("tv-usec")->value());
- ss >> tv.tv_usec;
- ut->set_timestamp(tv);
-
- for (XMLNodeConstIterator child_it = t->children().begin();
+ for (XMLNodeConstIterator it = tree.root()->children().begin(); it != tree.root()->children().end(); it++) {
+
+ XMLNode *t = *it;
+ UndoTransaction* ut = new UndoTransaction ();
+ struct timeval tv;
+
+ ut->set_name(t->property("name")->value());
+ stringstream ss(t->property("tv-sec")->value());
+ ss >> tv.tv_sec;
+ ss.str(t->property("tv-usec")->value());
+ ss >> tv.tv_usec;
+ ut->set_timestamp(tv);
+
+ for (XMLNodeConstIterator child_it = t->children().begin();
child_it != t->children().end(); child_it++)
- {
- XMLNode *n = *child_it;
- Command *c;
-
- if (n->name() == "MementoCommand" ||
+ {
+ XMLNode *n = *child_it;
+ Command *c;
+
+ if (n->name() == "MementoCommand" ||
n->name() == "MementoUndoCommand" ||
n->name() == "MementoRedoCommand") {
- if ((c = memento_command_factory(n))) {
- ut->add_command(c);
- }
-
- } else if (n->name() == X_("GlobalRouteStateCommand")) {
-
- if ((c = global_state_command_factory (*n))) {
- ut->add_command (c);
- }
-
- } else if (n->name() == "DeltaCommand") {
- PBD::ID id(n->property("midi-source")->value());
- boost::shared_ptr<MidiSource> midi_source =
- boost::dynamic_pointer_cast<MidiSource, Source>(source_by_id(id));
- if(midi_source) {
- ut->add_command(new MidiModel::DeltaCommand(midi_source->model(), *n));
- } else {
- error << "FIXME: Failed to downcast MidiSource for DeltaCommand" << endmsg;
- }
- } else if (n->name() == "DiffCommand") {
- PBD::ID id(n->property("midi-source")->value());
- boost::shared_ptr<MidiSource> midi_source =
- boost::dynamic_pointer_cast<MidiSource, Source>(source_by_id(id));
- if(midi_source) {
- ut->add_command(new MidiModel::DiffCommand(midi_source->model(), *n));
- } else {
- error << "FIXME: Failed to downcast MidiSource for DeltaCommand" << endmsg;
- }
-
- } else {
- error << string_compose(_("Couldn't figure out how to make a Command out of a %1 XMLNode."), n->name()) << endmsg;
- }
- }
-
- _history.add (ut);
- }
-
- return 0;
+ if ((c = memento_command_factory(n))) {
+ ut->add_command(c);
+ }
+
+ } else if (n->name() == X_("GlobalRouteStateCommand")) {
+
+ if ((c = global_state_command_factory (*n))) {
+ ut->add_command (c);
+ }
+
+ } else if (n->name() == "DeltaCommand") {
+ PBD::ID id(n->property("midi-source")->value());
+ boost::shared_ptr<MidiSource> midi_source =
+ boost::dynamic_pointer_cast<MidiSource, Source>(source_by_id(id));
+ if (midi_source) {
+ ut->add_command(new MidiModel::DeltaCommand(midi_source->model(), *n));
+ } else {
+ error << _("Failed to downcast MidiSource for DeltaCommand") << endmsg;
+ }
+
+ } else if (n->name() == "DiffCommand") {
+ PBD::ID id(n->property("midi-source")->value());
+ boost::shared_ptr<MidiSource> midi_source =
+ boost::dynamic_pointer_cast<MidiSource, Source>(source_by_id(id));
+ if (midi_source) {
+ ut->add_command(new MidiModel::DiffCommand(midi_source->model(), *n));
+ } else {
+ error << _("Failed to downcast MidiSource for DeltaCommand") << endmsg;
+ }
+
+ } else {
+ error << string_compose(_("Couldn't figure out how to make a Command out of a %1 XMLNode."), n->name()) << endmsg;
+ }
+ }
+
+ _history.add (ut);
+ }
+
+ return 0;
}
void
if (ours) {
set_dirty ();
}
-
+
if (p == "seamless-loop") {
-
+
} else if (p == "rf-speed") {
-
+
} else if (p == "auto-loop") {
-
+
} else if (p == "auto-input") {
-
+
if (Config->get_monitoring_model() == HardwareMonitoring && transport_rolling()) {
/* auto-input only makes a difference if we're rolling */
-
+
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
-
+
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if ((*i)->record_enabled ()) {
(*i)->monitor_input (!config.get_auto_input());
} else if (p == "punch-in") {
Location* location;
-
+
if ((location = _locations.auto_punch_location()) != 0) {
-
+
if (config.get_punch_in ()) {
replace_event (Event::PunchIn, location->start());
} else {
remove_event (location->start(), Event::PunchIn);
}
}
-
+
} else if (p == "punch-out") {
Location* location;
-
+
if ((location = _locations.auto_punch_location()) != 0) {
-
+
if (config.get_punch_out()) {
replace_event (Event::PunchOut, location->end());
} else {
} else if (p == "edit-mode") {
Glib::Mutex::Lock lm (playlist_lock);
-
+
for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i) {
(*i)->set_edit_mode (Config->get_edit_mode ());
}
}
} else if (p == "midi-control") {
-
+
//poke_midi_thread ();
} else if (p == "raid-path") {
}
} else if (p == "send-mtc") {
-
+
/* only set the internal flag if we have
a port.
*/
-
+
if (_mtc_port != 0) {
session_send_mtc = Config->get_send_mtc();
if (session_send_mtc) {
}
} else if (p == "send-mmc") {
-
+
/* only set the internal flag if we have
a port.
*/
-
+
if (_mmc_port != 0) {
session_send_mmc = Config->get_send_mmc();
} else {
mmc = 0;
- session_send_mmc = false;
+ session_send_mmc = false;
}
} else if (p == "midi-feedback") {
-
+
/* only set the internal flag if we have
a port.
*/
-
+
if (_mtc_port != 0) {
session_midi_feedback = Config->get_midi_feedback();
}
if (_mmc_port && Config->get_initial_program_change() >= 0) {
MIDI::byte buf[2];
-
+
buf[0] = MIDI::program; // channel zero by default
buf[1] = (Config->get_initial_program_change() & 0x7f);
if (_mmc_port && Config->get_initial_program_change() >= 0) {
MIDI::byte* buf = new MIDI::byte[2];
-
+
buf[0] = MIDI::program; // channel zero by default
buf[1] = (Config->get_initial_program_change() & 0x7f);
// deliver_midi (_mmc_port, buf, 2);
projects / ardour.git / blobdiff