/*
- 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
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.
-
+
*/
-#define __STDC_FORMAT_MACROS 1
+
+#ifdef WAF_BUILD
+#include "libardour-config.h"
+#endif
+
#include <stdint.h>
#include <algorithm>
#include <fstream>
#include <string>
#include <cerrno>
-
-#include <sigc++/bind.h>
-
#include <cstdio> /* snprintf(3) ... grrr */
#include <cmath>
#include <unistd.h>
#include <signal.h>
#include <sys/mman.h>
#include <sys/time.h>
-#include <dirent.h>
#ifdef HAVE_SYS_VFS_H
#include <sys/vfs.h>
#include <sys/mount.h>
#endif
+#include <glib.h>
+
#include <glibmm.h>
#include <glibmm/thread.h>
+#include <boost/algorithm/string.hpp>
+
#include "midi++/mmc.h"
#include "midi++/port.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 "pbd/pathscanner.h"
#include "pbd/pthread_utils.h"
#include "pbd/search_path.h"
#include "pbd/stacktrace.h"
+#include "pbd/convert.h"
+#include "pbd/clear_dir.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/configuration.h"
-#include "ardour/session.h"
-#include "ardour/session_directory.h"
-#include "ardour/session_utils.h"
-#include "ardour/session_state_utils.h"
-#include "ardour/session_metadata.h"
+#include "ardour/audiofilesource.h"
+#include "ardour/audioplaylist.h"
+#include "ardour/audioregion.h"
+#include "ardour/auditioner.h"
+#include "ardour/automation_control.h"
#include "ardour/buffer.h"
-#include "ardour/audio_diskstream.h"
+#include "ardour/butler.h"
+#include "ardour/configuration.h"
+#include "ardour/control_protocol_manager.h"
+#include "ardour/crossfade.h"
+#include "ardour/cycle_timer.h"
+#include "ardour/directory_names.h"
+#include "ardour/filename_extensions.h"
+#include "ardour/io_processor.h"
+#include "ardour/location.h"
#include "ardour/midi_diskstream.h"
-#include "ardour/utils.h"
-#include "ardour/audioplaylist.h"
+#include "ardour/midi_model.h"
+#include "ardour/midi_patch_manager.h"
#include "ardour/midi_playlist.h"
-#include "ardour/smf_source.h"
-#include "ardour/audiofilesource.h"
-#include "ardour/silentfilesource.h"
-#include "ardour/sndfilesource.h"
+#include "ardour/midi_region.h"
#include "ardour/midi_source.h"
-#include "ardour/sndfile_helpers.h"
-#include "ardour/auditioner.h"
-#include "ardour/io_processor.h"
-#include "ardour/send.h"
-#include "ardour/processor.h"
-#include "ardour/user_bundle.h"
-#include "ardour/slave.h"
-#include "ardour/tempo.h"
-#include "ardour/audio_track.h"
#include "ardour/midi_track.h"
-#include "ardour/midi_patch_manager.h"
-#include "ardour/cycle_timer.h"
-#include "ardour/utils.h"
#include "ardour/named_selection.h"
-#include "ardour/version.h"
-#include "ardour/location.h"
-#include "ardour/audioregion.h"
-#include "ardour/midi_region.h"
-#include "ardour/crossfade.h"
-#include "ardour/control_protocol_manager.h"
+#include "ardour/pannable.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"
+#include "ardour/session.h"
+#include "ardour/session_directory.h"
+#include "ardour/session_metadata.h"
+#include "ardour/session_state_utils.h"
+#include "ardour/session_playlists.h"
+#include "ardour/session_utils.h"
+#include "ardour/silentfilesource.h"
+#include "ardour/slave.h"
+#include "ardour/smf_source.h"
+#include "ardour/sndfile_helpers.h"
+#include "ardour/sndfilesource.h"
#include "ardour/source_factory.h"
-#include "ardour/playlist_factory.h"
-#include "ardour/filename_extensions.h"
-#include "ardour/directory_names.h"
+#include "ardour/speakers.h"
#include "ardour/template_utils.h"
+#include "ardour/tempo.h"
#include "ardour/ticker.h"
-#include "ardour/route_group.h"
+#include "ardour/user_bundle.h"
+#include "ardour/utils.h"
+#include "ardour/utils.h"
+#include "ardour/version.h"
+#include "ardour/playlist_factory.h"
#include "control_protocol/control_protocol.h"
using namespace ARDOUR;
using namespace PBD;
+/** @param snapshot_name Snapshot name, without the .ardour prefix */
void
Session::first_stage_init (string fullpath, string snapshot_name)
{
_path = string(buf);
- if (_path[_path.length()-1] != '/') {
- _path += '/';
+ if (_path[_path.length()-1] != G_DIR_SEPARATOR) {
+ _path += G_DIR_SEPARATOR;
}
/* these two are just provisional settings. set_state()
_base_frame_rate = _current_frame_rate;
_tempo_map = new TempoMap (_current_frame_rate);
- _tempo_map->StateChanged.connect (mem_fun (*this, &Session::tempo_map_changed));
+ _tempo_map->PropertyChanged.connect_same_thread (*this, boost::bind (&Session::tempo_map_changed, this, _1));
_non_soloed_outs_muted = false;
+ _listen_cnt = 0;
+ _solo_isolated_cnt = 0;
g_atomic_int_set (&processing_prohibited, 0);
_transport_speed = 0;
_last_transport_speed = 0;
auto_play_legal = false;
transport_sub_state = 0;
_transport_frame = 0;
- end_location = new Location (0, 0, _("end"), Location::Flags ((Location::IsMark|Location::IsEnd)));
- start_location = new Location (0, 0, _("start"), Location::Flags ((Location::IsMark|Location::IsStart)));
+ _requested_return_frame = -1;
+ _session_range_location = 0;
g_atomic_int_set (&_record_status, Disabled);
loop_changing = false;
play_loop = false;
have_looped = false;
_last_roll_location = 0;
+ _last_roll_or_reversal_location = 0;
_last_record_location = 0;
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;
+ outbound_mtc_timecode_frame = 0;
next_quarter_frame_to_send = -1;
current_block_size = 0;
solo_update_disabled = false;
_have_captured = false;
_worst_output_latency = 0;
_worst_input_latency = 0;
- _worst_track_latency = 0;
+ _worst_track_latency = 0;
_state_of_the_state = StateOfTheState(CannotSave|InitialConnecting|Loading);
-
+ _was_seamless = Config->get_seamless_loop ();
_slave = 0;
- session_send_mmc = false;
- session_send_mtc = false;
- post_transport_work = PostTransportWork (0);
- g_atomic_int_set (&butler_should_do_transport_work, 0);
+ _send_qf_mtc = false;
+ _pframes_since_last_mtc = 0;
g_atomic_int_set (&_playback_load, 100);
g_atomic_int_set (&_capture_load, 100);
- g_atomic_int_set (&_playback_load_min, 100);
- g_atomic_int_set (&_capture_load_min, 100);
_play_range = false;
_exporting = false;
- _exporting_realtime = false;
- _gain_automation_buffer = 0;
- _pan_automation_buffer = 0;
- _npan_buffers = 0;
pending_abort = false;
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;
+ post_export_sync = false;
+ midi_control_ui = 0;
+ _step_editors = 0;
+ no_questions_about_missing_files = false;
+ _speakers.reset (new Speakers);
AudioDiskstream::allocate_working_buffers();
/* default short fade = 15ms */
- Crossfade::set_short_xfade_length ((nframes_t) floor (config.get_short_xfade_seconds() * frame_rate()));
+ Crossfade::set_short_xfade_length ((framecnt_t) floor (config.get_short_xfade_seconds() * frame_rate()));
SndFileSource::setup_standard_crossfades (*this, frame_rate());
last_mmc_step.tv_sec = 0;
/* click sounds are unset by default, which causes us to internal
waveforms for clicks.
*/
-
+
click_length = 0;
click_emphasis_length = 0;
_clicking = false;
waiting_for_sync_offset = false;
}
- last_smpte_when = 0;
- _smpte_offset = 0;
- _smpte_offset_negative = true;
- last_smpte_valid = false;
+ last_timecode_when = 0;
+ last_timecode_valid = false;
sync_time_vars ();
last_rr_session_dir = session_dirs.begin();
refresh_disk_space ();
- // set_default_fade (0.2, 5.0); /* steepness, millisecs */
+ /* default: assume simple stereo speaker configuration */
+
+ _speakers->setup_default_speakers (2);
/* slave stuff */
average_slave_delta = 1800; // !!! why 1800 ????
have_first_delta_accumulator = false;
delta_accumulator_cnt = 0;
- slave_state = Stopped;
+ _slave_state = Stopped;
- _engine.GraphReordered.connect (mem_fun (*this, &Session::graph_reordered));
-
- /* These are all static "per-class" signals */
+ _solo_cut_control.reset (new ProxyControllable (_("solo cut control (dB)"), PBD::Controllable::GainLike,
+ boost::bind (&RCConfiguration::set_solo_mute_gain, Config, _1),
+ boost::bind (&RCConfiguration::get_solo_mute_gain, Config)));
+ add_controllable (_solo_cut_control);
- RegionFactory::CheckNewRegion.connect (mem_fun (*this, &Session::add_region));
- SourceFactory::SourceCreated.connect (mem_fun (*this, &Session::add_source));
- PlaylistFactory::PlaylistCreated.connect (mem_fun (*this, &Session::add_playlist));
- Processor::ProcessorCreated.connect (mem_fun (*this, &Session::add_processor));
- NamedSelection::NamedSelectionCreated.connect (mem_fun (*this, &Session::add_named_selection));
- AutomationList::AutomationListCreated.connect (mem_fun (*this, &Session::add_automation_list));
+ _engine.GraphReordered.connect_same_thread (*this, boost::bind (&Session::graph_reordered, this));
- Controllable::Destroyed.connect (mem_fun (*this, &Session::remove_controllable));
+ /* These are all static "per-class" signals */
- IO::PortCountChanged.connect (mem_fun (*this, &Session::ensure_buffers));
+ SourceFactory::SourceCreated.connect_same_thread (*this, boost::bind (&Session::add_source, this, _1));
+ PlaylistFactory::PlaylistCreated.connect_same_thread (*this, boost::bind (&Session::add_playlist, this, _1, _2));
+ AutomationList::AutomationListCreated.connect_same_thread (*this, boost::bind (&Session::add_automation_list, this, _1));
+ Controllable::Destroyed.connect_same_thread (*this, boost::bind (&Session::remove_controllable, this, _1));
+ IO::PortCountChanged.connect_same_thread (*this, boost::bind (&Session::ensure_buffers, this, _1));
/* stop IO objects from doing stuff until we're ready for them */
}
int
-Session::second_stage_init (bool new_session)
+Session::second_stage_init ()
{
AudioFileSource::set_peak_dir (_session_dir->peak_path().to_string());
- if (!new_session) {
+ if (!_is_new) {
if (load_state (_current_snapshot_name)) {
return -1;
}
- remove_empty_sounds ();
}
- if (start_butler_thread()) {
+ if (_butler->start_thread()) {
return -1;
}
return -1;
}
+ setup_midi_machine_control ();
+
// set_state() will call setup_raid_path(), but if it's a new session we need
// 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 {
_state_of_the_state = StateOfTheState (_state_of_the_state|CannotSave|Loading);
-
- _locations.changed.connect (mem_fun (this, &Session::locations_changed));
- _locations.added.connect (mem_fun (this, &Session::locations_added));
+ _locations->changed.connect_same_thread (*this, boost::bind (&Session::locations_changed, this));
+ _locations->added.connect_same_thread (*this, boost::bind (&Session::locations_added, this, _1));
setup_click_sounds (0);
setup_midi_control ();
/* Pay attention ... */
- _engine.Halted.connect (mem_fun (*this, &Session::engine_halted));
- _engine.Xrun.connect (mem_fun (*this, &Session::xrun_recovery));
+ _engine.Halted.connect_same_thread (*this, boost::bind (&Session::engine_halted, this));
+ _engine.Xrun.connect_same_thread (*this, boost::bind (&Session::xrun_recovery, this));
try {
- when_engine_running();
+ when_engine_running ();
}
/* 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;
send_full_time_code (0);
_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);
-
- /* initial program change will be delivered later; see ::config_changed() */
- BootMessage (_("Reset Control Protocols"));
+ MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdMmcReset));
+ MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (Timecode::Time ()));
- ControlProtocolManager::instance().set_session (*this);
+ MidiClockTicker::instance().set_session (this);
+ MIDI::Name::MidiPatchManager::instance().set_session (this);
- config.set_end_marker_is_free (new_session);
+ /* initial program change will be delivered later; see ::config_changed() */
_state_of_the_state = Clean;
-
+
+ Port::set_connecting_blocked (false);
+
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;
midi_search_path += sdir.midi_path ();
}
- // set the search path for each data type
- FileSource::set_search_path (DataType::AUDIO, sound_search_path.to_string ());
- SMFSource::set_search_path (DataType::MIDI, midi_search_path.to_string ());
-
// reset the round-robin soundfile path thingie
last_rr_session_dir = session_dirs.begin();
}
+bool
+Session::path_is_within_session (const std::string& path)
+{
+ for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
+ if (path.find ((*i).path) == 0) {
+ return true;
+ }
+ }
+ return false;
+}
+
int
Session::ensure_subdirs ()
{
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 -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;
}
+ dir = plugins_dir ();
+
+ if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
+ error << string_compose(_("Session: cannot create session plugins folder \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
+ return -1;
+ }
+
return 0;
}
+/** @param session_template directory containing session template, or empty.
+ * Caller must not hold process lock.
+ */
int
-Session::create (bool& new_session, const string& mix_template, nframes_t initial_length)
+Session::create (const string& session_template, BusProfile* bus_profile)
{
-
if (g_mkdir_with_parents (_path.c_str(), 0755) < 0) {
error << string_compose(_("Session: cannot create session folder \"%1\" (%2)"), _path, strerror (errno)) << endmsg;
return -1;
return -1;
}
- /* check new_session so we don't overwrite an existing one */
+ _writable = exists_and_writable (sys::path (_path));
- if (!mix_template.empty()) {
- std::string in_path = mix_template;
+ if (!session_template.empty()) {
+ std::string in_path = session_template_dir_to_file (session_template);
ifstream in(in_path.c_str());
- if (in){
+ if (in) {
string out_path = _path;
out_path += _name;
out_path += statefile_suffix;
ofstream out(out_path.c_str());
- if (out){
+ if (out) {
out << in.rdbuf();
+ _is_new = false;
- // okay, session is set up. Treat like normal saved
- // session from now on.
-
- new_session = false;
+ /* Copy plugin state files from template to new session */
+ sys::path template_plugins = session_template;
+ template_plugins /= X_("plugins");
+ sys::copy_files (template_plugins, plugins_dir ());
+
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 session 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 session template %1 for reading"), in_path)
<< endmsg;
return -1;
}
}
-
+
/* Instantiate metadata */
-
+
_metadata = new SessionMetadata ();
/* set initial start + end point */
- start_location->set_end (0);
- _locations.add (start_location);
+ _state_of_the_state = Clean;
- end_location->set_end (initial_length);
- _locations.add (end_location);
+ /* set up Master Out and Control Out if necessary */
- _state_of_the_state = Clean;
+ if (bus_profile) {
- save_state ("");
+ RouteList rl;
+ int control_id = 1;
+ ChanCount count(DataType::AUDIO, bus_profile->master_out_channels);
- return 0;
-}
+ if (bus_profile->master_out_channels) {
+ 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 (r.get(), "Route");
+#endif
+ {
+ 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);
-int
-Session::load_diskstreams (const XMLNode& node)
-{
- XMLNodeList clist;
- XMLNodeConstIterator citer;
-
- clist = node.children();
+ if (Config->get_use_monitor_bus()) {
+ 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 (r.get(), "Route");
+#endif
+ {
+ 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);
- for (citer = clist.begin(); citer != clist.end(); ++citer) {
+ rl.push_back (r);
+ }
- try {
- /* diskstreams added automatically by DiskstreamCreated handler */
- if ((*citer)->name() == "AudioDiskstream" || (*citer)->name() == "DiskStream") {
- boost::shared_ptr<AudioDiskstream> dstream (new AudioDiskstream (*this, **citer));
- add_diskstream (dstream);
- } else if ((*citer)->name() == "MidiDiskstream") {
- boost::shared_ptr<MidiDiskstream> dstream (new MidiDiskstream (*this, **citer));
- add_diskstream (dstream);
- } 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;
+ } 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);
}
- }
+
+ /* 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);
+ }
+
+ save_state ("");
return 0;
}
Session::remove_pending_capture_state ()
{
sys::path pending_state_file_path(_session_dir->root_path());
-
- pending_state_file_path /= _current_snapshot_name + pending_suffix;
+
+ pending_state_file_path /= legalize_for_path (_current_snapshot_name) + pending_suffix;
try
{
}
/** 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)
return;
}
- const string old_xml_filename = old_name + statefile_suffix;
- const string new_xml_filename = new_name + statefile_suffix;
+ const string old_xml_filename = legalize_for_path (old_name) + statefile_suffix;
+ const string new_xml_filename = legalize_for_path (new_name) + statefile_suffix;
const sys::path old_xml_path = _session_dir->root_path() / old_xml_filename;
const sys::path new_xml_path = _session_dir->root_path() / new_xml_filename;
}
/** Remove a state file.
- * @param snapshot_name Snapshot name.
+ * @param snapshot_name Snapshot name.
*/
void
Session::remove_state (string snapshot_name)
sys::path xml_path(_session_dir->root_path());
- xml_path /= snapshot_name + statefile_suffix;
+ xml_path /= legalize_for_path (snapshot_name) + statefile_suffix;
if (!create_backup_file (xml_path)) {
// don't remove it if a backup can't be made
sys::remove (xml_path);
}
+#ifdef HAVE_JACK_SESSION
+void
+Session::jack_session_event (jack_session_event_t * event)
+{
+ char timebuf[128];
+ time_t n;
+ struct tm local_time;
+
+ time (&n);
+ localtime_r (&n, &local_time);
+ strftime (timebuf, sizeof(timebuf), "JS_%FT%T", &local_time);
+
+ if (event->type == JackSessionSaveTemplate)
+ {
+ if (save_template( timebuf )) {
+ event->flags = JackSessionSaveError;
+ } else {
+ string cmd ("ardour3 -P -U ");
+ cmd += event->client_uuid;
+ cmd += " -T ";
+ cmd += timebuf;
+
+ event->command_line = strdup (cmd.c_str());
+ }
+ }
+ else
+ {
+ if (save_state (timebuf)) {
+ event->flags = JackSessionSaveError;
+ } else {
+ sys::path xml_path (_session_dir->root_path());
+ xml_path /= legalize_for_path (timebuf) + statefile_suffix;
+
+ string cmd ("ardour3 -P -U ");
+ cmd += event->client_uuid;
+ cmd += " \"";
+ cmd += xml_path.to_string();
+ cmd += '\"';
+
+ event->command_line = strdup (cmd.c_str());
+ }
+ }
+
+ jack_session_reply (_engine.jack(), event);
+
+ if (event->type == JackSessionSaveAndQuit) {
+ Quit (); /* EMIT SIGNAL */
+ }
+
+ jack_session_event_free( event );
+}
+#endif
+
+/** @param snapshot_name Name to save under, without .ardour / .pending prefix */
int
-Session::save_state (string snapshot_name, bool pending)
+Session::save_state (string snapshot_name, bool pending, bool switch_to_snapshot)
{
XMLTree tree;
sys::path xml_path(_session_dir->root_path());
- if (_state_of_the_state & CannotSave) {
+ if (!_writable || (_state_of_the_state & CannotSave)) {
return 1;
}
if (!_engine.connected ()) {
- error << _("Ardour's audio engine is not connected and state saving would lose all I/O connections. Session not saved")
+ 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;
}
/* tell sources we're saving first, in case they write out to a new file
* which should be saved with the state rather than the old one */
- for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i)
+ for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
i->second->session_saved();
+ }
tree.set_root (&get_state());
if (snapshot_name.empty()) {
snapshot_name = _current_snapshot_name;
- }
+ } else if (switch_to_snapshot) {
+ _current_snapshot_name = snapshot_name;
+ }
if (!pending) {
/* proper save: use statefile_suffix (.ardour in English) */
-
- xml_path /= snapshot_name + statefile_suffix;
+
+ xml_path /= legalize_for_path (snapshot_name) + statefile_suffix;
/* make a backup copy of the old file */
} else {
/* pending save: use pending_suffix (.pending in English) */
- xml_path /= snapshot_name + pending_suffix;
+ xml_path /= legalize_for_path (snapshot_name) + pending_suffix;
}
sys::path tmp_path(_session_dir->root_path());
- tmp_path /= snapshot_name + temp_suffix;
+ tmp_path /= legalize_for_path (snapshot_name) + temp_suffix;
// cerr << "actually writing state to " << xml_path.to_string() << endl;
} 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);
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;
}
/* check for leftover pending state from a crashed capture attempt */
sys::path xmlpath(_session_dir->root_path());
- xmlpath /= snapshot_name + pending_suffix;
+ xmlpath /= legalize_for_path (snapshot_name) + pending_suffix;
if (sys::exists (xmlpath)) {
/* there is pending state from a crashed capture attempt */
- if (AskAboutPendingState()) {
+ boost::optional<int> r = AskAboutPendingState();
+ if (r.get_value_or (1)) {
state_was_pending = true;
- }
- }
+ }
+ }
if (!state_was_pending) {
xmlpath = _session_dir->root_path();
- xmlpath /= 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;
+ xmlpath /= snapshot_name;
}
+ if (!sys::exists (xmlpath)) {
+ 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;
+ }
+ }
+
state_tree = new XMLTree;
set_dirty();
+ _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;
delete state_tree;
}
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;
+ error << string_compose (_("Session file %1 is not a session"), xmlpath.to_string()) << endmsg;
delete state_tree;
state_tree = 0;
return -1;
}
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;
+
+ sscanf (prop->value().c_str(), "%d.%d.%d", &major, &minor, µ);
+ Stateful::loading_state_version = (major * 1000) + minor;
}
- if (is_old) {
+ if (Stateful::loading_state_version < CURRENT_SESSION_FILE_VERSION) {
sys::path backup_path(_session_dir->root_path());
- backup_path /= snapshot_name + "-1" + statefile_suffix;
+ backup_path /= legalize_for_path (snapshot_name) + "-1" + statefile_suffix;
// only create a backup once
if (sys::exists (backup_path)) {
return 0;
}
- 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())
+ info << string_compose (_("Copying old session file %1 to %2\nUse %2 with %3 versions before 2.0 from now on"),
+ xmlpath.to_string(), backup_path.to_string(), PROGRAM_NAME)
<< endmsg;
try
Session::load_options (const XMLNode& node)
{
LocaleGuard lg (X_("POSIX"));
-
config.set_variables (node);
-
- /* now reset MIDI ports because the session can have its own
- MIDI configuration.
- */
-
- setup_midi ();
-
return 0;
}
{
/* 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);
+ snprintf (buf, sizeof (buf), "%" PRId64, _nominal_frame_rate);
node->add_property ("sample-rate", buf);
if (session_dirs.size() > 1) {
++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);
+ /* save the event ID counter */
+
+ snprintf (buf, sizeof (buf), "%d", Evoral::event_id_counter());
+ node->add_property ("event-counter", buf);
+
/* various options */
node->add_child_nocopy (config.get_variables ());
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) {
+
+ /* 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->length(fs->timeline_position()) == 0) {
+ if (fs->empty() && !fs->used()) {
continue;
}
}
+
+ child->add_child_nocopy (siter->second->get_state());
}
-
- 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->add_child_nocopy (i->second->state (true));
- }
- }
- }
-
- 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()) {
- child->add_child_nocopy ((*i)->get_state());
+ const RegionFactory::RegionMap& region_map (RegionFactory::all_regions());
+ for (RegionFactory::RegionMap::const_iterator i = region_map.begin(); i != region_map.end(); ++i) {
+ boost::shared_ptr<Region> r = i->second;
+ /* only store regions not attached to playlists */
+ if (r->playlist() == 0) {
+ 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) {
- node->add_child_nocopy (_locations.get_state());
+ node->add_child_nocopy (_locations->get_state());
} else {
// for a template, just create a new Locations, populate it
// with the default start and end, and get the state for that.
- Locations loc;
- Location* start = new Location(0, 0, _("start"), Location::Flags ((Location::IsMark|Location::IsStart)));
- Location* end = new Location(0, 0, _("end"), Location::Flags ((Location::IsMark|Location::IsEnd)));
- start->set_end(0);
- loc.add (start);
- end->set_end(compute_initial_length());
- loc.add (end);
+ Locations loc (*this);
+ Location* range = new Location (*this, 0, 0, _("session"), Location::IsSessionRange);
+ range->set (max_framepos, 0);
+ loc.add (range);
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);
-
+
+ /* the sort should have put control outs first */
+
+ if (_monitor_out) {
+ assert (_monitor_out == public_order.front());
+ }
+
for (RouteList::iterator i = public_order.begin(); i != public_order.end(); ++i) {
if (!(*i)->is_hidden()) {
if (full_state) {
}
}
-
- child = node->add_child ("EditGroups");
- for (list<RouteGroup *>::iterator i = edit_groups.begin(); i != edit_groups.end(); ++i) {
- child->add_child_nocopy ((*i)->get_state());
- }
+ playlists->add_state (node, full_state);
- child = node->add_child ("MixGroups");
- for (list<RouteGroup *>::iterator i = mix_groups.begin(); i != mix_groups.end(); ++i) {
+ 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());
}
- child = node->add_child ("Playlists");
- for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i) {
- if (!(*i)->hidden()) {
- if (!(*i)->empty()) {
- if (full_state) {
- child->add_child_nocopy ((*i)->get_state());
- } else {
- child->add_child_nocopy ((*i)->get_template());
- }
- }
- }
- }
-
- child = node->add_child ("UnusedPlaylists");
- for (PlaylistList::iterator i = unused_playlists.begin(); i != unused_playlists.end(); ++i) {
- if (!(*i)->hidden()) {
- if (!(*i)->empty()) {
- if (full_state) {
- child->add_child_nocopy ((*i)->get_state());
- } else {
- child->add_child_nocopy ((*i)->get_template());
- }
- }
- }
- }
-
-
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());
- }
+ }
}
}
+ node->add_child_nocopy (_speakers->get_state());
node->add_child_nocopy (_tempo_map->get_state());
-
node->add_child_nocopy (get_control_protocol_state());
if (_extra_xml) {
}
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")){
+
+ 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 ();
}
_nominal_frame_rate = atoi (prop->value());
if (_nominal_frame_rate != _current_frame_rate) {
- if (AskAboutSampleRateMismatch (_nominal_frame_rate, _current_frame_rate)) {
+ boost::optional<int> r = AskAboutSampleRateMismatch (_nominal_frame_rate, _current_frame_rate);
+ if (r.get_value_or (0)) {
return -1;
}
}
ID::init_counter (now);
}
-
- IO::disable_connecting ();
+ if ((prop = node.property (X_("event-counter"))) != 0) {
+ Evoral::init_event_id_counter (atoi (prop->value()));
+ }
- /* Object loading order:
-
- Path
- Extra
- Options/Config
- MIDI Control // relies on data from Options/Config
- Metadata
- Locations
- Sources
- AudioRegions
- AudioDiskstreams
- Connections
- Routes
- EditGroups
- MixGroups
- Click
- ControlProtocols
- */
+ IO::disable_connecting ();
- 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);
error << _("Session: XML state has no options section") << endmsg;
}
- if (use_config_midi_ports ()) {
+ 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, 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, "Metadata")) == 0) {
- warning << _("Session: XML state has no metadata section (2.0 session?)") << endmsg;
- } else if (_metadata->set_state (*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 ((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;
}
Location* location;
- if ((location = _locations.auto_loop_location()) != 0) {
+ if ((location = _locations->auto_loop_location()) != 0) {
set_auto_loop_location (location);
}
- if ((location = _locations.auto_punch_location()) != 0) {
+ if ((location = _locations->auto_punch_location()) != 0) {
set_auto_punch_location (location);
}
- if ((location = _locations.end_location()) == 0) {
- _locations.add (end_location);
- } else {
- delete end_location;
- end_location = location;
- }
-
- if ((location = _locations.start_location()) == 0) {
- _locations.add (start_location);
- } else {
- delete start_location;
- start_location = location;
+ if ((location = _locations->session_range_location()) != 0) {
+ delete _session_range_location;
+ _session_range_location = location;
}
- AudioFileSource::set_header_position_offset (start_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 (_session_range_location) {
+ AudioFileSource::set_header_position_offset (_session_range_location->start());
}
if ((child = find_named_node (node, "Regions")) == 0) {
if ((child = find_named_node (node, "Playlists")) == 0) {
error << _("Session: XML state has no playlists section") << endmsg;
goto out;
- } else if (load_playlists (*child)) {
+ } else if (playlists->load (*this, *child)) {
goto out;
}
if ((child = find_named_node (node, "UnusedPlaylists")) == 0) {
// this is OK
- } else if (load_unused_playlists (*child)) {
+ } 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;
}
}
- if ((child = find_named_node (node, "DiskStreams")) == 0) {
- error << _("Session: XML state has no diskstreams section") << endmsg;
- goto out;
- } else if (load_diskstreams (*child)) {
- goto out;
+ 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, "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 ((child = find_named_node (node, "EditGroups")) == 0) {
- error << _("Session: XML state has no edit groups section") << endmsg;
- goto out;
- } else if (load_edit_groups (*child)) {
- 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, "MixGroups")) == 0) {
- error << _("Session: XML state has no mix groups section") << endmsg;
+ if ((child = find_named_node (node, "Routes")) == 0) {
+ error << _("Session: XML state has no routes section") << endmsg;
goto out;
- } else if (load_mix_groups (*child)) {
+ } else if (load_routes (*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)) {
- goto out;
- }
+ /* our diskstreams list is no longer needed as they are now all owned by their Route */
+ _diskstreams_2X.clear ();
- if ((child = find_named_node (node, "Routes")) == 0) {
- error << _("Session: XML state has no routes section") << endmsg;
- goto out;
- } else if (load_routes (*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, "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;
+ if (version < 3000) {
+ route = XMLRouteFactory_2X (**niter, version);
+ } else {
+ route = XMLRouteFactory (**niter, version);
+ }
if (route == 0) {
error << _("Session: cannot create Route from XML description.") << endmsg;
new_routes.push_back (route);
}
- add_routes (new_routes, false);
+ add_routes (new_routes, false, false);
return 0;
}
boost::shared_ptr<Route>
-Session::XMLRouteFactory (const XMLNode& node)
+Session::XMLRouteFactory (const XMLNode& node, int version)
{
+ boost::shared_ptr<Route> ret;
+
if (node.name() != "Route") {
- return boost::shared_ptr<Route> ((Route*) 0);
+ return ret;
}
- bool has_diskstream = (node.property ("diskstream") != 0 || node.property ("diskstream-id") != 0);
-
+ XMLNode* ds_child = find_named_node (node, X_("Diskstream"));
+
DataType type = DataType::AUDIO;
const XMLProperty* prop = node.property("default-type");
if (prop) {
- type = DataType(prop->value());
- }
-
- assert(type != DataType::NIL);
+ type = DataType (prop->value());
+ }
+
+ assert (type != DataType::NIL);
+
+ if (ds_child) {
+
+ 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;
+ }
+
+#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
+ // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
+#endif
+ ret = track;
- if (has_diskstream) {
- if (type == DataType::AUDIO) {
- boost::shared_ptr<Route> ret (new AudioTrack (*this, node));
- return ret;
- } else {
- boost::shared_ptr<Route> ret (new MidiTrack (*this, node));
- return ret;
- }
} else {
- boost::shared_ptr<Route> ret (new Route (*this, node));
+ boost::shared_ptr<Route> r (new Route (*this, X_("toBeResetFroXML")));
+
+ if (r->init () == 0 && r->set_state (node, version) == 0) {
+#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
+ // boost_debug_shared_ptr_mark_interesting (r.get(), "Route");
+#endif
+ ret = r;
+ }
+ }
+
+ return ret;
+}
+
+boost::shared_ptr<Route>
+Session::XMLRouteFactory_2X (const XMLNode& node, int version)
+{
+ boost::shared_ptr<Route> ret;
+
+ if (node.name() != "Route") {
return ret;
}
+
+ XMLProperty const * ds_prop = node.property (X_("diskstream-id"));
+ if (!ds_prop) {
+ ds_prop = node.property (X_("diskstream"));
+ }
+
+ DataType type = DataType::AUDIO;
+ const XMLProperty* prop = node.property("default-type");
+
+ if (prop) {
+ type = DataType (prop->value());
+ }
+
+ assert (type != DataType::NIL);
+
+ if (ds_prop) {
+
+ list<boost::shared_ptr<Diskstream> >::iterator i = _diskstreams_2X.begin ();
+ while (i != _diskstreams_2X.end() && (*i)->id() != ds_prop->value()) {
+ ++i;
+ }
+
+ if (i == _diskstreams_2X.end()) {
+ error << _("Could not find diskstream for route") << endmsg;
+ return boost::shared_ptr<Route> ();
+ }
+
+ 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;
+ }
+
+ track->set_diskstream (*i);
+
+#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
+ // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
+#endif
+ ret = track;
+
+ } else {
+ boost::shared_ptr<Route> r (new Route (*this, X_("toBeResetFroXML")));
+
+ if (r->init () == 0 && r->set_state (node, version) == 0) {
+#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
+ // boost_debug_shared_ptr_mark_interesting (r.get(), "Route");
+#endif
+ ret = r;
+ }
+ }
+
+ return ret;
}
int
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)
{
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));
+ 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") {
+ return boost::shared_ptr<Region>(XMLMidiRegionFactory (node, full));
+ }
- }
-
} catch (failed_constructor& err) {
return boost::shared_ptr<Region> ();
}
}
boost::shared_ptr<AudioRegion>
-Session::XMLAudioRegionFactory (const XMLNode& node, bool full)
+Session::XMLAudioRegionFactory (const XMLNode& node, bool /*full*/)
{
const XMLProperty* prop;
boost::shared_ptr<Source> source;
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<MidiRegion>
-Session::XMLMidiRegionFactory (const XMLNode& node, bool full)
+Session::XMLMidiRegionFactory (const XMLNode& node, bool /*full*/)
{
const XMLProperty* prop;
boost::shared_ptr<Source> source;
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 ();
}
- // Multiple midi channels? that's just crazy talk
- assert(nchans == 1);
-
if ((prop = node.property (X_("source-0"))) == 0) {
if ((prop = node.property ("source")) == 0) {
error << _("Session: XMLNode describing a MidiRegion is incomplete (no source)") << endmsg;
sys::path source_dir = ((type == DataType::AUDIO)
? sdir.sound_path() : sdir.midi_path());
- string ext = ((type == DataType::AUDIO) ? ".wav" : ".mid");
+ string ext = native_header_format_extension (config.get_native_file_header_format(), type);
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)
set_dirty();
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
+ retry:
try {
if ((source = XMLSourceFactory (**niter)) == 0) {
error << _("Session: cannot create Source from XML description.") << endmsg;
}
+
} catch (MissingSource& err) {
- warning << _("A sound file is missing. It will be replaced by silence.") << endmsg;
- source = SourceFactory::createSilent (*this, **niter, max_frames, _current_frame_rate);
+
+ int user_choice;
+
+ if (!no_questions_about_missing_files) {
+ user_choice = MissingFile (this, err.path, err.type).get_value_or (-1);
+ } else {
+ user_choice = -2;
+ }
+
+ switch (user_choice) {
+ case 0:
+ /* user added a new search location, so try again */
+ goto retry;
+
+
+ case 1:
+ /* user asked to quit the entire session load
+ */
+ return -1;
+
+ case 2:
+ no_questions_about_missing_files = true;
+ goto retry;
+
+ case 3:
+ no_questions_about_missing_files = true;
+ /* fallthru */
+
+ case -1:
+ default:
+ warning << _("A sound file is missing. It will be replaced by silence.") << endmsg;
+ source = SourceFactory::createSilent (*this, **niter, max_framecnt, _current_frame_rate);
+ break;
+ }
}
}
}
catch (failed_constructor& err) {
- error << _("Found a sound file that cannot be used by Ardour. Talk to the progammers.") << endmsg;
+ error << string_compose (_("Found a sound file that cannot be used by %1. Talk to the progammers."), PROGRAM_NAME) << endmsg;
return boost::shared_ptr<Source>();
}
}
}
catch(sys::filesystem_error& ex)
{
- error << string_compose(_("Could not create mix templates directory \"%1\" (%2)"),
+ error << string_compose(_("Could not create templates directory \"%1\" (%2)"),
user_template_dir.to_string(), ex.what()) << endmsg;
return -1;
}
tree.set_root (&get_template());
- sys::path template_file_path(user_template_dir);
- template_file_path /= template_name + template_suffix;
-
- if (sys::exists (template_file_path))
+ sys::path template_dir_path(user_template_dir);
+
+ /* directory to put the template in */
+ template_dir_path /= template_name;
+ if (sys::exists (template_dir_path))
{
warning << string_compose(_("Template \"%1\" already exists - new version not created"),
- template_file_path.to_string()) << endmsg;
- return -1;
- }
-
- if (!tree.write (template_file_path.to_string())) {
- error << _("mix template not saved") << endmsg;
+ template_dir_path.to_string()) << endmsg;
return -1;
}
+
+ sys::create_directories (template_dir_path);
- return 0;
-}
-
-int
-Session::rename_template (string old_name, string new_name)
-{
- sys::path old_path (user_template_directory());
- old_path /= old_name + template_suffix;
-
- sys::path new_path(user_template_directory());
- new_path /= new_name + template_suffix;
+ /* file to write */
+ sys::path template_file_path = template_dir_path;
+ template_file_path /= template_name + template_suffix;
- if (sys::exists (new_path)) {
- warning << string_compose(_("Template \"%1\" already exists - template not renamed"),
- new_path.to_string()) << endmsg;
+ if (!tree.write (template_file_path.to_string())) {
+ error << _("template not saved") << endmsg;
return -1;
}
- try {
- sys::rename (old_path, new_path);
- return 0;
- } catch (...) {
- return -1;
- }
-}
+ /* copy plugin state directory */
-int
-Session::delete_template (string name)
-{
- sys::path path = user_template_directory();
- path /= name + template_suffix;
+ sys::path template_plugin_state_path = template_dir_path;
+ template_plugin_state_path /= X_("plugins");
+ sys::create_directories (template_plugin_state_path);
+ sys::copy_files (plugins_dir(), template_plugin_state_path);
- try {
- sys::remove (path);
- return 0;
- } catch (...) {
- return -1;
- }
+ return 0;
}
void
/* 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;
}
int
-Session::load_playlists (const XMLNode& node)
+Session::load_named_selections (const XMLNode& node)
{
XMLNodeList nlist;
XMLNodeConstIterator niter;
- boost::shared_ptr<Playlist> playlist;
+ NamedSelection *ns;
nlist = node.children();
set_dirty();
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
-
- if ((playlist = XMLPlaylistFactory (**niter)) == 0) {
- error << _("Session: cannot create Playlist from XML description.") << endmsg;
+
+ if ((ns = XMLNamedSelectionFactory (**niter)) == 0) {
+ error << _("Session: cannot create Named Selection from XML description.") << endmsg;
}
}
return 0;
}
-int
-Session::load_unused_playlists (const XMLNode& node)
-{
- XMLNodeList nlist;
- XMLNodeConstIterator niter;
- boost::shared_ptr<Playlist> playlist;
-
- nlist = node.children();
-
- 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;
- }
-
- // now manually untrack it
-
- track_playlist (false, boost::weak_ptr<Playlist> (playlist));
- }
-
- return 0;
-}
-
-boost::shared_ptr<Playlist>
-Session::XMLPlaylistFactory (const XMLNode& node)
-{
- try {
- return PlaylistFactory::create (*this, node);
- }
-
- catch (failed_constructor& err) {
- return boost::shared_ptr<Playlist>();
- }
-}
-
-int
-Session::load_named_selections (const XMLNode& node)
-{
- XMLNodeList nlist;
- XMLNodeConstIterator niter;
- NamedSelection *ns;
-
- nlist = node.children();
-
- 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;
- }
- }
-
- return 0;
-}
-
-NamedSelection *
-Session::XMLNamedSelectionFactory (const XMLNode& node)
+NamedSelection *
+Session::XMLNamedSelectionFactory (const XMLNode& node)
{
try {
return new NamedSelection (*this, node);
return Glib::build_filename (_path, "analysis");
}
+string
+Session::plugins_dir () const
+{
+ return Glib::build_filename (_path, "plugins");
+}
+
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_edit_groups (const XMLNode& node)
-{
- return load_route_groups (node, true);
-}
-
-int
-Session::load_mix_groups (const XMLNode& node)
-{
- return load_route_groups (node, false);
}
int
-Session::load_route_groups (const XMLNode& node, bool edit)
+Session::load_route_groups (const XMLNode& node, int version)
{
XMLNodeList nlist = node.children();
XMLNodeConstIterator niter;
- set_dirty();
+ set_dirty ();
- for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
- if ((*niter)->name() == "RouteGroup") {
- RouteGroup* rg = new RouteGroup (*this, "");
- if (edit) {
- add_edit_group (rg);
- rg->set_state (**niter);
- } else {
- add_mix_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()
}
static bool
-state_file_filter (const string &str, void *arg)
+state_file_filter (const string &str, void */*arg*/)
{
return (str.length() > strlen(statefile_suffix) &&
str.find (statefile_suffix) == (str.length() - strlen (statefile_suffix)));
remove_end(string* state)
{
string statename(*state);
-
+
string::size_type start,end;
- if ((start = statename.find_last_of ('/')) != string::npos) {
+ if ((start = statename.find_last_of (G_DIR_SEPARATOR)) != 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;
}
}
void
-Session::add_edit_group (RouteGroup* g)
+Session::add_route_group (RouteGroup* g)
{
- edit_groups.push_back (g);
- edit_group_added (g); /* EMIT SIGNAL */
- set_dirty ();
-}
+ _route_groups.push_back (g);
+ route_group_added (g); /* EMIT SIGNAL */
+
+ 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));
-void
-Session::add_mix_group (RouteGroup* g)
-{
- mix_groups.push_back (g);
- mix_group_added (g); /* EMIT SIGNAL */
set_dirty ();
}
void
-Session::remove_edit_group (RouteGroup& rg)
+Session::remove_route_group (RouteGroup& rg)
{
list<RouteGroup*>::iterator i;
- if ((i = find (edit_groups.begin(), edit_groups.end(), &rg)) != edit_groups.end()) {
- (*i)->apply (&Route::drop_edit_group, this);
- edit_groups.erase (i);
- edit_group_removed (); /* EMIT SIGNAL */
- }
+ if ((i = find (_route_groups.begin(), _route_groups.end(), &rg)) != _route_groups.end()) {
+ _route_groups.erase (i);
+ delete &rg;
- delete &rg;
+ 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::remove_mix_group (RouteGroup& rg)
+Session::reorder_route_groups (list<RouteGroup*> groups)
{
- list<RouteGroup*>::iterator i;
-
- if ((i = find (mix_groups.begin(), mix_groups.end(), &rg)) != mix_groups.end()) {
- (*i)->apply (&Route::drop_mix_group, this);
- mix_groups.erase (i);
- mix_group_removed (); /* EMIT SIGNAL */
- }
+ _route_groups = groups;
- delete &rg;
+ route_groups_reordered (); /* EMIT SIGNAL */
+ set_dirty ();
}
-RouteGroup *
-Session::mix_group_by_name (string name)
-{
- list<RouteGroup *>::iterator i;
-
- for (i = mix_groups.begin(); i != mix_groups.end(); ++i) {
- if ((*i)->name() == name) {
- return* i;
- }
- }
- return 0;
-}
RouteGroup *
-Session::edit_group_by_name (string name)
+Session::route_group_by_name (string name)
{
list<RouteGroup *>::iterator i;
- for (i = edit_groups.begin(); i != edit_groups.end(); ++i) {
+ for (i = _route_groups.begin(); i != _route_groups.end(); ++i) {
if ((*i)->name() == name) {
return* i;
}
return 0;
}
-void
-Session::begin_reversible_command(const string& name)
+RouteGroup&
+Session::all_route_group() const
{
- UndoTransaction* trans = new UndoTransaction();
- trans->set_name(name);
- if (!_current_trans.empty()) {
- _current_trans.top()->add_command(trans);
- }
- _current_trans.push(trans);
+ return *_all_route_group;
}
void
-Session::commit_reversible_command(Command *cmd)
+Session::add_commands (vector<Command*> const & cmds)
{
- assert(!_current_trans.empty());
- struct timeval now;
-
- if (cmd) {
- _current_trans.top()->add_command(cmd);
+ for (vector<Command*>::const_iterator i = cmds.begin(); i != cmds.end(); ++i) {
+ add_command (*i);
}
-
- if (_current_trans.top()->empty()) {
- _current_trans.pop();
- return;
- }
-
- gettimeofday(&now, 0);
- _current_trans.top()->set_timestamp(now);
-
- _history.add(_current_trans.top());
- _current_trans.pop();
}
-Session::GlobalRouteBooleanState
-Session::get_global_route_boolean (bool (Route::*method)(void) const)
+void
+Session::begin_reversible_command (const string& name)
{
- GlobalRouteBooleanState s;
- boost::shared_ptr<RouteList> r = routes.reader ();
-
- 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);
- }
- }
-
- return s;
+ begin_reversible_command (g_quark_from_string (name.c_str ()));
}
-Session::GlobalRouteMeterState
-Session::get_global_route_metering ()
+/** Begin a reversible command using a GQuark to identify it.
+ * begin_reversible_command() and commit_reversible_command() calls may be nested,
+ * but there must be as many begin...()s as there are commit...()s.
+ */
+void
+Session::begin_reversible_command (GQuark q)
{
- GlobalRouteMeterState s;
- boost::shared_ptr<RouteList> r = routes.reader ();
+ /* If nested begin/commit pairs are used, we create just one UndoTransaction
+ to hold all the commands that are committed. This keeps the order of
+ commands correct in the history.
+ */
- 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);
- }
+ 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));
}
- return s;
+ _current_trans_quarks.push_front (q);
}
void
-Session::set_global_route_metering (GlobalRouteMeterState s, void* arg)
+Session::commit_reversible_command (Command *cmd)
{
- for (GlobalRouteMeterState::iterator i = s.begin(); i != s.end(); ++i) {
+ assert (_current_trans);
+ assert (!_current_trans_quarks.empty ());
- boost::shared_ptr<Route> r = (i->first.lock());
+ struct timeval now;
- if (r) {
- r->set_meter_point (i->second, arg);
- }
+ if (cmd) {
+ _current_trans->add_command (cmd);
}
-}
-void
-Session::set_global_route_boolean (GlobalRouteBooleanState s, void (Route::*method)(bool, void*), void* arg)
-{
- for (GlobalRouteBooleanState::iterator i = s.begin(); i != s.end(); ++i) {
+ _current_trans_quarks.pop_front ();
- boost::shared_ptr<Route> r = (i->first.lock());
+ if (!_current_trans_quarks.empty ()) {
+ /* the transaction we're committing is not the top-level one */
+ return;
+ }
- if (r) {
- Route* rp = r.get();
- (rp->*method) (i->second, arg);
- }
+ if (_current_trans->empty()) {
+ /* no commands were added to the transaction, so just get rid of it */
+ delete _current_trans;
+ _current_trans = 0;
+ return;
}
-}
-void
-Session::set_global_mute (GlobalRouteBooleanState s, void* src)
-{
- set_global_route_boolean (s, &Route::set_mute, src);
-}
+ gettimeofday (&now, 0);
+ _current_trans->set_timestamp (now);
-void
-Session::set_global_solo (GlobalRouteBooleanState s, void* src)
-{
- set_global_route_boolean (s, &Route::set_solo, src);
+ _history.add (_current_trans);
+ _current_trans = 0;
}
-void
-Session::set_global_record_enable (GlobalRouteBooleanState s, void* src)
+static bool
+accept_all_audio_files (const string& path, void */*arg*/)
{
- set_global_route_boolean (s, &Route::set_record_enable, src);
+ if (!Glib::file_test (path, Glib::FILE_TEST_IS_REGULAR)) {
+ return false;
+ }
+
+ if (!AudioFileSource::safe_audio_file_extension (path)) {
+ return false;
+ }
+
+ return true;
}
static bool
-accept_all_non_peak_files (const string& path, void *arg)
+accept_all_midi_files (const string& path, void */*arg*/)
{
- return (path.length() > 5 && path.find (peakfile_suffix) != (path.length() - 5));
+ 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)
+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));
}
-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) {
+ continue;
+ }
+
+ DataType type (prop->value());
+
if ((prop = (*niter)->property (X_("name"))) == 0) {
continue;
}
- if (prop->value()[0] == '/') {
+ if (Glib::path_is_absolute (prop->value())) {
/* external file, ignore */
continue;
}
- sys::path source_path = _session_dir->sound_path ();
-
- source_path /= prop->value ();
+ string found_path;
+ bool is_new;
+ uint16_t chan;
- result.insert (source_path.to_string ());
+ if (FileSource::find (*this, type, prop->value(), true, is_new, chan, found_path)) {
+ result.insert (found_path);
+ }
}
return 0;
ripped = _path;
- if (ripped[ripped.length()-1] == '/') {
+ if (ripped[ripped.length()-1] == G_DIR_SEPARATOR) {
ripped = ripped.substr (0, ripped.length() - 1);
}
state_files = scanner (ripped, accept_all_state_files, (void *) 0, false, true);
-
+
if (state_files == 0) {
/* impossible! */
return 0;
}
this_snapshot_path = _path;
- this_snapshot_path += _current_snapshot_name;
+ this_snapshot_path += legalize_for_path (_current_snapshot_name);
this_snapshot_path += statefile_suffix;
for (vector<string*>::iterator i = state_files->begin(); i != state_files->end(); ++i) {
AudioSourceList::iterator iter;
boost::shared_ptr<Region> region;
uint32_t count;
-
+
RegionCounter() : count (0) {}
};
int
-Session::cleanup_sources (Session::cleanup_report& rep)
+Session::ask_about_playlist_deletion (boost::shared_ptr<Playlist> p)
+{
+ boost::optional<int> r = AskAboutPlaylistDeletion (p);
+ return r.get_value_or (1);
+}
+
+void
+Session::cleanup_regions ()
+{
+ const RegionFactory::RegionMap& regions (RegionFactory::regions());
+
+ for (RegionFactory::RegionMap::const_iterator i = regions.begin(); i != regions.end(); ++i) {
+
+ uint32_t used = playlists->region_use_count (i->second);
+
+ if (used == 0 && !i->second->automatic ()) {
+ RegionFactory::map_remove (i->second);
+ }
+ }
+
+ /* dump the history list */
+ _history.clear ();
+
+ save_state ("");
+}
+
+int
+Session::cleanup_sources (CleanupReport& rep)
{
// FIXME: needs adaptation to midi
-
+
vector<boost::shared_ptr<Source> > dead_sources;
- vector<boost::shared_ptr<Playlist> > playlists_tbd;
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;
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) {
- int status;
-
- status = AskAboutPlaylistDeletion (*x);
-
- switch (status) {
- case -1:
- ret = 0;
- goto out;
- break;
+ _state_of_the_state = (StateOfTheState) (_state_of_the_state | InCleanup);
- case 0:
- playlists_tbd.push_back (*x);
- break;
+ /* consider deleting all unused playlists */
- default:
- /* leave it alone */
- break;
- }
+ if (playlists->maybe_delete_unused (boost::bind (Session::ask_about_playlist_deletion, _1))) {
+ ret = 0;
+ goto out;
}
- /* now delete any that were marked for deletion */
-
- for (vector<boost::shared_ptr<Playlist> >::iterator x = playlists_tbd.begin(); x != playlists_tbd.end(); ++x) {
- (*x)->drop_references ();
- }
+ /* sync the "all regions" property of each playlist with its current state
+ */
- playlists_tbd.clear ();
+ playlists->sync_all_regions_with_regions ();
- /* step 2: find all un-used sources */
+ /* find all un-used sources */
rep.paths.clear ();
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->second->drop_references ();
+ }
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.
*/
-
+
find_all_sources_across_snapshots (all_sources, true);
/* 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) {
- used = false;
- spath = **x;
+ if (candidates) {
+ for (vector<string*>::iterator x = candidates->begin(); x != candidates->end(); ++x) {
- for (set<string>::iterator i = all_sources.begin(); i != all_sources.end(); ++i) {
+ used = false;
+ spath = **x;
- realpath(spath.c_str(), tmppath1);
- realpath((*i).c_str(), tmppath2);
+ for (set<string>::iterator i = all_sources.begin(); i != all_sources.end(); ++i) {
- if (strcmp(tmppath1, tmppath2) == 0) {
- used = true;
- break;
- }
- }
+ if (realpath(spath.c_str(), tmppath1) == 0) {
+ error << string_compose (_("Cannot expand path %1 (%2)"),
+ spath, strerror (errno)) << endmsg;
+ continue;
+ }
- if (!used) {
- unused.push_back (spath);
- }
- }
+ 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 (!used) {
+ unused.push_back (spath);
+ }
+
+ delete *x;
+ }
- /* now try to move all unused files into the "dead_sounds" directory(ies) */
+ delete candidates;
+ }
+
+ /* 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.
*/
/* 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" 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 += '/';
- 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 += '/';
- newpath += Glib::path_get_basename ((*x));
-
- if (access (newpath.c_str(), F_OK) == 0) {
-
+ 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 */
-
+
char buf[PATH_MAX+1];
int version = 1;
string newpath_v;
-
+
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;
}
-
+
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 */
-
+
}
+ 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 so we don't end up a session file
referring to non-existent sources.
*/
-
+
save_state ("");
+ ret = 0;
out:
_state_of_the_state = (StateOfTheState) (_state_of_the_state & ~InCleanup);
}
int
-Session::cleanup_trash_sources (Session::cleanup_report& rep)
+Session::cleanup_trash_sources (CleanupReport& rep)
{
// FIXME: needs adaptation for MIDI
-
+
vector<space_and_path>::iterator i;
- string dead_sound_dir;
- struct dirent* dentry;
- struct stat statbuf;
- DIR* dead;
+ 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;
-
- if ((dead = opendir (dead_sound_dir.c_str())) == 0) {
- continue;
- }
-
- while ((dentry = readdir (dead)) != 0) {
-
- /* avoid '.' and '..' */
-
- if ((dentry->d_name[0] == '.' && dentry->d_name[1] == '\0') ||
- (dentry->d_name[2] == '\0' && dentry->d_name[0] == '.' && dentry->d_name[1] == '.')) {
- continue;
- }
-
- string fullpath;
-
- fullpath = dead_sound_dir;
- fullpath += '/';
- fullpath += dentry->d_name;
-
- if (stat (fullpath.c_str(), &statbuf)) {
- continue;
- }
-
- if (!S_ISREG (statbuf.st_mode)) {
- continue;
- }
- if (unlink (fullpath.c_str())) {
- error << string_compose (_("cannot remove dead sound file %1 (%2)"),
- fullpath, strerror (errno))
- << endmsg;
- }
+ dead_dir = Glib::build_filename ((*i).path, dead_dir_name);
- rep.paths.push_back (dentry->d_name);
- rep.space += statbuf.st_size;
- }
-
- closedir (dead);
-
+ clear_directory (dead_dir, &rep.space, &rep.paths);
}
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
Glib::Mutex::Lock lm (controllables_lock);
- Controllables::iterator x = controllables.find(
- boost::shared_ptr<Controllable>(c, null_deleter()));
+ Controllables::iterator x = controllables.find (boost::shared_ptr<Controllable>(c, null_deleter()));
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
+boost::shared_ptr<Controllable>
+Session::controllable_by_descriptor (const ControllableDescriptor& desc)
+{
+ boost::shared_ptr<Controllable> c;
+ boost::shared_ptr<Route> r;
+
+ switch (desc.top_level_type()) {
+ case ControllableDescriptor::NamedRoute:
+ {
+ std::string str = desc.top_level_name();
+ if (str == "master") {
+ r = _master_out;
+ } else if (str == "control" || str == "listen") {
+ r = _monitor_out;
+ } else {
+ r = route_by_name (desc.top_level_name());
+ }
+ break;
+ }
+
+ case ControllableDescriptor::RemoteControlID:
+ r = route_by_remote_id (desc.rid());
+ break;
+ }
+
+ if (!r) {
+ return c;
+ }
+
+ switch (desc.subtype()) {
+ case ControllableDescriptor::Gain:
+ c = r->gain_control ();
+ break;
+
+ case ControllableDescriptor::Solo:
+ c = r->solo_control();
+ break;
+
+ case ControllableDescriptor::Mute:
+ c = r->mute_control();
+ break;
+
+ case ControllableDescriptor::Recenable:
+ {
+ boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track>(r);
+
+ if (t) {
+ c = t->rec_enable_control ();
+ }
+ break;
+ }
+
+ case ControllableDescriptor::PanDirection:
+ {
+ c = r->pannable()->pan_azimuth_control;
+ break;
+ }
+
+ case ControllableDescriptor::PanWidth:
+ {
+ c = r->pannable()->pan_width_control;
+ break;
+ }
+
+ case ControllableDescriptor::PanElevation:
+ {
+ c = r->pannable()->pan_elevation_control;
+ break;
+ }
+
+ case ControllableDescriptor::Balance:
+ /* XXX simple pan control */
+ break;
+
+ case ControllableDescriptor::PluginParameter:
+ {
+ uint32_t plugin = desc.target (0);
+ uint32_t parameter_index = desc.target (1);
+
+ /* revert to zero based counting */
+
+ if (plugin > 0) {
+ --plugin;
+ }
+
+ if (parameter_index > 0) {
+ --parameter_index;
+ }
+
+ boost::shared_ptr<Processor> p = r->nth_plugin (plugin);
+
+ if (p) {
+ c = boost::dynamic_pointer_cast<ARDOUR::AutomationControl>(
+ p->control(Evoral::Parameter(PluginAutomation, 0, parameter_index)));
+ }
+ break;
+ }
+
+ case ControllableDescriptor::SendGain:
+ {
+ uint32_t send = desc.target (0);
+
+ /* 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();
+
+ if (a) {
+ c = s->amp()->gain_control();
+ }
+ }
+ break;
+ }
+
+ default:
+ /* relax and return a null pointer */
+ break;
+ }
+
+ return c;
+}
+
+void
Session::add_instant_xml (XMLNode& node, bool write_to_config)
{
- Stateful::add_instant_xml (node, _path);
+ if (_writable) {
+ Stateful::add_instant_xml (node, _path);
+ }
+
if (write_to_config) {
Config->add_instant_xml (node);
}
return Stateful::instant_xml (node_name, _path);
}
-int
+int
Session::save_history (string snapshot_name)
{
XMLTree tree;
-
- if (snapshot_name.empty()) {
+
+ if (!_writable) {
+ return 0;
+ }
+
+ if (snapshot_name.empty()) {
snapshot_name = _current_snapshot_name;
}
-
- const string history_filename = 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()))
{
snapshot_name = _current_snapshot_name;
}
- const string xml_filename = snapshot_name + history_suffix;
+ 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 {
- 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() == "NoteDiffCommand") {
+ 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::NoteDiffCommand(midi_source->model(), *n));
+ } else {
+ error << _("Failed to downcast MidiSource for NoteDiffCommand") << endmsg;
+ }
+
+ } else if (n->name() == "SysExDiffCommand") {
+
+ 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::SysExDiffCommand (midi_source->model(), *n));
+ } else {
+ error << _("Failed to downcast MidiSource for SysExDiffCommand") << endmsg;
+ }
+
+ } else if (n->name() == "PatchChangeDiffCommand") {
+
+ 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::PatchChangeDiffCommand (midi_source->model(), *n));
+ } else {
+ error << _("Failed to downcast MidiSource for PatchChangeDiffCommand") << endmsg;
+ }
+
+ } else if (n->name() == "StatefulDiffCommand") {
+ if ((c = stateful_diff_command_factory (n))) {
+ ut->add_command (c);
+ }
+ } 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());
- }
- }
+ set_track_monitor_input_status (!config.get_auto_input());
}
} else if (p == "punch-in") {
Location* location;
-
- if ((location = _locations.auto_punch_location()) != 0) {
-
+
+ if ((location = _locations->auto_punch_location()) != 0) {
+
if (config.get_punch_in ()) {
- replace_event (Event::PunchIn, location->start());
+ replace_event (SessionEvent::PunchIn, location->start());
} else {
- remove_event (location->start(), Event::PunchIn);
+ remove_event (location->start(), SessionEvent::PunchIn);
}
}
-
+
} else if (p == "punch-out") {
Location* location;
-
- if ((location = _locations.auto_punch_location()) != 0) {
-
+
+ if ((location = _locations->auto_punch_location()) != 0) {
+
if (config.get_punch_out()) {
- replace_event (Event::PunchOut, location->end());
+ replace_event (SessionEvent::PunchOut, location->end());
} else {
- clear_events (Event::PunchOut);
+ clear_events (SessionEvent::PunchOut);
}
}
} else if (p == "edit-mode") {
- Glib::Mutex::Lock lm (playlist_lock);
-
- for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i) {
+ Glib::Mutex::Lock lm (playlists->lock);
+
+ for (SessionPlaylists::List::iterator i = playlists->playlists.begin(); i != playlists->playlists.end(); ++i) {
(*i)->set_edit_mode (Config->get_edit_mode ());
}
//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") {
- if (mmc) {
- mmc->set_receive_device_id (Config->get_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") {
- if (mmc) {
- mmc->set_send_device_id (Config->get_mmc_send_device_id());
- }
+ MIDI::Manager::instance()->mmc()->set_send_device_id (Config->get_mmc_send_device_id());
} else if (p == "midi-control") {
-
+
//poke_midi_thread ();
} else if (p == "raid-path") {
setup_raid_path (config.get_raid_path());
- } else if (p == "smpte-format") {
+ } else if (p == "timecode-format") {
sync_time_vars ();
}
} 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) {
- /* mark us ready to send */
- next_quarter_frame_to_send = 0;
- }
- } else {
- session_send_mtc = false;
+
+ if (Config->get_send_mtc ()) {
+ /* mark us ready to send */
+ next_quarter_frame_to_send = 0;
}
} 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;
- }
+
+ MIDI::Manager::instance()->mmc()->enable_send (Config->get_send_mmc ());
} 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();
- }
+
+ session_midi_feedback = Config->get_midi_feedback();
} else if (p == "jack-time-master") {
first_file_data_format_reset = false;
- } else if (p == "slave-source") {
- set_slave_source (Config->get_slave_source());
+ } else if (p == "external-sync") {
+ if (!config.get_external_sync()) {
+ drop_sync_source ();
+ } else {
+ switch_to_sync_source (config.get_sync_source());
+ }
} else if (p == "remote-model") {
set_remote_control_ids ();
} else if (p == "denormal-model") {
sync_order_keys ("session");
} else if (p == "initial-program-change") {
- if (_mmc_port && Config->get_initial_program_change() >= 0) {
+ if (MIDI::Manager::instance()->mmc()->output_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);
-
- _mmc_port->midimsg (buf, sizeof (buf), 0);
- }
- } else if (p == "initial-program-change") {
- 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);
+
+ MIDI::Manager::instance()->mmc()->output_port()->midimsg (buf, sizeof (buf), 0);
}
} else if (p == "solo-mute-override") {
// catch_up_on_solo_mute_override ();
- } else if (p == "solo-model") {
- solo_model_changed ();
+ } 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 ();
{
_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 ()
+{
+ 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));
+ mmc->FastForward.connect_same_thread (*this, boost::bind (&Session::mmc_fast_forward, this, _1));
+ mmc->Rewind.connect_same_thread (*this, boost::bind (&Session::mmc_rewind, this, _1));
+ mmc->Pause.connect_same_thread (*this, boost::bind (&Session::mmc_pause, this, _1));
+ mmc->RecordPause.connect_same_thread (*this, boost::bind (&Session::mmc_record_pause, this, _1));
+ mmc->RecordStrobe.connect_same_thread (*this, boost::bind (&Session::mmc_record_strobe, this, _1));
+ mmc->RecordExit.connect_same_thread (*this, boost::bind (&Session::mmc_record_exit, this, _1));
+ mmc->Locate.connect_same_thread (*this, boost::bind (&Session::mmc_locate, this, _1, _2));
+ mmc->Step.connect_same_thread (*this, boost::bind (&Session::mmc_step, this, _1, _2));
+ mmc->Shuttle.connect_same_thread (*this, boost::bind (&Session::mmc_shuttle, this, _1, _2, _3));
+ mmc->TrackRecordStatusChange.connect_same_thread (*this, boost::bind (&Session::mmc_record_enable, this, _1, _2, _3));
+
+ /* also handle MIDI SPP because its so common */
+
+ mmc->SPPStart.connect_same_thread (*this, boost::bind (&Session::spp_start, this, _1, _2));
+ mmc->SPPContinue.connect_same_thread (*this, boost::bind (&Session::spp_continue, this, _1, _2));
+ mmc->SPPStop.connect_same_thread (*this, boost::bind (&Session::spp_stop, this, _1, _2));
+}
+
+boost::shared_ptr<Controllable>
+Session::solo_cut_control() const
+{
+ /* the solo cut control is a bit of an anomaly, at least as of Febrary 2011. There are no other
+ controls in Ardour that currently get presented to the user in the GUI that require
+ access as a Controllable and are also NOT owned by some SessionObject (e.g. Route, or MonitorProcessor).
+
+ its actually an RCConfiguration parameter, so we use a ProxyControllable to wrap
+ 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;
+
+ string const old_sources_root = _session_dir->sources_root().to_string ();
+
+#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;
+ }
+ }
+
+ /* update file source paths */
+
+ for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
+ boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (i->second);
+ if (fs) {
+ string p = fs->path ();
+ boost::replace_all (p, old_sources_root, _session_dir->sources_root().to_string ());
+ fs->set_path (p);
+ }
+ }
+
+ /* 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