X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fsession_state.cc;h=6c7e7bff0e186388467ccc44e048c97960582101;hb=304b491a29430d3ef9f2e17d50e1f0e39d6abede;hp=5c3ffae3cc087c58031b3384bb5e01e2511ec89d;hpb=2b9421fd391efcddde0be3397cb66e19b744a155;p=ardour.git diff --git a/libs/ardour/session_state.cc b/libs/ardour/session_state.cc index 5c3ffae3cc..5729c889bd 100644 --- a/libs/ardour/session_state.cc +++ b/libs/ardour/session_state.cc @@ -25,13 +25,12 @@ #include #include -#include #include #include #include /* snprintf(3) ... grrr */ #include + #include -#include #include #include #include @@ -40,7 +39,7 @@ #include #endif -#ifdef __APPLE__ +#if defined(__APPLE__) || defined(__FreeBSD__) #include #include #endif @@ -50,10 +49,11 @@ #endif #include -#include +#include "pbd/gstdio_compat.h" #include #include +#include #include @@ -62,28 +62,30 @@ #include "evoral/SMF.hpp" -#include "pbd/boost_debug.h" #include "pbd/basename.h" -#include "pbd/controllable_descriptor.h" +#include "pbd/debug.h" #include "pbd/enumwriter.h" #include "pbd/error.h" #include "pbd/file_utils.h" #include "pbd/pathexpand.h" -#include "pbd/pathscanner.h" #include "pbd/pthread_utils.h" #include "pbd/stacktrace.h" #include "pbd/convert.h" -#include "pbd/clear_dir.h" #include "pbd/localtime_r.h" +#include "pbd/unwind.h" #include "ardour/amp.h" +#include "ardour/async_midi_port.h" #include "ardour/audio_diskstream.h" #include "ardour/audio_track.h" #include "ardour/audioengine.h" #include "ardour/audiofilesource.h" #include "ardour/audioregion.h" +#include "ardour/auditioner.h" #include "ardour/automation_control.h" +#include "ardour/boost_debug.h" #include "ardour/butler.h" +#include "ardour/controllable_descriptor.h" #include "ardour/control_protocol_manager.h" #include "ardour/directory_names.h" #include "ardour/filename_extensions.h" @@ -92,15 +94,19 @@ #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/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" +#include "ardour/revision.h" #include "ardour/route_group.h" #include "ardour/send.h" #include "ardour/session.h" @@ -116,16 +122,22 @@ #include "ardour/tempo.h" #include "ardour/ticker.h" #include "ardour/user_bundle.h" +#include "ardour/vca.h" +#include "ardour/vca_manager.h" #include "control_protocol/control_protocol.h" -#include "i18n.h" +#include "LuaBridge/LuaBridge.h" + +#include "pbd/i18n.h" #include using namespace std; using namespace ARDOUR; using namespace PBD; +#define DEBUG_UNDO_HISTORY(msg) DEBUG_TRACE (PBD::DEBUG::UndoHistory, string_compose ("%1: %2\n", __LINE__, msg)); + void Session::pre_engine_init (string fullpath) { @@ -137,16 +149,20 @@ Session::pre_engine_init (string fullpath) /* discover canonical fullpath */ _path = canonical_path(fullpath); - - /* we require _path to end with a dir separator */ - - if (_path[_path.length()-1] != G_DIR_SEPARATOR) { - _path += G_DIR_SEPARATOR; - } /* is it new ? */ + if (Profile->get_trx() ) { + // Waves TracksLive has a usecase of session replacement with a new one. + // We should check session state file (.ardour) existance + // to determine if the session is new or not - _is_new = !Glib::file_test (_path, Glib::FileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)); + string full_session_name = Glib::build_filename( fullpath, _name ); + full_session_name += statefile_suffix; + + _is_new = !Glib::file_test (full_session_name, Glib::FileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)); + } else { + _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. @@ -170,7 +186,7 @@ Session::pre_engine_init (string fullpath) last_rr_session_dir = session_dirs.begin(); set_history_depth (Config->get_history_depth()); - + /* default: assume simple stereo speaker configuration */ _speakers->setup_default_speakers (2); @@ -192,8 +208,6 @@ Session::pre_engine_init (string fullpath) Delivery::disable_panners (); IO::disable_connecting (); - - AudioFileSource::set_peak_dir (_session_dir->peak_path()); } int @@ -207,16 +221,26 @@ Session::post_engine_init () BootMessage (_("Using configuration")); _midi_ports = new MidiPortManager; + + MIDISceneChanger* msc; + + _scene_changer = msc = new MIDISceneChanger (*this); + msc->set_input_port (boost::dynamic_pointer_cast(scene_input_port())); + msc->set_output_port (boost::dynamic_pointer_cast(scene_output_port())); + + boost::function timer_func (boost::bind (&Session::audible_frame, this)); + boost::dynamic_pointer_cast(scene_input_port())->set_timer (timer_func); + setup_midi_machine_control (); - + if (_butler->start_thread()) { return -1; } - + if (start_midi_thread ()) { return -1; } - + setup_click_sounds (0); setup_midi_control (); @@ -226,11 +250,14 @@ Session::post_engine_init () try { /* 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)); - + _tempo_map->MetricPositionChanged.connect_same_thread (*this, boost::bind (&Session::gui_tempo_map_changed, this)); + /* MidiClock requires a tempo map */ + delete midi_clock; midi_clock = new MidiClockTicker (); midi_clock->set_session (this); @@ -238,14 +265,14 @@ Session::post_engine_init () 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; @@ -260,54 +287,56 @@ Session::post_engine_init () 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); + _butler->map_parameters (); /* 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)); - _locations->added.connect_same_thread (*this, boost::bind (&Session::locations_added, this, _1)); - + } catch (AudioEngine::PortRegistrationFailure& err) { /* handle this one in a different way than all others, so that its clear what happened */ error << err.what() << endmsg; @@ -321,10 +350,10 @@ Session::post_engine_init () // send_full_time_code (0); _engine.transport_locate (0); - _mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdMmcReset)); - _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); + MIDI::Name::MidiPatchManager::instance().add_search_path (session_directory().midi_patch_path() ); ltc_tx_initialize(); /* initial program change will be delivered later; see ::config_changed() */ @@ -343,9 +372,44 @@ Session::post_engine_init () state_was_pending = false; } + /* Now, finally, we can fill the playback buffers */ + + BootMessage (_("Filling playback buffers")); + + boost::shared_ptr rl = routes.reader(); + for (RouteList::iterator r = rl->begin(); r != rl->end(); ++r) { + boost::shared_ptr trk = boost::dynamic_pointer_cast (*r); + if (trk && !trk->hidden()) { + trk->seek (_transport_frame, true); + } + } + return 0; } +void +Session::session_loaded () +{ + SessionLoaded(); + + _state_of_the_state = Clean; + + DirtyChanged (); /* EMIT SIGNAL */ + + if (_is_new) { + save_state (""); + } else if (state_was_pending) { + save_state (""); + remove_pending_capture_state (); + state_was_pending = false; + } + + /* Now, finally, we can fill the playback buffers */ + + BootMessage (_("Filling playback buffers")); + force_locate (_transport_frame, false); +} + string Session::raid_path () const { @@ -482,9 +546,9 @@ Session::create (const string& session_template, BusProfile* bus_profile) _writable = exists_and_writable (_path); if (!session_template.empty()) { - std::string in_path = session_template_dir_to_file (session_template); + string in_path = (ARDOUR::Profile->get_trx () ? session_template : session_template_dir_to_file (session_template)); - ifstream in(in_path.c_str()); + FILE* in = g_fopen (in_path.c_str(), "rb"); if (in) { /* no need to call legalize_for_path() since the string @@ -492,21 +556,51 @@ Session::create (const string& session_template, BusProfile* bus_profile) */ string out_path = Glib::build_filename (_session_dir->root_path(), _name + statefile_suffix); - ofstream out(out_path.c_str()); + FILE* out = g_fopen (out_path.c_str(), "wb"); if (out) { - out << in.rdbuf(); - _is_new = false; + char buf[1024]; + stringstream new_session; + + while (!feof (in)) { + size_t charsRead = fread (buf, sizeof(char), 1024, in); + + if (ferror (in)) { + error << string_compose (_("Error reading session template file %1 (%2)"), in_path, strerror (errno)) << endmsg; + fclose (in); + fclose (out); + return -1; + } + if (charsRead == 0) { + break; + } + new_session.write (buf, charsRead); + } + fclose (in); + + string file_contents = new_session.str(); + size_t writeSize = file_contents.length(); + if (fwrite (file_contents.c_str(), sizeof(char), writeSize, out) != writeSize) { + error << string_compose (_("Error writing session template file %1 (%2)"), out_path, strerror (errno)) << endmsg; + fclose (out); + return -1; + } + fclose (out); + + _is_new = false; + + if (!ARDOUR::Profile->get_trx()) { + /* Copy plugin state files from template to new session */ + std::string template_plugins = Glib::build_filename (session_template, X_("plugins")); + copy_recurse (template_plugins, plugins_dir ()); + } - /* 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 ()); - return 0; } else { error << string_compose (_("Could not open %1 for writing session template"), out_path) << endmsg; + fclose(in); return -1; } @@ -518,26 +612,41 @@ Session::create (const string& session_template, BusProfile* bus_profile) } - /* set initial start + end point */ + if (Profile->get_trx()) { + + /* set initial start + end point : ARDOUR::Session::session_end_shift long. + Remember that this is a brand new session. Sessions + loaded from saved state will get this range from the saved state. + */ + + set_session_range_location (0, 0); + + /* Initial loop location, from absolute zero, length 10 seconds */ + + Location* loc = new Location (*this, 0, 10.0 * _engine.sample_rate(), _("Loop"), Location::IsAutoLoop); + _locations->add (loc, true); + set_auto_loop_location (loc); + } _state_of_the_state = Clean; - /* set up Master Out and Control Out if necessary */ + /* set up Master Out and Monitor Out if necessary */ if (bus_profile) { RouteList rl; ChanCount count(DataType::AUDIO, bus_profile->master_out_channels); - if (bus_profile->master_out_channels) { - boost::shared_ptr r (new Route (*this, _("master"), Route::MasterOut, DataType::AUDIO)); + // Waves Tracks: always create master bus for Tracks + if (ARDOUR::Profile->get_trx() || bus_profile->master_out_channels) { + boost::shared_ptr r (new Route (*this, _("Master"), PresentationInfo::MasterOut, DataType::AUDIO)); if (r->init ()) { return -1; } -#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS - // boost_debug_shared_ptr_mark_interesting (r.get(), "Route"); -#endif - { + + BOOST_MARK_ROUTE(r); + + { Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ()); r->input()->ensure_io (count, false, this); r->output()->ensure_io (count, false, this); @@ -551,19 +660,23 @@ Session::create (const string& session_template, BusProfile* bus_profile) } if (!rl.empty()) { - add_routes (rl, false, false, false); + add_routes (rl, false, false, false, PresentationInfo::max_order); } - /* this allows the user to override settings with an environment variable. - */ + // Waves Tracks: Skip this. Always use autoconnection for Tracks + if (!ARDOUR::Profile->get_trx()) { - if (no_auto_connect()) { - bus_profile->input_ac = AutoConnectOption (0); - bus_profile->output_ac = AutoConnectOption (0); - } + /* this allows the user to override settings with an environment variable. + */ + + if (no_auto_connect()) { + bus_profile->input_ac = AutoConnectOption (0); + bus_profile->output_ac = AutoConnectOption (0); + } - Config->set_input_auto_connect (bus_profile->input_ac); - Config->set_output_auto_connect (bus_profile->output_ac); + Config->set_input_auto_connect (bus_profile->input_ac); + Config->set_output_auto_connect (bus_profile->output_ac); + } } if (Config->get_use_monitor_bus() && bus_profile) { @@ -650,15 +763,27 @@ Session::remove_state (string snapshot_name) /** @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) { + DEBUG_TRACE (DEBUG::Locale, string_compose ("Session::save_state locale '%1'\n", setlocale (LC_NUMERIC, NULL))); + 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) @@ -666,6 +791,10 @@ Session::save_state (string snapshot_name, bool pending, bool switch_to_snapshot return 1; } +#ifndef NDEBUG + const int64_t save_start_time = g_get_monotonic_time(); +#endif + /* tell sources we're saving first, in case they write out to a new file * which should be saved with the state rather than the old one */ for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) { @@ -676,15 +805,28 @@ Session::save_state (string snapshot_name, bool pending, bool switch_to_snapshot } } - SaveSession (); /* EMIT SIGNAL */ + SessionSaveUnderway (); /* EMIT SIGNAL */ + + bool mark_as_clean = true; + + if (!snapshot_name.empty() && !switch_to_snapshot) { + mark_as_clean = false; + } - tree.set_root (&get_state()); + if (template_only) { + mark_as_clean = false; + tree.set_root (&get_template()); + } else { + tree.set_root (&get_state()); + } if (snapshot_name.empty()) { snapshot_name = _current_snapshot_name; } else if (switch_to_snapshot) { - _current_snapshot_name = snapshot_name; - } + set_snapshot_name (snapshot_name); + } + + assert (!snapshot_name.empty()); if (!pending) { @@ -708,7 +850,7 @@ Session::save_state (string snapshot_name, bool pending, bool switch_to_snapshot std::string tmp_path(_session_dir->root_path()); tmp_path = Glib::build_filename (tmp_path, legalize_for_path (snapshot_name) + temp_suffix); - // cerr << "actually writing state to " << xml_path << endl; + 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; @@ -720,6 +862,8 @@ Session::save_state (string snapshot_name, bool pending, bool switch_to_snapshot } else { + 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; @@ -735,17 +879,23 @@ Session::save_state (string snapshot_name, bool pending, bool switch_to_snapshot save_history (snapshot_name); - bool was_dirty = dirty(); + if (mark_as_clean) { + bool was_dirty = dirty(); - _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty); + _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty); - if (was_dirty) { - DirtyChanged (); /* EMIT SIGNAL */ + if (was_dirty) { + DirtyChanged (); /* EMIT SIGNAL */ + } } StateSaved (snapshot_name); /* EMIT SIGNAL */ } +#ifndef NDEBUG + const int64_t elapsed_time_us = g_get_monotonic_time() - save_start_time; + cerr << "saved state in " << fixed << setprecision (1) << elapsed_time_us / 1000. << " ms\n"; +#endif return 0; } @@ -798,7 +948,7 @@ 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)) { error << string_compose(_("Could not understand session file %1"), xmlpath) << endmsg; @@ -807,7 +957,7 @@ Session::load_state (string snapshot_name) return -1; } - XMLNode& root (*state_tree->root()); + XMLNode const & root (*state_tree->root()); if (root.name() != X_("Session")) { error << string_compose (_("Session file %1 is not a session"), xmlpath) << endmsg; @@ -816,7 +966,7 @@ Session::load_state (string snapshot_name) return -1; } - const XMLProperty* prop; + XMLProperty const * prop; if ((prop = root.property ("version")) == 0) { /* no version implies very old version of Ardour */ @@ -843,26 +993,48 @@ Session::load_state (string snapshot_name) // only create a backup for a given statefile version once if (!Glib::file_test (backup_path, Glib::FILE_TEST_EXISTS)) { - + VersionMismatch (xmlpath, backup_path); - + if (!copy_file (xmlpath, backup_path)) {; return -1; } } + } else { + XMLNode* child; + if ((child = find_named_node (root, "ProgramVersion")) != 0) { + if ((prop = child->property ("modified-with")) != 0) { + std::string modified_with = prop->value (); + + const double modified_with_version = atof (modified_with.substr ( modified_with.find(" ", 0) + 1, string::npos).c_str()); + const int modified_with_revision = atoi (modified_with.substr (modified_with.find("-", 0) + 1, string::npos).c_str()); + + if (modified_with_version <= 5.3 && !(modified_with_version == 5.3 && modified_with_revision > 42)) { + _midi_regions_use_bbt_beats = true; + } + } + } } + save_snapshot_name (snapshot_name); + return 0; } int Session::load_options (const XMLNode& node) { - LocaleGuard lg (X_("POSIX")); + LocaleGuard lg; config.set_variables (node); return 0; } +bool +Session::save_default_options () +{ + return config.save_state(); +} + XMLNode& Session::get_state() { @@ -885,6 +1057,7 @@ Session::get_template() XMLNode& Session::state (bool full_state) { + LocaleGuard lg; XMLNode* node = new XMLNode("Session"); XMLNode* child; @@ -892,12 +1065,18 @@ Session::state (bool full_state) snprintf(buf, sizeof(buf), "%d", CURRENT_SESSION_FILE_VERSION); node->add_property("version", buf); + child = node->add_child ("ProgramVersion"); + child->add_property("created-with", created_with); + + std::string modified_with = string_compose ("%1 %2", PROGRAM_NAME, revision); + child->add_property("modified-with", modified_with); + /* store configuration settings */ if (full_state) { node->add_property ("name", _name); - snprintf (buf, sizeof (buf), "%" PRId64, _nominal_frame_rate); + snprintf (buf, sizeof (buf), "%" PRId64, _base_frame_rate); node->add_property ("sample-rate", buf); if (session_dirs.size() > 1) { @@ -916,7 +1095,7 @@ Session::state (bool full_state) p += (*i).path; if (next != session_dirs.end()) { - p += ':'; + p += G_SEARCHPATH_SEPARATOR; } else { break; } @@ -930,16 +1109,26 @@ Session::state (bool full_state) } } + node->add_property ("end-is-free", _session_range_end_is_free ? X_("yes") : X_("no")); + /* save the ID counter */ snprintf (buf, sizeof (buf), "%" PRIu64, ID::counter()); node->add_property ("id-counter", buf); + snprintf (buf, sizeof (buf), "%u", name_id_counter ()); + node->add_property ("name-counter", buf); + /* save the event ID counter */ snprintf (buf, sizeof (buf), "%d", Evoral::event_id_counter()); node->add_property ("event-counter", buf); + /* save the VCA counter */ + + snprintf (buf, sizeof (buf), "%" PRIu32, VCA::get_next_vca_number()); + node->add_property ("vca-counter", buf); + /* various options */ list midi_port_nodes = _midi_ports->get_midi_port_states(); @@ -1016,16 +1205,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 tracks we need stored the Auto Loop Range and all MIDI markers. + 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"); @@ -1039,6 +1243,8 @@ Session::state (bool full_state) } } + node->add_child_nocopy (_vca_manager->get_state()); + child = node->add_child ("Routes"); { boost::shared_ptr r = routes.reader (); @@ -1047,11 +1253,11 @@ Session::state (bool full_state) RouteList public_order (*r); public_order.sort (cmp); - /* the sort should have put control outs first */ + /* the sort should have put the monitor out first */ - if (_monitor_out) { - assert (_monitor_out == public_order.front()); - } + if (_monitor_out) { + assert (_monitor_out == public_order.front()); + } for (RouteList::iterator i = public_order.begin(); i != public_order.end(); ++i) { if (!(*i)->is_auditioner()) { @@ -1095,6 +1301,26 @@ Session::state (bool full_state) node->add_child_copy (*_extra_xml); } + { + Glib::Threads::Mutex::Lock lm (lua_lock); + std::string saved; + { + luabridge::LuaRef savedstate ((*_lua_save)()); + saved = savedstate.cast(); + } + lua.collect_garbage (); + lm.release (); + + gchar* b64 = g_base64_encode ((const guchar*)saved.c_str (), saved.size ()); + std::string b64s (b64); + g_free (b64); + + XMLNode* script_node = new XMLNode (X_("Script")); + script_node->add_property (X_("lua"), LUA_VERSION); + script_node->add_content (b64s); + node->add_child_nocopy (*script_node); + } + return *node; } @@ -1108,16 +1334,17 @@ Session::get_control_protocol_state () int Session::set_state (const XMLNode& node, int version) { + LocaleGuard lg; XMLNodeList nlist; XMLNode* child; - const XMLProperty* prop; + XMLProperty const * prop; int ret = -1; _state_of_the_state = StateOfTheState (_state_of_the_state|CannotSave); if (node.name() != X_("Session")) { fatal << _("programming error: Session: incorrect XML node sent to set_state()") << endmsg; - return -1; + goto out; } if ((prop = node.property ("name")) != 0) { @@ -1126,18 +1353,31 @@ Session::set_state (const XMLNode& node, int version) if ((prop = node.property (X_("sample-rate"))) != 0) { - _nominal_frame_rate = atoi (prop->value()); + _base_frame_rate = atoi (prop->value()); + _nominal_frame_rate = _base_frame_rate; - if (_nominal_frame_rate != _current_frame_rate) { - boost::optional r = AskAboutSampleRateMismatch (_nominal_frame_rate, _current_frame_rate); + assert (AudioEngine::instance()->running ()); + if (_base_frame_rate != AudioEngine::instance()->sample_rate ()) { + boost::optional r = AskAboutSampleRateMismatch (_base_frame_rate, _current_frame_rate); if (r.get_value_or (0)) { - return -1; + goto out; } } } + created_with = "unknown"; + if ((child = find_named_node (node, "ProgramVersion")) != 0) { + if ((prop = child->property (X_("created-with"))) != 0) { + created_with = prop->value (); + } + } + setup_raid_path(_session_dir->root_path()); + if ((prop = node.property (X_("end-is-free"))) != 0) { + _session_range_end_is_free = string_is_affirmative (prop->value()); + } + if ((prop = node.property (X_("id-counter"))) != 0) { uint64_t x; sscanf (prop->value().c_str(), "%" PRIu64, &x); @@ -1152,10 +1392,21 @@ Session::set_state (const XMLNode& node, int version) ID::init_counter (now); } - if ((prop = node.property (X_("event-counter"))) != 0) { - Evoral::init_event_id_counter (atoi (prop->value())); - } + if ((prop = node.property (X_("name-counter"))) != 0) { + init_name_id_counter (atoi (prop->value())); + } + + if ((prop = node.property (X_("event-counter"))) != 0) { + Evoral::init_event_id_counter (atoi (prop->value())); + } + if ((prop = node.property (X_("vca-counter"))) != 0) { + uint32_t x; + sscanf (prop->value().c_str(), "%" PRIu32, &x); + VCA::set_next_vca_number (x); + } else { + VCA::set_next_vca_number (1); + } if ((child = find_named_node (node, "MIDIPorts")) != 0) { _midi_ports->set_midi_port_states (child->children()); @@ -1206,20 +1457,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()); @@ -1272,6 +1510,10 @@ Session::set_state (const XMLNode& node, int version) } } + if ((child = find_named_node (node, VCAManager::xml_node_name)) != 0) { + _vca_manager->set_state (*child, version); + } + if ((child = find_named_node (node, "Routes")) == 0) { error << _("Session: XML state has no routes section") << endmsg; goto out; @@ -1279,6 +1521,10 @@ Session::set_state (const XMLNode& node, int version) goto out; } + /* Now that we have Routes and masters loaded, connect them if appropriate */ + + Slavable::Assign (_vca_manager); /* EMIT SIGNAL */ + /* our diskstreams list is no longer needed as they are now all owned by their Route */ _diskstreams_2X.clear (); @@ -1318,15 +1564,35 @@ Session::set_state (const XMLNode& node, int version) ControlProtocolManager::instance().set_state (*child, version); } - update_have_rec_enabled_track (); + if ((child = find_named_node (node, "Script"))) { + for (XMLNodeList::const_iterator n = child->children ().begin (); n != child->children ().end (); ++n) { + if (!(*n)->is_content ()) { continue; } + gsize size; + guchar* buf = g_base64_decode ((*n)->content ().c_str (), &size); + try { + Glib::Threads::Mutex::Lock lm (lua_lock); + (*_lua_load)(std::string ((const char*)buf, size)); + } catch (luabridge::LuaException const& e) { + cerr << "LuaException:" << e.what () << endl; + } + g_free (buf); + } + } + + update_route_record_state (); /* here beginneth the second phase ... */ + set_snapshot_name (_current_snapshot_name); StateReady (); /* EMIT SIGNAL */ + delete state_tree; + state_tree = 0; return 0; out: + delete state_tree; + state_tree = 0; return ret; } @@ -1360,7 +1626,11 @@ Session::load_routes (const XMLNode& node, int version) new_routes.push_back (route); } - add_routes (new_routes, false, false, false); + BootMessage (_("Tracks/busses loaded; Adding to Session")); + + add_routes (new_routes, false, false, false, PresentationInfo::max_order); + + BootMessage (_("Finished adding tracks/busses")); return 0; } @@ -1377,7 +1647,7 @@ Session::XMLRouteFactory (const XMLNode& node, int version) XMLNode* ds_child = find_named_node (node, X_("Diskstream")); DataType type = DataType::AUDIO; - const XMLProperty* prop = node.property("default-type"); + XMLProperty const * prop = node.property("default-type"); if (prop) { type = DataType (prop->value()); @@ -1403,18 +1673,15 @@ Session::XMLRouteFactory (const XMLNode& node, int version) return ret; } -#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS - // boost_debug_shared_ptr_mark_interesting (track.get(), "Track"); -#endif + BOOST_MARK_TRACK (track); ret = track; } else { - boost::shared_ptr r (new Route (*this, X_("toBeResetFroXML"))); + PresentationInfo::Flag flags = PresentationInfo::get_flags (node); + 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 - // boost_debug_shared_ptr_mark_interesting (r.get(), "Route"); -#endif + BOOST_MARK_ROUTE (r); ret = r; } } @@ -1437,7 +1704,7 @@ Session::XMLRouteFactory_2X (const XMLNode& node, int version) } DataType type = DataType::AUDIO; - const XMLProperty* prop = node.property("default-type"); + XMLProperty const * prop = node.property("default-type"); if (prop) { type = DataType (prop->value()); @@ -1475,18 +1742,15 @@ Session::XMLRouteFactory_2X (const XMLNode& node, int version) track->set_diskstream (*i); -#ifdef BOOST_SP_ENABLE_DEBUG_HOOKS - // boost_debug_shared_ptr_mark_interesting (track.get(), "Track"); -#endif + BOOST_MARK_TRACK (track); ret = track; } else { - boost::shared_ptr r (new Route (*this, X_("toBeResetFroXML"))); + PresentationInfo::Flag flags = PresentationInfo::get_flags (node); + 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 - // boost_debug_shared_ptr_mark_interesting (r.get(), "Route"); -#endif + BOOST_MARK_ROUTE (r); ret = r; } } @@ -1508,7 +1772,7 @@ Session::load_regions (const XMLNode& node) for (niter = nlist.begin(); niter != nlist.end(); ++niter) { if ((region = XMLRegionFactory (**niter, false)) == 0) { error << _("Session: cannot create Region from XML description."); - const XMLProperty *name = (**niter).property("name"); + XMLProperty const * name = (**niter).property("name"); if (name) { error << " " << string_compose (_("Can not load state for region '%1'"), name->value()); @@ -1526,7 +1790,7 @@ Session::load_compounds (const XMLNode& node) { XMLNodeList calist = node.children(); XMLNodeConstIterator caiter; - XMLProperty *caprop; + XMLProperty const * caprop; for (caiter = calist.begin(); caiter != calist.end(); ++caiter) { XMLNode* ca = *caiter; @@ -1570,10 +1834,10 @@ Session::load_nested_sources (const XMLNode& node) for (niter = nlist.begin(); niter != nlist.end(); ++niter) { if ((*niter)->name() == "Source") { - /* it may already exist, so don't recreate it unnecessarily + /* it may already exist, so don't recreate it unnecessarily */ - XMLProperty* prop = (*niter)->property (X_("id")); + XMLProperty const * prop = (*niter)->property (X_("id")); if (!prop) { error << _("Nested source has no ID info in session file! (ignored)") << endmsg; continue; @@ -1597,7 +1861,7 @@ Session::load_nested_sources (const XMLNode& node) boost::shared_ptr Session::XMLRegionFactory (const XMLNode& node, bool full) { - const XMLProperty* type = node.property("type"); + XMLProperty const * type = node.property("type"); try { @@ -1626,7 +1890,7 @@ Session::XMLRegionFactory (const XMLNode& node, bool full) boost::shared_ptr Session::XMLAudioRegionFactory (const XMLNode& node, bool /*full*/) { - const XMLProperty* prop; + XMLProperty const * prop; boost::shared_ptr source; boost::shared_ptr as; SourceList sources; @@ -1745,7 +2009,7 @@ Session::XMLAudioRegionFactory (const XMLNode& node, bool /*full*/) boost::shared_ptr Session::XMLMidiRegionFactory (const XMLNode& node, bool /*full*/) { - const XMLProperty* prop; + XMLProperty const * prop; boost::shared_ptr source; boost::shared_ptr ms; SourceList sources; @@ -1816,47 +2080,29 @@ 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()); - std::string 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()); - } - - std::string source_path = Glib::build_filename (source_dir, buf); - - if (!Glib::file_test (source_path, Glib::FILE_TEST_EXISTS)) { - return source_path; + 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) { + _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); } } - - 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 ""; } - 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(); @@ -1873,9 +2119,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; } @@ -1900,8 +2152,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; } } @@ -1923,68 +2202,79 @@ 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(); } } int -Session::save_template (string template_name) +Session::save_template (string template_name, bool replace_existing) { - XMLTree tree; - - if (_state_of_the_state & CannotSave) { + if ((_state_of_the_state & CannotSave) || template_name.empty ()) { return -1; } - std::string user_template_dir(user_template_directory()); + bool absolute_path = Glib::path_is_absolute (template_name); - 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; - } + /* directory to put the template in */ + std::string template_dir_path; - tree.set_root (&get_template()); + if (!absolute_path) { + std::string user_template_dir(user_template_directory()); - std::string template_dir_path(user_template_dir); - - /* directory to put the template in */ - template_dir_path = Glib::build_filename (template_dir_path, template_name); + 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; + } - 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; + template_dir_path = Glib::build_filename (user_template_dir, template_name); + } else { + template_dir_path = template_name; } - - 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; + + if (!ARDOUR::Profile->get_trx()) { + if (!replace_existing && 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 -2; + } + + 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; + } } /* file to write */ - std::string template_file_path(template_dir_path); - template_file_path = Glib::build_filename (template_file_path, template_name + template_suffix); + std::string template_file_path; - if (!tree.write (template_file_path)) { - error << _("template not saved") << endmsg; - return -1; + 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); + } } - /* copy plugin state directory */ + SessionSaveUnderway (); /* EMIT SIGNAL */ - std::string template_plugin_state_path(template_dir_path); - template_plugin_state_path = Glib::build_filename (template_plugin_state_path, X_("plugins")); + XMLTree tree; + + { + PBD::Unwinder uw (_template_state_dir, template_dir_path); + tree.set_root (&get_template()); + } - 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; + if (!tree.write (template_file_path)) { + error << _("template not saved") << endmsg; return -1; } - copy_files (plugins_dir(), template_plugin_state_path); + store_recent_templates (template_file_path); return 0; } @@ -1992,8 +2282,8 @@ Session::save_template (string template_name) void Session::refresh_disk_space () { -#if __APPLE__ || (HAVE_SYS_VFS_H && HAVE_SYS_STATVFS_H) - +#if __APPLE__ || __FreeBSD__ || (HAVE_SYS_VFS_H && HAVE_SYS_STATVFS_H) + Glib::Threads::Mutex::Lock lm (space_lock); /* get freespace on every FS that is part of the session path */ @@ -2035,7 +2325,7 @@ Session::refresh_disk_space () _total_free_4k_blocks_uncertain = true; } } -#elif defined (COMPILER_MSVC) +#elif defined PLATFORM_WINDOWS vector scanned_volumes; vector::iterator j; vector::iterator i; @@ -2087,7 +2377,7 @@ Session::refresh_disk_space () } 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,25 +2477,25 @@ Session::get_best_session_directory_for_new_source () string Session::automation_dir () const { - return Glib::build_filename (_path, "automation"); + return Glib::build_filename (_path, automation_dir_name); } string Session::analysis_dir () const { - return Glib::build_filename (_path, "analysis"); + return Glib::build_filename (_path, analysis_dir_name); } string Session::plugins_dir () const { - return Glib::build_filename (_path, "plugins"); + return Glib::build_filename (_path, plugins_dir_name); } string Session::externals_dir () const { - return Glib::build_filename (_path, "externals"); + return Glib::build_filename (_path, externals_dir_name); } int @@ -2262,12 +2552,6 @@ 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*/) { @@ -2275,44 +2559,37 @@ state_file_filter (const string &str, void* /*arg*/) 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); @@ -2384,6 +2661,25 @@ Session::add_commands (vector const & cmds) } } +void +Session::add_command (Command* const cmd) +{ + assert (_current_trans); + DEBUG_UNDO_HISTORY ( + string_compose ("Current Undo Transaction %1, adding command: %2", + _current_trans->name (), + cmd->name ())); + _current_trans->add_command (cmd); +} + +PBD::StatefulDiffCommand* +Session::add_stateful_diff_command (boost::shared_ptr sfd) +{ + PBD::StatefulDiffCommand* cmd = new PBD::StatefulDiffCommand (sfd); + add_command (cmd); + return cmd; +} + void Session::begin_reversible_command (const string& name) { @@ -2403,36 +2699,72 @@ Session::begin_reversible_command (GQuark q) */ if (_current_trans == 0) { + DEBUG_UNDO_HISTORY (string_compose ( + "Begin Reversible Command, new transaction: %1", g_quark_to_string (q))); + /* start a new transaction */ assert (_current_trans_quarks.empty ()); _current_trans = new UndoTransaction(); _current_trans->set_name (g_quark_to_string (q)); + } else { + DEBUG_UNDO_HISTORY ( + string_compose ("Begin Reversible Command, current transaction: %1", + _current_trans->name ())); } _current_trans_quarks.push_front (q); } void -Session::commit_reversible_command (Command *cmd) +Session::abort_reversible_command () { - assert (_current_trans); - assert (!_current_trans_quarks.empty ()); + if (_current_trans != 0) { + DEBUG_UNDO_HISTORY ( + string_compose ("Abort Reversible Command: %1", _current_trans->name ())); + _current_trans->clear(); + delete _current_trans; + _current_trans = 0; + _current_trans_quarks.clear(); + } +} + +void +Session::commit_reversible_command (Command *cmd) +{ + assert (_current_trans); + assert (!_current_trans_quarks.empty ()); struct timeval now; if (cmd) { + DEBUG_UNDO_HISTORY ( + string_compose ("Current Undo Transaction %1, adding command: %2", + _current_trans->name (), + cmd->name ())); _current_trans->add_command (cmd); } + DEBUG_UNDO_HISTORY ( + string_compose ("Commit Reversible Command, current transaction: %1", + _current_trans->name ())); + _current_trans_quarks.pop_front (); if (!_current_trans_quarks.empty ()) { + DEBUG_UNDO_HISTORY ( + string_compose ("Commit Reversible Command, transaction is not " + "top-level, current transaction: %1", + _current_trans->name ())); /* the transaction we're committing is not the top-level one */ return; } if (_current_trans->empty()) { /* no commands were added to the transaction, so just get rid of it */ + DEBUG_UNDO_HISTORY ( + string_compose ("Commit Reversible Command, No commands were " + "added to current transaction: %1", + _current_trans->name ())); delete _current_trans; _current_trans = 0; return; @@ -2474,11 +2806,16 @@ accept_all_midi_files (const string& path, void* /*arg*/) static bool 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 @@ -2504,7 +2841,7 @@ Session::find_all_sources (string path, set& result) for (niter = nlist.begin(); niter != nlist.end(); ++niter) { - XMLProperty* prop; + XMLProperty const * prop; if ((prop = (*niter)->property (X_("type"))) == 0) { continue; @@ -2536,8 +2873,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; @@ -2549,24 +2885,27 @@ 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, true, 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; } - this_snapshot_path = _path; - this_snapshot_path += legalize_for_path (_current_snapshot_name); + this_snapshot_path = Glib::build_filename (_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) { + + cerr << "Looking at snapshot " << (*i) << " ( with this = [" << this_snapshot_path << "])\n"; - if (exclude_this_snapshot && **i == this_snapshot_path) { + if (exclude_this_snapshot && *i == this_snapshot_path) { + cerr << "\texcluded\n"; continue; + } - if (find_all_sources (**i, result) < 0) { + if (find_all_sources (*i, result) < 0) { return -1; } } @@ -2593,14 +2932,38 @@ 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) { + for (RegionFactory::RegionMap::const_iterator i = regions.begin(); i != regions.end();) { uint32_t used = playlists->region_use_count (i->second); if (used == 0 && !i->second->automatic ()) { - RegionFactory::map_remove (i->second); + boost::weak_ptr w = i->second; + ++i; + removed = true; + RegionFactory::map_remove (w); + } else { + ++i; + } + } + + if (removed) { + // re-check to remove parent references of compound regions + for (RegionFactory::RegionMap::const_iterator i = regions.begin(); i != regions.end();) { + if (!(i->second->whole_file() && i->second->max_source_level() > 0)) { + ++i; + continue; + } + assert(boost::dynamic_pointer_cast(i->second->source (0)) != 0); + if (0 == playlists->region_use_count (i->second)) { + boost::weak_ptr w = i->second; + ++i; + RegionFactory::map_remove (w); + } else { + ++i; + } } } @@ -2610,29 +2973,104 @@ Session::cleanup_regions () save_state (""); } +bool +Session::can_cleanup_peakfiles () const +{ + if (deletion_in_progress()) { + return false; + } + if (!_writable || (_state_of_the_state & CannotSave)) { + warning << _("Cannot cleanup peak-files for read-only session.") << endmsg; + return false; + } + if (record_status() == Recording) { + error << _("Cannot cleanup peak-files while recording") << endmsg; + return false; + } + return true; +} + +int +Session::cleanup_peakfiles () +{ + Glib::Threads::Mutex::Lock lm (peak_cleanup_lock, Glib::Threads::TRY_LOCK); + if (!lm.locked()) { + return -1; + } + + assert (can_cleanup_peakfiles ()); + assert (!peaks_cleanup_in_progres()); + + _state_of_the_state = StateOfTheState (_state_of_the_state | PeakCleanup); + + int timeout = 5000; // 5 seconds + while (!SourceFactory::files_with_peaks.empty()) { + Glib::usleep (1000); + if (--timeout < 0) { + warning << _("Timeout waiting for peak-file creation to terminate before cleanup, please try again later.") << endmsg; + _state_of_the_state = StateOfTheState (_state_of_the_state & (~PeakCleanup)); + return -1; + } + } + + for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) { + boost::shared_ptr as; + if ((as = boost::dynamic_pointer_cast (i->second)) != 0) { + as->close_peakfile(); + } + } + + PBD::clear_directory (session_directory().peak_path()); + + _state_of_the_state = StateOfTheState (_state_of_the_state & (~PeakCleanup)); + + for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) { + boost::shared_ptr as; + if ((as = boost::dynamic_pointer_cast (i->second)) != 0) { + SourceFactory::setup_peakfile(as, true); + } + } + return 0; +} + +static void +merge_all_sources (boost::shared_ptr pl, std::set >* all_sources) +{ + pl->deep_sources (*all_sources); +} + int 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; + set sources_used_by_all_snapshots; string spath; int ret = -1; string tmppath1; string tmppath2; + Searchpath asp; + Searchpath msp; + set > sources_used_by_this_snapshot; _state_of_the_state = (StateOfTheState) (_state_of_the_state | InCleanup); + /* this is mostly for windows which doesn't allow file + * renaming if the file is in use. But we don't special + * case it because we need to know if this causes + * problems, and the easiest way to notice that is to + * keep it in place for all platforms. + */ + + request_stop (false); + _butler->summon (); + _butler->wait_until_finished (); + /* consider deleting all unused playlists */ if (playlists->maybe_delete_unused (boost::bind (Session::ask_about_playlist_deletion, _1))) { @@ -2671,61 +3109,39 @@ 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); + 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); - /* merge them */ + /* add sources from all other snapshots as "used", but don't use this + snapshot because the state file on disk still references sources we + may have already dropped. + */ - 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_all_sources_across_snapshots (sources_used_by_all_snapshots, true); - /* find all sources, but don't use this snapshot because the - state file on disk still references sources we may have already - dropped. - */ + /* Although the region factory has a list of all regions ever created + * for this session, we're only interested in regions actually in + * playlists right now. So merge all playlist regions lists together. + * + * This will include the playlists used within compound regions. + */ - find_all_sources_across_snapshots (all_sources, true); + playlists->foreach (boost::bind (merge_all_sources, _1, &sources_used_by_this_snapshot)); /* add our current source list */ @@ -2735,56 +3151,99 @@ Session::cleanup_sources (CleanupReport& rep) SourceMap::iterator tmp = i; ++tmp; - if ((fs = boost::dynamic_pointer_cast (i->second)) != 0) { - if (playlists->source_use_count (fs) != 0) { - all_sources.insert (fs->path()); - } else { + if ((fs = boost::dynamic_pointer_cast (i->second)) == 0) { + /* not a file */ + i = tmp; + continue; + } - /* 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. - */ + /* this is mostly for windows which doesn't allow file + * renaming if the file is in use. But we do not special + * case it because we need to know if this causes + * problems, and the easiest way to notice that is to + * keep it in place for all platforms. + */ - RegionFactory::remove_regions_using_source (i->second); - sources.erase (i); - } + fs->close (); + + if (!fs->is_stub()) { + + /* Note that we're checking a list of all + * sources across all snapshots with the list + * of sources used by this snapshot. + */ + + if (sources_used_by_this_snapshot.find (i->second) != sources_used_by_this_snapshot.end()) { + /* this source is in use by this snapshot */ + sources_used_by_all_snapshots.insert (fs->path()); + cerr << "Source from source list found in used_by_this_snapshot (" << fs->path() << ")\n"; + } else { + cerr << "Source from source list NOT found in used_by_this_snapshot (" << fs->path() << ")\n"; + /* this source is NOT in use by this snapshot + */ + + /* remove all related regions from RegionFactory master list + */ + + RegionFactory::remove_regions_using_source (i->second); + + /* remove from our current source list + * also. We may not remove it from + * disk, because it may be used by + * other snapshots, but it isn't used inside this + * snapshot anymore, so we don't need a + * reference to it. + */ + + sources.erase (i); + } } i = tmp; } - if (candidates) { - for (vector::iterator x = candidates->begin(); x != candidates->end(); ++x) { + /* now check each candidate source to see if it exists in the list of + sources_used_by_all_snapshots. If it doesn't, put it into "unused". + */ - used = false; - spath = **x; + cerr << "Candidates: " << candidates.size() << endl; + cerr << "Used by others: " << sources_used_by_all_snapshots.size() << endl; - for (set::iterator i = all_sources.begin(); i != all_sources.end(); ++i) { + for (vector::iterator x = candidates.begin(); x != candidates.end(); ++x) { - tmppath1 = canonical_path (spath); - tmppath2 = canonical_path ((*i)); + bool used = false; + spath = *x; - if (tmppath1 == tmppath2) { - used = true; - break; - } - } + for (set::iterator i = sources_used_by_all_snapshots.begin(); i != sources_used_by_all_snapshots.end(); ++i) { - if (!used) { - unused.push_back (spath); - } + tmppath1 = canonical_path (spath); + tmppath2 = canonical_path ((*i)); - delete *x; - } + cerr << "\t => " << tmppath2 << endl; - delete candidates; - } + if (tmppath1 == tmppath2) { + used = true; + break; + } + } + + if (!used) { + unused.push_back (spath); + } + } + + cerr << "Actually unused: " << unused.size() << endl; + + if (unused.empty()) { + /* Nothing to do */ + ret = 0; + goto out; + } /* now try to move all unused files into the "dead" directory(ies) */ for (vector::iterator x = unused.begin(); x != unused.end(); ++x) { - struct stat statbuf; + GStatBuf statbuf; string newpath; @@ -2843,45 +3302,40 @@ Session::cleanup_sources (CleanupReport& rep) newpath = newpath_v; } - } else { - - /* it doesn't exist, or we can't read it or something */ - } - stat ((*x).c_str(), &statbuf); + if (0 == g_stat ((*x).c_str(), &statbuf)) { - if (::rename ((*x).c_str(), newpath.c_str()) != 0) { - error << string_compose (_("cannot rename unused file source from %1 to %2 (%3)"), - (*x), newpath, strerror (errno)) - << endmsg; - goto out; - } + if (::g_rename ((*x).c_str(), newpath.c_str()) != 0) { + error << string_compose (_("cannot rename unused file source from %1 to %2 (%3)"), (*x), newpath, g_strerror (errno)) << endmsg; + continue; + } - /* see if there an easy to find peakfile for this file, and remove it. - */ + /* see if there an easy to find peakfile for this file, and remove it. + */ - string base = basename_nosuffix (*x); - base += "%A"; /* this is what we add for the channel suffix of all native files, - or for the first channel of embedded files. it will miss - some peakfiles for other channels - */ - string peakpath = peak_path (base); - - if (Glib::file_test (peakpath.c_str(), Glib::FILE_TEST_EXISTS)) { - if (::g_unlink (peakpath.c_str()) != 0) { - error << string_compose (_("cannot remove peakfile %1 for %2 (%3)"), - peakpath, _path, strerror (errno)) - << endmsg; - /* try to back out */ - ::rename (newpath.c_str(), _path.c_str()); - goto out; + string base = Glib::path_get_basename (*x); + base += "%A"; /* this is what we add for the channel suffix of all native files, + or for the first channel of embedded files. it will miss + some peakfiles for other channels + */ + string peakpath = construct_peak_filepath (base); + + if (Glib::file_test (peakpath.c_str(), Glib::FILE_TEST_EXISTS)) { + if (::g_unlink (peakpath.c_str()) != 0) { + error << string_compose (_("cannot remove peakfile %1 for %2 (%3)"), + peakpath, _path, g_strerror (errno)) + << endmsg; + /* try to back out */ + ::g_rename (newpath.c_str(), _path.c_str()); + goto out; + } } - } - rep.paths.push_back (*x); - rep.space += statbuf.st_size; - } + rep.paths.push_back (*x); + rep.space += statbuf.st_size; + } + } /* dump the history list */ @@ -2924,6 +3378,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); @@ -3009,71 +3469,86 @@ boost::shared_ptr Session::controllable_by_descriptor (const ControllableDescriptor& desc) { boost::shared_ptr c; + boost::shared_ptr s; boost::shared_ptr r; switch (desc.top_level_type()) { case ControllableDescriptor::NamedRoute: { std::string str = desc.top_level_name(); - if (str == "master") { - r = _master_out; - } else if (str == "control" || str == "listen") { - r = _monitor_out; + + if (str == "Master" || str == "master") { + s = _master_out; + } else if (str == "control" || str == "listen" || str == "monitor" || str == "Monitor") { + s = _monitor_out; + } else if (str == "auditioner") { + s = auditioner; } else { - r = route_by_name (desc.top_level_name()); + s = route_by_name (desc.top_level_name()); } + break; } - case ControllableDescriptor::RemoteControlID: - r = route_by_remote_id (desc.rid()); + case ControllableDescriptor::PresentationOrderRoute: + s = get_remote_nth_stripable (desc.presentation_order(), PresentationInfo::Route); + break; + + case ControllableDescriptor::PresentationOrderTrack: + s = get_remote_nth_stripable (desc.presentation_order(), PresentationInfo::Track); + break; + + case ControllableDescriptor::PresentationOrderBus: + s = get_remote_nth_stripable (desc.presentation_order(), PresentationInfo::Bus); + break; + + case ControllableDescriptor::PresentationOrderVCA: + s = get_remote_nth_stripable (desc.presentation_order(), PresentationInfo::VCA); + break; + + case ControllableDescriptor::SelectionCount: + s = route_by_selected_count (desc.selection_id()); break; } - if (!r) { + if (!s) { return c; } + r = boost::dynamic_pointer_cast (s); + switch (desc.subtype()) { case ControllableDescriptor::Gain: - c = r->gain_control (); + c = s->gain_control (); + break; + + case ControllableDescriptor::Trim: + c = s->trim_control (); break; case ControllableDescriptor::Solo: - c = r->solo_control(); + c = s->solo_control(); break; case ControllableDescriptor::Mute: - c = r->mute_control(); + c = s->mute_control(); break; case ControllableDescriptor::Recenable: - { - boost::shared_ptr t = boost::dynamic_pointer_cast(r); - - if (t) { - c = t->rec_enable_control (); - } + c = s->rec_enable_control (); break; - } case ControllableDescriptor::PanDirection: - { - c = r->pannable()->pan_azimuth_control; + c = s->pan_azimuth_control(); break; - } case ControllableDescriptor::PanWidth: - { - c = r->pannable()->pan_width_control; + c = s->pan_width_control(); break; - } case ControllableDescriptor::PanElevation: - { - c = r->pannable()->pan_elevation_control; + c = s->pan_elevation_control(); break; - } case ControllableDescriptor::Balance: /* XXX simple pan control */ @@ -3094,6 +3569,10 @@ Session::controllable_by_descriptor (const ControllableDescriptor& desc) --parameter_index; } + if (!r) { + return c; + } + boost::shared_ptr p = r->nth_plugin (plugin); if (p) { @@ -3103,26 +3582,15 @@ Session::controllable_by_descriptor (const ControllableDescriptor& desc) break; } - case ControllableDescriptor::SendGain: - { + case ControllableDescriptor::SendGain: { uint32_t send = desc.target (0); - - /* revert to zero-based counting */ - if (send > 0) { --send; } - - boost::shared_ptr p = r->nth_send (send); - - if (p) { - boost::shared_ptr s = boost::dynamic_pointer_cast(p); - boost::shared_ptr a = s->amp(); - - if (a) { - c = s->amp()->gain_control(); - } + if (!r) { + return c; } + c = r->send_level_controllable (send); break; } @@ -3161,6 +3629,11 @@ 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; } @@ -3177,10 +3650,6 @@ Session::save_history (string snapshot_name) } } - 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)) @@ -3422,9 +3891,9 @@ Session::config_changed (std::string p, bool ours) } } else if (p == "click-gain") { - + if (_click_gain) { - _click_gain->set_gain (Config->get_click_gain(), this); + _click_gain->gain_control()->set_value (Config->get_click_gain(), Controllable::NoGroup); } } else if (p == "send-mtc") { @@ -3492,18 +3961,20 @@ 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 (true, Controllable::NoGroup); } 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(); + } else if (p == "auto-return-target-list") { + follow_playhead_priority (); } set_dirty (); @@ -3549,7 +4020,20 @@ void Session::setup_midi_machine_control () { _mmc = new MIDI::MachineControl; - _mmc->set_ports (_midi_ports->mmc_input_port(), _midi_ports->mmc_output_port()); + + boost::shared_ptr async_in = boost::dynamic_pointer_cast (_midi_ports->mmc_input_port()); + boost::shared_ptr async_out = boost::dynamic_pointer_cast (_midi_ports->mmc_output_port()); + + if (!async_out || !async_out) { + return; + } + + /* XXXX argh, passing raw pointers back into libmidi++ */ + + MIDI::Port* mmc_in = async_in.get(); + MIDI::Port* mmc_out = async_out.get(); + + _mmc->set_ports (mmc_in, mmc_out); _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)); @@ -3587,18 +4071,48 @@ Session::solo_cut_control() const return _solo_cut_control; } +void +Session::save_snapshot_name (const std::string & n) +{ + /* assure Stateful::_instant_xml is loaded + * add_instant_xml() only adds to existing data and defaults + * to use an empty Tree otherwise + */ + instant_xml ("LastUsedSnapshot"); + + XMLNode* last_used_snapshot = new XMLNode ("LastUsedSnapshot"); + last_used_snapshot->add_property ("name", string(n)); + add_instant_xml (*last_used_snapshot, false); +} + +void +Session::set_snapshot_name (const std::string & n) +{ + _current_snapshot_name = n; + save_snapshot_name (n); +} + 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: @@ -3606,16 +4120,29 @@ Session::rename (const std::string& new_name) * interchange subdirectory * session file * session history - + * 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; @@ -3629,18 +4156,23 @@ Session::rename (const std::string& new_name) } 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 */ - - for (vector::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) { + + first = true; + + for (vector::iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) { + vector v; oldstr = (*i).path; @@ -3655,87 +4187,113 @@ Session::rename (const std::string& new_name) } string base = Glib::path_get_dirname (oldstr); - string p = Glib::path_get_basename (oldstr); - newstr = Glib::build_filename (base, legal_name); - cerr << "Rename " << oldstr << " => " << newstr << endl; + cerr << "for " << oldstr << " new dir = " << newstr << endl; - if (RENAME (oldstr.c_str(), newstr.c_str()) != 0) { + cerr << "Rename " << oldstr << " => " << newstr << endl; + 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 */ + + 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; - - if (RENAME (oldstr.c_str(), newstr.c_str()) != 0) { + new_interchange_dir = Glib::build_filename (v); + + cerr << "Rename " << old_interchange_dir << " => " << new_interchange_dir << endl; + + 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; - - cerr << "Rename " << oldstr << " => " << newstr << endl; - if (RENAME (oldstr.c_str(), newstr.c_str()) != 0) { + 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 (::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; - - cerr << "Rename " << oldstr << " => " << newstr << endl; - - if (RENAME (oldstr.c_str(), newstr.c_str()) != 0) { + newstr = Glib::build_filename (new_path, legal_name) + history_suffix; + + cerr << "Rename " << oldstr << " => " << newstr << endl; + + 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) { boost::shared_ptr fs = boost::dynamic_pointer_cast (i->second); if (fs) { 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; + set_snapshot_name (new_name); _name = new_name; set_dirty (); @@ -3744,14 +4302,11 @@ Session::rename (const std::string& new_name) save_state (_current_snapshot_name); - /* add to recent sessions */ store_recent_sessions (new_name, _path); return 0; - -#undef RENAME } int @@ -3781,27 +4336,29 @@ Session::get_info_from_path (const string& xmlpath, float& sample_rate, SampleFo /* sample rate */ - const XMLProperty* prop; - if ((prop = tree.root()->property (X_("sample-rate"))) != 0) { + XMLProperty const * prop; + XMLNode const * root (tree.root()); + + if ((prop = root->property (X_("sample-rate"))) != 0) { sample_rate = atoi (prop->value()); found_sr = true; } - const XMLNodeList& children (tree.root()->children()); + const XMLNodeList& children (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"); + XMLNode const * option = *oc; + XMLProperty const * name = option->property("name"); if (!name) { continue; } if (name->value() == "native-file-data-format") { - const XMLProperty* value = option->property ("value"); + XMLProperty const * value = option->property ("value"); if (value) { SampleFormat fmt = (SampleFormat) string_2_enum (option->property ("value")->value(), fmt); data_format = fmt; @@ -3818,3 +4375,579 @@ Session::get_info_from_path (const string& xmlpath, float& sample_rate, SampleFo return !(found_sr && found_data_format); // zero if they are both found } + +std::string +Session::get_snapshot_from_instant (const std::string& session_dir) +{ + std::string instant_xml_path = Glib::build_filename (session_dir, "instant.xml"); + + if (!Glib::file_test (instant_xml_path, Glib::FILE_TEST_EXISTS)) { + return ""; + } + + XMLTree tree; + if (!tree.read (instant_xml_path)) { + return ""; + } + + XMLProperty const * prop; + XMLNode *last_used_snapshot = tree.root()->child("LastUsedSnapshot"); + if (last_used_snapshot && (prop = last_used_snapshot->property ("name")) != 0) { + return prop->value(); + } + + return ""; +} + +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; + set_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); + cerr << "be sure to include " << *s << " for audio" << endl; + } + + /* 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; + + store_recent_sessions (_name, _path); + + if (!saveas.switch_to) { + + /* switch back to the way things were */ + + _path = old_path; + _name = old_name; + set_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; +} + +void +Session::undo (uint32_t n) +{ + if (actively_recording()) { + return; + } + + _history.undo (n); +} + +void +Session::redo (uint32_t n) +{ + if (actively_recording()) { + return; + } + + _history.redo (n); +}