#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"
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) {
/* 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
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
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)"),
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) {
if (!ms->model()) {
ms->load_model (lm);
}
- if (ms->write_to (lm, newsrc, Evoral::MinBeats, Evoral::MaxBeats)) {
+ 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) {
// 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();
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) {
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 */
root = &get_template ();
}
- root->remove_nodes (X_("description"));
+ root->remove_nodes_and_delete (X_("description"));
+
if (!description.empty()) {
XMLNode* desc = new XMLNode (X_("description"));
XMLNode* desc_cont = new XMLNode (X_("content"), description);
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 ()
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