X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fsession_state.cc;h=ff7da665ed00508238d990ca29bde17e28a69f61;hb=1f98535b5231e2ff128f08061a59ae5673f04b73;hp=1305653c54e088bd6f34fe633d59813b75877843;hpb=e26e59b00634d5a66f39e40dea71d56a8dea0f2a;p=ardour.git diff --git a/libs/ardour/session_state.cc b/libs/ardour/session_state.cc index 1305653c54..669517bdfb 100644 --- a/libs/ardour/session_state.cc +++ b/libs/ardour/session_state.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 1999-2002 Paul Davis + Copyright (C) 1999-2013 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 @@ -33,15 +33,14 @@ #include #include #include -#include -#include #include -#include #include #ifdef HAVE_SYS_VFS_H #include -#else +#endif + +#ifdef __APPLE__ #include #include #endif @@ -51,15 +50,16 @@ #endif #include +#include #include -#include +#include +#include #include #include "midi++/mmc.h" #include "midi++/port.h" -#include "midi++/manager.h" #include "evoral/SMF.hpp" @@ -68,16 +68,15 @@ #include "pbd/controllable_descriptor.h" #include "pbd/enumwriter.h" #include "pbd/error.h" -#include "pbd/filesystem.h" #include "pbd/file_utils.h" -#include "pbd/pathscanner.h" +#include "pbd/pathexpand.h" #include "pbd/pthread_utils.h" -#include "pbd/search_path.h" #include "pbd/stacktrace.h" #include "pbd/convert.h" -#include "pbd/clear_dir.h" +#include "pbd/localtime_r.h" #include "ardour/amp.h" +#include "ardour/async_midi_port.h" #include "ardour/audio_diskstream.h" #include "ardour/audio_track.h" #include "ardour/audioengine.h" @@ -88,17 +87,20 @@ #include "ardour/control_protocol_manager.h" #include "ardour/directory_names.h" #include "ardour/filename_extensions.h" +#include "ardour/graph.h" #include "ardour/location.h" #include "ardour/midi_model.h" #include "ardour/midi_patch_manager.h" #include "ardour/midi_region.h" +#include "ardour/midi_scene_changer.h" #include "ardour/midi_source.h" #include "ardour/midi_track.h" -#include "ardour/named_selection.h" #include "ardour/pannable.h" #include "ardour/playlist_factory.h" +#include "ardour/playlist_source.h" #include "ardour/port.h" #include "ardour/processor.h" +#include "ardour/profile.h" #include "ardour/proxy_controllable.h" #include "ardour/recent_sessions.h" #include "ardour/region_factory.h" @@ -109,7 +111,6 @@ #include "ardour/session_metadata.h" #include "ardour/session_playlists.h" #include "ardour/session_state_utils.h" -#include "ardour/session_utils.h" #include "ardour/silentfilesource.h" #include "ardour/sndfilesource.h" #include "ardour/source_factory.h" @@ -128,118 +129,34 @@ using namespace std; using namespace ARDOUR; using namespace PBD; -/** @param snapshot_name Snapshot name, without the .ardour prefix */ void -Session::first_stage_init (string fullpath, string snapshot_name) +Session::pre_engine_init (string fullpath) { - if (fullpath.length() == 0) { - destroy (); - throw failed_constructor(); - } - - char buf[PATH_MAX+1]; - if (!realpath (fullpath.c_str(), buf) && (errno != ENOENT)) { - error << string_compose(_("Could not use path %1 (%s)"), buf, strerror(errno)) << endmsg; + if (fullpath.empty()) { destroy (); throw failed_constructor(); } - _path = string(buf); - - if (_path[_path.length()-1] != G_DIR_SEPARATOR) { - _path += G_DIR_SEPARATOR; - } - - /* these two are just provisional settings. set_state() - will likely override them. - */ - - _name = _current_snapshot_name = snapshot_name; + /* discover canonical fullpath */ - set_history_depth (Config->get_history_depth()); + _path = canonical_path(fullpath); - _current_frame_rate = _engine.frame_rate (); - _nominal_frame_rate = _current_frame_rate; - _base_frame_rate = _current_frame_rate; + /* is it new ? */ - _tempo_map = new TempoMap (_current_frame_rate); - _tempo_map->PropertyChanged.connect_same_thread (*this, boost::bind (&Session::tempo_map_changed, this, _1)); + _is_new = !Glib::file_test (_path, Glib::FileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)); + /* finish initialization that can't be done in a normal C++ constructor + definition. + */ - _non_soloed_outs_muted = false; - _listen_cnt = 0; - _solo_isolated_cnt = 0; + timerclear (&last_mmc_step); g_atomic_int_set (&processing_prohibited, 0); - _transport_speed = 0; - _default_transport_speed = 1.0; - _last_transport_speed = 0; - _target_transport_speed = 0; - auto_play_legal = false; - transport_sub_state = 0; - _transport_frame = 0; - _requested_return_frame = -1; - _session_range_location = 0; g_atomic_int_set (&_record_status, Disabled); - loop_changing = false; - play_loop = false; - have_looped = false; - _last_roll_location = 0; - _last_roll_or_reversal_location = 0; - _last_record_location = 0; - pending_locate_frame = 0; - pending_locate_roll = false; - pending_locate_flush = false; - state_was_pending = false; - set_next_event (); - outbound_mtc_timecode_frame = 0; - next_quarter_frame_to_send = -1; - current_block_size = 0; - solo_update_disabled = false; - _have_captured = false; - _worst_output_latency = 0; - _worst_input_latency = 0; - _worst_track_latency = 0; - _state_of_the_state = StateOfTheState(CannotSave|InitialConnecting|Loading); - _was_seamless = Config->get_seamless_loop (); - _slave = 0; - _send_qf_mtc = false; - _pframes_since_last_mtc = 0; g_atomic_int_set (&_playback_load, 100); g_atomic_int_set (&_capture_load, 100); - _play_range = false; - _exporting = false; - pending_abort = false; - destructive_index = 0; - first_file_data_format_reset = true; - first_file_header_format_reset = true; - post_export_sync = false; - midi_control_ui = 0; - _step_editors = 0; - no_questions_about_missing_files = false; - _speakers.reset (new Speakers); - _clicks_cleared = 0; - ignore_route_processor_changes = false; - _pre_export_mmc_enabled = false; - - AudioDiskstream::allocate_working_buffers(); - - /* default short fade = 15ms */ - - SndFileSource::setup_standard_crossfades (*this, frame_rate()); - - last_mmc_step.tv_sec = 0; - last_mmc_step.tv_usec = 0; - step_speed = 0.0; - - /* click sounds are unset by default, which causes us to internal - waveforms for clicks. - */ - - click_length = 0; - click_emphasis_length = 0; - _clicking = false; - - process_function = &Session::process_with_events; + set_next_event (); + _all_route_group->set_active (true, this); + interpolation.add_channel_to (0, 0); if (config.get_use_video_sync()) { waiting_for_sync_offset = true; @@ -247,32 +164,19 @@ Session::first_stage_init (string fullpath, string snapshot_name) waiting_for_sync_offset = false; } - last_timecode_when = 0; - last_timecode_valid = false; - - sync_time_vars (); - last_rr_session_dir = session_dirs.begin(); - refresh_disk_space (); + set_history_depth (Config->get_history_depth()); + /* default: assume simple stereo speaker configuration */ _speakers->setup_default_speakers (2); - /* slave stuff */ - - average_slave_delta = 1800; // !!! why 1800 ???? - have_first_delta_accumulator = false; - delta_accumulator_cnt = 0; - _slave_state = Stopped; - _solo_cut_control.reset (new ProxyControllable (_("solo cut control (dB)"), PBD::Controllable::GainLike, boost::bind (&RCConfiguration::set_solo_mute_gain, Config, _1), boost::bind (&RCConfiguration::get_solo_mute_gain, Config))); add_controllable (_solo_cut_control); - _engine.GraphReordered.connect_same_thread (*this, boost::bind (&Session::graph_reordered, this)); - /* These are all static "per-class" signals */ SourceFactory::SourceCreated.connect_same_thread (*this, boost::bind (&Session::add_source, this, _1)); @@ -285,90 +189,153 @@ Session::first_stage_init (string fullpath, string snapshot_name) Delivery::disable_panners (); IO::disable_connecting (); + + AudioFileSource::set_peak_dir (_session_dir->peak_path()); } int -Session::second_stage_init () +Session::post_engine_init () { - AudioFileSource::set_peak_dir (_session_dir->peak_path()); + BootMessage (_("Set block size and sample rate")); - if (!_is_new) { - if (load_state (_current_snapshot_name)) { - return -1; - } - } + set_block_size (_engine.samples_per_cycle()); + set_frame_rate (_engine.sample_rate()); + + BootMessage (_("Using configuration")); + + _midi_ports = new MidiPortManager; + + MIDISceneChanger* msc; + _scene_changer = msc = new MIDISceneChanger (*this); + msc->set_input_port (scene_input_port()); + msc->set_output_port (scene_out()); + + boost::function timer_func (boost::bind (&Session::audible_frame, this)); + boost::dynamic_pointer_cast(scene_in())->set_timer (timer_func); + + setup_midi_machine_control (); + if (_butler->start_thread()) { return -1; } - + if (start_midi_thread ()) { return -1; } - - setup_midi_machine_control (); - - // set_state() will call setup_raid_path(), but if it's a new session we need - // to call setup_raid_path() here. - - if (state_tree) { - if (set_state (*state_tree->root(), Stateful::loading_state_version)) { - return -1; - } - } else { - setup_raid_path(_path); - } - - /* we can't save till after ::when_engine_running() is called, - because otherwise we save state with no connections made. - therefore, we reset _state_of_the_state because ::set_state() - will have cleared it. - - we also have to include Loading so that any events that get - generated between here and the end of ::when_engine_running() - will be processed directly rather than queued. - */ - - _state_of_the_state = StateOfTheState (_state_of_the_state|CannotSave|Loading); - - _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_same_thread (*this, boost::bind (&Session::engine_halted, this)); _engine.Xrun.connect_same_thread (*this, boost::bind (&Session::xrun_recovery, this)); - midi_clock = new MidiClockTicker (); - midi_clock->set_session (this); - try { - when_engine_running (); - } + /* tempo map requires sample rate knowledge */ + + delete _tempo_map; + _tempo_map = new TempoMap (_current_frame_rate); + _tempo_map->PropertyChanged.connect_same_thread (*this, boost::bind (&Session::tempo_map_changed, this, _1)); + + /* MidiClock requires a tempo map */ + + midi_clock = new MidiClockTicker (); + midi_clock->set_session (this); + + /* crossfades require sample rate knowledge */ + + SndFileSource::setup_standard_crossfades (*this, frame_rate()); + _engine.GraphReordered.connect_same_thread (*this, boost::bind (&Session::graph_reordered, this)); + + AudioDiskstream::allocate_working_buffers(); + refresh_disk_space (); + + /* we're finally ready to call set_state() ... all objects have + * been created, the engine is running. + */ + + if (state_tree) { + if (set_state (*state_tree->root(), Stateful::loading_state_version)) { + return -1; + } + } else { + // set_state() will call setup_raid_path(), but if it's a new session we need + // to call setup_raid_path() here. + setup_raid_path (_path); + } - /* handle this one in a different way than all others, so that its clear what happened */ + /* ENGINE */ - catch (AudioEngine::PortRegistrationFailure& err) { + boost::function ff (boost::bind (&Session::config_changed, this, _1, false)); + boost::function ft (boost::bind (&Session::config_changed, this, _1, true)); + + Config->map_parameters (ff); + config.map_parameters (ft); + + /* Reset all panners */ + + Delivery::reset_panners (); + + /* this will cause the CPM to instantiate any protocols that are in use + * (or mandatory), which will pass it this Session, and then call + * set_state() on each instantiated protocol to match stored state. + */ + + ControlProtocolManager::instance().set_session (this); + + /* This must be done after the ControlProtocolManager set_session above, + as it will set states for ports which the ControlProtocolManager creates. + */ + + // XXX set state of MIDI::Port's + // MidiPortManager::instance()->set_port_states (Config->midi_port_states ()); + + /* And this must be done after the MIDI::Manager::set_port_states as + * it will try to make connections whose details are loaded by set_port_states. + */ + + hookup_io (); + + /* Let control protocols know that we are now all connected, so they + * could start talking to surfaces if they want to. + */ + + ControlProtocolManager::instance().midi_connectivity_established (); + + if (_is_new && !no_auto_connect()) { + Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock()); + auto_connect_master_bus (); + } + + _state_of_the_state = StateOfTheState (_state_of_the_state & ~(CannotSave|Dirty)); + + /* update latencies */ + + initialize_latencies (); + + _locations->added.connect_same_thread (*this, boost::bind (&Session::location_added, this, _1)); + _locations->removed.connect_same_thread (*this, boost::bind (&Session::location_removed, this, _1)); + _locations->changed.connect_same_thread (*this, boost::bind (&Session::locations_changed, this)); + + } catch (AudioEngine::PortRegistrationFailure& err) { + /* handle this one in a different way than all others, so that its clear what happened */ error << err.what() << endmsg; return -1; - } - - catch (...) { + } catch (...) { return -1; } BootMessage (_("Reset Remote Controls")); - send_full_time_code (0); + // send_full_time_code (0); _engine.transport_locate (0); - MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdMmcReset)); - MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (Timecode::Time ())); + send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdMmcReset)); + send_immediate_mmc (MIDI::MachineControlCommand (Timecode::Time ())); MIDI::Name::MidiPatchManager::instance().set_session (this); + ltc_tx_initialize(); /* initial program change will be delivered later; see ::config_changed() */ _state_of_the_state = Clean; @@ -377,21 +344,21 @@ Session::second_stage_init () DirtyChanged (); /* EMIT SIGNAL */ - if (state_was_pending) { - save_state (_current_snapshot_name); + if (_is_new) { + save_state (""); + } else if (state_was_pending) { + save_state (""); remove_pending_capture_state (); state_was_pending = false; } - BootMessage (_("Session loading complete")); - return 0; } string Session::raid_path () const { - SearchPath raid_search_path; + Searchpath raid_search_path; for (vector::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) { raid_search_path += (*i).path; @@ -412,11 +379,11 @@ Session::setup_raid_path (string path) session_dirs.clear (); - SearchPath search_path(path); - SearchPath sound_search_path; - SearchPath midi_search_path; + Searchpath search_path(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; sp.blocks = 0; // not needed session_dirs.push_back (sp); @@ -521,17 +488,18 @@ Session::create (const string& session_template, BusProfile* bus_profile) return -1; } - _writable = exists_and_writable (sys::path (_path)); + _writable = exists_and_writable (_path); if (!session_template.empty()) { - std::string in_path = session_template_dir_to_file (session_template); + std::string in_path = (ARDOUR::Profile->get_trx () ? session_template : session_template_dir_to_file (session_template)); ifstream in(in_path.c_str()); if (in) { - string out_path = _path; - out_path += _name; - out_path += statefile_suffix; + /* no need to call legalize_for_path() since the string + * in session_template is already a legal path name + */ + string out_path = Glib::build_filename (_session_dir->root_path(), _name + statefile_suffix); ofstream out(out_path.c_str()); @@ -541,7 +509,7 @@ Session::create (const string& session_template, BusProfile* bus_profile) /* Copy plugin state files from template to new session */ std::string template_plugins = Glib::build_filename (session_template, X_("plugins")); - copy_files (template_plugins, plugins_dir ()); + copy_recurse (template_plugins, plugins_dir ()); return 0; @@ -571,7 +539,7 @@ Session::create (const string& session_template, BusProfile* bus_profile) ChanCount count(DataType::AUDIO, bus_profile->master_out_channels); if (bus_profile->master_out_channels) { - boost::shared_ptr r (new Route (*this, _("master"), Route::MasterOut, DataType::AUDIO)); + boost::shared_ptr r (new Route (*this, _("Master"), Route::MasterOut, DataType::AUDIO)); if (r->init ()) { return -1; } @@ -579,7 +547,7 @@ Session::create (const string& session_template, BusProfile* bus_profile) // boost_debug_shared_ptr_mark_interesting (r.get(), "Route"); #endif { - Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ()); + Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ()); r->input()->ensure_io (count, false, this); r->output()->ensure_io (count, false, this); } @@ -611,8 +579,6 @@ Session::create (const string& session_template, BusProfile* bus_profile) add_monitor_section (); } - save_state (""); - return 0; } @@ -627,18 +593,15 @@ Session::maybe_write_autosave() void Session::remove_pending_capture_state () { - sys::path pending_state_file_path(_session_dir->root_path()); + std::string pending_state_file_path(_session_dir->root_path()); - pending_state_file_path /= legalize_for_path (_current_snapshot_name) + pending_suffix; + pending_state_file_path = Glib::build_filename (pending_state_file_path, legalize_for_path (_current_snapshot_name) + pending_suffix); - 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; + if (!Glib::file_test (pending_state_file_path, Glib::FILE_TEST_EXISTS)) return; + + if (g_remove (pending_state_file_path.c_str()) != 0) { + error << string_compose(_("Could not remove pending capture state at path \"%1\" (%2)"), + pending_state_file_path, g_strerror (errno)) << endmsg; } } @@ -657,17 +620,12 @@ Session::rename_state (string old_name, string new_name) 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(Glib::build_filename (_session_dir->root_path(), old_xml_filename)); - const sys::path new_xml_path(Glib::build_filename (_session_dir->root_path(), new_xml_filename)); + const std::string old_xml_path(Glib::build_filename (_session_dir->root_path(), old_xml_filename)); + const std::string new_xml_path(Glib::build_filename (_session_dir->root_path(), new_xml_filename)); - try - { - sys::rename (old_xml_path, new_xml_path); - } - catch (const sys::filesystem_error& err) - { + if (::g_rename (old_xml_path.c_str(), new_xml_path.c_str()) != 0) { error << string_compose(_("could not rename snapshot %1 to %2 (%3)"), - old_name, new_name, err.what()) << endmsg; + old_name, new_name, g_strerror(errno)) << endmsg; } } @@ -693,73 +651,33 @@ Session::remove_state (string snapshot_name) } // and delete it - sys::remove (xml_path); -} - -#ifdef HAVE_JACK_SESSION -void -Session::jack_session_event (jack_session_event_t * event) -{ - char timebuf[128]; - time_t n; - struct tm local_time; - - time (&n); - localtime_r (&n, &local_time); - strftime (timebuf, sizeof(timebuf), "JS_%FT%T", &local_time); - - if (event->type == JackSessionSaveTemplate) - { - if (save_template( timebuf )) { - event->flags = JackSessionSaveError; - } else { - string cmd ("ardour3 -P -U "); - cmd += event->client_uuid; - cmd += " -T "; - cmd += timebuf; - - event->command_line = strdup (cmd.c_str()); - } - } - else - { - if (save_state (timebuf)) { - event->flags = JackSessionSaveError; - } else { - sys::path xml_path (_session_dir->root_path()); - xml_path /= legalize_for_path (timebuf) + statefile_suffix; - - string cmd ("ardour3 -P -U "); - cmd += event->client_uuid; - cmd += " \""; - cmd += xml_path.to_string(); - cmd += '\"'; - - event->command_line = strdup (cmd.c_str()); - } - } - - jack_session_reply (_engine.jack(), event); - - if (event->type == JackSessionSaveAndQuit) { - Quit (); /* EMIT SIGNAL */ + if (g_remove (xml_path.c_str()) != 0) { + error << string_compose(_("Could not remove session file at path \"%1\" (%2)"), + xml_path, g_strerror (errno)) << endmsg; } - - jack_session_event_free( event ); } -#endif /** @param snapshot_name Name to save under, without .ardour / .pending prefix */ int -Session::save_state (string snapshot_name, bool pending, bool switch_to_snapshot) +Session::save_state (string snapshot_name, bool pending, bool switch_to_snapshot, bool template_only) { XMLTree tree; std::string xml_path(_session_dir->root_path()); + /* prevent concurrent saves from different threads */ + + Glib::Threads::Mutex::Lock lm (save_state_lock); + if (!_writable || (_state_of_the_state & CannotSave)) { return 1; } + if (g_atomic_int_get(&_suspend_save)) { + _save_queued = true; + return 1; + } + _save_queued = false; + if (!_engine.connected ()) { error << string_compose (_("the %1 audio engine is not connected and state saving would lose all I/O connections. Session not saved"), PROGRAM_NAME) @@ -777,7 +695,13 @@ Session::save_state (string snapshot_name, bool pending, bool switch_to_snapshot } } - tree.set_root (&get_state()); + SessionSaveUnderway (); /* EMIT SIGNAL */ + + if (template_only) { + tree.set_root (&get_template()); + } else { + tree.set_root (&get_state()); + } if (snapshot_name.empty()) { snapshot_name = _current_snapshot_name; @@ -793,7 +717,7 @@ Session::save_state (string snapshot_name, bool pending, bool switch_to_snapshot /* make a backup copy of the old file */ - if (sys::exists(xml_path) && !create_backup_file (xml_path)) { + if (Glib::file_test (xml_path, Glib::FILE_TEST_EXISTS) && !create_backup_file (xml_path)) { // create_backup_file will log the error return -1; } @@ -804,23 +728,30 @@ Session::save_state (string snapshot_name, bool pending, bool switch_to_snapshot xml_path = Glib::build_filename (xml_path, legalize_for_path (snapshot_name) + pending_suffix); } - sys::path tmp_path(_session_dir->root_path()); + std::string tmp_path(_session_dir->root_path()); + tmp_path = Glib::build_filename (tmp_path, legalize_for_path (snapshot_name) + temp_suffix); - tmp_path /= legalize_for_path (snapshot_name) + temp_suffix; - - // cerr << "actually writing state to " << xml_path.to_string() << endl; - - 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); + cerr << "actually writing state to " << tmp_path << endl; + + if (!tree.write (tmp_path)) { + error << string_compose (_("state could not be saved to %1"), tmp_path) << endmsg; + if (g_remove (tmp_path.c_str()) != 0) { + error << string_compose(_("Could not remove temporary session file at path \"%1\" (%2)"), + tmp_path, g_strerror (errno)) << endmsg; + } return -1; } else { - if (::rename (tmp_path.to_string().c_str(), xml_path.c_str()) != 0) { - error << string_compose (_("could not rename temporary session file %1 to %2"), - tmp_path.to_string(), xml_path) << endmsg; - sys::remove (tmp_path); + cerr << "renaming state to " << xml_path << endl; + + if (::g_rename (tmp_path.c_str(), xml_path.c_str()) != 0) { + error << string_compose (_("could not rename temporary session file %1 to %2 (%3)"), + tmp_path, xml_path, g_strerror(errno)) << endmsg; + if (g_remove (tmp_path.c_str()) != 0) { + error << string_compose(_("Could not remove temporary session file at path \"%1\" (%2)"), + tmp_path, g_strerror (errno)) << endmsg; + } return -1; } } @@ -863,10 +794,10 @@ Session::load_state (string snapshot_name) /* check for leftover pending state from a crashed capture attempt */ - sys::path xmlpath(_session_dir->root_path()); - xmlpath /= legalize_for_path (snapshot_name) + pending_suffix; + std::string xmlpath(_session_dir->root_path()); + xmlpath = Glib::build_filename (xmlpath, legalize_for_path (snapshot_name) + pending_suffix); - if (sys::exists (xmlpath)) { + if (Glib::file_test (xmlpath, Glib::FILE_TEST_EXISTS)) { /* there is pending state from a crashed capture attempt */ @@ -877,15 +808,13 @@ Session::load_state (string snapshot_name) } if (!state_was_pending) { - xmlpath = _session_dir->root_path(); - xmlpath /= snapshot_name; + xmlpath = Glib::build_filename (_session_dir->root_path(), snapshot_name); } - if (!sys::exists (xmlpath)) { - xmlpath = _session_dir->root_path(); - xmlpath /= legalize_for_path (snapshot_name) + statefile_suffix; - if (!sys::exists (xmlpath)) { - error << string_compose(_("%1: session state information file \"%2\" doesn't exist!"), _name, xmlpath.to_string()) << endmsg; + if (!Glib::file_test (xmlpath, Glib::FILE_TEST_EXISTS)) { + xmlpath = Glib::build_filename (_session_dir->root_path(), legalize_for_path (snapshot_name) + statefile_suffix); + if (!Glib::file_test (xmlpath, Glib::FILE_TEST_EXISTS)) { + error << string_compose(_("%1: session file \"%2\" doesn't exist!"), _name, xmlpath) << endmsg; return 1; } } @@ -894,10 +823,10 @@ Session::load_state (string snapshot_name) set_dirty(); - _writable = exists_and_writable (xmlpath); + _writable = exists_and_writable (xmlpath) && exists_and_writable(Glib::path_get_dirname(xmlpath)); - if (!state_tree->read (xmlpath.to_string())) { - error << string_compose(_("Could not understand ardour file %1"), xmlpath.to_string()) << endmsg; + if (!state_tree->read (xmlpath)) { + error << string_compose(_("Could not understand session file %1"), xmlpath) << endmsg; delete state_tree; state_tree = 0; return -1; @@ -906,7 +835,7 @@ Session::load_state (string snapshot_name) XMLNode& root (*state_tree->root()); if (root.name() != X_("Session")) { - error << string_compose (_("Session file %1 is not a session"), xmlpath.to_string()) << endmsg; + error << string_compose (_("Session file %1 is not a session"), xmlpath) << endmsg; delete state_tree; state_tree = 0; return -1; @@ -932,19 +861,17 @@ Session::load_state (string snapshot_name) if (Stateful::loading_state_version < CURRENT_SESSION_FILE_VERSION && _writable) { - sys::path backup_path(_session_dir->root_path()); - - backup_path /= string_compose ("%1-%2%3", legalize_for_path (snapshot_name), Stateful::loading_state_version, statefile_suffix); + std::string backup_path(_session_dir->root_path()); + std::string backup_filename = string_compose ("%1-%2%3", legalize_for_path (snapshot_name), Stateful::loading_state_version, statefile_suffix); + backup_path = Glib::build_filename (backup_path, backup_filename); // only create a backup for a given statefile version once - if (!sys::exists (backup_path)) { + if (!Glib::file_test (backup_path, Glib::FILE_TEST_EXISTS)) { - info << string_compose (_("Copying old session file %1 to %2\nUse %2 with %3 versions before 2.0 from now on"), - xmlpath.to_string(), backup_path.to_string(), PROGRAM_NAME) - << endmsg; + VersionMismatch (xmlpath, backup_path); - if (!copy_file (xmlpath.to_string(), backup_path.to_string())) {; + if (!copy_file (xmlpath, backup_path)) {; return -1; } } @@ -956,11 +883,17 @@ Session::load_state (string snapshot_name) int Session::load_options (const XMLNode& node) { - LocaleGuard lg (X_("POSIX")); + LocaleGuard lg (X_("C")); config.set_variables (node); return 0; } +bool +Session::save_default_options () +{ + return config.save_state(); +} + XMLNode& Session::get_state() { @@ -1014,7 +947,7 @@ Session::state (bool full_state) p += (*i).path; if (next != session_dirs.end()) { - p += ':'; + p += G_SEARCHPATH_SEPARATOR; } else { break; } @@ -1040,6 +973,15 @@ Session::state (bool full_state) /* various options */ + list midi_port_nodes = _midi_ports->get_midi_port_states(); + if (!midi_port_nodes.empty()) { + XMLNode* midi_port_stuff = new XMLNode ("MIDIPorts"); + for (list::const_iterator n = midi_port_nodes.begin(); n != midi_port_nodes.end(); ++n) { + midi_port_stuff->add_child_nocopy (**n); + } + node->add_child_nocopy (*midi_port_stuff); + } + node->add_child_nocopy (config.get_variables ()); node->add_child_nocopy (ARDOUR::SessionMetadata::Metadata()->get_state()); @@ -1047,7 +989,7 @@ Session::state (bool full_state) child = node->add_child ("Sources"); if (full_state) { - Glib::Mutex::Lock sl (source_lock); + Glib::Threads::Mutex::Lock sl (source_lock); for (SourceMap::iterator siter = sources.begin(); siter != sources.end(); ++siter) { @@ -1074,13 +1016,17 @@ Session::state (bool full_state) child = node->add_child ("Regions"); if (full_state) { - Glib::Mutex::Lock rl (region_lock); + Glib::Threads::Mutex::Lock rl (region_lock); const RegionFactory::RegionMap& region_map (RegionFactory::all_regions()); for (RegionFactory::RegionMap::const_iterator i = region_map.begin(); i != region_map.end(); ++i) { boost::shared_ptr r = i->second; /* only store regions not attached to playlists */ if (r->playlist() == 0) { - child->add_child_nocopy (r->state ()); + if (boost::dynamic_pointer_cast(r)) { + child->add_child_nocopy ((boost::dynamic_pointer_cast(r))->get_basic_state ()); + } else { + child->add_child_nocopy (r->get_state ()); + } } } @@ -1100,17 +1046,31 @@ Session::state (bool full_state) } } } + + if (full_state) { - node->add_child_nocopy (_locations->get_state()); + + if (_locations) { + node->add_child_nocopy (_locations->get_state()); + } } else { + Locations loc (*this); // for a template, just create a new Locations, populate it // with the default start and end, and get the state for that. - Locations loc (*this); Location* range = new Location (*this, 0, 0, _("session"), Location::IsSessionRange); range->set (max_framepos, 0); loc.add (range); - node->add_child_nocopy (loc.get_state()); + XMLNode& locations_state = loc.get_state(); + + if (ARDOUR::Profile->get_trx() && _locations) { + for (Locations::LocationList::const_iterator i = _locations->list ().begin (); i != _locations->list ().end (); ++i) { + if ((*i)->is_mark () || (*i)->is_auto_loop ()) { + locations_state.add_child_nocopy ((*i)->get_state ()); + } + } + } + node->add_child_nocopy (locations_state); } child = node->add_child ("Bundles"); @@ -1131,15 +1091,15 @@ Session::state (bool full_state) RoutePublicOrderSorter cmp; RouteList public_order (*r); public_order.sort (cmp); - - /* the sort should have put control outs first */ - - if (_monitor_out) { - assert (_monitor_out == public_order.front()); - } + + /* the sort should have put control outs first */ + + if (_monitor_out) { + assert (_monitor_out == public_order.front()); + } for (RouteList::iterator i = public_order.begin(); i != public_order.end(); ++i) { - if (!(*i)->is_hidden()) { + if (!(*i)->is_auditioner()) { if (full_state) { child->add_child_nocopy ((*i)->get_state()); } else { @@ -1162,13 +1122,14 @@ Session::state (bool full_state) gain_child->add_child_nocopy (_click_gain->state (full_state)); } - if (full_state) { - XMLNode* ns_child = node->add_child ("NamedSelections"); - for (NamedSelectionList::iterator i = named_selections.begin(); i != named_selections.end(); ++i) { - if (full_state) { - ns_child->add_child_nocopy ((*i)->get_state()); - } - } + if (_ltc_input) { + XMLNode* ltc_input_child = node->add_child ("LTC-In"); + ltc_input_child->add_child_nocopy (_ltc_input->state (full_state)); + } + + if (_ltc_input) { + XMLNode* ltc_output_child = node->add_child ("LTC-Out"); + ltc_output_child->add_child_nocopy (_ltc_output->state (full_state)); } node->add_child_nocopy (_speakers->get_state()); @@ -1201,7 +1162,7 @@ Session::set_state (const XMLNode& node, int version) if (node.name() != X_("Session")) { fatal << _("programming error: Session: incorrect XML node sent to set_state()") << endmsg; - return -1; + goto out; } if ((prop = node.property ("name")) != 0) { @@ -1215,7 +1176,7 @@ Session::set_state (const XMLNode& node, int version) if (_nominal_frame_rate != _current_frame_rate) { boost::optional r = AskAboutSampleRateMismatch (_nominal_frame_rate, _current_frame_rate); if (r.get_value_or (0)) { - return -1; + goto out; } } } @@ -1240,6 +1201,11 @@ Session::set_state (const XMLNode& node, int version) Evoral::init_event_id_counter (atoi (prop->value())); } + + if ((child = find_named_node (node, "MIDIPorts")) != 0) { + _midi_ports->set_midi_port_states (child->children()); + } + IO::disable_connecting (); Stateful::save_extra_xml (node); @@ -1285,20 +1251,7 @@ Session::set_state (const XMLNode& node, int version) goto out; } - Location* location; - - if ((location = _locations->auto_loop_location()) != 0) { - set_auto_loop_location (location); - } - - if ((location = _locations->auto_punch_location()) != 0) { - set_auto_punch_location (location); - } - - if ((location = _locations->session_range_location()) != 0) { - delete _session_range_location; - _session_range_location = location; - } + locations_changed (); if (_session_range_location) { AudioFileSource::set_header_position_offset (_session_range_location->start()); @@ -1330,12 +1283,6 @@ Session::set_state (const XMLNode& node, int version) } } - if ((child = find_named_node (node, "NamedSelections")) != 0) { - if (load_named_selections (*child)) { - goto out; - } - } - if (version >= 3000) { if ((child = find_named_node (node, "Bundles")) == 0) { warning << _("Session: XML state has no bundles section") << endmsg; @@ -1396,17 +1343,11 @@ Session::set_state (const XMLNode& node, int version) if ((child = find_named_node (node, "Click")) == 0) { warning << _("Session: XML state has no click section") << endmsg; } else if (_click_io) { - const XMLNodeList& children (child->children()); - XMLNodeList::const_iterator i = children.begin(); - _click_io->set_state (**i, version); - ++i; - if (i != children.end()) { - _click_gain->set_state (**i, version); - } + setup_click_state (&node); } - if ((child = find_named_node (node, "ControlProtocols")) != 0) { - ControlProtocolManager::instance().set_protocol_states (*child); + if ((child = find_named_node (node, ControlProtocolManager::state_node_name)) != 0) { + ControlProtocolManager::instance().set_state (*child, version); } update_have_rec_enabled_track (); @@ -1415,9 +1356,13 @@ Session::set_state (const XMLNode& node, int version) StateReady (); /* EMIT SIGNAL */ + delete state_tree; + state_tree = 0; return 0; out: + delete state_tree; + state_tree = 0; return ret; } @@ -1451,8 +1396,12 @@ Session::load_routes (const XMLNode& node, int version) new_routes.push_back (route); } + BootMessage (_("Tracks/busses loaded; Adding to Session")); + add_routes (new_routes, false, false, false); + BootMessage (_("Finished adding tracks/busses")); + return 0; } @@ -1500,7 +1449,13 @@ Session::XMLRouteFactory (const XMLNode& node, int version) ret = track; } else { - boost::shared_ptr r (new Route (*this, X_("toBeResetFroXML"))); + enum Route::Flag flags = Route::Flag(0); + const XMLProperty* prop = node.property("flags"); + if (prop) { + flags = Route::Flag (string_2_enum (prop->value(), flags)); + } + + boost::shared_ptr r (new Route (*this, X_("toBeResetFroXML"), flags)); if (r->init () == 0 && r->set_state (node, version) == 0) { #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS @@ -1572,7 +1527,13 @@ Session::XMLRouteFactory_2X (const XMLNode& node, int version) ret = track; } else { - boost::shared_ptr r (new Route (*this, X_("toBeResetFroXML"))); + enum Route::Flag flags = Route::Flag(0); + const XMLProperty* prop = node.property("flags"); + if (prop) { + flags = Route::Flag (string_2_enum (prop->value(), flags)); + } + + boost::shared_ptr r (new Route (*this, X_("toBeResetFroXML"), flags)); if (r->init () == 0 && r->set_state (node, version) == 0) { #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS @@ -1666,7 +1627,7 @@ Session::load_nested_sources (const XMLNode& node) XMLProperty* prop = (*niter)->property (X_("id")); if (!prop) { - error << _("Nested source has no ID info in session state file! (ignored)") << endmsg; + error << _("Nested source has no ID info in session file! (ignored)") << endmsg; continue; } @@ -1898,7 +1859,7 @@ Session::get_sources_as_xml () { XMLNode* node = new XMLNode (X_("Sources")); - Glib::Mutex::Lock lm (source_lock); + Glib::Threads::Mutex::Lock lm (source_lock); for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) { node->add_child_nocopy (i->second->get_state()); @@ -1907,47 +1868,31 @@ Session::get_sources_as_xml () return *node; } -string -Session::path_from_region_name (DataType type, string name, string identifier) +void +Session::reset_write_sources (bool mark_write_complete, bool force) { - char buf[PATH_MAX+1]; - uint32_t n; - SessionDirectory sdir(get_best_session_directory_for_new_source()); - sys::path source_dir = ((type == DataType::AUDIO) - ? sdir.sound_path() : sdir.midi_path()); - - string ext = native_header_format_extension (config.get_native_file_header_format(), type); - - for (n = 0; n < 999999; ++n) { - if (identifier.length()) { - snprintf (buf, sizeof(buf), "%s%s%" PRIu32 "%s", name.c_str(), - identifier.c_str(), n, ext.c_str()); - } else { - snprintf (buf, sizeof(buf), "%s-%" PRIu32 "%s", name.c_str(), - n, ext.c_str()); - } - - sys::path source_path = source_dir / buf; - - if (!sys::exists (source_path)) { - return source_path.to_string(); - } - } - - error << string_compose (_("cannot create new file from region name \"%1\" with ident = \"%2\": too many existing files with similar names"), - name, identifier) - << endmsg; - - return ""; + boost::shared_ptr rl = routes.reader(); + for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) { + boost::shared_ptr tr = boost::dynamic_pointer_cast (*i); + if (tr) { + + // block state saving + _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup); + tr->reset_write_sources(mark_write_complete, force); + _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup); + } + } } - int Session::load_sources (const XMLNode& node) { XMLNodeList nlist; XMLNodeConstIterator niter; - boost::shared_ptr source; + boost::shared_ptr source; /* don't need this but it stops some + * versions of gcc complaining about + * discarded return values. + */ nlist = node.children(); @@ -1964,9 +1909,15 @@ Session::load_sources (const XMLNode& node) int user_choice; + if (err.type == DataType::MIDI && Glib::path_is_absolute (err.path)) { + error << string_compose (_("A external MIDI file is missing. %1 cannot currently recover from missing external MIDI files"), + PROGRAM_NAME) << endmsg; + return -1; + } + if (!no_questions_about_missing_files) { - user_choice = MissingFile (this, err.path, err.type).get_value_or (-1); - } else { + user_choice = MissingFile (this, err.path, err.type).get_value_or (-1); + } else { user_choice = -2; } @@ -1991,8 +1942,35 @@ Session::load_sources (const XMLNode& node) case -1: default: - warning << _("A sound file is missing. It will be replaced by silence.") << endmsg; - source = SourceFactory::createSilent (*this, **niter, max_framecnt, _current_frame_rate); + switch (err.type) { + + case DataType::AUDIO: + source = SourceFactory::createSilent (*this, **niter, max_framecnt, _current_frame_rate); + break; + + case DataType::MIDI: + /* The MIDI file is actually missing so + * just create a new one in the same + * location. Do not announce its + */ + string fullpath; + + if (!Glib::path_is_absolute (err.path)) { + fullpath = Glib::build_filename (source_search_path (DataType::MIDI).front(), err.path); + } else { + /* this should be an unrecoverable error: we would be creating a MIDI file outside + the session tree. + */ + return -1; + } + /* Note that we do not announce the source just yet - we need to reset its ID before we do that */ + source = SourceFactory::createWritable (DataType::MIDI, *this, fullpath, false, _current_frame_rate, false, false); + /* reset ID to match the missing one */ + source->set_id (**niter); + /* Now we can announce it */ + SourceFactory::SourceCreated (source); + break; + } break; } } @@ -2014,7 +1992,7 @@ Session::XMLSourceFactory (const XMLNode& node) } catch (failed_constructor& err) { - error << string_compose (_("Found a sound file that cannot be used by %1. Talk to the progammers."), PROGRAM_NAME) << endmsg; + error << string_compose (_("Found a sound file that cannot be used by %1. Talk to the programmers."), PROGRAM_NAME) << endmsg; return boost::shared_ptr(); } } @@ -2022,55 +2000,80 @@ Session::XMLSourceFactory (const XMLNode& node) int Session::save_template (string template_name) { - XMLTree tree; - - if (_state_of_the_state & CannotSave) { - return -1; - } - - sys::path user_template_dir(user_template_directory()); - - try - { - sys::create_directories (user_template_dir); - } - catch(sys::filesystem_error& ex) - { - error << string_compose(_("Could not create templates directory \"%1\" (%2)"), - user_template_dir.to_string(), ex.what()) << endmsg; + if ((_state_of_the_state & CannotSave) || template_name.empty ()) { return -1; } - tree.set_root (&get_template()); + bool absolute_path = Glib::path_is_absolute (template_name); - sys::path template_dir_path(user_template_dir); - /* directory to put the template in */ - template_dir_path /= template_name; - if (sys::exists (template_dir_path)) - { - warning << string_compose(_("Template \"%1\" already exists - new version not created"), - template_dir_path.to_string()) << endmsg; - return -1; - } - - sys::create_directories (template_dir_path); + std::string template_dir_path; - /* file to write */ - sys::path template_file_path = template_dir_path; - template_file_path /= template_name + template_suffix; + if (!absolute_path) { + std::string user_template_dir(user_template_directory()); - if (!tree.write (template_file_path.to_string())) { - error << _("template not saved") << endmsg; - return -1; + if (g_mkdir_with_parents (user_template_dir.c_str(), 0755) != 0) { + error << string_compose(_("Could not create templates directory \"%1\" (%2)"), + user_template_dir, g_strerror (errno)) << endmsg; + return -1; + } + + template_dir_path = Glib::build_filename (user_template_dir, template_name); + } else { + template_dir_path = template_name; } - /* copy plugin state directory */ + if (!ARDOUR::Profile->get_trx()) { + if (Glib::file_test (template_dir_path, Glib::FILE_TEST_EXISTS)) { + warning << string_compose(_("Template \"%1\" already exists - new version not created"), + template_dir_path) << endmsg; + return -1; + } + + if (g_mkdir_with_parents (template_dir_path.c_str(), 0755) != 0) { + error << string_compose(_("Could not create directory for Session template\"%1\" (%2)"), + template_dir_path, g_strerror (errno)) << endmsg; + return -1; + } + } - sys::path template_plugin_state_path = template_dir_path; - template_plugin_state_path /= X_("plugins"); - sys::create_directories (template_plugin_state_path); - copy_files (plugins_dir(), template_plugin_state_path.to_string()); + /* file to write */ + std::string template_file_path; + + if (ARDOUR::Profile->get_trx()) { + template_file_path = template_name; + } else { + if (absolute_path) { + template_file_path = Glib::build_filename (template_dir_path, Glib::path_get_basename (template_dir_path) + template_suffix); + } else { + template_file_path = Glib::build_filename (template_dir_path, template_name + template_suffix); + } + } + + SessionSaveUnderway (); /* EMIT SIGNAL */ + + XMLTree tree; + + tree.set_root (&get_template()); + if (!tree.write (template_file_path)) { + error << _("template not saved") << endmsg; + return -1; + } + + if (!ARDOUR::Profile->get_trx()) { + /* copy plugin state directory */ + + std::string template_plugin_state_path (Glib::build_filename (template_dir_path, X_("plugins"))); + + if (g_mkdir_with_parents (template_plugin_state_path.c_str(), 0755) != 0) { + error << string_compose(_("Could not create directory for Session template plugin state\"%1\" (%2)"), + template_plugin_state_path, g_strerror (errno)) << endmsg; + return -1; + } + copy_files (plugins_dir(), template_plugin_state_path); + } + + store_recent_templates (template_file_path); return 0; } @@ -2078,9 +2081,9 @@ Session::save_template (string template_name) void Session::refresh_disk_space () { -#if HAVE_SYS_VFS_H && HAVE_SYS_STATVFS_H +#if __APPLE__ || (HAVE_SYS_VFS_H && HAVE_SYS_STATVFS_H) - Glib::Mutex::Lock lm (space_lock); + Glib::Threads::Mutex::Lock lm (space_lock); /* get freespace on every FS that is part of the session path */ @@ -2121,11 +2124,59 @@ Session::refresh_disk_space () _total_free_4k_blocks_uncertain = true; } } +#elif defined PLATFORM_WINDOWS + vector scanned_volumes; + vector::iterator j; + vector::iterator i; + DWORD nSectorsPerCluster, nBytesPerSector, + nFreeClusters, nTotalClusters; + char disk_drive[4]; + bool volume_found; + + _total_free_4k_blocks = 0; + + for (i = session_dirs.begin(); i != session_dirs.end(); i++) { + strncpy (disk_drive, (*i).path.c_str(), 3); + disk_drive[3] = 0; + strupr(disk_drive); + + volume_found = false; + if (0 != (GetDiskFreeSpace(disk_drive, &nSectorsPerCluster, &nBytesPerSector, &nFreeClusters, &nTotalClusters))) + { + int64_t nBytesPerCluster = nBytesPerSector * nSectorsPerCluster; + int64_t nFreeBytes = nBytesPerCluster * (int64_t)nFreeClusters; + i->blocks = (uint32_t)(nFreeBytes / 4096); + + for (j = scanned_volumes.begin(); j != scanned_volumes.end(); j++) { + if (0 == j->compare(disk_drive)) { + volume_found = true; + break; + } + } + + if (!volume_found) { + scanned_volumes.push_back(disk_drive); + _total_free_4k_blocks += i->blocks; + } + } + } + + if (0 == _total_free_4k_blocks) { + strncpy (disk_drive, path().c_str(), 3); + disk_drive[3] = 0; + + if (0 != (GetDiskFreeSpace(disk_drive, &nSectorsPerCluster, &nBytesPerSector, &nFreeClusters, &nTotalClusters))) + { + int64_t nBytesPerCluster = nBytesPerSector * nSectorsPerCluster; + int64_t nFreeBytes = nBytesPerCluster * (int64_t)nFreeClusters; + _total_free_4k_blocks = (uint32_t)(nFreeBytes / 4096); + } + } #endif } string -Session::get_best_session_directory_for_new_source () +Session::get_best_session_directory_for_new_audio () { vector::iterator i; string result = _session_dir->root_path(); @@ -2187,7 +2238,8 @@ Session::get_best_session_directory_for_new_source () } if ((*i).blocks * 4096 >= Config->get_disk_choice_space_threshold()) { - if (create_session_directory ((*i).path)) { + SessionDirectory sdir(i->path); + if (sdir.create ()) { result = (*i).path; last_rr_session_dir = i; return result; @@ -2209,7 +2261,8 @@ Session::get_best_session_directory_for_new_source () sort (sorted.begin(), sorted.end(), cmp); for (i = sorted.begin(); i != sorted.end(); ++i) { - if (create_session_directory ((*i).path)) { + SessionDirectory sdir(i->path); + if (sdir.create ()) { result = (*i).path; last_rr_session_dir = i; return result; @@ -2220,39 +2273,6 @@ Session::get_best_session_directory_for_new_source () return result; } -int -Session::load_named_selections (const XMLNode& node) -{ - XMLNodeList nlist; - XMLNodeConstIterator niter; - NamedSelection *ns; - - nlist = node.children(); - - set_dirty(); - - for (niter = nlist.begin(); niter != nlist.end(); ++niter) { - - if ((ns = XMLNamedSelectionFactory (**niter)) == 0) { - error << _("Session: cannot create Named Selection from XML description.") << endmsg; - } - } - - return 0; -} - -NamedSelection * -Session::XMLNamedSelectionFactory (const XMLNode& node) -{ - try { - return new NamedSelection (*this, node); - } - - catch (failed_constructor& err) { - return 0; - } -} - string Session::automation_dir () const { @@ -2291,7 +2311,7 @@ Session::load_bundles (XMLNode const & node) } else if ((*niter)->name() == "OutputBundle") { add_bundle (boost::shared_ptr (new UserBundle (**niter, false))); } else { - error << string_compose(_("Unknown node \"%1\" found in Bundles list from state file"), (*niter)->name()) << endmsg; + error << string_compose(_("Unknown node \"%1\" found in Bundles list from session file"), (*niter)->name()) << endmsg; return -1; } } @@ -2331,57 +2351,44 @@ Session::load_route_groups (const XMLNode& node, int version) return 0; } -void -Session::auto_save() -{ - save_state (_current_snapshot_name); -} - static bool -state_file_filter (const string &str, void */*arg*/) +state_file_filter (const string &str, void* /*arg*/) { return (str.length() > strlen(statefile_suffix) && str.find (statefile_suffix) == (str.length() - strlen (statefile_suffix))); } -struct string_cmp { - bool operator()(const string* a, const string* b) { - return *a < *b; - } -}; - -static string* -remove_end(string* state) +static string +remove_end(string state) { - string statename(*state); + string statename(state); string::size_type start,end; if ((start = statename.find_last_of (G_DIR_SEPARATOR)) != string::npos) { statename = statename.substr (start+1); } - if ((end = statename.rfind(".ardour")) == string::npos) { + if ((end = statename.rfind(statefile_suffix)) == string::npos) { end = statename.length(); } - return new string(statename.substr (0, end)); + return string(statename.substr (0, end)); } -vector * +vector Session::possible_states (string path) { - PathScanner scanner; - vector* states = scanner (path, state_file_filter, 0, false, false); + vector states; + find_files_matching_filter (states, path, state_file_filter, 0, false, false); - transform(states->begin(), states->end(), states->begin(), remove_end); + transform(states.begin(), states.end(), states.begin(), remove_end); - string_cmp cmp; - sort (states->begin(), states->end(), cmp); + sort (states.begin(), states.end()); return states; } -vector * +vector Session::possible_states () const { return possible_states(_path); @@ -2481,6 +2488,17 @@ Session::begin_reversible_command (GQuark q) _current_trans_quarks.push_front (q); } +void +Session::abort_reversible_command () +{ + if (_current_trans != 0) { + _current_trans->clear(); + delete _current_trans; + _current_trans = 0; + _current_trans_quarks.clear(); + } +} + void Session::commit_reversible_command (Command *cmd) { @@ -2515,7 +2533,7 @@ Session::commit_reversible_command (Command *cmd) } static bool -accept_all_audio_files (const string& path, void */*arg*/) +accept_all_audio_files (const string& path, void* /*arg*/) { if (!Glib::file_test (path, Glib::FILE_TEST_IS_REGULAR)) { return false; @@ -2529,7 +2547,7 @@ accept_all_audio_files (const string& path, void */*arg*/) } static bool -accept_all_midi_files (const string& path, void */*arg*/) +accept_all_midi_files (const string& path, void* /*arg*/) { if (!Glib::file_test (path, Glib::FILE_TEST_IS_REGULAR)) { return false; @@ -2541,13 +2559,18 @@ accept_all_midi_files (const string& path, void */*arg*/) } static bool -accept_all_state_files (const string& path, void */*arg*/) +accept_all_state_files (const string& path, void* /*arg*/) { - if (!Glib::file_test (path, Glib::FILE_TEST_IS_REGULAR)) { - return false; - } + if (!Glib::file_test (path, Glib::FILE_TEST_IS_REGULAR)) { + return false; + } - return (path.length() > 7 && path.find (".ardour") == (path.length() - 7)); + std::string const statefile_ext (statefile_suffix); + if (path.length() >= statefile_ext.length()) { + return (0 == path.compare (path.length() - statefile_ext.length(), statefile_ext.length(), statefile_ext)); + } else { + return false; + } } int @@ -2605,8 +2628,7 @@ Session::find_all_sources (string path, set& result) int Session::find_all_sources_across_snapshots (set& result, bool exclude_this_snapshot) { - PathScanner scanner; - vector* state_files; + vector state_files; string ripped; string this_snapshot_path; @@ -2618,9 +2640,9 @@ Session::find_all_sources_across_snapshots (set& result, bool exclude_th ripped = ripped.substr (0, ripped.length() - 1); } - state_files = scanner (ripped, accept_all_state_files, (void *) 0, false, true); + find_files_matching_filter (state_files, ripped, accept_all_state_files, (void *) 0, true, true); - if (state_files == 0) { + if (state_files.empty()) { /* impossible! */ return 0; } @@ -2629,13 +2651,13 @@ Session::find_all_sources_across_snapshots (set& result, bool exclude_th 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) { + for (vector::iterator i = state_files.begin(); i != state_files.end(); ++i) { - if (exclude_this_snapshot && **i == this_snapshot_path) { + if (exclude_this_snapshot && *i == this_snapshot_path) { continue; } - if (find_all_sources (**i, result) < 0) { + if (find_all_sources (*i, result) < 0) { return -1; } } @@ -2662,6 +2684,7 @@ Session::ask_about_playlist_deletion (boost::shared_ptr p) void Session::cleanup_regions () { + bool removed = false; const RegionFactory::RegionMap& regions (RegionFactory::regions()); for (RegionFactory::RegionMap::const_iterator i = regions.begin(); i != regions.end(); ++i) { @@ -2669,10 +2692,24 @@ Session::cleanup_regions () uint32_t used = playlists->region_use_count (i->second); if (used == 0 && !i->second->automatic ()) { + removed = true; RegionFactory::map_remove (i->second); } } + if (removed) { + // re-check to remove parent references of compound regions + for (RegionFactory::RegionMap::const_iterator i = regions.begin(); i != regions.end(); ++i) { + if (!(i->second->whole_file() && i->second->max_source_level() > 0)) { + continue; + } + assert(boost::dynamic_pointer_cast(i->second->source (0)) != 0); + if (0 == playlists->region_use_count (i->second)) { + RegionFactory::map_remove (i->second); + } + } + } + /* dump the history list */ _history.clear (); @@ -2685,18 +2722,18 @@ Session::cleanup_sources (CleanupReport& rep) // FIXME: needs adaptation to midi vector > dead_sources; - PathScanner scanner; string audio_path; string midi_path; - vector::iterator i; - vector::iterator nexti; - vector* candidates; - vector* candidates2; + vector candidates; vector unused; set all_sources; bool used; string spath; int ret = -1; + string tmppath1; + string tmppath2; + Searchpath asp; + Searchpath msp; _state_of_the_state = (StateOfTheState) (_state_of_the_state | InCleanup); @@ -2738,54 +2775,23 @@ Session::cleanup_sources (CleanupReport& rep) /* build a list of all the possible audio directories for the session */ - for (i = session_dirs.begin(); i != session_dirs.end(); ) { - - nexti = i; - ++nexti; - + for (vector::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) { SessionDirectory sdir ((*i).path); - audio_path += sdir.sound_path(); - - if (nexti != session_dirs.end()) { - audio_path += ':'; - } - - i = nexti; + asp += sdir.sound_path(); } + audio_path += asp.to_string(); /* build a list of all the possible midi directories for the session */ - for (i = session_dirs.begin(); i != session_dirs.end(); ) { - - nexti = i; - ++nexti; - + for (vector::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) { SessionDirectory sdir ((*i).path); - midi_path += sdir.midi_path(); - - if (nexti != session_dirs.end()) { - midi_path += ':'; - } - - i = nexti; + msp += sdir.midi_path(); } + midi_path += msp.to_string(); - candidates = scanner (audio_path, accept_all_audio_files, (void *) 0, true, true); - candidates2 = scanner (midi_path, accept_all_midi_files, (void *) 0, true, true); - - /* merge them */ - - if (candidates) { - if (candidates2) { - for (vector::iterator i = candidates2->begin(); i != candidates2->end(); ++i) { - candidates->push_back (*i); - } - delete candidates2; - } - } else { - candidates = candidates2; // might still be null - } + find_files_matching_filter (candidates, audio_path, accept_all_audio_files, (void *) 0, true, true); + find_files_matching_filter (candidates, midi_path, accept_all_midi_files, (void *) 0, true, true); /* find all sources, but don't use this snapshot because the state file on disk still references sources we may have already @@ -2803,62 +2809,58 @@ Session::cleanup_sources (CleanupReport& rep) ++tmp; if ((fs = boost::dynamic_pointer_cast (i->second)) != 0) { - if (playlists->source_use_count (fs) != 0) { - all_sources.insert (fs->path()); - } else { - /* we might not remove this source from disk, because it may be used - by other snapshots, but its not being used in this version - so lets get rid of it now, along with any representative regions - in the region list. - */ + if (!fs->is_stub()) { - RegionFactory::remove_regions_using_source (i->second); - sources.erase (i); - } + if (playlists->source_use_count (fs) != 0) { + all_sources.insert (fs->path()); + } else { + + /* we might not remove this source from disk, because it may be used + by other snapshots, but its not being used in this version + so lets get rid of it now, along with any representative regions + in the region list. + */ + + RegionFactory::remove_regions_using_source (i->second); + sources.erase (i); + + // also remove source from all_sources + + for (set::iterator j = all_sources.begin(); j != all_sources.end(); ++j) { + spath = Glib::path_get_basename (*j); + if ( spath == i->second->name () ) { + all_sources.erase (j); + break; + } + } + } + } } i = tmp; } - char tmppath1[PATH_MAX+1]; - char tmppath2[PATH_MAX+1]; - - if (candidates) { - for (vector::iterator x = candidates->begin(); x != candidates->end(); ++x) { - - used = false; - spath = **x; + for (vector::iterator x = candidates.begin(); x != candidates.end(); ++x) { - for (set::iterator i = all_sources.begin(); i != all_sources.end(); ++i) { + used = false; + spath = *x; - if (realpath(spath.c_str(), tmppath1) == 0) { - error << string_compose (_("Cannot expand path %1 (%2)"), - spath, strerror (errno)) << endmsg; - continue; - } + for (set::iterator i = all_sources.begin(); i != all_sources.end(); ++i) { - if (realpath((*i).c_str(), tmppath2) == 0) { - error << string_compose (_("Cannot expand path %1 (%2)"), - (*i), strerror (errno)) << endmsg; - continue; - } + tmppath1 = canonical_path (spath); + tmppath2 = canonical_path ((*i)); - if (strcmp(tmppath1, tmppath2) == 0) { - used = true; - break; - } - } - - if (!used) { - unused.push_back (spath); - } - - delete *x; - } + if (tmppath1 == tmppath2) { + used = true; + break; + } + } - delete candidates; - } + if (!used) { + unused.push_back (spath); + } + } /* now try to move all unused files into the "dead" directory(ies) */ @@ -2948,7 +2950,7 @@ Session::cleanup_sources (CleanupReport& rep) string peakpath = peak_path (base); if (Glib::file_test (peakpath.c_str(), Glib::FILE_TEST_EXISTS)) { - if (::unlink (peakpath.c_str()) != 0) { + if (::g_unlink (peakpath.c_str()) != 0) { error << string_compose (_("cannot remove peakfile %1 for %2 (%3)"), peakpath, _path, strerror (errno)) << endmsg; @@ -3003,6 +3005,12 @@ Session::cleanup_trash_sources (CleanupReport& rep) void Session::set_dirty () { + /* never mark session dirty during loading */ + + if (_state_of_the_state & Loading) { + return; + } + bool was_dirty = dirty(); _state_of_the_state = StateOfTheState (_state_of_the_state | Dirty); @@ -3048,7 +3056,7 @@ Session::add_controllable (boost::shared_ptr c) as part of the session. */ - Glib::Mutex::Lock lm (controllables_lock); + Glib::Threads::Mutex::Lock lm (controllables_lock); controllables.insert (c); } @@ -3061,7 +3069,7 @@ Session::remove_controllable (Controllable* c) return; } - Glib::Mutex::Lock lm (controllables_lock); + Glib::Threads::Mutex::Lock lm (controllables_lock); Controllables::iterator x = controllables.find (boost::shared_ptr(c, null_deleter())); @@ -3073,7 +3081,7 @@ Session::remove_controllable (Controllable* c) boost::shared_ptr Session::controllable_by_id (const PBD::ID& id) { - Glib::Mutex::Lock lm (controllables_lock); + Glib::Threads::Mutex::Lock lm (controllables_lock); for (Controllables::iterator i = controllables.begin(); i != controllables.end(); ++i) { if ((*i)->id() == id) { @@ -3094,7 +3102,7 @@ Session::controllable_by_descriptor (const ControllableDescriptor& desc) case ControllableDescriptor::NamedRoute: { std::string str = desc.top_level_name(); - if (str == "master") { + if (str == "Master" || str == "master") { r = _master_out; } else if (str == "control" || str == "listen") { r = _monitor_out; @@ -3118,6 +3126,10 @@ Session::controllable_by_descriptor (const ControllableDescriptor& desc) c = r->gain_control (); break; + case ControllableDescriptor::Trim: + c = r->trim()->gain_control (); + break; + case ControllableDescriptor::Solo: c = r->solo_control(); break; @@ -3197,7 +3209,7 @@ Session::controllable_by_descriptor (const ControllableDescriptor& desc) if (p) { boost::shared_ptr s = boost::dynamic_pointer_cast(p); boost::shared_ptr a = s->amp(); - + if (a) { c = s->amp()->gain_control(); } @@ -3240,46 +3252,40 @@ Session::save_history (string snapshot_name) return 0; } + if (!Config->get_save_history() || Config->get_saved_history_depth() < 0 || + (_history.undo_depth() == 0 && _history.redo_depth() == 0)) { + return 0; + } + if (snapshot_name.empty()) { snapshot_name = _current_snapshot_name; } const string history_filename = legalize_for_path (snapshot_name) + history_suffix; const string backup_filename = history_filename + backup_suffix; - const sys::path xml_path(Glib::build_filename (_session_dir->root_path(), history_filename)); - const sys::path backup_path(Glib::build_filename (_session_dir->root_path(), backup_filename)); + const std::string xml_path(Glib::build_filename (_session_dir->root_path(), history_filename)); + const std::string backup_path(Glib::build_filename (_session_dir->root_path(), backup_filename)); - if (sys::exists (xml_path)) { - try - { - sys::rename (xml_path, backup_path); - } - catch (const sys::filesystem_error& err) - { + if (Glib::file_test (xml_path, Glib::FILE_TEST_EXISTS)) { + if (::g_rename (xml_path.c_str(), backup_path.c_str()) != 0) { error << _("could not backup old history file, current history not saved") << endmsg; return -1; } } - if (!Config->get_save_history() || Config->get_saved_history_depth() < 0) { - return 0; - } - tree.set_root (&_history.get_state (Config->get_saved_history_depth())); - if (!tree.write (xml_path.to_string())) + if (!tree.write (xml_path)) { - error << string_compose (_("history could not be saved to %1"), xml_path.to_string()) << endmsg; + error << string_compose (_("history could not be saved to %1"), xml_path) << endmsg; - try - { - sys::remove (xml_path); - sys::rename (backup_path, xml_path); + if (g_remove (xml_path.c_str()) != 0) { + error << string_compose(_("Could not remove history file at path \"%1\" (%2)"), + xml_path, g_strerror (errno)) << endmsg; } - catch (const sys::filesystem_error& err) - { + if (::g_rename (backup_path.c_str(), xml_path.c_str()) != 0) { error << string_compose (_("could not restore history file from backup %1 (%2)"), - backup_path.to_string(), err.what()) << endmsg; + backup_path, g_strerror (errno)) << endmsg; } return -1; @@ -3297,20 +3303,20 @@ Session::restore_history (string snapshot_name) snapshot_name = _current_snapshot_name; } - const string xml_filename = legalize_for_path (snapshot_name) + history_suffix; - const sys::path xml_path(Glib::build_filename (_session_dir->root_path(), xml_filename)); + const std::string xml_filename = legalize_for_path (snapshot_name) + history_suffix; + const std::string xml_path(Glib::build_filename (_session_dir->root_path(), xml_filename)); - info << "Loading history from " << xml_path.to_string() << endmsg; + info << "Loading history from " << xml_path << endmsg; - if (!sys::exists (xml_path)) { + if (!Glib::file_test (xml_path, Glib::FILE_TEST_EXISTS)) { info << string_compose (_("%1: no history file \"%2\" for this session."), - _name, xml_path.to_string()) << endmsg; + _name, xml_path) << endmsg; return 1; } - if (!tree.read (xml_path.to_string())) { + if (!tree.read (xml_path)) { error << string_compose (_("Could not understand session history file \"%1\""), - xml_path.to_string()) << endmsg; + xml_path) << endmsg; return -1; } @@ -3439,7 +3445,7 @@ Session::config_changed (std::string p, bool ours) } else if (p == "edit-mode") { - Glib::Mutex::Lock lm (playlists->lock); + Glib::Threads::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 ()); @@ -3455,11 +3461,11 @@ Session::config_changed (std::string p, bool ours) } else if (p == "mmc-device-id" || p == "mmc-receive-id" || p == "mmc-receive-device-id") { - MIDI::Manager::instance()->mmc()->set_receive_device_id (Config->get_mmc_receive_device_id()); + _mmc->set_receive_device_id (Config->get_mmc_receive_device_id()); } else if (p == "mmc-send-id" || p == "mmc-send-device-id") { - MIDI::Manager::instance()->mmc()->set_send_device_id (Config->get_mmc_send_device_id()); + _mmc->set_send_device_id (Config->get_mmc_send_device_id()); } else if (p == "midi-control") { @@ -3522,7 +3528,7 @@ Session::config_changed (std::string p, bool ours) } else if (p == "send-mmc") { - MIDI::Manager::instance()->mmc()->enable_send (Config->get_send_mmc ()); + _mmc->enable_send (Config->get_send_mmc ()); } else if (p == "midi-feedback") { @@ -3552,25 +3558,25 @@ Session::config_changed (std::string p, bool ours) if (!config.get_external_sync()) { drop_sync_source (); } else { - switch_to_sync_source (config.get_sync_source()); + switch_to_sync_source (Config->get_sync_source()); } - } else if (p == "remote-model") { - set_remote_control_ids (); } 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 == "remote-model") { + /* XXX DO SOMETHING HERE TO TELL THE GUI THAT WE NEED + TO SET REMOTE ID'S + */ } else if (p == "initial-program-change") { - if (MIDI::Manager::instance()->mmc()->output_port() && Config->get_initial_program_change() >= 0) { + if (_mmc->output_port() && Config->get_initial_program_change() >= 0) { MIDI::byte buf[2]; buf[0] = MIDI::program; // channel zero by default buf[1] = (Config->get_initial_program_change() & 0x7f); - MIDI::Manager::instance()->mmc()->output_port()->midimsg (buf, sizeof (buf), 0); + _mmc->output_port()->midimsg (buf, sizeof (buf), 0); } } else if (p == "solo-mute-override") { // catch_up_on_solo_mute_override (); @@ -3578,12 +3584,18 @@ Session::config_changed (std::string p, bool ours) listen_position_changed (); } else if (p == "solo-control-is-listen-control") { solo_control_mode_changed (); + } else if (p == "solo-mute-gain") { + _solo_cut_control->Changed(); } else if (p == "timecode-offset" || p == "timecode-offset-negative") { last_timecode_valid = false; } else if (p == "playback-buffer-seconds") { AudioSource::allocate_working_buffers (frame_rate()); - } else if (p == "automation-thinning-factor") { - Evoral::ControlList::set_thinning_factor (Config->get_automation_thinning_factor()); + } else if (p == "ltc-source-port") { + reconnect_ltc_input (); + } else if (p == "ltc-sink-port") { + reconnect_ltc_output (); + } else if (p == "timecode-generator-offset") { + ltc_tx_parse_offset(); } set_dirty (); @@ -3628,27 +3640,28 @@ Session::load_diskstreams_2X (XMLNode const & node, int) void Session::setup_midi_machine_control () { - MIDI::MachineControl* mmc = MIDI::Manager::instance()->mmc (); - - mmc->Play.connect_same_thread (*this, boost::bind (&Session::mmc_deferred_play, this, _1)); - mmc->DeferredPlay.connect_same_thread (*this, boost::bind (&Session::mmc_deferred_play, this, _1)); - mmc->Stop.connect_same_thread (*this, boost::bind (&Session::mmc_stop, this, _1)); - mmc->FastForward.connect_same_thread (*this, boost::bind (&Session::mmc_fast_forward, this, _1)); - mmc->Rewind.connect_same_thread (*this, boost::bind (&Session::mmc_rewind, this, _1)); - mmc->Pause.connect_same_thread (*this, boost::bind (&Session::mmc_pause, this, _1)); - mmc->RecordPause.connect_same_thread (*this, boost::bind (&Session::mmc_record_pause, this, _1)); - mmc->RecordStrobe.connect_same_thread (*this, boost::bind (&Session::mmc_record_strobe, this, _1)); - mmc->RecordExit.connect_same_thread (*this, boost::bind (&Session::mmc_record_exit, this, _1)); - mmc->Locate.connect_same_thread (*this, boost::bind (&Session::mmc_locate, this, _1, _2)); - mmc->Step.connect_same_thread (*this, boost::bind (&Session::mmc_step, this, _1, _2)); - mmc->Shuttle.connect_same_thread (*this, boost::bind (&Session::mmc_shuttle, this, _1, _2, _3)); - mmc->TrackRecordStatusChange.connect_same_thread (*this, boost::bind (&Session::mmc_record_enable, this, _1, _2, _3)); + _mmc = new MIDI::MachineControl; + _mmc->set_ports (_midi_ports->mmc_input_port(), _midi_ports->mmc_output_port()); + + _mmc->Play.connect_same_thread (*this, boost::bind (&Session::mmc_deferred_play, this, _1)); + _mmc->DeferredPlay.connect_same_thread (*this, boost::bind (&Session::mmc_deferred_play, this, _1)); + _mmc->Stop.connect_same_thread (*this, boost::bind (&Session::mmc_stop, this, _1)); + _mmc->FastForward.connect_same_thread (*this, boost::bind (&Session::mmc_fast_forward, this, _1)); + _mmc->Rewind.connect_same_thread (*this, boost::bind (&Session::mmc_rewind, this, _1)); + _mmc->Pause.connect_same_thread (*this, boost::bind (&Session::mmc_pause, this, _1)); + _mmc->RecordPause.connect_same_thread (*this, boost::bind (&Session::mmc_record_pause, this, _1)); + _mmc->RecordStrobe.connect_same_thread (*this, boost::bind (&Session::mmc_record_strobe, this, _1)); + _mmc->RecordExit.connect_same_thread (*this, boost::bind (&Session::mmc_record_exit, this, _1)); + _mmc->Locate.connect_same_thread (*this, boost::bind (&Session::mmc_locate, this, _1, _2)); + _mmc->Step.connect_same_thread (*this, boost::bind (&Session::mmc_step, this, _1, _2)); + _mmc->Shuttle.connect_same_thread (*this, boost::bind (&Session::mmc_shuttle, this, _1, _2, _3)); + _mmc->TrackRecordStatusChange.connect_same_thread (*this, boost::bind (&Session::mmc_record_enable, this, _1, _2, _3)); /* also handle MIDI SPP because its so common */ - mmc->SPPStart.connect_same_thread (*this, boost::bind (&Session::spp_start, this)); - mmc->SPPContinue.connect_same_thread (*this, boost::bind (&Session::spp_continue, this)); - mmc->SPPStop.connect_same_thread (*this, boost::bind (&Session::spp_stop, this)); + _mmc->SPPStart.connect_same_thread (*this, boost::bind (&Session::spp_start, this)); + _mmc->SPPContinue.connect_same_thread (*this, boost::bind (&Session::spp_continue, this)); + _mmc->SPPStop.connect_same_thread (*this, boost::bind (&Session::spp_stop, this)); } boost::shared_ptr @@ -3670,14 +3683,23 @@ int Session::rename (const std::string& new_name) { string legal_name = legalize_for_path (new_name); - string newpath; + string new_path; string oldstr; string newstr; bool first = true; string const old_sources_root = _session_dir->sources_root(); -#define RENAME ::rename + if (!_writable || (_state_of_the_state & CannotSave)) { + error << _("Cannot rename read-only session.") << endmsg; + return 0; // don't show "messed up" warning + } + if (record_status() == Recording) { + error << _("Cannot rename session while recording") << endmsg; + return 0; // don't show "messed up" warning + } + + StateProtector stp (this); /* Rename: @@ -3689,115 +3711,163 @@ Session::rename (const std::string& new_name) * Backup files are left unchanged and not renamed. */ + /* Windows requires that we close all files before attempting the + * rename. This works on other platforms, but isn't necessary there. + * Leave it in place for all platforms though, since it may help + * catch issues that could arise if the way Source files work ever + * change (since most developers are not using Windows). + */ + + for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) { + boost::shared_ptr fs = boost::dynamic_pointer_cast (i->second); + if (fs) { + fs->close (); + } + } + /* pass one: not 100% safe check that the new directory names don't * already exist ... */ for (vector::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) { - vector v; - + oldstr = (*i).path; - + /* this is a stupid hack because Glib::path_get_dirname() is * lexical-only, and so passing it /a/b/c/ gives a different * result than passing it /a/b/c ... */ - + if (oldstr[oldstr.length()-1] == G_DIR_SEPARATOR) { oldstr = oldstr.substr (0, oldstr.length() - 1); } - + string base = Glib::path_get_dirname (oldstr); - string p = Glib::path_get_basename (oldstr); - + newstr = Glib::build_filename (base, legal_name); + cerr << "Looking for " << newstr << endl; + if (Glib::file_test (newstr, Glib::FILE_TEST_EXISTS)) { + cerr << " exists\n"; return -1; } } /* Session dirs */ + + first = true; - for (vector::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) { + for (vector::iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) { + vector v; oldstr = (*i).path; - + /* this is a stupid hack because Glib::path_get_dirname() is * lexical-only, and so passing it /a/b/c/ gives a different * result than passing it /a/b/c ... */ - + if (oldstr[oldstr.length()-1] == G_DIR_SEPARATOR) { oldstr = oldstr.substr (0, oldstr.length() - 1); } string base = Glib::path_get_dirname (oldstr); - string p = Glib::path_get_basename (oldstr); - newstr = Glib::build_filename (base, legal_name); + cerr << "for " << oldstr << " new dir = " << newstr << endl; + cerr << "Rename " << oldstr << " => " << newstr << endl; - - if (RENAME (oldstr.c_str(), newstr.c_str()) != 0) { + if (::g_rename (oldstr.c_str(), newstr.c_str()) != 0) { + cerr << string_compose (_("renaming %s as %2 failed (%3)"), oldstr, newstr, g_strerror (errno)) << endl; + error << string_compose (_("renaming %s as %2 failed (%3)"), oldstr, newstr, g_strerror (errno)) << endmsg; return 1; } + /* Reset path in "session dirs" */ + + (*i).path = newstr; + (*i).blocks = 0; + + /* reset primary SessionDirectory object */ + if (first) { (*_session_dir) = newstr; - newpath = newstr; - first = 1; + new_path = newstr; + first = false; } - /* directory below interchange */ + /* now rename directory below session_dir/interchange */ - v.push_back (newstr); + string old_interchange_dir; + string new_interchange_dir; + + /* use newstr here because we renamed the path + * (folder/directory) that used to be oldstr to newstr above + */ + + v.push_back (newstr); v.push_back (interchange_dir_name); - v.push_back (p); + v.push_back (Glib::path_get_basename (oldstr)); - oldstr = Glib::build_filename (v); + old_interchange_dir = Glib::build_filename (v); v.clear (); v.push_back (newstr); v.push_back (interchange_dir_name); v.push_back (legal_name); - - newstr = Glib::build_filename (v); - cerr << "Rename " << oldstr << " => " << newstr << endl; + new_interchange_dir = Glib::build_filename (v); + + cerr << "Rename " << old_interchange_dir << " => " << new_interchange_dir << endl; - if (RENAME (oldstr.c_str(), newstr.c_str()) != 0) { + if (::g_rename (old_interchange_dir.c_str(), new_interchange_dir.c_str()) != 0) { + cerr << string_compose (_("renaming %s as %2 failed (%3)"), + old_interchange_dir, new_interchange_dir, + g_strerror (errno)) + << endl; + error << string_compose (_("renaming %s as %2 failed (%3)"), + old_interchange_dir, new_interchange_dir, + g_strerror (errno)) + << endmsg; return 1; } } /* state file */ - oldstr = Glib::build_filename (newpath, _current_snapshot_name) + statefile_suffix; - newstr= Glib::build_filename (newpath, legal_name) + statefile_suffix; + oldstr = Glib::build_filename (new_path, _current_snapshot_name + statefile_suffix); + newstr= Glib::build_filename (new_path, legal_name + statefile_suffix); cerr << "Rename " << oldstr << " => " << newstr << endl; - if (RENAME (oldstr.c_str(), newstr.c_str()) != 0) { + if (::g_rename (oldstr.c_str(), newstr.c_str()) != 0) { + cerr << string_compose (_("renaming %1 as %2 failed (%3)"), oldstr, newstr, g_strerror (errno)) << endl; + error << string_compose (_("renaming %1 as %2 failed (%3)"), oldstr, newstr, g_strerror (errno)) << endmsg; return 1; } /* history file */ - - oldstr = Glib::build_filename (newpath, _current_snapshot_name) + history_suffix; + oldstr = Glib::build_filename (new_path, _current_snapshot_name) + history_suffix; if (Glib::file_test (oldstr, Glib::FILE_TEST_EXISTS)) { - newstr = Glib::build_filename (newpath, legal_name) + history_suffix; + newstr = Glib::build_filename (new_path, legal_name) + history_suffix; cerr << "Rename " << oldstr << " => " << newstr << endl; - if (RENAME (oldstr.c_str(), newstr.c_str()) != 0) { + if (::g_rename (oldstr.c_str(), newstr.c_str()) != 0) { + cerr << string_compose (_("renaming %1 as %2 failed (%3)"), oldstr, newstr, g_strerror (errno)) << endl; + error << string_compose (_("renaming %1 as %2 failed (%3)"), oldstr, newstr, g_strerror (errno)) << endmsg; return 1; } } + /* remove old name from recent sessions */ + remove_recent_sessions (_path); + _path = new_path; + /* update file source paths */ for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) { @@ -3806,29 +3876,617 @@ Session::rename (const std::string& new_name) string p = fs->path (); boost::replace_all (p, old_sources_root, _session_dir->sources_root()); fs->set_path (p); + SourceFactory::setup_peakfile(i->second, true); } } - /* remove old name from recent sessions */ - - remove_recent_sessions (_path); - - _path = newpath; _current_snapshot_name = new_name; _name = new_name; - + set_dirty (); /* save state again to get everything just right */ save_state (_current_snapshot_name); - /* add to recent sessions */ store_recent_sessions (new_name, _path); return 0; +} -#undef RENAME +int +Session::get_session_info_from_path (XMLTree& tree, const string& xmlpath) +{ + if (!Glib::file_test (xmlpath, Glib::FILE_TEST_EXISTS)) { + return -1; + } + + if (!tree.read (xmlpath)) { + return -1; + } + + return 0; +} + +int +Session::get_info_from_path (const string& xmlpath, float& sample_rate, SampleFormat& data_format) +{ + XMLTree tree; + bool found_sr = false; + bool found_data_format = false; + + if (get_session_info_from_path (tree, xmlpath)) { + return -1; + } + + /* sample rate */ + + const XMLProperty* prop; + if ((prop = tree.root()->property (X_("sample-rate"))) != 0) { + sample_rate = atoi (prop->value()); + found_sr = true; + } + + const XMLNodeList& children (tree.root()->children()); + for (XMLNodeList::const_iterator c = children.begin(); c != children.end(); ++c) { + const XMLNode* child = *c; + if (child->name() == "Config") { + const XMLNodeList& options (child->children()); + for (XMLNodeList::const_iterator oc = options.begin(); oc != options.end(); ++oc) { + const XMLNode* option = *oc; + const XMLProperty* name = option->property("name"); + + if (!name) { + continue; + } + + if (name->value() == "native-file-data-format") { + const XMLProperty* value = option->property ("value"); + if (value) { + SampleFormat fmt = (SampleFormat) string_2_enum (option->property ("value")->value(), fmt); + data_format = fmt; + found_data_format = true; + break; + } + } + } + } + if (found_data_format) { + break; + } + } + + return !(found_sr && found_data_format); // zero if they are both found +} + +typedef std::vector > SeveralFileSources; +typedef std::map SourcePathMap; + +int +Session::bring_all_sources_into_session (boost::function callback) +{ + uint32_t total = 0; + uint32_t n = 0; + SourcePathMap source_path_map; + string new_path; + boost::shared_ptr afs; + int ret = 0; + + { + + Glib::Threads::Mutex::Lock lm (source_lock); + + cerr << " total sources = " << sources.size(); + + for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) { + boost::shared_ptr fs = boost::dynamic_pointer_cast (i->second); + + if (!fs) { + continue; + } + + if (fs->within_session()) { + continue; + } + + if (source_path_map.find (fs->path()) != source_path_map.end()) { + source_path_map[fs->path()].push_back (fs); + } else { + SeveralFileSources v; + v.push_back (fs); + source_path_map.insert (make_pair (fs->path(), v)); + } + + total++; + } + + cerr << " fsources = " << total << endl; + + for (SourcePathMap::iterator i = source_path_map.begin(); i != source_path_map.end(); ++i) { + + /* tell caller where we are */ + + string old_path = i->first; + + callback (n, total, old_path); + + cerr << old_path << endl; + + new_path.clear (); + + switch (i->second.front()->type()) { + case DataType::AUDIO: + new_path = new_audio_source_path_for_embedded (old_path); + break; + + case DataType::MIDI: + /* XXX not implemented yet */ + break; + } + + if (new_path.empty()) { + continue; + } + + cerr << "Move " << old_path << " => " << new_path << endl; + + if (!copy_file (old_path, new_path)) { + cerr << "failed !\n"; + ret = -1; + } + + /* make sure we stop looking in the external + dir/folder. Remember, this is an all-or-nothing + operations, it doesn't merge just some files. + */ + remove_dir_from_search_path (Glib::path_get_dirname (old_path), i->second.front()->type()); + + for (SeveralFileSources::iterator f = i->second.begin(); f != i->second.end(); ++f) { + (*f)->set_path (new_path); + } + } + } + + save_state ("", false, false); + + return ret; +} + +static +bool accept_all_files (string const &, void *) +{ + return true; +} + +void +Session::save_as_bring_callback (uint32_t,uint32_t,string) +{ + /* It would be good if this did something useful vis-a-vis save-as, but the arguments doesn't provide the correct information right now to do this. + */ +} + +static string +make_new_media_path (string old_path, string new_session_folder, string new_session_path) +{ + /* typedir is the "midifiles" or "audiofiles" etc. part of the path. */ + + string typedir = Glib::path_get_basename (Glib::path_get_dirname (old_path)); + vector v; + v.push_back (new_session_folder); /* full path */ + v.push_back (interchange_dir_name); + v.push_back (new_session_path); /* just one directory/folder */ + v.push_back (typedir); + v.push_back (Glib::path_get_basename (old_path)); + + return Glib::build_filename (v); +} + +int +Session::save_as (SaveAs& saveas) +{ + vector files; + string current_folder = Glib::path_get_dirname (_path); + string new_folder = legalize_for_path (saveas.new_name); + string to_dir = Glib::build_filename (saveas.new_parent_folder, new_folder); + int64_t total_bytes = 0; + int64_t copied = 0; + int64_t cnt = 0; + int64_t all = 0; + int32_t internal_file_cnt = 0; + + vector do_not_copy_extensions; + do_not_copy_extensions.push_back (statefile_suffix); + do_not_copy_extensions.push_back (pending_suffix); + do_not_copy_extensions.push_back (backup_suffix); + do_not_copy_extensions.push_back (temp_suffix); + do_not_copy_extensions.push_back (history_suffix); + + /* get total size */ + + for (vector::const_iterator sd = session_dirs.begin(); sd != session_dirs.end(); ++sd) { + + /* need to clear this because + * find_files_matching_filter() is cumulative + */ + + files.clear (); + + find_files_matching_filter (files, (*sd).path, accept_all_files, 0, false, true, true); + + all += files.size(); + + for (vector::iterator i = files.begin(); i != files.end(); ++i) { + GStatBuf gsb; + g_stat ((*i).c_str(), &gsb); + total_bytes += gsb.st_size; + } + } + + /* save old values so we can switch back if we are not switching to the new session */ + + string old_path = _path; + string old_name = _name; + string old_snapshot = _current_snapshot_name; + string old_sd = _session_dir->root_path(); + vector old_search_path[DataType::num_types]; + string old_config_search_path[DataType::num_types]; + + old_search_path[DataType::AUDIO] = source_search_path (DataType::AUDIO); + old_search_path[DataType::MIDI] = source_search_path (DataType::MIDI); + old_config_search_path[DataType::AUDIO] = config.get_audio_search_path (); + old_config_search_path[DataType::MIDI] = config.get_midi_search_path (); + + /* switch session directory */ + + (*_session_dir) = to_dir; + + /* create new tree */ + + if (!_session_dir->create()) { + saveas.failure_message = string_compose (_("Cannot create new session folder %1"), to_dir); + return -1; + } + + try { + /* copy all relevant files. Find each location in session_dirs, + * and copy files from there to target. + */ + + for (vector::const_iterator sd = session_dirs.begin(); sd != session_dirs.end(); ++sd) { + + /* need to clear this because + * find_files_matching_filter() is cumulative + */ + + files.clear (); + + const size_t prefix_len = (*sd).path.size(); + + /* Work just on the files within this session dir */ + + find_files_matching_filter (files, (*sd).path, accept_all_files, 0, false, true, true); + + /* add dir separator to protect against collisions with + * track names (e.g. track named "audiofiles" or + * "analysis". + */ + + static const std::string audiofile_dir_string = string (sound_dir_name) + G_DIR_SEPARATOR; + static const std::string midifile_dir_string = string (midi_dir_name) + G_DIR_SEPARATOR; + static const std::string analysis_dir_string = analysis_dir() + G_DIR_SEPARATOR; + + /* copy all the files. Handling is different for media files + than others because of the *silly* subtree we have below the interchange + folder. That really was a bad idea, but I'm not fixing it as part of + implementing ::save_as(). + */ + + for (vector::iterator i = files.begin(); i != files.end(); ++i) { + + std::string from = *i; + +#ifdef __APPLE__ + string filename = Glib::path_get_basename (from); + std::transform (filename.begin(), filename.end(), filename.begin(), ::toupper); + if (filename == ".DS_STORE") { + continue; + } +#endif + + if (from.find (audiofile_dir_string) != string::npos) { + + /* audio file: only copy if asked */ + + if (saveas.include_media && saveas.copy_media) { + + string to = make_new_media_path (*i, to_dir, new_folder); + + info << "media file copying from " << from << " to " << to << endmsg; + + if (!copy_file (from, to)) { + throw Glib::FileError (Glib::FileError::IO_ERROR, + string_compose(_("\ncopying \"%1\" failed !"), from)); + } + } + + /* we found media files inside the session folder */ + + internal_file_cnt++; + + } else if (from.find (midifile_dir_string) != string::npos) { + + /* midi file: always copy unless + * creating an empty new session + */ + + if (saveas.include_media) { + + string to = make_new_media_path (*i, to_dir, new_folder); + + info << "media file copying from " << from << " to " << to << endmsg; + + if (!copy_file (from, to)) { + throw Glib::FileError (Glib::FileError::IO_ERROR, "copy failed"); + } + } + + /* we found media files inside the session folder */ + + internal_file_cnt++; + + } else if (from.find (analysis_dir_string) != string::npos) { + + /* make sure analysis dir exists in + * new session folder, but we're not + * copying analysis files here, see + * below + */ + + (void) g_mkdir_with_parents (analysis_dir().c_str(), 775); + continue; + + } else { + + /* normal non-media file. Don't copy state, history, etc. + */ + + bool do_copy = true; + + for (vector::iterator v = do_not_copy_extensions.begin(); v != do_not_copy_extensions.end(); ++v) { + if ((from.length() > (*v).length()) && (from.find (*v) == from.length() - (*v).length())) { + /* end of filename matches extension, do not copy file */ + do_copy = false; + break; + } + } + + if (!saveas.copy_media && from.find (peakfile_suffix) != string::npos) { + /* don't copy peakfiles if + * we're not copying media + */ + do_copy = false; + } + + if (do_copy) { + string to = Glib::build_filename (to_dir, from.substr (prefix_len)); + + info << "attempting to make directory/folder " << to << endmsg; + + if (g_mkdir_with_parents (Glib::path_get_dirname (to).c_str(), 0755)) { + throw Glib::FileError (Glib::FileError::IO_ERROR, "cannot create required directory"); + } + + info << "attempting to copy " << from << " to " << to << endmsg; + + if (!copy_file (from, to)) { + throw Glib::FileError (Glib::FileError::IO_ERROR, + string_compose(_("\ncopying \"%1\" failed !"), from)); + } + } + } + + /* measure file size even if we're not going to copy so that our Progress + signals are correct, since we included these do-not-copy files + in the computation of the total size and file count. + */ + + GStatBuf gsb; + g_stat (from.c_str(), &gsb); + copied += gsb.st_size; + cnt++; + + double fraction = (double) copied / total_bytes; + + bool keep_going = true; + + if (saveas.copy_media) { + + /* no need or expectation of this if + * media is not being copied, because + * it will be fast(ish). + */ + + /* tell someone "X percent, file M of N"; M is one-based */ + + boost::optional res = saveas.Progress (fraction, cnt, all); + + if (res) { + keep_going = *res; + } + } + + if (!keep_going) { + throw Glib::FileError (Glib::FileError::FAILED, "copy cancelled"); + } + } + + } + + /* copy optional folders, if any */ + + string old = plugins_dir (); + if (Glib::file_test (old, Glib::FILE_TEST_EXISTS)) { + string newdir = Glib::build_filename (to_dir, Glib::path_get_basename (old)); + copy_files (old, newdir); + } + + old = externals_dir (); + if (Glib::file_test (old, Glib::FILE_TEST_EXISTS)) { + string newdir = Glib::build_filename (to_dir, Glib::path_get_basename (old)); + copy_files (old, newdir); + } + + old = automation_dir (); + if (Glib::file_test (old, Glib::FILE_TEST_EXISTS)) { + string newdir = Glib::build_filename (to_dir, Glib::path_get_basename (old)); + copy_files (old, newdir); + } + + if (saveas.include_media) { + + if (saveas.copy_media) { +#ifndef PLATFORM_WINDOWS + /* There are problems with analysis files on + * Windows, because they used a colon in their + * names as late as 4.0. Colons are not legal + * under Windows even if NTFS allows them. + * + * This is a tricky problem to solve so for + * just don't copy these files. They will be + * regenerated as-needed anyway, subject to the + * existing issue that the filenames will be + * rejected by Windows, which is a separate + * problem (though related). + */ + + /* only needed if we are copying media, since the + * analysis data refers to media data + */ + + old = analysis_dir (); + if (Glib::file_test (old, Glib::FILE_TEST_EXISTS)) { + string newdir = Glib::build_filename (to_dir, "analysis"); + copy_files (old, newdir); + } +#endif /* PLATFORM_WINDOWS */ + } + } + + + _path = to_dir; + _current_snapshot_name = saveas.new_name; + _name = saveas.new_name; + + if (saveas.include_media && !saveas.copy_media) { + + /* reset search paths of the new session (which we're pretending to be right now) to + include the original session search path, so we can still find all audio. + */ + + if (internal_file_cnt) { + for (vector::iterator s = old_search_path[DataType::AUDIO].begin(); s != old_search_path[DataType::AUDIO].end(); ++s) { + ensure_search_path_includes (*s, DataType::AUDIO); + } + + /* we do not do this for MIDI because we copy + all MIDI files if saveas.include_media is + true + */ + } + } + + bool was_dirty = dirty (); + + save_state ("", false, false, !saveas.include_media); + save_default_options (); + + if (saveas.copy_media && saveas.copy_external) { + if (bring_all_sources_into_session (boost::bind (&Session::save_as_bring_callback, this, _1, _2, _3))) { + throw Glib::FileError (Glib::FileError::NO_SPACE_LEFT, "consolidate failed"); + } + } + + saveas.final_session_folder_name = _path; + + if (!saveas.switch_to) { + + /* switch back to the way things were */ + + _path = old_path; + _name = old_name; + _current_snapshot_name = old_snapshot; + + (*_session_dir) = old_sd; + + if (was_dirty) { + set_dirty (); + } + + if (internal_file_cnt) { + /* reset these to their original values */ + config.set_audio_search_path (old_config_search_path[DataType::AUDIO]); + config.set_midi_search_path (old_config_search_path[DataType::MIDI]); + } + + } else { + + /* prune session dirs, and update disk space statistics + */ + + space_and_path sp; + sp.path = _path; + session_dirs.clear (); + session_dirs.push_back (sp); + refresh_disk_space (); + + /* ensure that all existing tracks reset their current capture source paths + */ + reset_write_sources (true, true); + + /* the copying above was based on actually discovering files, not just iterating over the sources list. + But if we're going to switch to the new (copied) session, we need to change the paths in the sources also. + */ + + for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) { + boost::shared_ptr fs = boost::dynamic_pointer_cast (i->second); + + if (!fs) { + continue; + } + + if (fs->within_session()) { + string newpath = make_new_media_path (fs->path(), to_dir, new_folder); + fs->set_path (newpath); + } + } + } + + } catch (Glib::FileError& e) { + + saveas.failure_message = e.what(); + + /* recursively remove all the directories */ + + remove_directory (to_dir); + + /* return error */ + + return -1; + + } catch (...) { + + saveas.failure_message = _("unknown reason"); + + /* recursively remove all the directories */ + + remove_directory (to_dir); + + /* return error */ + + return -1; + } + + return 0; }