#include <glib.h>
#include "pbd/gstdio_compat.h"
+#include "pbd/locale_guard.h"
#include <glibmm.h>
#include <glibmm/threads.h>
#include "pbd/debug.h"
#include "pbd/enumwriter.h"
#include "pbd/error.h"
-#include "pbd/file_archive.h"
#include "pbd/file_utils.h"
#include "pbd/pathexpand.h"
#include "pbd/pthread_utils.h"
#include "ardour/amp.h"
#include "ardour/async_midi_port.h"
-#include "ardour/audio_diskstream.h"
#include "ardour/audio_track.h"
#include "ardour/audioengine.h"
#include "ardour/audiofilesource.h"
#include "ardour/controllable_descriptor.h"
#include "ardour/control_protocol_manager.h"
#include "ardour/directory_names.h"
+#include "ardour/disk_reader.h"
#include "ardour/filename_extensions.h"
#include "ardour/graph.h"
#include "ardour/location.h"
#include "ardour/revision.h"
#include "ardour/route_group.h"
#include "ardour/send.h"
+#include "ardour/selection.h"
#include "ardour/session.h"
#include "ardour/session_directory.h"
#include "ardour/session_metadata.h"
#include "ardour/session_playlists.h"
#include "ardour/session_state_utils.h"
#include "ardour/silentfilesource.h"
+#include "ardour/smf_source.h"
#include "ardour/sndfilesource.h"
#include "ardour/source_factory.h"
#include "ardour/speakers.h"
g_atomic_int_set (&_capture_load, 100);
set_next_event ();
_all_route_group->set_active (true, this);
- interpolation.add_channel_to (0, 0);
+ interpolation.add_channel ();
if (config.get_use_video_sync()) {
waiting_for_sync_offset = true;
BootMessage (_("Set block size and sample rate"));
set_block_size (_engine.samples_per_cycle());
- set_frame_rate (_engine.sample_rate());
+ set_sample_rate (_engine.sample_rate());
BootMessage (_("Using configuration"));
msc->set_input_port (boost::dynamic_pointer_cast<MidiPort>(scene_input_port()));
msc->set_output_port (boost::dynamic_pointer_cast<MidiPort>(scene_output_port()));
- boost::function<framecnt_t(void)> timer_func (boost::bind (&Session::audible_frame, this, (bool*)(0)));
+ boost::function<samplecnt_t(void)> timer_func (boost::bind (&Session::audible_sample, this, (bool*)(0)));
boost::dynamic_pointer_cast<AsyncMIDIPort>(scene_input_port())->set_timer (timer_func);
setup_midi_machine_control ();
/* tempo map requires sample rate knowledge */
delete _tempo_map;
- _tempo_map = new TempoMap (_current_frame_rate);
+ _tempo_map = new TempoMap (_current_sample_rate);
_tempo_map->PropertyChanged.connect_same_thread (*this, boost::bind (&Session::tempo_map_changed, this, _1));
_tempo_map->MetricPositionChanged.connect_same_thread (*this, boost::bind (&Session::tempo_map_changed, this, _1));
+ } catch (std::exception const & e) {
+ error << _("Unexpected exception during session setup: ") << e.what() << endmsg;
+ return -2;
+ } catch (...) {
+ error << _("Unknown exception during session setup") << endmsg;
+ return -3;
+ }
+ try {
/* MidiClock requires a tempo map */
delete midi_clock;
/* crossfades require sample rate knowledge */
- SndFileSource::setup_standard_crossfades (*this, frame_rate());
+ SndFileSource::setup_standard_crossfades (*this, sample_rate());
_engine.GraphReordered.connect_same_thread (*this, boost::bind (&Session::graph_reordered, this));
_engine.MidiSelectionPortsChanged.connect_same_thread (*this, boost::bind (&Session::rewire_midi_selection_ports, this));
- AudioDiskstream::allocate_working_buffers();
+ DiskReader::allocate_working_buffers();
refresh_disk_space ();
/* we're finally ready to call set_state() ... all objects have
*/
if (state_tree) {
- if (set_state (*state_tree->root(), Stateful::loading_state_version)) {
- error << _("Could not set session state from XML") << endmsg;
- return -1;
+ try {
+ if (set_state (*state_tree->root(), Stateful::loading_state_version)) {
+ error << _("Could not set session state from XML") << endmsg;
+ return -4;
+ }
+ } catch (PBD::unknown_enumeration& e) {
+ error << _("Session state: ") << e.what() << endmsg;
+ return -4;
}
} else {
// set_state() will call setup_raid_path(), but if it's a new session we need
_locations->changed.connect_same_thread (*this, boost::bind (&Session::locations_changed, this));
} catch (AudioEngine::PortRegistrationFailure& err) {
- /* handle this one in a different way than all others, so that its clear what happened */
error << err.what() << endmsg;
- return -1;
+ return -5;
} catch (std::exception const & e) {
error << _("Unexpected exception during session setup: ") << e.what() << endmsg;
- return -1;
+ return -6;
} catch (...) {
error << _("Unknown exception during session setup") << endmsg;
- return -1;
+ return -7;
}
BootMessage (_("Reset Remote Controls"));
boost::shared_ptr<RouteList> rl = routes.reader();
for (RouteList::iterator r = rl->begin(); r != rl->end(); ++r) {
boost::shared_ptr<Track> trk = boost::dynamic_pointer_cast<Track> (*r);
- if (trk && !trk->hidden()) {
- trk->seek (_transport_frame, true);
+ if (trk && !trk->is_private_route()) {
+ trk->seek (_transport_sample, true);
}
}
/* Now, finally, we can fill the playback buffers */
BootMessage (_("Filling playback buffers"));
- force_locate (_transport_frame, false);
+ force_locate (_transport_sample, false);
}
string
/* set up Master Out and Monitor Out if necessary */
if (bus_profile) {
-
RouteList rl;
ChanCount count(DataType::AUDIO, bus_profile->master_out_channels);
+ if (bus_profile->master_out_channels) {
+ int rv = add_master_bus (count);
- // Waves Tracks: always create master bus for Tracks
- if (ARDOUR::Profile->get_trx() || bus_profile->master_out_channels) {
- boost::shared_ptr<Route> r (new Route (*this, _("Master"), PresentationInfo::MasterOut, DataType::AUDIO));
- if (r->init ()) {
- return -1;
- }
-
- BOOST_MARK_ROUTE(r);
-
- {
- Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
- r->input()->ensure_io (count, false, this);
- r->output()->ensure_io (count, false, this);
+ if (rv) {
+ return rv;
}
- rl.push_back (r);
-
- } else {
- /* prohibit auto-connect to master, because there isn't one */
- bus_profile->output_ac = AutoConnectOption (bus_profile->output_ac & ~AutoConnectMaster);
- }
-
- if (!rl.empty()) {
- add_routes (rl, false, false, false, PresentationInfo::max_order);
+ if (Config->get_use_monitor_bus())
+ add_monitor_section ();
}
-
- // Waves Tracks: Skip this. Always use autoconnection for Tracks
- if (!ARDOUR::Profile->get_trx()) {
-
- /* this allows the user to override settings with an environment variable.
- */
-
- if (no_auto_connect()) {
- 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);
- }
- }
-
- if (Config->get_use_monitor_bus() && bus_profile) {
- add_monitor_section ();
}
return 0;
}
_save_queued = false;
- if (!_engine.connected ()) {
- error << string_compose (_("the %1 audio engine is not connected and state saving would lose all I/O connections. Session not saved"), PROGRAM_NAME)
- << endmsg;
- return 1;
+ snapshot_t fork_state = NormalSave;
+ if (!snapshot_name.empty() && snapshot_name != _current_snapshot_name && !template_only && !pending) {
+ /* snapshot, close midi */
+ fork_state = switch_to_snapshot ? SwitchToSnapshot : SnapshotKeep;
}
#ifndef NDEBUG
mark_as_clean = false;
tree.set_root (&get_template());
} else {
- tree.set_root (&get_state());
+ tree.set_root (&state (true, fork_state));
}
if (snapshot_name.empty()) {
std::string tmp_path(_session_dir->root_path());
tmp_path = Glib::build_filename (tmp_path, legalize_for_path (snapshot_name) + temp_suffix);
+#ifndef NDEBUG
cerr << "actually writing state to " << tmp_path << endl;
+#endif
if (!tree.write (tmp_path)) {
error << string_compose (_("state could not be saved to %1"), tmp_path) << endmsg;
} else {
+#ifndef NDEBUG
cerr << "renaming state to " << xml_path << endl;
+#endif
if (::g_rename (tmp_path.c_str(), xml_path.c_str()) != 0) {
error << string_compose (_("could not rename temporary session file %1 to %2 (%3)"),
int
Session::restore_state (string snapshot_name)
{
- if (load_state (snapshot_name) == 0) {
- set_state (*state_tree->root(), Stateful::loading_state_version);
+ try {
+ if (load_state (snapshot_name) == 0) {
+ set_state (*state_tree->root(), Stateful::loading_state_version);
+ }
+ } catch (...) {
+ // SessionException
+ // unknown_enumeration
+ return -1;
}
return 0;
}
std::string version;
- if (root.get_property ("version", version)) {
- if (version.find ('.') != string::npos) {
- /* old school version format */
- if (version[0] == '2') {
- Stateful::loading_state_version = 2000;
- } else {
- Stateful::loading_state_version = 3000;
- }
- } else {
- Stateful::loading_state_version = string_to<int32_t>(version);
- }
- } else {
- /* no version implies very old version of Ardour */
- Stateful::loading_state_version = 1000;
+ root.get_property ("version", version);
+ Stateful::loading_state_version = parse_stateful_loading_version (version);
+
+ if ((Stateful::loading_state_version / 1000L) > (CURRENT_SESSION_FILE_VERSION / 1000L)) {
+ cerr << "Session-version: " << Stateful::loading_state_version << " is not supported. Current: " << CURRENT_SESSION_FILE_VERSION << "\n";
+ throw SessionException (string_compose (_("Incomatible Session Version. That session was created with a newer version of %1"), PROGRAM_NAME));
}
if (Stateful::loading_state_version < CURRENT_SESSION_FILE_VERSION && _writable) {
int
Session::load_options (const XMLNode& node)
{
- LocaleGuard lg;
config.set_variables (node);
return 0;
}
return tree.write (sn.c_str());
}
+namespace
+{
+struct route_id_compare {
+ bool
+ operator() (const boost::shared_ptr<Route>& r1, const boost::shared_ptr<Route>& r2)
+ {
+ return r1->id () < r2->id ();
+ }
+};
+} // anon namespace
+
XMLNode&
-Session::state (bool full_state)
+Session::state (bool full_state, snapshot_t snapshot_type)
{
LocaleGuard lg;
XMLNode* node = new XMLNode("Session");
if (full_state) {
node->set_property ("name", _name);
- node->set_property ("sample-rate", _base_frame_rate);
+ node->set_property ("sample-rate", _base_sample_rate);
if (session_dirs.size() > 1) {
child = node->add_child ("Path");
child->add_content (p);
}
+ node->set_property ("end-is-free", _session_range_end_is_free);
}
- node->set_property ("end-is-free", _session_range_end_is_free);
-
/* save the ID counter */
node->set_property ("id-counter", ID::counter());
* 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 = boost::dynamic_pointer_cast<FileSource> (siter->second)) == 0) {
+ continue;
+ }
+
+ if (!fs->destructive()) {
+ if (fs->empty() && !fs->used()) {
+ continue;
+ }
+ }
- if (!fs->destructive()) {
- if (fs->empty() && !fs->used()) {
+ if (snapshot_type != NormalSave && fs->within_session ()) {
+ /* copy MIDI sources to new file
+ *
+ * We cannot replace the midi-source and MidiRegion::clobber_sources,
+ * because the GUI (midi_region) has a direct pointer to the midi-model
+ * of the source, as does UndoTransaction.
+ *
+ * On the upside, .mid files are not kept open. The file is only open
+ * when reading the model initially and when flushing the model to disk:
+ * source->session_saved () or export.
+ *
+ * We can change the _path of the existing source under the hood, keeping
+ * all IDs, references and pointers intact.
+ * */
+ boost::shared_ptr<SMFSource> ms;
+ if ((ms = boost::dynamic_pointer_cast<SMFSource> (siter->second)) != 0) {
+ const std::string ancestor_name = ms->ancestor_name();
+ const std::string base = PBD::basename_nosuffix(ancestor_name);
+ const string path = new_midi_source_path (base, false);
+
+ /* use SMF-API to clone data (use the midi_model, not data on disk) */
+ boost::shared_ptr<SMFSource> newsrc (new SMFSource (*this, path, SndFileSource::default_writable_flags));
+ Source::Lock lm (ms->mutex());
+
+ // TODO special-case empty, removable() files: just create a new removable.
+ // (load + write flushes the model and creates the file)
+ if (!ms->model()) {
+ ms->load_model (lm);
+ }
+ if (ms->write_to (lm, newsrc, Temporal::Beats(), std::numeric_limits<Temporal::Beats>::max())) {
+ error << string_compose (_("Session-Save: Failed to copy MIDI Source '%1' for snapshot"), ancestor_name) << endmsg;
+ } else {
+ if (snapshot_type == SnapshotKeep) {
+ /* keep working on current session.
+ *
+ * Save snapshot-state with the original filename.
+ * Switch to use new path for future saves of the main session.
+ */
+ child->add_child_nocopy (ms->get_state());
+ }
+
+ /* swap file-paths.
+ * ~SMFSource unlinks removable() files.
+ */
+ std::string npath (ms->path ());
+ ms->replace_file (newsrc->path ());
+ newsrc->replace_file (npath);
+
+ if (snapshot_type == SwitchToSnapshot) {
+ /* save and switch to snapshot.
+ *
+ * Leave the old file in place (as is).
+ * Snapshot uses new source directly
+ */
+ child->add_child_nocopy (ms->get_state());
+ }
continue;
}
}
-
- child->add_child_nocopy (siter->second->get_state());
}
+
+ child->add_child_nocopy (siter->second->get_state());
}
}
if (full_state) {
+ node->add_child_nocopy (_selection->get_state());
+
if (_locations) {
node->add_child_nocopy (_locations->get_state());
}
// for a template, just create a new Locations, populate it
// with the default start and end, and get the state for that.
Location* range = new Location (*this, 0, 0, _("session"), Location::IsSessionRange, 0);
- range->set (max_framepos, 0);
+ range->set (max_samplepos, 0);
loc.add (range);
XMLNode& locations_state = loc.get_state();
{
boost::shared_ptr<RouteList> r = routes.reader ();
- RoutePublicOrderSorter cmp;
- RouteList public_order (*r);
- public_order.sort (cmp);
+ route_id_compare cmp;
+ RouteList xml_node_order (*r);
+ xml_node_order.sort (cmp);
- /* the sort should have put the monitor out first */
-
- if (_monitor_out) {
- assert (_monitor_out == public_order.front());
- }
-
- for (RouteList::iterator i = public_order.begin(); i != public_order.end(); ++i) {
+ 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());
node.get_property ("name", _name);
- if (node.get_property (X_("sample-rate"), _base_frame_rate)) {
+ if (node.get_property (X_("sample-rate"), _base_sample_rate)) {
- _nominal_frame_rate = _base_frame_rate;
+ _nominal_sample_rate = _base_sample_rate;
assert (AudioEngine::instance()->running ());
- if (_base_frame_rate != AudioEngine::instance()->sample_rate ()) {
- boost::optional<int> r = AskAboutSampleRateMismatch (_base_frame_rate, _current_frame_rate);
+ if (_base_sample_rate != AudioEngine::instance()->sample_rate ()) {
+ boost::optional<int> r = AskAboutSampleRateMismatch (_base_sample_rate, _current_sample_rate);
if (r.get_value_or (0)) {
goto out;
}
}
}
- if (version < 3000) {
- if ((child = find_named_node (node, X_("DiskStreams"))) == 0) {
- error << _("Session: XML state has no diskstreams section") << endmsg;
- goto out;
- } else if (load_diskstreams_2X (*child, version)) {
- goto out;
- }
- }
-
if ((child = find_named_node (node, VCAManager::xml_node_name)) != 0) {
_vca_manager->set_state (*child, version);
}
Slavable::Assign (_vca_manager); /* EMIT SIGNAL */
- /* our diskstreams list is no longer needed as they are now all owned by their Route */
- _diskstreams_2X.clear ();
-
if (version >= 3000) {
if ((child = find_named_node (node, "RouteGroups")) == 0) {
(*_lua_load)(std::string ((const char*)buf, size));
} catch (luabridge::LuaException const& e) {
cerr << "LuaException:" << e.what () << endl;
- }
+ } catch (...) { }
g_free (buf);
}
}
+ if ((child = find_named_node (node, X_("Selection")))) {
+ _selection->set_state (*child, version);
+ }
+
update_route_record_state ();
/* here beginneth the second phase ... */
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
boost::shared_ptr<Route> route;
+
if (version < 3000) {
route = XMLRouteFactory_2X (**niter, version);
+ } else if (version < 5000) {
+ route = XMLRouteFactory_3X (**niter, version);
} else {
route = XMLRouteFactory (**niter, version);
}
return ret;
}
+ XMLProperty const * pl_prop = node.property (X_("audio-playlist"));
+
+ if (!pl_prop) {
+ pl_prop = node.property (X_("midi-playlist"));
+ }
+
+ DataType type = DataType::AUDIO;
+ node.get_property("default-type", type);
+
+ assert (type != DataType::NIL);
+
+ if (pl_prop) {
+
+ /* has at least 1 playlist, therefore a track ... */
+
+ boost::shared_ptr<Track> track;
+
+ if (type == DataType::AUDIO) {
+ track.reset (new AudioTrack (*this, X_("toBeResetFroXML")));
+ } else {
+ track.reset (new MidiTrack (*this, X_("toBeResetFroXML")));
+ }
+
+ if (track->init()) {
+ return ret;
+ }
+
+ if (track->set_state (node, version)) {
+ return ret;
+ }
+
+ BOOST_MARK_TRACK (track);
+ ret = track;
+
+ } else {
+ PresentationInfo::Flag flags = PresentationInfo::get_flags (node);
+ boost::shared_ptr<Route> r (new Route (*this, X_("toBeResetFroXML"), flags));
+
+
+ if (r->init () == 0 && r->set_state (node, version) == 0) {
+ BOOST_MARK_ROUTE (r);
+ ret = r;
+ }
+ }
+
+ return ret;
+}
+
+boost::shared_ptr<Route>
+Session::XMLRouteFactory_3X (const XMLNode& node, int version)
+{
+ boost::shared_ptr<Route> ret;
+
+ if (node.name() != "Route") {
+ return ret;
+ }
+
XMLNode* ds_child = find_named_node (node, X_("Diskstream"));
DataType type = DataType::AUDIO;
if (ds_prop) {
- list<boost::shared_ptr<Diskstream> >::iterator i = _diskstreams_2X.begin ();
- while (i != _diskstreams_2X.end() && (*i)->id() != ds_prop->value()) {
- ++i;
- }
+ /* see comment in current ::set_state() regarding diskstream
+ * state and DiskReader/DiskWRiter.
+ */
- if (i == _diskstreams_2X.end()) {
- error << _("Could not find diskstream for route") << endmsg;
- return boost::shared_ptr<Route> ();
- }
+ error << _("Could not find diskstream for route") << endmsg;
+ return boost::shared_ptr<Route> ();
boost::shared_ptr<Track> track;
return ret;
}
- track->set_diskstream (*i);
-
BOOST_MARK_TRACK (track);
ret = track;
switch (err.type) {
case DataType::AUDIO:
- source = SourceFactory::createSilent (*this, **niter, max_framecnt, _current_frame_rate);
+ source = SourceFactory::createSilent (*this, **niter, max_samplecnt, _current_sample_rate);
break;
case DataType::MIDI:
return -1;
}
/* Note that we do not announce the source just yet - we need to reset its ID before we do that */
- source = SourceFactory::createWritable (DataType::MIDI, *this, fullpath, false, _current_frame_rate, false, false);
+ source = SourceFactory::createWritable (DataType::MIDI, *this, fullpath, false, _current_sample_rate, false, false);
/* reset ID to match the missing one */
source->set_id (**niter);
/* Now we can announce it */
}
int
-Session::save_template (string template_name, bool replace_existing)
+Session::save_template (const string& template_name, const string& description, bool replace_existing)
{
if ((_state_of_the_state & CannotSave) || template_name.empty ()) {
return -1;
SessionSaveUnderway (); /* EMIT SIGNAL */
XMLTree tree;
-
+ XMLNode* root;
{
PBD::Unwinder<std::string> uw (_template_state_dir, template_dir_path);
- tree.set_root (&get_template());
+ root = &get_template ();
+ }
+
+ root->remove_nodes_and_delete (X_("description"));
+
+ if (!description.empty()) {
+ XMLNode* desc = new XMLNode (X_("description"));
+ XMLNode* desc_cont = new XMLNode (X_("content"), description);
+ desc->add_child_nocopy (*desc_cont);
+
+ root->add_child_nocopy (*desc);
}
+ tree.set_root (root);
+
if (!tree.write (template_file_path)) {
error << _("template not saved") << endmsg;
return -1;
return boost::shared_ptr<Controllable>();
}
+boost::shared_ptr<AutomationControl>
+Session::automation_control_by_id (const PBD::ID& id)
+{
+ return boost::dynamic_pointer_cast<AutomationControl> (controllable_by_id (id));
+}
+
boost::shared_ptr<Controllable>
Session::controllable_by_descriptor (const ControllableDescriptor& desc)
{
if ((location = _locations->auto_punch_location()) != 0) {
if (config.get_punch_in ()) {
- replace_event (SessionEvent::PunchIn, location->start());
+ auto_punch_start_changed (location);
} else {
- remove_event (location->start(), SessionEvent::PunchIn);
+ clear_events (SessionEvent::PunchIn);
}
}
if ((location = _locations->auto_punch_location()) != 0) {
if (config.get_punch_out()) {
- replace_event (SessionEvent::PunchOut, location->end());
+ auto_punch_end_changed (location);
} else {
clear_events (SessionEvent::PunchOut);
}
} else if (p == "send-mmc") {
_mmc->enable_send (Config->get_send_mmc ());
+ if (Config->get_send_mmc ()) {
+ /* re-initialize MMC */
+ send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdMmcReset));
+ send_immediate_mmc (MIDI::MachineControlCommand (Timecode::Time ()));
+ }
} else if (p == "jack-time-master") {
} 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());
+ AudioSource::allocate_working_buffers (sample_rate());
} else if (p == "ltc-source-port") {
reconnect_ltc_input ();
} else if (p == "ltc-sink-port") {
_history.set_depth (d);
}
-int
-Session::load_diskstreams_2X (XMLNode const & node, int)
-{
- XMLNodeList clist;
- XMLNodeConstIterator citer;
-
- clist = node.children();
-
- for (citer = clist.begin(); citer != clist.end(); ++citer) {
-
- try {
- /* diskstreams added automatically by DiskstreamCreated handler */
- if ((*citer)->name() == "AudioDiskstream" || (*citer)->name() == "DiskStream") {
- boost::shared_ptr<AudioDiskstream> dsp (new AudioDiskstream (*this, **citer));
- _diskstreams_2X.push_back (dsp);
- } 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;
- }
- }
-
- return 0;
-}
-
/** Connect things to the MMC object */
void
Session::setup_midi_machine_control ()
return 0;
}
+int
+Session::parse_stateful_loading_version (const std::string& version)
+{
+ if (version.empty ()) {
+ /* no version implies very old version of Ardour */
+ return 1000;
+ }
+
+ if (version.find ('.') != string::npos) {
+ /* old school version format */
+ if (version[0] == '2') {
+ return 2000;
+ } else {
+ return 3000;
+ }
+ } else {
+ return string_to<int32_t>(version);
+ }
+}
+
int
Session::get_info_from_path (const string& xmlpath, float& sample_rate, SampleFormat& data_format, std::string& program_version)
{
bool found_sr = false;
bool found_data_format = false;
+ std::string version;
program_version = "";
if (!Glib::file_test (xmlpath, Glib::FILE_TEST_EXISTS)) {
return -1;
}
- /* sample rate */
+ /* sample rate & version*/
xmlAttrPtr attr;
for (attr = node->properties; attr; attr = attr->next) {
+ if (!strcmp ((const char*)attr->name, "version") && attr->children) {
+ version = std::string ((char*)attr->children->content);
+ }
if (!strcmp ((const char*)attr->name, "sample-rate") && attr->children) {
sample_rate = atoi ((char*)attr->children->content);
found_sr = true;
}
}
+ if ((parse_stateful_loading_version(version) / 1000L) > (CURRENT_SESSION_FILE_VERSION / 1000L)) {
+ return -1;
+ }
+
node = node->children;
while (node != NULL) {
if (!strcmp((const char*) node->name, "ProgramVersion")) {
xmlFree (pv);
xmlChar* val = xmlGetProp (node, (const xmlChar*)"value");
if (val) {
- SampleFormat fmt = (SampleFormat) string_2_enum (string ((const char*)val), fmt);
- data_format = fmt;
- found_data_format = true;
+ try {
+ SampleFormat fmt = (SampleFormat) string_2_enum (string ((const char*)val), fmt);
+ data_format = fmt;
+ found_data_format = true;
+ } catch (PBD::unknown_enumeration& e) {}
}
xmlFree (val);
break;
xmlFreeParserCtxt(ctxt);
xmlFreeDoc (doc);
- return !(found_sr && found_data_format); // zero if they are both found
+ return (found_sr && found_data_format) ? 0 : 1;
}
std::string
session_dirs.push_back (sp);
refresh_disk_space ();
+ _writable = exists_and_writable (_path);
+
/* ensure that all existing tracks reset their current capture source paths
*/
reset_write_sources (true, true);
Session::archive_session (const std::string& dest,
const std::string& name,
ArchiveEncode compress_audio,
+ FileArchive::CompressionLevel compression_level,
bool only_used_sources,
Progress* progress)
{
}
/* prepare archive */
- string archive = Glib::build_filename (dest, name + ".tar.xz");
+ string archive = Glib::build_filename (dest, name + session_archive_suffix);
PBD::ScopedConnectionList progress_connection;
PBD::FileArchive ar (archive);
orig_gain[afs] = afs->gain();
std::string new_path = make_new_media_path (afs->path (), to_dir, name);
- new_path = Glib::build_filename (Glib::path_get_dirname (new_path), PBD::basename_nosuffix (new_path) + ".flac");
+
+ std::string channelsuffix = "";
+ if (afs->channel() > 0) { /* n_channels() is /wrongly/ 1. */
+ /* embedded external multi-channel files are converted to multiple-mono */
+ channelsuffix = string_compose ("-c%1", afs->channel ());
+ }
+ 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);
+
if (progress) {
progress->descend ((float)afs->readable_length () / total_size);
}
#ifdef LV2_SUPPORT
PBD::Unwinder<bool> uw (LV2Plugin::force_state_save, true);
#endif
- save_state (name);
+ 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_default_options ();
size_t prefix_len = _path.size();
i->first->set_gain (i->second, true);
}
- int rv = ar.create (filemap);
+ int rv = ar.create (filemap, compression_level);
remove_directory (to_dir);
return rv;
projects / ardour.git / blobdiff