X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fsession_state.cc;h=e222de2221624a1df43ea398569179f483840b9a;hb=9e0d03020ff47773f7d1c0414de1c74e6c9e0dac;hp=ea53a696d1805614e2a28009ff7bff85d2cdb3ec;hpb=36291eb399316b01bf7d23137eb9b9a3bad6998d;p=ardour.git diff --git a/libs/ardour/session_state.cc b/libs/ardour/session_state.cc index ea53a696d1..e222de2221 100644 --- a/libs/ardour/session_state.cc +++ b/libs/ardour/session_state.cc @@ -1,12 +1,12 @@ /* - Copyright (C) 1999-2002 Paul Davis + Copyright (C) 1999-2002 Paul Davis This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. - This program is distributed in the hope that it will be useful, + This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. @@ -14,9 +14,14 @@ 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. - + */ + +#ifdef WAF_BUILD +#include "libardour-config.h" +#endif + #define __STDC_FORMAT_MACROS 1 #include @@ -25,7 +30,6 @@ #include #include -#include #include /* snprintf(3) ... grrr */ #include @@ -47,61 +51,71 @@ #endif #include - -#include -#include -#include - #include -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include + +#include "midi++/mmc.h" +#include "midi++/port.h" + +#include "pbd/boost_debug.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 "ardour/amp.h" +#include "ardour/audio_diskstream.h" +#include "ardour/audio_track.h" +#include "ardour/audioengine.h" +#include "ardour/audiofilesource.h" +#include "ardour/audioplaylist.h" +#include "ardour/audioregion.h" +#include "ardour/auditioner.h" +#include "ardour/buffer.h" +#include "ardour/butler.h" +#include "ardour/configuration.h" +#include "ardour/control_protocol_manager.h" +#include "ardour/crossfade.h" +#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/midi_patch_manager.h" +#include "ardour/midi_playlist.h" +#include "ardour/midi_region.h" +#include "ardour/midi_source.h" +#include "ardour/midi_track.h" +#include "ardour/named_selection.h" +#include "ardour/processor.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/template_utils.h" +#include "ardour/tempo.h" +#include "ardour/ticker.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" #include "i18n.h" #include @@ -131,82 +145,86 @@ Session::first_stage_init (string fullpath, string snapshot_name) _path += '/'; } + if (Glib::file_test (_path, Glib::FILE_TEST_EXISTS) && ::access (_path.c_str(), W_OK)) { + _writable = false; + } else { + _writable = true; + } + /* these two are just provisional settings. set_state() will likely override them. */ _name = _current_snapshot_name = snapshot_name; + set_history_depth (Config->get_history_depth()); + _current_frame_rate = _engine.frame_rate (); + _nominal_frame_rate = _current_frame_rate; + _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->StateChanged.connect_same_thread (*this, boost::bind (&Session::tempo_map_changed, this, _1)); + + _non_soloed_outs_muted = false; + _listen_cnt = 0; g_atomic_int_set (&processing_prohibited, 0); - insert_cnt = 0; _transport_speed = 0; _last_transport_speed = 0; + _target_transport_speed = 0; auto_play_legal = false; transport_sub_state = 0; _transport_frame = 0; - last_stop_frame = 0; + _requested_return_frame = -1; 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))); - _end_location_is_free = true; g_atomic_int_set (&_record_status, Disabled); loop_changing = false; play_loop = false; + have_looped = false; _last_roll_location = 0; _last_record_location = 0; pending_locate_frame = 0; pending_locate_roll = false; pending_locate_flush = false; - dstream_buffer_size = 0; - state_tree = 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; - currently_soloing = false; _have_captured = false; _worst_output_latency = 0; _worst_input_latency = 0; - _worst_track_latency = 0; - _state_of_the_state = StateOfTheState(CannotSave|InitialConnecting|Loading|Deletion); + _worst_track_latency = 0; + _state_of_the_state = StateOfTheState(CannotSave|InitialConnecting|Loading); + _was_seamless = Config->get_seamless_loop (); _slave = 0; - butler_mixdown_buffer = 0; - butler_gain_buffer = 0; - mmc = 0; session_send_mmc = false; session_send_mtc = false; - post_transport_work = PostTransportWork (0); - g_atomic_int_set (&butler_should_do_transport_work, 0); - g_atomic_int_set (&butler_active, 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; - waiting_to_start = false; _exporting = false; _gain_automation_buffer = 0; _pan_automation_buffer = 0; _npan_buffers = 0; pending_abort = false; destructive_index = 0; - current_trans = 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; AudioDiskstream::allocate_working_buffers(); /* default short fade = 15ms */ - Crossfade::set_short_xfade_length ((nframes_t) floor (Config->get_short_xfade_seconds() * frame_rate())); - SndFileSource::setup_standard_crossfades (frame_rate()); + Crossfade::set_short_xfade_length ((nframes_t) floor (config.get_short_xfade_seconds() * frame_rate())); + SndFileSource::setup_standard_crossfades (*this, frame_rate()); last_mmc_step.tv_sec = 0; last_mmc_step.tv_usec = 0; @@ -215,28 +233,23 @@ Session::first_stage_init (string fullpath, string snapshot_name) /* click sounds are unset by default, which causes us to internal waveforms for clicks. */ - - click_data = 0; - click_emphasis_data = 0; + click_length = 0; click_emphasis_length = 0; _clicking = false; process_function = &Session::process_with_events; - if (Config->get_use_video_sync()) { + if (config.get_use_video_sync()) { waiting_for_sync_offset = true; } else { waiting_for_sync_offset = false; } - _current_frame_rate = 48000; - _base_frame_rate = 48000; - - last_smpte_when = 0; - _smpte_offset = 0; - _smpte_offset_negative = true; - last_smpte_valid = false; + last_timecode_when = 0; + _timecode_offset = 0; + _timecode_offset_negative = true; + last_timecode_valid = false; sync_time_vars (); @@ -247,30 +260,26 @@ Session::first_stage_init (string fullpath, string snapshot_name) /* slave stuff */ - average_slave_delta = 1800; + 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)); + _engine.GraphReordered.connect_same_thread (*this, boost::bind (&Session::graph_reordered, this)); /* These are all static "per-class" signals */ - 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)); - Redirect::RedirectCreated.connect (mem_fun (*this, &Session::add_redirect)); - NamedSelection::NamedSelectionCreated.connect (mem_fun (*this, &Session::add_named_selection)); - AutomationList::AutomationListCreated.connect (mem_fun (*this, &Session::add_automation_list)); - - Controllable::Destroyed.connect (mem_fun (*this, &Session::remove_controllable)); - - IO::MoreChannels.connect (mem_fun (*this, &Session::ensure_buffers)); + RegionFactory::CheckNewRegion.connect_same_thread (*this, boost::bind (&Session::add_region, this, _1)); + 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)); + Processor::ProcessorCreated.connect_same_thread (*this, boost::bind (&Session::add_processor, this, _1)); + 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 */ - IO::disable_panners (); - IO::disable_ports (); + Delivery::disable_panners (); IO::disable_connecting (); } @@ -286,18 +295,19 @@ Session::second_stage_init (bool new_session) remove_empty_sounds (); } - if (start_butler_thread()) { + if (_butler->start_thread()) { return -1; } - /*if (start_midi_thread ()) { + if (start_midi_thread ()) { return -1; - }*/ + } // 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 { @@ -316,26 +326,25 @@ Session::second_stage_init (bool new_session) _state_of_the_state = StateOfTheState (_state_of_the_state|CannotSave|Loading); - // set_auto_input (true); - _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(); } /* handle this one in a different way than all others, so that its clear what happened */ - + catch (AudioEngine::PortRegistrationFailure& err) { - error << _("Unable to create all required ports") - << endmsg; + error << err.what() << endmsg; return -1; } @@ -343,19 +352,36 @@ Session::second_stage_init (bool new_session) return -1; } - //send_full_time_code (); + BootMessage (_("Reset Remote Controls")); + + send_full_time_code (0); _engine.transport_locate (0); deliver_mmc (MIDI::MachineControl::cmdMmcReset, 0); deliver_mmc (MIDI::MachineControl::cmdLocate, 0); - ControlProtocolManager::instance().set_session (*this); + MidiClockTicker::instance().set_session (this); + MIDI::Name::MidiPatchManager::instance().set_session (this); - if (new_session) { - _end_location_is_free = true; - } else { - _end_location_is_free = false; + /* initial program change will be delivered later; see ::config_changed() */ + + BootMessage (_("Reset Control Protocols")); + + ControlProtocolManager::instance().set_session (this); + + config.set_end_marker_is_free (new_session); + + _state_of_the_state = Clean; + + DirtyChanged (); /* EMIT SIGNAL */ + + if (state_was_pending) { + save_state (_current_snapshot_name); + remove_pending_capture_state (); + state_was_pending = false; } - + + BootMessage (_("Session loading complete")); + return 0; } @@ -367,8 +393,8 @@ Session::raid_path () const for (vector::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) { raid_search_path += sys::path((*i).path); } - - return raid_search_path.get_string (); + + return raid_search_path.to_string (); } void @@ -377,7 +403,7 @@ Session::setup_raid_path (string path) if (path.empty()) { return; } - + space_and_path sp; string fspath; @@ -387,12 +413,7 @@ Session::setup_raid_path (string path) SearchPath sound_search_path; SearchPath midi_search_path; - for ( - SearchPath::const_iterator i = search_path.begin(); - i != search_path.end(); - ++i - ) - { + for (SearchPath::const_iterator i = search_path.begin(); i != search_path.end(); ++i) { sp.path = (*i).to_string (); sp.blocks = 0; // not needed session_dirs.push_back (sp); @@ -403,57 +424,151 @@ Session::setup_raid_path (string path) midi_search_path += sdir.midi_path (); } - // set the AudioFileSource and SMFSource search path - - AudioFileSource::set_search_path (sound_search_path.get_string ()); - SMFSource::set_search_path (midi_search_path.get_string ()); + // 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(); } -void -Session::initialize_start_and_end_locations (nframes_t start, nframes_t end) +bool +Session::path_is_within_session (const std::string& path) { - start_location->set_end (start); - _locations.add (start_location); - - end_location->set_end (end); - _locations.add (end_location); + for (vector::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) { + if (path.find ((*i).path) == 0) { + return true; + } + } + return false; } -bool -Session::create_session_file () +int +Session::ensure_subdirs () { - _state_of_the_state = Clean; + string dir; + + dir = session_directory().peak_path().to_string(); + + if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) { + error << string_compose(_("Session: cannot create session peakfile folder \"%1\" (%2)"), dir, strerror (errno)) << endmsg; + return -1; + } + + dir = session_directory().sound_path().to_string(); - if (save_state (_current_snapshot_name)) { - error << "Could not create new session file" << endmsg; - return false; + if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) { + 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) { + error << string_compose(_("Session: cannot create session midi dir \"%1\" (%2)"), dir, strerror (errno)) << endmsg; + return -1; + } + + dir = session_directory().dead_sound_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 = session_directory().export_path().to_string(); + + if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) { + error << string_compose(_("Session: cannot create session export folder \"%1\" (%2)"), dir, strerror (errno)) << endmsg; + return -1; + } + + dir = analysis_dir (); + + if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) { + error << string_compose(_("Session: cannot create session analysis folder \"%1\" (%2)"), dir, strerror (errno)) << endmsg; + return -1; } - return true; + + return 0; } -bool -Session::create_session_file_from_template (const string& template_path) +int +Session::create (bool& new_session, const string& mix_template, nframes_t initial_length) { - string out_path = _path + _name + statefile_suffix; - if(!copy_file (template_path, out_path)) { - error << string_compose (_("Could not use session template %1 to create new session."), template_path) - << endmsg; - return false; + 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; + } + + if (ensure_subdirs ()) { + return -1; + } + + /* check new_session so we don't overwrite an existing one */ + + if (!mix_template.empty()) { + std::string in_path = mix_template; + + ifstream in(in_path.c_str()); + + if (in){ + string out_path = _path; + out_path += _name; + out_path += statefile_suffix; + + ofstream out(out_path.c_str()); + + if (out){ + out << in.rdbuf(); + + // okay, session is set up. Treat like normal saved + // session from now on. + + new_session = false; + return 0; + + } else { + error << string_compose (_("Could not open %1 for writing mix template"), out_path) + << endmsg; + return -1; + } + + } else { + error << string_compose (_("Could not open mix template %1 for reading"), in_path) + << endmsg; + return -1; + } + } - return true; + + /* Instantiate metadata */ + + _metadata = new SessionMetadata (); + + /* set initial start + end point */ + + start_location->set_end (0); + _locations.add (start_location); + + end_location->set_end (initial_length); + _locations.add (end_location); + + _state_of_the_state = Clean; + + save_state (""); + + return 0; } + int Session::load_diskstreams (const XMLNode& node) { XMLNodeList clist; XMLNodeConstIterator citer; - + clist = node.children(); for (citer = clist.begin(); citer != clist.end(); ++citer) { @@ -461,7 +576,8 @@ Session::load_diskstreams (const XMLNode& node) try { /* diskstreams added automatically by DiskstreamCreated handler */ if ((*citer)->name() == "AudioDiskstream" || (*citer)->name() == "DiskStream") { - boost::shared_ptr dstream (new AudioDiskstream (*this, **citer)); + AudioDiskstream* dsp (new AudioDiskstream (*this, **citer)); + boost::shared_ptr dstream (dsp); add_diskstream (dstream); } else if ((*citer)->name() == "MidiDiskstream") { boost::shared_ptr dstream (new MidiDiskstream (*this, **citer)); @@ -469,8 +585,8 @@ Session::load_diskstreams (const XMLNode& node) } 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; @@ -491,13 +607,19 @@ Session::maybe_write_autosave() void Session::remove_pending_capture_state () { - string xml_path; + sys::path pending_state_file_path(_session_dir->root_path()); - xml_path = _path; - xml_path += _current_snapshot_name; - xml_path += pending_suffix; + pending_state_file_path /= legalize_for_path (_current_snapshot_name) + pending_suffix; - unlink (xml_path.c_str()); + try + { + sys::remove (pending_state_file_path); + } + catch(sys::filesystem_error& ex) + { + error << string_compose(_("Could remove pending capture state at path \"%1\" (%2)"), + pending_state_file_path.to_string(), ex.what()) << endmsg; + } } /** Rename a state file. @@ -510,12 +632,21 @@ Session::rename_state (string old_name, string new_name) /* refuse to rename the current snapshot or the "main" one */ return; } - - const string old_xml_path = _path + old_name + statefile_suffix; - const string new_xml_path = _path + new_name + statefile_suffix; - if (rename (old_xml_path.c_str(), new_xml_path.c_str()) != 0) { - error << string_compose(_("could not rename snapshot %1 to %2"), old_name, new_name) << endmsg; + 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; + + try + { + sys::rename (old_xml_path, new_xml_path); + } + catch (const sys::filesystem_error& err) + { + error << string_compose(_("could not rename snapshot %1 to %2 (%3)"), + old_name, new_name, err.what()) << endmsg; } } @@ -526,30 +657,31 @@ void Session::remove_state (string snapshot_name) { if (snapshot_name == _current_snapshot_name || snapshot_name == _name) { - /* refuse to remove the current snapshot or the "main" one */ + // refuse to remove the current snapshot or the "main" one return; } - - const string xml_path = _path + snapshot_name + statefile_suffix; - /* make a backup copy of the state file */ - const string bak_path = xml_path + ".bak"; - if (g_file_test (xml_path.c_str(), G_FILE_TEST_EXISTS)) { - copy_file (xml_path, bak_path); + sys::path xml_path(_session_dir->root_path()); + + 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 + // create_backup_file will log the error. + return; } - /* and delete it */ - unlink (xml_path.c_str()); + // and delete it + sys::remove (xml_path); } int Session::save_state (string snapshot_name, bool pending) { XMLTree tree; - string xml_path; - string bak_path; + sys::path xml_path(_session_dir->root_path()); - if (_state_of_the_state & CannotSave) { + if (!_writable || (_state_of_the_state & CannotSave)) { return 1; } @@ -559,6 +691,11 @@ Session::save_state (string snapshot_name, bool pending) 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) + i->second->session_saved(); + tree.set_root (&get_state()); if (snapshot_name.empty()) { @@ -568,61 +705,55 @@ Session::save_state (string snapshot_name, bool pending) if (!pending) { /* proper save: use statefile_suffix (.ardour in English) */ - xml_path = _path; - xml_path += snapshot_name; - xml_path += statefile_suffix; + + xml_path /= legalize_for_path (snapshot_name) + statefile_suffix; /* make a backup copy of the old file */ - bak_path = xml_path; - bak_path += ".bak"; - - if (g_file_test (xml_path.c_str(), G_FILE_TEST_EXISTS)) { - copy_file (xml_path, bak_path); + + if (sys::exists(xml_path) && !create_backup_file (xml_path)) { + // create_backup_file will log the error + return -1; } } else { /* pending save: use pending_suffix (.pending in English) */ - xml_path = _path; - xml_path += snapshot_name; - xml_path += pending_suffix; - + xml_path /= legalize_for_path (snapshot_name) + pending_suffix; } - string tmp_path; + sys::path tmp_path(_session_dir->root_path()); - tmp_path = _path; - tmp_path += snapshot_name; - tmp_path += ".tmp"; + tmp_path /= legalize_for_path (snapshot_name) + temp_suffix; - // cerr << "actually writing state to " << xml_path << endl; + // cerr << "actually writing state to " << xml_path.to_string() << endl; - if (!tree.write (tmp_path)) { - error << string_compose (_("state could not be saved to %1"), tmp_path) << endmsg; - unlink (tmp_path.c_str()); + if (!tree.write (tmp_path.to_string())) { + error << string_compose (_("state could not be saved to %1"), tmp_path.to_string()) << endmsg; + sys::remove (tmp_path); return -1; } else { - if (rename (tmp_path.c_str(), xml_path.c_str()) != 0) { - error << string_compose (_("could not rename temporary session file %1 to %2"), tmp_path, xml_path) << endmsg; - unlink (tmp_path.c_str()); + 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); return -1; } } if (!pending) { - save_history (snapshot_name); + save_history (snapshot_name); bool was_dirty = dirty(); _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty); - + if (was_dirty) { DirtyChanged (); /* EMIT SIGNAL */ } - + StateSaved (snapshot_name); /* EMIT SIGNAL */ } @@ -633,48 +764,41 @@ int 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; } int Session::load_state (string snapshot_name) { - if (state_tree) { - delete state_tree; - state_tree = 0; - } + delete state_tree; + state_tree = 0; - string xmlpath; - state_was_pending = false; /* check for leftover pending state from a crashed capture attempt */ - xmlpath = _path; - xmlpath += snapshot_name; - xmlpath += pending_suffix; + sys::path xmlpath(_session_dir->root_path()); + xmlpath /= legalize_for_path (snapshot_name) + pending_suffix; - if (Glib::file_test (xmlpath, Glib::FILE_TEST_EXISTS)) { + if (sys::exists (xmlpath)) { /* there is pending state from a crashed capture attempt */ - if (AskAboutPendingState()) { + if (*AskAboutPendingState()) { state_was_pending = true; - } - } + } + } if (!state_was_pending) { - - xmlpath = _path; - xmlpath += snapshot_name; - xmlpath += statefile_suffix; + xmlpath = _session_dir->root_path(); + xmlpath /= legalize_for_path (snapshot_name) + statefile_suffix; } - - if (!Glib::file_test (xmlpath, Glib::FILE_TEST_EXISTS)) { - error << string_compose(_("%1: session state information file \"%2\" doesn't exist!"), _name, xmlpath) << endmsg; + + if (!sys::exists (xmlpath)) { + error << string_compose(_("%1: session state information file \"%2\" doesn't exist!"), _name, xmlpath.to_string()) << endmsg; return 1; } @@ -682,51 +806,71 @@ Session::load_state (string snapshot_name) set_dirty(); - if (!state_tree->read (xmlpath)) { - error << string_compose(_("Could not understand ardour file %1"), xmlpath) << endmsg; + /* writable() really reflects the whole folder, but if for any + reason the session state file can't be written to, still + make us unwritable. + */ + + if (::access (xmlpath.to_string().c_str(), W_OK) != 0) { + _writable = false; + } + + if (!state_tree->read (xmlpath.to_string())) { + error << string_compose(_("Could not understand ardour file %1"), xmlpath.to_string()) << endmsg; delete state_tree; state_tree = 0; return -1; } XMLNode& root (*state_tree->root()); - + if (root.name() != X_("Session")) { - error << string_compose (_("Session file %1 is not an Ardour session"), xmlpath) << endmsg; + error << string_compose (_("Session file %1 is not an Ardour session"), xmlpath.to_string()) << endmsg; delete state_tree; state_tree = 0; return -1; } const XMLProperty* prop; - bool is_old = false; 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()); // 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 (Stateful::loading_state_version < CURRENT_SESSION_FILE_VERSION) { - if (is_old) { - string backup_path; + sys::path backup_path(_session_dir->root_path()); - backup_path = _path; - backup_path += snapshot_name; - backup_path += "-1"; - backup_path += 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, backup_path) + xmlpath.to_string(), backup_path.to_string()) << endmsg; - copy_file (xmlpath, backup_path); - - /* if it fails, don't worry. right? */ + try + { + sys::copy_file (xmlpath, backup_path); + } + catch(sys::filesystem_error& ex) + { + error << string_compose (_("Unable to make backup of state file %1 (%2)"), + xmlpath.to_string(), ex.what()) + << endmsg; + return -1; + } } return 0; @@ -735,44 +879,11 @@ Session::load_state (string snapshot_name) int Session::load_options (const XMLNode& node) { - XMLNode* child; - XMLProperty* prop; LocaleGuard lg (X_("POSIX")); - - Config->set_variables (node, ConfigVariableBase::Session); - - if ((child = find_named_node (node, "end-marker-is-free")) != 0) { - if ((prop = child->property ("val")) != 0) { - _end_location_is_free = (prop->value() == "yes"); - } - } - + config.set_variables (node); return 0; } -bool -Session::save_config_options_predicate (ConfigVariableBase::Owner owner) const -{ - const ConfigVariableBase::Owner modified_by_session_or_user = (ConfigVariableBase::Owner) - (ConfigVariableBase::Session|ConfigVariableBase::Interface); - - return owner & modified_by_session_or_user; -} - -XMLNode& -Session::get_options () const -{ - XMLNode* child; - LocaleGuard lg (X_("POSIX")); - - XMLNode& option_root = Config->get_variables (mem_fun (*this, &Session::save_config_options_predicate)); - - child = option_root.add_child ("end-marker-is-free"); - child->add_property ("val", _end_location_is_free ? "yes" : "no"); - - return option_root; -} - XMLNode& Session::get_state() { @@ -784,9 +895,9 @@ Session::get_template() { /* 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); @@ -800,16 +911,16 @@ Session::state(bool full_state) // store libardour version, just in case char buf[16]; - snprintf(buf, sizeof(buf)-1, "%d.%d.%d", - libardour_major_version, libardour_minor_version, libardour_micro_version); + 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) { - - /* store the name */ + node->add_property ("name", _name); + snprintf (buf, sizeof (buf), "%" PRId32, _nominal_frame_rate); + node->add_property ("sample-rate", buf); if (session_dirs.size() > 1) { @@ -835,20 +946,22 @@ Session::state(bool full_state) ++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); /* various options */ - node->add_child_nocopy (get_options()); + node->add_child_nocopy (config.get_variables ()); + + node->add_child_nocopy (_metadata->get_state()); child = node->add_child ("Sources"); @@ -856,35 +969,30 @@ Session::state(bool full_state) Glib::Mutex::Lock sl (source_lock); for (SourceMap::iterator siter = sources.begin(); siter != sources.end(); ++siter) { - - /* Don't save information about AudioFileSources that are empty */ - - boost::shared_ptr fs; - - if ((fs = boost::dynamic_pointer_cast (siter->second)) != 0) { - /* Don't save sources that are empty, unless they're destructive (which are OK - if they are empty, because we will re-use them every time.) - */ + /* 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 fs; + if ((fs = boost::dynamic_pointer_cast (siter->second)) != 0) { if (!fs->destructive()) { - if (fs->length() == 0) { + if (fs->length(fs->timeline_position()) == 0) { continue; } } } - + 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) { @@ -895,7 +1003,7 @@ Session::state(bool full_state) child = node->add_child ("DiskStreams"); - { + { boost::shared_ptr dsl = diskstreams.reader(); for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) { if (!(*i)->hidden()) { @@ -918,13 +1026,14 @@ Session::state(bool full_state) loc.add (end); node->add_child_nocopy (loc.get_state()); } - - child = node->add_child ("Connections"); + + child = node->add_child ("Bundles"); { - Glib::Mutex::Lock lm (bundle_lock); - for (BundleList::iterator i = _bundles.begin(); i != _bundles.end(); ++i) { - if (!(*i)->dynamic()) { - child->add_child_nocopy ((*i)->get_state()); + boost::shared_ptr bundles = _bundles.reader (); + for (BundleList::iterator i = bundles->begin(); i != bundles->end(); ++i) { + boost::shared_ptr b = boost::dynamic_pointer_cast (*i); + if (b) { + child->add_child_nocopy (b->get_state()); } } } @@ -932,13 +1041,13 @@ Session::state(bool full_state) child = node->add_child ("Routes"); { boost::shared_ptr r = routes.reader (); - + RoutePublicOrderSorter cmp; RouteList public_order (*r); public_order.sort (cmp); - + for (RouteList::iterator i = public_order.begin(); i != public_order.end(); ++i) { - if (!(*i)->hidden()) { + if (!(*i)->is_hidden()) { if (full_state) { child->add_child_nocopy ((*i)->get_state()); } else { @@ -948,44 +1057,13 @@ Session::state(bool full_state) } } - - child = node->add_child ("EditGroups"); - for (list::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::iterator i = mix_groups.begin(); i != mix_groups.end(); ++i) { + child = node->add_child ("RouteGroups"); + for (list::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)); @@ -996,7 +1074,7 @@ Session::state(bool full_state) for (NamedSelectionList::iterator i = named_selections.begin(); i != named_selections.end(); ++i) { if (full_state) { child->add_child_nocopy ((*i)->get_state()); - } + } } } @@ -1019,7 +1097,7 @@ Session::get_control_protocol_state () } int -Session::set_state (const XMLNode& node) +Session::set_state (const XMLNode& node, int version) { XMLNodeList nlist; XMLNode* child; @@ -1027,17 +1105,32 @@ Session::set_state (const XMLNode& node) int ret = -1; _state_of_the_state = StateOfTheState (_state_of_the_state|CannotSave); - + if (node.name() != X_("Session")){ fatal << _("programming error: Session: incorrect XML node sent to set_state()") << endmsg; return -1; } + if ((prop = node.property ("version")) != 0) { + version = atoi (prop->value ()) * 1000; + } + if ((prop = node.property ("name")) != 0) { _name = prop->value (); } - setup_raid_path(_path); + if ((prop = node.property (X_("sample-rate"))) != 0) { + + _nominal_frame_rate = atoi (prop->value()); + + if (_nominal_frame_rate != _current_frame_rate) { + if (*AskAboutSampleRateMismatch (_nominal_frame_rate, _current_frame_rate)) { + return -1; + } + } + } + + setup_raid_path(_session_dir->root_path().to_string()); if ((prop = node.property (X_("id-counter"))) != 0) { uint64_t x; @@ -1053,32 +1146,29 @@ Session::set_state (const XMLNode& node) ID::init_counter (now); } - - IO::disable_ports (); + IO::disable_connecting (); /* Object loading order: - MIDI Control Path - extra + Extra Options/Config + MIDI Control // relies on data from Options/Config + Metadata Locations Sources AudioRegions AudioDiskstreams Connections Routes - EditGroups + RouteGroups MixGroups Click ControlProtocols */ - if (use_config_midi_ports ()) { - } - - if ((child = find_named_node (node, "extra")) != 0) { + if ((child = find_named_node (node, "Extra")) != 0) { _extra_xml = new XMLNode (*child); } @@ -1090,10 +1180,21 @@ Session::set_state (const XMLNode& node) 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, "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; } @@ -1140,13 +1241,13 @@ Session::set_state (const XMLNode& node) 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; } @@ -1163,47 +1264,64 @@ Session::set_state (const XMLNode& node) goto out; } - if ((child = find_named_node (node, "Connections")) == 0) { - error << _("Session: XML state has no connections section") << endmsg; - goto out; - } else if (load_bundles (*child)) { - goto out; - } - - 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 ((child = find_named_node (node, "MixGroups")) == 0) { - error << _("Session: XML state has no mix groups section") << endmsg; - goto out; - } else if (load_mix_groups (*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, "TempoMap")) == 0) { error << _("Session: XML state has no Tempo Map section") << endmsg; goto out; - } else if (_tempo_map->set_state (*child)) { + } else if (_tempo_map->set_state (*child, version)) { goto out; } if ((child = find_named_node (node, "Routes")) == 0) { error << _("Session: XML state has no routes section") << endmsg; goto out; - } else if (load_routes (*child)) { + } else if (load_routes (*child, version)) { goto out; } + if (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) { ControlProtocolManager::instance().set_protocol_states (*child); } @@ -1212,14 +1330,6 @@ Session::set_state (const XMLNode& node) StateReady (); /* EMIT SIGNAL */ - _state_of_the_state = Clean; - - if (state_was_pending) { - save_state (_current_snapshot_name); - remove_pending_capture_state (); - state_was_pending = false; - } - return 0; out: @@ -1227,7 +1337,7 @@ Session::set_state (const XMLNode& node) } int -Session::load_routes (const XMLNode& node) +Session::load_routes (const XMLNode& node, int version) { XMLNodeList nlist; XMLNodeConstIterator niter; @@ -1239,49 +1349,58 @@ Session::load_routes (const XMLNode& node) for (niter = nlist.begin(); niter != nlist.end(); ++niter) { - boost::shared_ptr route (XMLRouteFactory (**niter)); + boost::shared_ptr route (XMLRouteFactory (**niter, version)); if (route == 0) { - error << _("Session: cannot create Route from XML description.") << endmsg; + error << _("Session: cannot create Route from XML description.") << endmsg; return -1; } + BootMessage (string_compose (_("Loaded track/bus %1"), route->name())); + new_routes.push_back (route); } - add_routes (new_routes); + add_routes (new_routes, false); return 0; } boost::shared_ptr -Session::XMLRouteFactory (const XMLNode& node) +Session::XMLRouteFactory (const XMLNode& node, int version) { if (node.name() != "Route") { return boost::shared_ptr ((Route*) 0); } bool has_diskstream = (node.property ("diskstream") != 0 || node.property ("diskstream-id") != 0); - + DataType type = DataType::AUDIO; const XMLProperty* prop = node.property("default-type"); - if (prop) + boost::shared_ptr ret; + + if (prop) { type = DataType(prop->value()); - + } + assert(type != DataType::NIL); if (has_diskstream) { if (type == DataType::AUDIO) { - boost::shared_ptr ret (new AudioTrack (*this, node)); - return ret; + AudioTrack* at = new AudioTrack (*this, node, version); + boost_debug_shared_ptr_mark_interesting (at, "Track"); + ret.reset (at); + } else { - boost::shared_ptr ret (new MidiTrack (*this, node)); - return ret; + ret.reset (new MidiTrack (*this, node, version)); } } else { - boost::shared_ptr ret (new Route (*this, node)); - return ret; + Route* rt = new Route (*this, node); + boost_debug_shared_ptr_mark_interesting (rt, "Route"); + ret.reset (rt); } + + return ret; } int @@ -1297,7 +1416,14 @@ Session::load_regions (const XMLNode& node) for (niter = nlist.begin(); niter != nlist.end(); ++niter) { if ((region = XMLRegionFactory (**niter, false)) == 0) { - error << _("Session: cannot create Region from XML description.") << endmsg; + error << _("Session: cannot create Region from XML description."); + const XMLProperty *name = (**niter).property("name"); + + if (name) { + error << " " << string_compose (_("Can not load state for region '%1'"), name->value()); + } + + error << endmsg; } } @@ -1310,17 +1436,17 @@ Session::XMLRegionFactory (const XMLNode& node, bool full) const XMLProperty* type = node.property("type"); try { - + if ( !type || type->value() == "audio" ) { return boost::shared_ptr(XMLAudioRegionFactory (node, full)); - + } else if (type->value() == "midi") { - + return boost::shared_ptr(XMLMidiRegionFactory (node, full)); } - + } catch (failed_constructor& err) { return boost::shared_ptr (); } @@ -1329,15 +1455,16 @@ Session::XMLRegionFactory (const XMLNode& node, bool full) } boost::shared_ptr -Session::XMLAudioRegionFactory (const XMLNode& node, bool full) +Session::XMLAudioRegionFactory (const XMLNode& node, bool /*full*/) { const XMLProperty* prop; boost::shared_ptr source; boost::shared_ptr as; SourceList sources; + SourceList master_sources; uint32_t nchans = 1; char buf[128]; - + if (node.name() != X_("Region")) { return boost::shared_ptr(); } @@ -1350,7 +1477,7 @@ Session::XMLAudioRegionFactory (const XMLNode& node, bool full) 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; @@ -1364,7 +1491,7 @@ Session::XMLAudioRegionFactory (const XMLNode& node, bool full) error << string_compose(_("Session: XMLNode describing a AudioRegion references an unknown source id =%1"), s_id) << endmsg; return boost::shared_ptr(); } - + as = boost::dynamic_pointer_cast(source); if (!as) { error << string_compose(_("Session: XMLNode describing a AudioRegion references a non-audio source id =%1"), s_id) << endmsg; @@ -1378,14 +1505,14 @@ Session::XMLAudioRegionFactory (const XMLNode& node, bool full) 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(); } - + as = boost::dynamic_pointer_cast(source); if (!as) { error << string_compose(_("Session: XMLNode describing a AudioRegion references a non-audio source id =%1"), id2) << endmsg; @@ -1394,7 +1521,27 @@ Session::XMLAudioRegionFactory (const XMLNode& node, bool full) sources.push_back (as); } } - + + 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(); + } + + as = boost::dynamic_pointer_cast(source); + if (!as) { + error << string_compose(_("Session: XMLNode describing a AudioRegion references a non-audio source id =%1"), id2) << endmsg; + return boost::shared_ptr(); + } + master_sources.push_back (as); + } + } + try { boost::shared_ptr region (boost::dynamic_pointer_cast (RegionFactory::create (sources, node))); @@ -1409,8 +1556,16 @@ Session::XMLAudioRegionFactory (const XMLNode& node, bool full) } } + if (!master_sources.empty()) { + if (master_sources.size() != nchans) { + error << _("Session: XMLNode describing an AudioRegion is missing some master sources; ignored") << endmsg; + } else { + region->set_master_sources (master_sources); + } + } + return region; - + } catch (failed_constructor& err) { @@ -1419,14 +1574,14 @@ Session::XMLAudioRegionFactory (const XMLNode& node, bool full) } boost::shared_ptr -Session::XMLMidiRegionFactory (const XMLNode& node, bool full) +Session::XMLMidiRegionFactory (const XMLNode& node, bool /*full*/) { const XMLProperty* prop; boost::shared_ptr source; boost::shared_ptr ms; SourceList sources; uint32_t nchans = 1; - + if (node.name() != X_("Region")) { return boost::shared_ptr(); } @@ -1434,7 +1589,7 @@ Session::XMLMidiRegionFactory (const XMLNode& node, bool full) 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 (); @@ -1501,23 +1656,29 @@ Session::get_sources_as_xml () } string -Session::path_from_region_name (string name, string identifier) +Session::path_from_region_name (DataType type, string name, string identifier) { char buf[PATH_MAX+1]; uint32_t n; SessionDirectory sdir(get_best_session_directory_for_new_source()); - string sound_dir = sdir.sound_path().to_string(); + sys::path source_dir = ((type == DataType::AUDIO) + ? sdir.sound_path() : sdir.midi_path()); + + string ext = ((type == DataType::AUDIO) ? ".wav" : ".mid"); for (n = 0; n < 999999; ++n) { if (identifier.length()) { - snprintf (buf, sizeof(buf), "%s/%s%s%" PRIu32 ".wav", sound_dir.c_str(), name.c_str(), - identifier.c_str(), n); + snprintf (buf, sizeof(buf), "%s%s%" PRIu32 "%s", name.c_str(), + identifier.c_str(), n, ext.c_str()); } else { - snprintf (buf, sizeof(buf), "%s/%s-%" PRIu32 ".wav", sound_dir.c_str(), name.c_str(), n); + snprintf (buf, sizeof(buf), "%s-%" PRIu32 "%s", name.c_str(), + n, ext.c_str()); } - if (!Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) { - return buf; + sys::path source_path = source_dir / buf; + + if (!sys::exists (source_path)) { + return source_path.to_string(); } } @@ -1527,7 +1688,7 @@ Session::path_from_region_name (string name, string identifier) return ""; } - + int Session::load_sources (const XMLNode& node) @@ -1541,14 +1702,11 @@ Session::load_sources (const XMLNode& node) set_dirty(); for (niter = nlist.begin(); niter != nlist.end(); ++niter) { - try { if ((source = XMLSourceFactory (**niter)) == 0) { error << _("Session: cannot create Source from XML description.") << endmsg; } - } - - catch (non_existent_source& err) { + } 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); } @@ -1565,7 +1723,8 @@ Session::XMLSourceFactory (const XMLNode& node) } try { - return SourceFactory::create (*this, node); + /* note: do peak building in another thread when loading session state */ + return SourceFactory::create (*this, node, true); } catch (failed_constructor& err) { @@ -1578,40 +1737,37 @@ int Session::save_template (string template_name) { XMLTree tree; - string xml_path, bak_path, template_path; if (_state_of_the_state & CannotSave) { return -1; } - DIR* dp; - string dir = template_dir(); + sys::path user_template_dir(user_template_directory()); - if ((dp = opendir (dir.c_str()))) { - closedir (dp); - } else { - if (g_mkdir_with_parents (dir.c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) { - error << string_compose(_("Could not create mix templates directory \"%1\" (%2)"), dir, strerror (errno)) << endmsg; - return -1; - } + try + { + sys::create_directories (user_template_dir); + } + catch(sys::filesystem_error& ex) + { + error << string_compose(_("Could not create mix templates directory \"%1\" (%2)"), + user_template_dir.to_string(), ex.what()) << endmsg; + return -1; } tree.set_root (&get_template()); - xml_path = dir; - xml_path += template_name; - xml_path += template_suffix; + sys::path template_file_path(user_template_dir); + template_file_path /= template_name + template_suffix; - ifstream in(xml_path.c_str()); - - if (in) { - warning << string_compose(_("Template \"%1\" already exists - new version not created"), template_name) << endmsg; + if (sys::exists (template_file_path)) + { + warning << string_compose(_("Template \"%1\" already exists - new version not created"), + template_file_path.to_string()) << endmsg; return -1; - } else { - in.close(); } - if (!tree.write (xml_path)) { + if (!tree.write (template_file_path.to_string())) { error << _("mix template not saved") << endmsg; return -1; } @@ -1620,22 +1776,40 @@ Session::save_template (string template_name) } int -Session::rename_template (string old_name, string new_name) +Session::rename_template (string old_name, string new_name) { - string old_path = template_dir() + old_name + template_suffix; - string new_path = template_dir() + new_name + template_suffix; + 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; + + if (sys::exists (new_path)) { + warning << string_compose(_("Template \"%1\" already exists - template not renamed"), + new_path.to_string()) << endmsg; + return -1; + } - return rename (old_path.c_str(), new_path.c_str()); + try { + sys::rename (old_path, new_path); + return 0; + } catch (...) { + return -1; + } } int -Session::delete_template (string name) +Session::delete_template (string name) { - string template_path = template_dir(); - template_path += name; - template_path += template_suffix; + sys::path path = user_template_directory(); + path /= name + template_suffix; - return remove (template_path.c_str()); + try { + sys::remove (path); + return 0; + } catch (...) { + return -1; + } } void @@ -1650,7 +1824,7 @@ Session::refresh_disk_space () /* 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); @@ -1675,8 +1849,8 @@ Session::get_best_session_directory_for_new_source () } /* 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 @@ -1695,15 +1869,15 @@ Session::get_best_session_directory_for_new_source () 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) { @@ -1739,13 +1913,13 @@ Session::get_best_session_directory_for_new_source () /* pick FS with the most freespace (and that seems to actually work ...) */ - + vector 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; @@ -1758,65 +1932,6 @@ Session::get_best_session_directory_for_new_source () return result; } -int -Session::load_playlists (const XMLNode& node) -{ - XMLNodeList nlist; - XMLNodeConstIterator niter; - boost::shared_ptr 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; - } - } - - return 0; -} - -int -Session::load_unused_playlists (const XMLNode& node) -{ - XMLNodeList nlist; - XMLNodeConstIterator niter; - boost::shared_ptr 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)); - } - - return 0; -} - -boost::shared_ptr -Session::XMLPlaylistFactory (const XMLNode& node) -{ - try { - return PlaylistFactory::create (*this, node); - } - - catch (failed_constructor& err) { - return boost::shared_ptr(); - } -} - int Session::load_named_selections (const XMLNode& node) { @@ -1829,7 +1944,7 @@ Session::load_named_selections (const XMLNode& node) 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; } @@ -1853,68 +1968,17 @@ Session::XMLNamedSelectionFactory (const XMLNode& node) string Session::automation_dir () const { - string res = _path; - res += "automation/"; - return res; -} - -string -Session::template_dir () -{ - string path = get_user_ardour_path(); - path += "templates/"; - - return path; -} - -string -Session::suffixed_search_path (string suffix, bool data) -{ - string path; - - path += get_user_ardour_path(); - if (path[path.length()-1] != ':') { - path += ':'; - } - - if (data) { - path += get_system_data_path(); - } else { - path += get_system_module_path(); - } - - vector split_path; - - split (path, split_path, ':'); - path = ""; - - for (vector::iterator i = split_path.begin(); i != split_path.end(); ++i) { - path += *i; - path += suffix; - path += '/'; - - if (distance (i, split_path.end()) != 1) { - path += ':'; - } - } - - return path; -} - -string -Session::template_path () -{ - return suffixed_search_path (templates_dir_name, true); + return Glib::build_filename (_path, "automation"); } string -Session::control_protocol_path () +Session::analysis_dir () const { - return suffixed_search_path (surfaces_dir_name, false); + return Glib::build_filename (_path, "analysis"); } int -Session::load_bundles (const XMLNode& node) +Session::load_bundles (XMLNode const & node) { XMLNodeList nlist = node.children(); XMLNodeConstIterator niter; @@ -1922,60 +1986,62 @@ Session::load_bundles (const XMLNode& node) set_dirty(); for (niter = nlist.begin(); niter != nlist.end(); ++niter) { - if ((*niter)->name() == "InputConnection") { - add_bundle (new ARDOUR::InputBundle (**niter)); - } else if ((*niter)->name() == "OutputConnection") { - add_bundle (new ARDOUR::OutputBundle (**niter)); + if ((*niter)->name() == "InputBundle") { + add_bundle (boost::shared_ptr (new UserBundle (**niter, true))); + } else if ((*niter)->name() == "OutputBundle") { + add_bundle (boost::shared_ptr (new UserBundle (**niter, false))); } else { - error << string_compose(_("Unknown node \"%1\" found in Connections list from state file"), (*niter)->name()) << endmsg; + 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; - RouteGroup* rg; - set_dirty(); + set_dirty (); - for (niter = nlist.begin(); niter != nlist.end(); ++niter) { - if ((*niter)->name() == "RouteGroup") { - if (edit) { - rg = add_edit_group (""); - rg->set_state (**niter); - } else { - rg = add_mix_group (""); - 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; -} -static bool -state_file_filter (const string &str, void *arg) -{ - return (str.length() > strlen(statefile_suffix) && - str.find (statefile_suffix) == (str.length() - strlen (statefile_suffix))); + return 0; +} + +void +Session::auto_save() +{ + save_state (_current_snapshot_name); +} + +static bool +state_file_filter (const string &str, void */*arg*/) +{ + return (str.length() > strlen(statefile_suffix) && + str.find (statefile_suffix) == (str.length() - strlen (statefile_suffix))); } struct string_cmp { @@ -1988,12 +2054,12 @@ static string* remove_end(string* state) { string statename(*state); - + string::size_type start,end; if ((start = statename.find_last_of ('/')) != string::npos) { statename = statename.substr (start+1); } - + if ((end = statename.rfind(".ardour")) == string::npos) { end = statename.length(); } @@ -2002,16 +2068,16 @@ remove_end(string* state) } vector * -Session::possible_states (string path) +Session::possible_states (string path) { PathScanner scanner; vector* 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; } @@ -2022,78 +2088,33 @@ Session::possible_states () const } void -Session::auto_save() +Session::add_route_group (RouteGroup* g) { - save_state (_current_snapshot_name); -} - -RouteGroup * -Session::add_edit_group (string name) -{ - RouteGroup* rg = new RouteGroup (*this, name); - edit_groups.push_back (rg); - edit_group_added (rg); /* EMIT SIGNAL */ - set_dirty(); - return rg; -} - -RouteGroup * -Session::add_mix_group (string name) -{ - RouteGroup* rg = new RouteGroup (*this, name, RouteGroup::Relative); - mix_groups.push_back (rg); - mix_group_added (rg); /* EMIT SIGNAL */ - set_dirty(); - return rg; + _route_groups.push_back (g); + route_group_added (g); /* EMIT SIGNAL */ + set_dirty (); } void -Session::remove_edit_group (RouteGroup& rg) +Session::remove_route_group (RouteGroup& rg) { list::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 */ - } - - delete &rg; -} + if ((i = find (_route_groups.begin(), _route_groups.end(), &rg)) != _route_groups.end()) { + _route_groups.erase (i); + delete &rg; -void -Session::remove_mix_group (RouteGroup& rg) -{ - list::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_group_removed (); /* EMIT SIGNAL */ } - delete &rg; -} - -RouteGroup * -Session::mix_group_by_name (string name) -{ - list::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::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; } @@ -2101,153 +2122,71 @@ Session::edit_group_by_name (string name) return 0; } -void -Session::begin_reversible_command (string name) +UndoTransaction* +Session::start_reversible_command (const string& name) { - current_trans = new UndoTransaction; - current_trans->set_name (name); + UndoTransaction* trans = new UndoTransaction(); + trans->set_name(name); + return trans; } void -Session::commit_reversible_command (Command *cmd) +Session::finish_reversible_command (UndoTransaction& ut) { struct timeval now; - - if (cmd) { - current_trans->add_command (cmd); - } - - gettimeofday (&now, 0); - current_trans->set_timestamp (now); - - _history.add (current_trans); -} - -Session::GlobalRouteBooleanState -Session::get_global_route_boolean (bool (Route::*method)(void) const) -{ - GlobalRouteBooleanState s; - boost::shared_ptr r = routes.reader (); - - for (RouteList::iterator i = r->begin(); i != r->end(); ++i) { - if (!(*i)->hidden()) { - RouteBooleanState v; - - v.first =* i; - Route* r = (*i).get(); - v.second = (r->*method)(); - - s.push_back (v); - } - } - - return s; -} - -Session::GlobalRouteMeterState -Session::get_global_route_metering () -{ - GlobalRouteMeterState s; - boost::shared_ptr r = routes.reader (); - - for (RouteList::iterator i = r->begin(); i != r->end(); ++i) { - if (!(*i)->hidden()) { - RouteMeterState v; - - v.first =* i; - v.second = (*i)->meter_point(); - - s.push_back (v); - } - } - - return s; + gettimeofday(&now, 0); + ut.set_timestamp(now); + _history.add (&ut); } void -Session::set_global_route_metering (GlobalRouteMeterState s, void* arg) +Session::begin_reversible_command(const string& name) { - for (GlobalRouteMeterState::iterator i = s.begin(); i != s.end(); ++i) { + UndoTransaction* trans = new UndoTransaction(); + trans->set_name(name); - boost::shared_ptr r = (i->first.lock()); - - if (r) { - r->set_meter_point (i->second, arg); - } + if (!_current_trans.empty()) { + _current_trans.top()->add_command (trans); + } else { + _current_trans.push(trans); } } void -Session::set_global_route_boolean (GlobalRouteBooleanState s, void (Route::*method)(bool, void*), void* arg) +Session::commit_reversible_command(Command *cmd) { - for (GlobalRouteBooleanState::iterator i = s.begin(); i != s.end(); ++i) { - - boost::shared_ptr r = (i->first.lock()); + assert(!_current_trans.empty()); + struct timeval now; - if (r) { - Route* rp = r.get(); - (rp->*method) (i->second, arg); - } + if (cmd) { + _current_trans.top()->add_command(cmd); } -} -void -Session::set_global_mute (GlobalRouteBooleanState s, void* src) -{ - set_global_route_boolean (s, &Route::set_mute, src); -} - -void -Session::set_global_solo (GlobalRouteBooleanState s, void* src) -{ - set_global_route_boolean (s, &Route::set_solo, src); -} - -void -Session::set_global_record_enable (GlobalRouteBooleanState s, void* src) -{ - set_global_route_boolean (s, &Route::set_record_enable, src); -} - -#if 0 -UndoAction -Session::global_mute_memento (void* src) -{ - return sigc::bind (mem_fun (*this, &Session::set_global_mute), get_global_route_boolean (&Route::muted), src); -} - -UndoAction -Session::global_metering_memento (void* src) -{ - return sigc::bind (mem_fun (*this, &Session::set_global_route_metering), get_global_route_metering (), src); -} + if (_current_trans.top()->empty()) { + _current_trans.pop(); + return; + } -UndoAction -Session::global_solo_memento (void* src) -{ - return sigc::bind (mem_fun (*this, &Session::set_global_solo), get_global_route_boolean (&Route::soloed), src); -} + gettimeofday(&now, 0); + _current_trans.top()->set_timestamp(now); -UndoAction -Session::global_record_enable_memento (void* src) -{ - return sigc::bind (mem_fun (*this, &Session::set_global_record_enable), get_global_route_boolean (&Route::record_enabled), src); + _history.add(_current_trans.top()); + _current_trans.pop(); } -#endif static bool -accept_all_non_peak_files (const string& path, void *arg) +accept_all_non_peak_files (const string& path, void */*arg*/) { return (path.length() > 5 && path.find (peakfile_suffix) != (path.length() - 5)); } static bool -accept_all_state_files (const string& path, void *arg) +accept_all_state_files (const string& path, void */*arg*/) { return (path.length() > 7 && path.find (".ardour") == (path.length() - 7)); } -int +int Session::find_all_sources (string path, set& result) { XMLTree tree; @@ -2269,9 +2208,15 @@ Session::find_all_sources (string path, set& result) 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; } @@ -2281,11 +2226,13 @@ Session::find_all_sources (string path, set& result) continue; } - sys::path source_path = _session_dir->sound_path (); - - source_path /= prop->value (); + Glib::ustring found_path; + bool is_new; + uint16_t chan; - result.insert (source_path.to_string ()); + if (FileSource::find (type, prop->value(), true, is_new, chan, found_path)) { + result.insert (found_path); + } } return 0; @@ -2308,14 +2255,14 @@ Session::find_all_sources_across_snapshots (set& result, bool exclude_th } 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::iterator i = state_files->begin(); i != state_files->end(); ++i) { @@ -2337,17 +2284,22 @@ struct RegionCounter { AudioSourceList::iterator iter; boost::shared_ptr region; uint32_t count; - + RegionCounter() : count (0) {} }; int -Session::cleanup_sources (Session::cleanup_report& rep) +Session::ask_about_playlist_deletion (boost::shared_ptr p) +{ + return *AskAboutPlaylistDeletion (p); +} + +int +Session::cleanup_sources (CleanupReport& rep) { // FIXME: needs adaptation to midi - + vector > dead_sources; - vector > playlists_tbd; PathScanner scanner; string sound_path; vector::iterator i; @@ -2358,47 +2310,23 @@ Session::cleanup_sources (Session::cleanup_report& rep) 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; - - case 0: - playlists_tbd.push_back (*x); - break; - default: - /* leave it alone */ - break; - } - } - - /* now delete any that were marked for deletion */ + _state_of_the_state = (StateOfTheState) (_state_of_the_state | InCleanup); - for (vector >::iterator x = playlists_tbd.begin(); x != playlists_tbd.end(); ++x) { - (*x)->drop_references (); + /* step 1: consider deleting all unused playlists */ + + if (playlists->maybe_delete_unused (boost::bind (Session::ask_about_playlist_deletion, _1))) { + ret = 0; + goto out; } - playlists_tbd.clear (); - /* step 2: 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; @@ -2408,10 +2336,10 @@ Session::cleanup_sources (Session::cleanup_report& rep) capture files. */ - if (!i->second->used() && i->second->length() > 0) { + if (!playlists->source_use_count(i->second) && i->second->length(i->second->timeline_position()) > 0) { dead_sources.push_back (i->second); - i->second->GoingAway(); - } + i->second->drop_references (); + } i = tmp; } @@ -2433,7 +2361,7 @@ Session::cleanup_sources (Session::cleanup_report& rep) i = nexti; } - /* now do the same thing for the files that ended up in the sounds dir(s) + /* now do the same thing for the files that ended up in the sounds dir(s) but are not referenced as sources in any snapshot. */ @@ -2447,23 +2375,23 @@ Session::cleanup_sources (Session::cleanup_report& rep) state file on disk still references sources we may have already dropped. */ - + find_all_sources_across_snapshots (all_sources, true); /* add our current source list */ - + for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) { - boost::shared_ptr fs; - - if ((fs = boost::dynamic_pointer_cast (i->second)) != 0) { + boost::shared_ptr fs; + + if ((fs = boost::dynamic_pointer_cast (i->second)) != 0) { all_sources.insert (fs->path()); - } + } } char tmppath1[PATH_MAX+1]; char tmppath2[PATH_MAX+1]; - + for (vector::iterator x = soundfiles->begin(); x != soundfiles->end(); ++x) { used = false; @@ -2496,7 +2424,7 @@ Session::cleanup_sources (Session::cleanup_report& rep) } string newpath; - + /* don't move the file across filesystems, just stick it in the `dead_sound_dir_name' directory on whichever filesystem it was already on. @@ -2506,14 +2434,14 @@ Session::cleanup_sources (Session::cleanup_report& rep) /* old school, go up 1 level */ - newpath = Glib::path_get_dirname (*x); // "sounds" + newpath = Glib::path_get_dirname (*x); // "sounds" newpath = Glib::path_get_dirname (newpath); // "session-name" } else { /* new school, go up 4 levels */ - - newpath = Glib::path_get_dirname (*x); // "audiofiles" + + newpath = Glib::path_get_dirname (*x); // "audiofiles" newpath = Glib::path_get_dirname (newpath); // "session-name" newpath = Glib::path_get_dirname (newpath); // "interchange" newpath = Glib::path_get_dirname (newpath); // "session-dir" @@ -2523,21 +2451,21 @@ Session::cleanup_sources (Session::cleanup_report& rep) newpath += dead_sound_dir_name; if (g_mkdir_with_parents (newpath.c_str(), 0755) < 0) { - error << string_compose(_("Session: cannot create session peakfile dir \"%1\" (%2)"), newpath, strerror (errno)) << endmsg; + error << string_compose(_("Session: cannot create session peakfile folder \"%1\" (%2)"), newpath, strerror (errno)) << endmsg; return -1; } newpath += '/'; newpath += Glib::path_get_basename ((*x)); - + if (access (newpath.c_str(), F_OK) == 0) { - + /* the new path already exists, try versioning */ - + char buf[PATH_MAX+1]; int version = 1; string newpath_v; - + snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), version); newpath_v = buf; @@ -2545,7 +2473,7 @@ Session::cleanup_sources (Session::cleanup_report& rep) 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) @@ -2553,11 +2481,11 @@ Session::cleanup_sources (Session::cleanup_report& rep) } else { newpath = newpath_v; } - + } else { - + /* it doesn't exist, or we can't read it or something */ - + } if (::rename ((*x).c_str(), newpath.c_str()) != 0) { @@ -2594,19 +2522,20 @@ Session::cleanup_sources (Session::cleanup_report& rep) /* save state so we don't end up a session file referring to non-existent sources. */ - + save_state (""); out: _state_of_the_state = (StateOfTheState) (_state_of_the_state & ~InCleanup); + return ret; } int -Session::cleanup_trash_sources (Session::cleanup_report& rep) +Session::cleanup_trash_sources (CleanupReport& rep) { // FIXME: needs adaptation for MIDI - + vector::iterator i; string dead_sound_dir; struct dirent* dentry; @@ -2617,7 +2546,7 @@ Session::cleanup_trash_sources (Session::cleanup_report& rep) 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; @@ -2628,8 +2557,8 @@ Session::cleanup_trash_sources (Session::cleanup_report& rep) while ((dentry = readdir (dead)) != 0) { /* avoid '.' and '..' */ - - if ((dentry->d_name[0] == '.' && dentry->d_name[1] == '\0') || + + if ((dentry->d_name[0] == '.' && dentry->d_name[1] == '\0') || (dentry->d_name[2] == '\0' && dentry->d_name[0] == '.' && dentry->d_name[1] == '.')) { continue; } @@ -2659,7 +2588,7 @@ Session::cleanup_trash_sources (Session::cleanup_report& rep) } closedir (dead); - + } return 0; @@ -2672,6 +2601,7 @@ Session::set_dirty () _state_of_the_state = StateOfTheState (_state_of_the_state | Dirty); + if (!was_dirty) { DirtyChanged(); /* EMIT SIGNAL */ } @@ -2682,9 +2612,10 @@ void Session::set_clean () { bool was_dirty = dirty(); - + _state_of_the_state = Clean; + if (was_dirty) { DirtyChanged(); /* EMIT SIGNAL */ } @@ -2697,7 +2628,13 @@ Session::set_deletion_in_progress () } void -Session::add_controllable (Controllable* c) +Session::clear_deletion_in_progress () +{ + _state_of_the_state = StateOfTheState (_state_of_the_state & (~Deletion)); +} + +void +Session::add_controllable (boost::shared_ptr c) { /* this adds a controllable to the list managed by the Session. this is a subset of those managed by the Controllable class @@ -2709,6 +2646,8 @@ Session::add_controllable (Controllable* c) controllables.insert (c); } +struct null_deleter { void operator()(void const *) const {} }; + void Session::remove_controllable (Controllable* c) { @@ -2718,32 +2657,152 @@ Session::remove_controllable (Controllable* c) Glib::Mutex::Lock lm (controllables_lock); - Controllables::iterator x = controllables.find (c); + Controllables::iterator x = controllables.find (boost::shared_ptr(c, null_deleter())); if (x != controllables.end()) { controllables.erase (x); } -} +} -Controllable* +boost::shared_ptr 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 0; + return boost::shared_ptr(); } -void -Session::add_instant_xml (XMLNode& node) +boost::shared_ptr +Session::controllable_by_descriptor (const ControllableDescriptor& desc) { - Stateful::add_instant_xml (node, _path); - Config->add_instant_xml (node); + boost::shared_ptr c; + boost::shared_ptr 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 = _control_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 t = boost::dynamic_pointer_cast(r); + + if (t) { + c = t->rec_enable_control (); + } + break; + } + + case ControllableDescriptor::Pan: + /* XXX pan 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 p = r->nth_plugin (plugin); + + if (p) { + c = boost::dynamic_pointer_cast( + p->data().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 p = r->nth_send (send); + + if (p) { + boost::shared_ptr s = boost::dynamic_pointer_cast(p); + boost::shared_ptr 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) +{ + if (_writable) { + Stateful::add_instant_xml (node, _path); + } + + if (write_to_config) { + Config->add_instant_xml (node); + } } XMLNode* @@ -2752,236 +2811,268 @@ Session::instant_xml (const string& node_name) return Stateful::instant_xml (node_name, _path); } -int +int Session::save_history (string snapshot_name) { - XMLTree tree; - string xml_path; - string bak_path; + XMLTree tree; - tree.set_root (&_history.get_state (Config->get_saved_history_depth())); + if (!_writable) { + return 0; + } - if (snapshot_name.empty()) { - snapshot_name = _current_snapshot_name; - } + if (snapshot_name.empty()) { + snapshot_name = _current_snapshot_name; + } - xml_path = _path + snapshot_name + ".history"; + 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 backup_path = _session_dir->root_path() / backup_filename; - bak_path = xml_path + ".bak"; + if (sys::exists (xml_path)) { + try + { + sys::rename (xml_path, backup_path); + } + catch (const sys::filesystem_error& err) + { + error << _("could not backup old history file, current history not saved") << endmsg; + return -1; + } + } - if ((access (xml_path.c_str(), F_OK) == 0) && - (rename (xml_path.c_str(), bak_path.c_str()))) - { - 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; + } - if (!tree.write (xml_path)) - { - error << string_compose (_("history could not be saved to %1"), xml_path) << endmsg; + tree.set_root (&_history.get_state (Config->get_saved_history_depth())); - /* don't leave a corrupt file lying around if it is - * possible to fix. - */ + if (!tree.write (xml_path.to_string())) + { + error << string_compose (_("history could not be saved to %1"), xml_path.to_string()) << endmsg; - if (unlink (xml_path.c_str())) { - error << string_compose (_("could not remove corrupt history file %1"), xml_path) << endmsg; - } else { - if (rename (bak_path.c_str(), xml_path.c_str())) + try { - error << string_compose (_("could not restore history file from backup %1"), bak_path) << endmsg; + sys::remove (xml_path); + sys::rename (backup_path, xml_path); + } + catch (const sys::filesystem_error& err) + { + error << string_compose (_("could not restore history file from backup %1 (%2)"), + backup_path.to_string(), err.what()) << endmsg; } - } - return -1; - } + return -1; + } - return 0; + return 0; } int Session::restore_history (string snapshot_name) { - XMLTree tree; - string xmlpath; - - if (snapshot_name.empty()) { - snapshot_name = _current_snapshot_name; - } - - /* read xml */ - xmlpath = _path + snapshot_name + ".history"; - cerr << string_compose(_("Loading history from '%1'."), xmlpath) << endmsg; - - if (access (xmlpath.c_str(), F_OK)) { - info << string_compose (_("%1: no history file \"%2\" for this session."), _name, xmlpath) << endmsg; - return 1; - } - - if (!tree.read (xmlpath)) { - error << string_compose (_("Could not understand session history file \"%1\""), xmlpath) << endmsg; - return -1; - } - - /* 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(); - child_it != t->children().end(); - child_it++) - { - XMLNode *n = *child_it; - Command *c; - - if (n->name() == "MementoCommand" || - n->name() == "MementoUndoCommand" || - n->name() == "MementoRedoCommand") { + XMLTree tree; - if ((c = memento_command_factory(n))) { - ut->add_command(c); - } - - } else if (n->name() == X_("GlobalRouteStateCommand")) { + if (snapshot_name.empty()) { + snapshot_name = _current_snapshot_name; + } - if ((c = global_state_command_factory (*n))) { - ut->add_command (c); - } - - } else { + const string xml_filename = legalize_for_path (snapshot_name) + history_suffix; + const sys::path xml_path = _session_dir->root_path() / xml_filename; - error << string_compose(_("Couldn't figure out how to make a Command out of a %1 XMLNode."), n->name()) << endmsg; - } - } + info << "Loading history from " << xml_path.to_string() << endmsg; - _history.add (ut); - } + if (!sys::exists (xml_path)) { + info << string_compose (_("%1: no history file \"%2\" for this session."), + _name, xml_path.to_string()) << endmsg; + return 1; + } - return 0; + if (!tree.read (xml_path.to_string())) { + error << string_compose (_("Could not understand session history file \"%1\""), + xml_path.to_string()) << endmsg; + return -1; + } + + // 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(); + child_it != t->children().end(); child_it++) + { + 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() == "DeltaCommand") { + PBD::ID id(n->property("midi-source")->value()); + boost::shared_ptr midi_source = + boost::dynamic_pointer_cast(source_by_id(id)); + if (midi_source) { + ut->add_command(new MidiModel::DeltaCommand(midi_source->model(), *n)); + } else { + error << _("Failed to downcast MidiSource for DeltaCommand") << endmsg; + } + + } else if (n->name() == "DiffCommand") { + PBD::ID id(n->property("midi-source")->value()); + boost::shared_ptr midi_source = + boost::dynamic_pointer_cast(source_by_id(id)); + if (midi_source) { + ut->add_command(new MidiModel::DiffCommand(midi_source->model(), *n)); + } else { + error << _("Failed to downcast MidiSource for DeltaCommand") << endmsg; + } + + } else { + error << string_compose(_("Couldn't figure out how to make a Command out of a %1 XMLNode."), n->name()) << endmsg; + } + } + + _history.add (ut); + } + + return 0; } void -Session::config_changed (const char* parameter_name) +Session::config_changed (std::string p, bool ours) { -#define PARAM_IS(x) (!strcmp (parameter_name, (x))) + if (ours) { + set_dirty (); + } - if (PARAM_IS ("seamless-loop")) { - - } else if (PARAM_IS ("rf-speed")) { - - } else if (PARAM_IS ("auto-loop")) { - - } else if (PARAM_IS ("auto-input")) { + 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 dsl = diskstreams.reader(); - + for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) { if ((*i)->record_enabled ()) { - (*i)->monitor_input (!Config->get_auto_input()); + (*i)->monitor_input (!config.get_auto_input()); } } } - } else if (PARAM_IS ("punch-in")) { + } else if (p == "punch-in") { Location* location; - + if ((location = _locations.auto_punch_location()) != 0) { - - if (Config->get_punch_in ()) { - replace_event (Event::PunchIn, location->start()); + + if (config.get_punch_in ()) { + replace_event (SessionEvent::PunchIn, location->start()); } else { - remove_event (location->start(), Event::PunchIn); + remove_event (location->start(), SessionEvent::PunchIn); } } - - } else if (PARAM_IS ("punch-out")) { + + } else if (p == "punch-out") { Location* location; - + if ((location = _locations.auto_punch_location()) != 0) { - - if (Config->get_punch_out()) { - replace_event (Event::PunchOut, location->end()); + + if (config.get_punch_out()) { + replace_event (SessionEvent::PunchOut, location->end()); } else { - clear_events (Event::PunchOut); + clear_events (SessionEvent::PunchOut); } } - } else if (PARAM_IS ("edit-mode")) { + } 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 ()); } - } else if (PARAM_IS ("use-video-sync")) { + } else if (p == "use-video-sync") { - waiting_for_sync_offset = Config->get_use_video_sync(); + waiting_for_sync_offset = config.get_use_video_sync(); - } else if (PARAM_IS ("mmc-control")) { + } else if (p == "mmc-control") { //poke_midi_thread (); - } else if (PARAM_IS ("mmc-device-id")) { + } else if (p == "mmc-device-id" || p == "mmc-receive-id") { if (mmc) { - mmc->set_device_id (Config->get_mmc_device_id()); + mmc->set_receive_device_id (Config->get_mmc_receive_device_id()); } - } else if (PARAM_IS ("midi-control")) { - + } else if (p == "mmc-send-id") { + + if (mmc) { + mmc->set_send_device_id (Config->get_mmc_send_device_id()); + } + + } else if (p == "midi-control") { + //poke_midi_thread (); - } else if (PARAM_IS ("raid-path")) { + } else if (p == "raid-path") { - setup_raid_path (Config->get_raid_path()); + setup_raid_path (config.get_raid_path()); - } else if (PARAM_IS ("smpte-format")) { + } else if (p == "timecode-format") { sync_time_vars (); - } else if (PARAM_IS ("video-pullup")) { + } else if (p == "video-pullup") { sync_time_vars (); - } else if (PARAM_IS ("seamless-loop")) { + } else if (p == "seamless-loop") { if (play_loop && transport_rolling()) { // to reset diskstreams etc request_play_loop (true); } - } else if (PARAM_IS ("rf-speed")) { + } else if (p == "rf-speed") { cumulative_rf_motion = 0; reset_rf_scale (0); - } else if (PARAM_IS ("click-sound")) { + } else if (p == "click-sound") { setup_click_sounds (1); - } else if (PARAM_IS ("click-emphasis-sound")) { + } else if (p == "click-emphasis-sound") { setup_click_sounds (-1); - } else if (PARAM_IS ("clicking")) { + } else if (p == "clicking") { if (Config->get_clicking()) { if (_click_io && click_data) { // don't require emphasis data @@ -2991,12 +3082,12 @@ Session::config_changed (const char* parameter_name) _clicking = false; } - } else if (PARAM_IS ("send-mtc")) { - + } 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) { @@ -3007,34 +3098,34 @@ Session::config_changed (const char* parameter_name) session_send_mtc = false; } - } else if (PARAM_IS ("send-mmc")) { - + } else if (p == "send-mmc") { + /* only set the internal flag if we have a port. */ - + if (_mmc_port != 0) { session_send_mmc = Config->get_send_mmc(); } else { mmc = 0; - session_send_mmc = false; + session_send_mmc = false; } - } else if (PARAM_IS ("midi-feedback")) { - + } 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(); } - } else if (PARAM_IS ("jack-time-master")) { + } else if (p == "jack-time-master") { engine().reset_timebase (); - } else if (PARAM_IS ("native-file-header-format")) { + } else if (p == "native-file-header-format") { if (!first_file_header_format_reset) { reset_native_file_format (); @@ -3042,7 +3133,7 @@ Session::config_changed (const char* parameter_name) first_file_header_format_reset = false; - } else if (PARAM_IS ("native-file-data-format")) { + } else if (p == "native-file-data-format") { if (!first_file_data_format_reset) { reset_native_file_format (); @@ -3050,16 +3141,53 @@ Session::config_changed (const char* parameter_name) first_file_data_format_reset = false; - } else if (PARAM_IS ("slave-source")) { - set_slave_source (Config->get_slave_source()); - } else if (PARAM_IS ("remote-model")) { + } 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 (PARAM_IS ("denormal-model")) { + } else if (p == "denormal-model") { setup_fpu (); + } else if (p == "history-depth") { + set_history_depth (Config->get_history_depth()); + } else if (p == "sync-all-route-ordering") { + sync_order_keys ("session"); + } else if (p == "initial-program-change") { + + if (_mmc_port && Config->get_initial_program_change() >= 0) { + MIDI::byte buf[2]; + + buf[0] = MIDI::program; // channel zero by default + buf[1] = (Config->get_initial_program_change() & 0x7f); + + _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); + } + } else if (p == "solo-mute-override") { + // catch_up_on_solo_mute_override (); + } else if (p == "listen-position") { + listen_position_changed (); + } else if (p == "solo-control-is-listen-control") { + solo_control_mode_changed (); } + set_dirty (); - -#undef PARAM_IS +} +void +Session::set_history_depth (uint32_t d) +{ + _history.set_depth (d); }