Move butler methods from Session to Butler.
[ardour.git] / libs / ardour / session_state.cc
index 7c4f8c918f77634bf023276b86c20ee668cda38f..4a5d974563dc0feed12b63972921db0c0d74e25c 100644 (file)
@@ -1,12 +1,12 @@
 /*
-  Copyright (C) 1999-2002 Paul Davis 
+  Copyright (C) 1999-2002 Paul Davis
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
+ This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-    
+
 */
 
+
+#ifdef WAF_BUILD
+#include "libardour-config.h"
+#endif
+
 #define __STDC_FORMAT_MACROS 1
 #include <stdint.h>
 
 #endif
 
 #include <glibmm.h>
-
-#include <midi++/mmc.h>
-#include <midi++/port.h>
-#include <pbd/error.h>
-
 #include <glibmm/thread.h>
-#include <pbd/pathscanner.h>
-#include <pbd/pthread_utils.h>
-#include <pbd/search_path.h>
-#include <pbd/stacktrace.h>
-
-#include <ardour/audioengine.h>
-#include <ardour/configuration.h>
-#include <ardour/session.h>
-#include <ardour/session_directory.h>
-#include <ardour/session_utils.h>
-#include <ardour/session_state_utils.h>
-#include <ardour/buffer.h>
-#include <ardour/audio_diskstream.h>
-#include <ardour/midi_diskstream.h>
-#include <ardour/utils.h>
-#include <ardour/audioplaylist.h>
-#include <ardour/midi_playlist.h>
-#include <ardour/smf_source.h>
-#include <ardour/audiofilesource.h>
-#include <ardour/silentfilesource.h>
-#include <ardour/sndfilesource.h>
-#include <ardour/midi_source.h>
-#include <ardour/sndfile_helpers.h>
-#include <ardour/auditioner.h>
-#include <ardour/export.h>
-#include <ardour/io_processor.h>
-#include <ardour/send.h>
-#include <ardour/processor.h>
-#include <ardour/bundle.h>
-#include <ardour/slave.h>
-#include <ardour/tempo.h>
-#include <ardour/audio_track.h>
-#include <ardour/midi_track.h>
-#include <ardour/cycle_timer.h>
-#include <ardour/utils.h>
-#include <ardour/named_selection.h>
-#include <ardour/version.h>
-#include <ardour/location.h>
-#include <ardour/audioregion.h>
-#include <ardour/midi_region.h>
-#include <ardour/crossfade.h>
-#include <ardour/control_protocol_manager.h>
-#include <ardour/region_factory.h>
-#include <ardour/source_factory.h>
-#include <ardour/playlist_factory.h>
-#include <ardour/filename_extensions.h>
-#include <ardour/directory_names.h>
-#include <ardour/template_utils.h>
-
-#include <control_protocol/control_protocol.h>
+
+#include "midi++/mmc.h"
+#include "midi++/port.h"
+
+#include "pbd/error.h"
+#include "pbd/pathscanner.h"
+#include "pbd/pthread_utils.h"
+#include "pbd/search_path.h"
+#include "pbd/stacktrace.h"
+
+#include "ardour/audio_diskstream.h"
+#include "ardour/audio_track.h"
+#include "ardour/audioengine.h"
+#include "ardour/audiofilesource.h"
+#include "ardour/audioplaylist.h"
+#include "ardour/audioregion.h"
+#include "ardour/auditioner.h"
+#include "ardour/buffer.h"
+#include "ardour/butler.h"
+#include "ardour/configuration.h"
+#include "ardour/control_protocol_manager.h"
+#include "ardour/crossfade.h"
+#include "ardour/cycle_timer.h"
+#include "ardour/directory_names.h"
+#include "ardour/filename_extensions.h"
+#include "ardour/io_processor.h"
+#include "ardour/location.h"
+#include "ardour/midi_diskstream.h"
+#include "ardour/midi_patch_manager.h"
+#include "ardour/midi_playlist.h"
+#include "ardour/midi_region.h"
+#include "ardour/midi_source.h"
+#include "ardour/midi_track.h"
+#include "ardour/named_selection.h"
+#include "ardour/playlist_factory.h"
+#include "ardour/processor.h"
+#include "ardour/region_factory.h"
+#include "ardour/route_group.h"
+#include "ardour/send.h"
+#include "ardour/session.h"
+#include "ardour/session_directory.h"
+#include "ardour/session_metadata.h"
+#include "ardour/session_state_utils.h"
+#include "ardour/session_utils.h"
+#include "ardour/silentfilesource.h"
+#include "ardour/slave.h"
+#include "ardour/smf_source.h"
+#include "ardour/sndfile_helpers.h"
+#include "ardour/sndfilesource.h"
+#include "ardour/source_factory.h"
+#include "ardour/template_utils.h"
+#include "ardour/tempo.h"
+#include "ardour/ticker.h"
+#include "ardour/user_bundle.h"
+#include "ardour/utils.h"
+#include "ardour/utils.h"
+#include "ardour/version.h"
+
+#include "control_protocol/control_protocol.h"
 
 #include "i18n.h"
 #include <locale.h>
@@ -132,82 +141,88 @@ Session::first_stage_init (string fullpath, string snapshot_name)
                _path += '/';
        }
 
+       if (Glib::file_test (_path, Glib::FILE_TEST_EXISTS) && ::access (_path.c_str(), W_OK)) {
+               cerr << "Session non-writable based on " << _path << endl;
+               _writable = false;
+       } else {
+               cerr << "Session writable based on " << _path << endl;
+               _writable = true;
+       }
+
        /* these two are just provisional settings. set_state()
           will likely override them.
        */
 
        _name = _current_snapshot_name = snapshot_name;
 
+       set_history_depth (Config->get_history_depth());
+
        _current_frame_rate = _engine.frame_rate ();
+       _nominal_frame_rate = _current_frame_rate;
+       _base_frame_rate = _current_frame_rate;
+
        _tempo_map = new TempoMap (_current_frame_rate);
        _tempo_map->StateChanged.connect (mem_fun (*this, &Session::tempo_map_changed));
 
+
+       _non_soloed_outs_muted = false;
+       _listen_cnt = 0;
        g_atomic_int_set (&processing_prohibited, 0);
-       insert_cnt = 0;
        _transport_speed = 0;
        _last_transport_speed = 0;
+       _target_transport_speed = 0;
        auto_play_legal = false;
        transport_sub_state = 0;
        _transport_frame = 0;
-       last_stop_frame = 0;
        end_location = new Location (0, 0, _("end"), Location::Flags ((Location::IsMark|Location::IsEnd)));
        start_location = new Location (0, 0, _("start"), Location::Flags ((Location::IsMark|Location::IsStart)));
-       _end_location_is_free = true;
        g_atomic_int_set (&_record_status, Disabled);
        loop_changing = false;
        play_loop = false;
+       have_looped = false;
        _last_roll_location = 0;
        _last_record_location = 0;
        pending_locate_frame = 0;
        pending_locate_roll = false;
        pending_locate_flush = false;
-       dstream_buffer_size = 0;
-       state_tree = 0;
        state_was_pending = false;
        set_next_event ();
        outbound_mtc_smpte_frame = 0;
        next_quarter_frame_to_send = -1;
        current_block_size = 0;
        solo_update_disabled = false;
-       currently_soloing = false;
        _have_captured = false;
        _worst_output_latency = 0;
        _worst_input_latency = 0;
        _worst_track_latency = 0;
-       _state_of_the_state = StateOfTheState(CannotSave|InitialConnecting|Loading|Deletion);
+       _state_of_the_state = StateOfTheState(CannotSave|InitialConnecting|Loading);
+
        _slave = 0;
-       butler_mixdown_buffer = 0;
-       butler_gain_buffer = 0;
-       mmc = 0;
        session_send_mmc = false;
        session_send_mtc = false;
        post_transport_work = PostTransportWork (0);
-       g_atomic_int_set (&butler_should_do_transport_work, 0);
-       g_atomic_int_set (&butler_active, 0);
        g_atomic_int_set (&_playback_load, 100);
        g_atomic_int_set (&_capture_load, 100);
        g_atomic_int_set (&_playback_load_min, 100);
        g_atomic_int_set (&_capture_load_min, 100);
        _play_range = false;
-       waiting_to_start = false;
        _exporting = false;
+       _exporting_realtime = false;
        _gain_automation_buffer = 0;
        _pan_automation_buffer = 0;
        _npan_buffers = 0;
        pending_abort = false;
        destructive_index = 0;
-       current_trans = 0;
        first_file_data_format_reset = true;
        first_file_header_format_reset = true;
-       butler_thread = (pthread_t) 0;
        //midi_thread = (pthread_t) 0;
 
        AudioDiskstream::allocate_working_buffers();
 
        /* default short fade = 15ms */
 
-       Crossfade::set_short_xfade_length ((nframes_t) floor (Config->get_short_xfade_seconds() * frame_rate()));
-       SndFileSource::setup_standard_crossfades (frame_rate());
+       Crossfade::set_short_xfade_length ((nframes_t) floor (config.get_short_xfade_seconds() * frame_rate()));
+       SndFileSource::setup_standard_crossfades (*this, frame_rate());
 
        last_mmc_step.tv_sec = 0;
        last_mmc_step.tv_usec = 0;
@@ -216,24 +231,19 @@ Session::first_stage_init (string fullpath, string snapshot_name)
        /* click sounds are unset by default, which causes us to internal
           waveforms for clicks.
        */
-       
-       click_data = 0;
-       click_emphasis_data = 0;
+
        click_length = 0;
        click_emphasis_length = 0;
        _clicking = false;
 
        process_function = &Session::process_with_events;
 
-       if (Config->get_use_video_sync()) {
+       if (config.get_use_video_sync()) {
                waiting_for_sync_offset = true;
        } else {
                waiting_for_sync_offset = false;
        }
 
-       _current_frame_rate = 48000;
-       _base_frame_rate = 48000;
-
        last_smpte_when = 0;
        _smpte_offset = 0;
        _smpte_offset_negative = true;
@@ -248,7 +258,7 @@ Session::first_stage_init (string fullpath, string snapshot_name)
 
        /* slave stuff */
 
-       average_slave_delta = 1800;
+       average_slave_delta = 1800; // !!! why 1800 ????
        have_first_delta_accumulator = false;
        delta_accumulator_cnt = 0;
        slave_state = Stopped;
@@ -266,12 +276,11 @@ Session::first_stage_init (string fullpath, string snapshot_name)
 
        Controllable::Destroyed.connect (mem_fun (*this, &Session::remove_controllable));
 
-       IO::MoreChannels.connect (mem_fun (*this, &Session::ensure_buffers));
+       IO::PortCountChanged.connect (mem_fun (*this, &Session::ensure_buffers));
 
        /* stop IO objects from doing stuff until we're ready for them */
 
-       IO::disable_panners ();
-       IO::disable_ports ();
+       Delivery::disable_panners ();
        IO::disable_connecting ();
 }
 
@@ -287,18 +296,19 @@ Session::second_stage_init (bool new_session)
                remove_empty_sounds ();
        }
 
-       if (start_butler_thread()) {
+       if (_butler->start_thread()) {
                return -1;
        }
 
-       /*if (start_midi_thread ()) {
+       if (start_midi_thread ()) {
                return -1;
-       }*/
+       }
 
        // set_state() will call setup_raid_path(), but if it's a new session we need
        // to call setup_raid_path() here.
+
        if (state_tree) {
-               if (set_state (*state_tree->root())) {
+               if (set_state (*state_tree->root(), Stateful::loading_state_version)) {
                        return -1;
                }
        } else {
@@ -317,7 +327,7 @@ Session::second_stage_init (bool new_session)
 
        _state_of_the_state = StateOfTheState (_state_of_the_state|CannotSave|Loading);
 
-       // set_auto_input (true);
+
        _locations.changed.connect (mem_fun (this, &Session::locations_changed));
        _locations.added.connect (mem_fun (this, &Session::locations_added));
        setup_click_sounds (0);
@@ -333,10 +343,9 @@ Session::second_stage_init (bool new_session)
        }
 
        /* handle this one in a different way than all others, so that its clear what happened */
-       
+
        catch (AudioEngine::PortRegistrationFailure& err) {
-               error << _("Unable to create all required ports")
-                     << endmsg;
+               error << err.what() << endmsg;
                return -1;
        }
 
@@ -344,19 +353,36 @@ Session::second_stage_init (bool new_session)
                return -1;
        }
 
-       //send_full_time_code ();
+       BootMessage (_("Reset Remote Controls"));
+
+       send_full_time_code (0);
        _engine.transport_locate (0);
        deliver_mmc (MIDI::MachineControl::cmdMmcReset, 0);
        deliver_mmc (MIDI::MachineControl::cmdLocate, 0);
 
+       MidiClockTicker::instance().set_session(*this);
+       MIDI::Name::MidiPatchManager::instance().set_session(*this);
+
+       /* initial program change will be delivered later; see ::config_changed() */
+
+       BootMessage (_("Reset Control Protocols"));
+
        ControlProtocolManager::instance().set_session (*this);
 
-       if (new_session) {
-               _end_location_is_free = true;
-       } else {
-               _end_location_is_free = false;
+       config.set_end_marker_is_free (new_session);
+
+       _state_of_the_state = Clean;
+
+       DirtyChanged (); /* EMIT SIGNAL */
+
+       if (state_was_pending) {
+               save_state (_current_snapshot_name);
+               remove_pending_capture_state ();
+               state_was_pending = false;
        }
-       
+
+       BootMessage (_("Session loading complete"));
+
        return 0;
 }
 
@@ -368,7 +394,7 @@ Session::raid_path () const
        for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
                raid_search_path += sys::path((*i).path);
        }
-       
+
        return raid_search_path.to_string ();
 }
 
@@ -378,7 +404,7 @@ Session::setup_raid_path (string path)
        if (path.empty()) {
                return;
        }
-       
+
        space_and_path sp;
        string fspath;
 
@@ -388,12 +414,7 @@ Session::setup_raid_path (string path)
        SearchPath sound_search_path;
        SearchPath midi_search_path;
 
-       for (
-                       SearchPath::const_iterator i = search_path.begin();
-                       i != search_path.end();
-                       ++i
-               )
-       {
+       for (SearchPath::const_iterator i = search_path.begin(); i != search_path.end(); ++i) {
                sp.path = (*i).to_string ();
                sp.blocks = 0; // not needed
                session_dirs.push_back (sp);
@@ -404,65 +425,140 @@ Session::setup_raid_path (string path)
                midi_search_path += sdir.midi_path ();
        }
 
-       // set the AudioFileSource and SMFSource search path
-
-       AudioFileSource::set_search_path (sound_search_path.to_string ());
-       SMFSource::set_search_path (midi_search_path.to_string ());
+       // set the search path for each data type
+       FileSource::set_search_path (DataType::AUDIO, sound_search_path.to_string ());
+       SMFSource::set_search_path (DataType::MIDI, midi_search_path.to_string ());
 
        // reset the round-robin soundfile path thingie
-       
        last_rr_session_dir = session_dirs.begin();
 }
 
-void
-Session::initialize_start_and_end_locations (nframes_t start, nframes_t end)
+int
+Session::ensure_subdirs ()
 {
-       start_location->set_end (start);
-       _locations.add (start_location);
+       string dir;
 
-       end_location->set_end (end);
-       _locations.add (end_location);
-}
+       dir = session_directory().peak_path().to_string();
 
-bool
-Session::create_session_file ()
-{
-       _state_of_the_state = Clean;
+       if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
+               error << string_compose(_("Session: cannot create session peakfile folder \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
+               return -1;
+       }
+
+       dir = session_directory().sound_path().to_string();
+
+       if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
+               error << string_compose(_("Session: cannot create session sounds dir \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
+               return -1;
+       }
+
+       dir = session_directory().midi_path().to_string();
+
+       if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
+               error << string_compose(_("Session: cannot create session midi dir \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
+               return -1;
+       }
 
-       if (save_state (_current_snapshot_name)) {
-               error << "Could not create new session file" << endmsg;
-               return false;
+       dir = session_directory().dead_sound_path().to_string();
+
+       if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
+               error << string_compose(_("Session: cannot create session dead sounds folder \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
+               return -1;
+       }
+
+       dir = session_directory().export_path().to_string();
+
+       if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
+               error << string_compose(_("Session: cannot create session export folder \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
+               return -1;
        }
-       return true;
+
+       dir = analysis_dir ();
+
+       if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
+               error << string_compose(_("Session: cannot create session analysis folder \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
+               return -1;
+       }
+
+       return 0;
 }
 
-bool
-Session::create_session_file_from_template (const string& template_path)
+int
+Session::create (bool& new_session, const string& mix_template, nframes_t initial_length)
 {
-       sys::path session_file_path(_session_dir->root_path());
 
-       session_file_path /= _name + statefile_suffix;
+       if (g_mkdir_with_parents (_path.c_str(), 0755) < 0) {
+               error << string_compose(_("Session: cannot create session folder \"%1\" (%2)"), _path, strerror (errno)) << endmsg;
+               return -1;
+       }
 
-       try
-       {
-               sys::copy_file (template_path, session_file_path);
+       if (ensure_subdirs ()) {
+               return -1;
        }
-       catch(sys::filesystem_error& ex)
-       {
-               error << string_compose (_("Could not use session template %1 to create new session (%2)."),
-                               template_path, ex.what())
-                       << endmsg;
-               return false;
+
+       /* check new_session so we don't overwrite an existing one */
+
+       if (!mix_template.empty()) {
+               std::string in_path = mix_template;
+
+               ifstream in(in_path.c_str());
+
+               if (in){
+                       string out_path = _path;
+                       out_path += _name;
+                       out_path += statefile_suffix;
+
+                       ofstream out(out_path.c_str());
+
+                       if (out){
+                               out << in.rdbuf();
+
+                               // okay, session is set up.  Treat like normal saved
+                               // session from now on.
+
+                               new_session = false;
+                               return 0;
+
+                       } else {
+                               error << string_compose (_("Could not open %1 for writing mix template"), out_path)
+                                       << endmsg;
+                               return -1;
+                       }
+
+               } else {
+                       error << string_compose (_("Could not open mix template %1 for reading"), in_path)
+                               << endmsg;
+                       return -1;
+               }
+
        }
-       return true;
+
+       /* Instantiate metadata */
+
+       _metadata = new SessionMetadata ();
+
+       /* set initial start + end point */
+
+       start_location->set_end (0);
+       _locations.add (start_location);
+
+       end_location->set_end (initial_length);
+       _locations.add (end_location);
+
+       _state_of_the_state = Clean;
+
+       save_state ("");
+
+       return 0;
 }
 
+
 int
 Session::load_diskstreams (const XMLNode& node)
 {
        XMLNodeList          clist;
        XMLNodeConstIterator citer;
-       
+
        clist = node.children();
 
        for (citer = clist.begin(); citer != clist.end(); ++citer) {
@@ -478,8 +574,8 @@ Session::load_diskstreams (const XMLNode& node)
                        } else {
                                error << _("Session: unknown diskstream type in XML") << endmsg;
                        }
-               } 
-               
+               }
+
                catch (failed_constructor& err) {
                        error << _("Session: could not load diskstream via XML state") << endmsg;
                        return -1;
@@ -502,7 +598,7 @@ Session::remove_pending_capture_state ()
 {
        sys::path pending_state_file_path(_session_dir->root_path());
 
-       pending_state_file_path /= _current_snapshot_name + pending_suffix;
+       pending_state_file_path /= legalize_for_path (_current_snapshot_name) + pending_suffix;
 
        try
        {
@@ -525,12 +621,21 @@ Session::rename_state (string old_name, string new_name)
                /* refuse to rename the current snapshot or the "main" one */
                return;
        }
-       
-       const string old_xml_path = _path + old_name + statefile_suffix;
-       const string new_xml_path = _path + new_name + statefile_suffix;
 
-       if (rename (old_xml_path.c_str(), new_xml_path.c_str()) != 0) {
-               error << string_compose(_("could not rename snapshot %1 to %2"), old_name, new_name) << endmsg;
+       const string old_xml_filename = legalize_for_path (old_name) + statefile_suffix;
+       const string new_xml_filename = legalize_for_path (new_name) + statefile_suffix;
+
+       const sys::path old_xml_path = _session_dir->root_path() / old_xml_filename;
+       const sys::path new_xml_path = _session_dir->root_path() / new_xml_filename;
+
+       try
+       {
+               sys::rename (old_xml_path, new_xml_path);
+       }
+       catch (const sys::filesystem_error& err)
+       {
+               error << string_compose(_("could not rename snapshot %1 to %2 (%3)"),
+                               old_name, new_name, err.what()) << endmsg;
        }
 }
 
@@ -547,7 +652,7 @@ Session::remove_state (string snapshot_name)
 
        sys::path xml_path(_session_dir->root_path());
 
-       xml_path /= snapshot_name + statefile_suffix;
+       xml_path /= legalize_for_path (snapshot_name) + statefile_suffix;
 
        if (!create_backup_file (xml_path)) {
                // don't remove it if a backup can't be made
@@ -565,7 +670,7 @@ Session::save_state (string snapshot_name, bool pending)
        XMLTree tree;
        sys::path xml_path(_session_dir->root_path());
 
-       if (_state_of_the_state & CannotSave) {
+       if (!_writable || (_state_of_the_state & CannotSave)) {
                return 1;
        }
 
@@ -589,8 +694,8 @@ Session::save_state (string snapshot_name, bool pending)
        if (!pending) {
 
                /* proper save: use statefile_suffix (.ardour in English) */
-               
-               xml_path /= snapshot_name + statefile_suffix;
+
+               xml_path /= legalize_for_path (snapshot_name) + statefile_suffix;
 
                /* make a backup copy of the old file */
 
@@ -602,12 +707,12 @@ Session::save_state (string snapshot_name, bool pending)
        } else {
 
                /* pending save: use pending_suffix (.pending in English) */
-               xml_path /= snapshot_name + pending_suffix;
+               xml_path /= legalize_for_path (snapshot_name) + pending_suffix;
        }
 
        sys::path tmp_path(_session_dir->root_path());
 
-       tmp_path /= snapshot_name + temp_suffix;
+       tmp_path /= legalize_for_path (snapshot_name) + temp_suffix;
 
        // cerr << "actually writing state to " << xml_path.to_string() << endl;
 
@@ -648,26 +753,24 @@ int
 Session::restore_state (string snapshot_name)
 {
        if (load_state (snapshot_name) == 0) {
-               set_state (*state_tree->root());
+               set_state (*state_tree->root(), Stateful::loading_state_version);
        }
-       
+
        return 0;
 }
 
 int
 Session::load_state (string snapshot_name)
 {
-       if (state_tree) {
-               delete state_tree;
-               state_tree = 0;
-       }
+       delete state_tree;
+       state_tree = 0;
 
        state_was_pending = false;
 
        /* check for leftover pending state from a crashed capture attempt */
 
        sys::path xmlpath(_session_dir->root_path());
-       xmlpath /= snapshot_name + pending_suffix;
+       xmlpath /= legalize_for_path (snapshot_name) + pending_suffix;
 
        if (sys::exists (xmlpath)) {
 
@@ -675,14 +778,14 @@ Session::load_state (string snapshot_name)
 
                if (AskAboutPendingState()) {
                        state_was_pending = true;
-               } 
-       } 
+               }
+       }
 
        if (!state_was_pending) {
                xmlpath = _session_dir->root_path();
-               xmlpath /= snapshot_name + statefile_suffix;
+               xmlpath /= legalize_for_path (snapshot_name) + statefile_suffix;
        }
-       
+
        if (!sys::exists (xmlpath)) {
                error << string_compose(_("%1: session state information file \"%2\" doesn't exist!"), _name, xmlpath.to_string()) << endmsg;
                return 1;
@@ -692,6 +795,15 @@ Session::load_state (string snapshot_name)
 
        set_dirty();
 
+       /* writable() really reflects the whole folder, but if for any
+          reason the session state file can't be written to, still
+          make us unwritable.
+       */
+
+       if (::access (xmlpath.to_string().c_str(), W_OK) != 0) {
+               _writable = false;
+       }
+
        if (!state_tree->read (xmlpath.to_string())) {
                error << string_compose(_("Could not understand ardour file %1"), xmlpath.to_string()) << endmsg;
                delete state_tree;
@@ -700,7 +812,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 an Ardour session"), xmlpath.to_string()) << endmsg;
                delete state_tree;
@@ -709,24 +821,24 @@ Session::load_state (string snapshot_name)
        }
 
        const XMLProperty* prop;
-       bool is_old = false;
 
        if ((prop = root.property ("version")) == 0) {
                /* no version implies very old version of Ardour */
-               is_old = true;
+               Stateful::loading_state_version = 1000;
        } else {
-               int major_version;
-               major_version = atoi (prop->value().c_str()); // grab just the first number before the period
-               if (major_version < 2) {
-                       is_old = true;
-               }
-       }
+               int major;
+               int minor;
+               int micro;
 
-       if (is_old) {
+               sscanf (prop->value().c_str(), "%d.%d.%d", &major, &minor, &micro);
+               Stateful::loading_state_version = (major * 1000) + minor;
+       }
+               
+       if (Stateful::loading_state_version < CURRENT_SESSION_FILE_VERSION) {
 
                sys::path backup_path(_session_dir->root_path());
 
-               backup_path /= snapshot_name + "-1" + statefile_suffix;
+               backup_path /= legalize_for_path (snapshot_name) + "-1" + statefile_suffix;
 
                // only create a backup once
                if (sys::exists (backup_path)) {
@@ -734,7 +846,7 @@ Session::load_state (string snapshot_name)
                }
 
                info << string_compose (_("Copying old session file %1 to %2\nUse %2 with Ardour versions before 2.0 from now on"),
-                                       xmlpath.to_string(), backup_path.to_string()) 
+                                       xmlpath.to_string(), backup_path.to_string())
                     << endmsg;
 
                try
@@ -756,42 +868,17 @@ Session::load_state (string snapshot_name)
 int
 Session::load_options (const XMLNode& node)
 {
-       XMLNode* child;
-       XMLProperty* prop;
        LocaleGuard lg (X_("POSIX"));
 
-       Config->set_variables (node, ConfigVariableBase::Session);
+       config.set_variables (node);
 
-       if ((child = find_named_node (node, "end-marker-is-free")) != 0) {
-               if ((prop = child->property ("val")) != 0) {
-                       _end_location_is_free = (prop->value() == "yes");
-               }
-       }
-
-       return 0;
-}
-
-bool
-Session::save_config_options_predicate (ConfigVariableBase::Owner owner) const
-{
-       const ConfigVariableBase::Owner modified_by_session_or_user = (ConfigVariableBase::Owner)
-               (ConfigVariableBase::Session|ConfigVariableBase::Interface);
-
-       return owner & modified_by_session_or_user;
-}
-
-XMLNode&
-Session::get_options () const
-{
-       XMLNode* child;
-       LocaleGuard lg (X_("POSIX"));
-
-       XMLNode& option_root = Config->get_variables (mem_fun (*this, &Session::save_config_options_predicate));
+       /* now reset MIDI ports because the session can have its own
+          MIDI configuration.
+       */
 
-       child = option_root.add_child ("end-marker-is-free");
-       child->add_property ("val", _end_location_is_free ? "yes" : "no");
+       setup_midi ();
 
-       return option_root;
+       return 0;
 }
 
 XMLNode&
@@ -805,9 +892,9 @@ Session::get_template()
 {
        /* if we don't disable rec-enable, diskstreams
           will believe they need to store their capture
-          sources in their state node. 
+          sources in their state node.
        */
-       
+
        disable_record (false);
 
        return state(false);
@@ -821,16 +908,16 @@ Session::state(bool full_state)
 
        // store libardour version, just in case
        char buf[16];
-       snprintf(buf, sizeof(buf)-1, "%d.%d.%d", 
-                libardour_major_version, libardour_minor_version, libardour_micro_version);
+       snprintf(buf, sizeof(buf), "%d.%d.%d", libardour3_major_version, libardour3_minor_version, libardour3_micro_version);
        node->add_property("version", string(buf));
-               
+
        /* store configuration settings */
 
        if (full_state) {
-       
-               /* store the name */
+
                node->add_property ("name", _name);
+               snprintf (buf, sizeof (buf), "%" PRId32, _nominal_frame_rate);
+               node->add_property ("sample-rate", buf);
 
                if (session_dirs.size() > 1) {
 
@@ -856,20 +943,22 @@ Session::state(bool full_state)
                                ++next;
                                ++i;
                        }
-                       
+
                        child = node->add_child ("Path");
                        child->add_content (p);
                }
        }
 
        /* save the ID counter */
-       
+
        snprintf (buf, sizeof (buf), "%" PRIu64, ID::counter());
        node->add_property ("id-counter", buf);
 
        /* various options */
 
-       node->add_child_nocopy (get_options());
+       node->add_child_nocopy (config.get_variables ());
+
+       node->add_child_nocopy (_metadata->get_state());
 
        child = node->add_child ("Sources");
 
@@ -877,35 +966,30 @@ Session::state(bool full_state)
                Glib::Mutex::Lock sl (source_lock);
 
                for (SourceMap::iterator siter = sources.begin(); siter != sources.end(); ++siter) {
-                       
-                       /* Don't save information about AudioFileSources that are empty */
-                       
-                       boost::shared_ptr<AudioFileSource> fs;
 
-                       if ((fs = boost::dynamic_pointer_cast<AudioFileSource> (siter->second)) != 0) {
-
-                               /* Don't save sources that are empty, unless they're destructive (which are OK
-                                  if they are empty, because we will re-use them every time.)
-                               */
+                       /* Don't save information about non-destructive file sources that are empty */
+                       /* FIXME: MIDI breaks if this is made FileSource like it should be... */
 
+                       boost::shared_ptr<AudioFileSource> fs;
+                       if ((fs = boost::dynamic_pointer_cast<AudioFileSource> (siter->second)) != 0) {
                                if (!fs->destructive()) {
-                                       if (fs->length() == 0) {
+                                       if (fs->length(fs->timeline_position()) == 0) {
                                                continue;
                                        }
                                }
                        }
-                       
+
                        child->add_child_nocopy (siter->second->get_state());
                }
        }
 
        child = node->add_child ("Regions");
 
-       if (full_state) { 
+       if (full_state) {
                Glib::Mutex::Lock rl (region_lock);
 
                for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
-                       
+
                        /* only store regions not attached to playlists */
 
                        if (i->second->playlist() == 0) {
@@ -916,7 +1000,7 @@ Session::state(bool full_state)
 
        child = node->add_child ("DiskStreams");
 
-       { 
+       {
                boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
                for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
                        if (!(*i)->hidden()) {
@@ -939,13 +1023,14 @@ Session::state(bool full_state)
                loc.add (end);
                node->add_child_nocopy (loc.get_state());
        }
-       
-       child = node->add_child ("Connections");
+
+       child = node->add_child ("Bundles");
        {
-               Glib::Mutex::Lock lm (bundle_lock);
-               for (BundleList::iterator i = _bundles.begin(); i != _bundles.end(); ++i) {
-                       if (!(*i)->dynamic()) {
-                               child->add_child_nocopy ((*i)->get_state());
+               boost::shared_ptr<BundleList> bundles = _bundles.reader ();
+               for (BundleList::iterator i = bundles->begin(); i != bundles->end(); ++i) {
+                       boost::shared_ptr<UserBundle> b = boost::dynamic_pointer_cast<UserBundle> (*i);
+                       if (b) {
+                               child->add_child_nocopy (b->get_state());
                        }
                }
        }
@@ -953,11 +1038,11 @@ Session::state(bool full_state)
        child = node->add_child ("Routes");
        {
                boost::shared_ptr<RouteList> r = routes.reader ();
-               
+
                RoutePublicOrderSorter cmp;
                RouteList public_order (*r);
                public_order.sort (cmp);
-               
+
                for (RouteList::iterator i = public_order.begin(); i != public_order.end(); ++i) {
                        if (!(*i)->is_hidden()) {
                                if (full_state) {
@@ -969,14 +1054,9 @@ Session::state(bool full_state)
                }
        }
 
-       
-       child = node->add_child ("EditGroups");
-       for (list<RouteGroup *>::iterator i = edit_groups.begin(); i != edit_groups.end(); ++i) {
-               child->add_child_nocopy ((*i)->get_state());
-       }
 
-       child = node->add_child ("MixGroups");
-       for (list<RouteGroup *>::iterator i = mix_groups.begin(); i != mix_groups.end(); ++i) {
+       child = node->add_child ("RouteGroups");
+       for (list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
                child->add_child_nocopy ((*i)->get_state());
        }
 
@@ -1005,8 +1085,8 @@ Session::state(bool full_state)
                        }
                }
        }
-       
-       
+
+
        if (_click_io) {
                child = node->add_child ("Click");
                child->add_child_nocopy (_click_io->state (full_state));
@@ -1017,7 +1097,7 @@ Session::state(bool full_state)
                for (NamedSelectionList::iterator i = named_selections.begin(); i != named_selections.end(); ++i) {
                        if (full_state) {
                                child->add_child_nocopy ((*i)->get_state());
-                       } 
+                       }
                }
        }
 
@@ -1040,7 +1120,7 @@ Session::get_control_protocol_state ()
 }
 
 int
-Session::set_state (const XMLNode& node)
+Session::set_state (const XMLNode& node, int version)
 {
        XMLNodeList nlist;
        XMLNode* child;
@@ -1048,16 +1128,31 @@ Session::set_state (const XMLNode& node)
        int ret = -1;
 
        _state_of_the_state = StateOfTheState (_state_of_the_state|CannotSave);
-       
+
        if (node.name() != X_("Session")){
                fatal << _("programming error: Session: incorrect XML node sent to set_state()") << endmsg;
                return -1;
        }
 
+       if ((prop = node.property ("version")) != 0) {
+               version = atoi (prop->value ()) * 1000;
+       }
+
        if ((prop = node.property ("name")) != 0) {
                _name = prop->value ();
        }
 
+       if ((prop = node.property (X_("sample-rate"))) != 0) {
+
+               _nominal_frame_rate = atoi (prop->value());
+
+               if (_nominal_frame_rate != _current_frame_rate) {
+                       if (AskAboutSampleRateMismatch (_nominal_frame_rate, _current_frame_rate)) {
+                               return -1;
+                       }
+               }
+       }
+
        setup_raid_path(_session_dir->root_path().to_string());
 
        if ((prop = node.property (X_("id-counter"))) != 0) {
@@ -1074,32 +1169,29 @@ Session::set_state (const XMLNode& node)
                ID::init_counter (now);
        }
 
-       
-       IO::disable_ports ();
+
        IO::disable_connecting ();
 
        /* Object loading order:
 
-       MIDI Control
        Path
-       extra
+       Extra
        Options/Config
+       MIDI Control // relies on data from Options/Config
+       Metadata
        Locations
        Sources
        AudioRegions
        AudioDiskstreams
        Connections
        Routes
-       EditGroups
+       RouteGroups
        MixGroups
        Click
        ControlProtocols
        */
 
-       if (use_config_midi_ports ()) {
-       }
-
-       if ((child = find_named_node (node, "extra")) != 0) {
+       if ((child = find_named_node (node, "Extra")) != 0) {
                _extra_xml = new XMLNode (*child);
        }
 
@@ -1111,10 +1203,21 @@ Session::set_state (const XMLNode& node)
                error << _("Session: XML state has no options section") << endmsg;
        }
 
+       if (use_config_midi_ports ()) {
+       }
+
+       if (version >= 3000) {
+               if ((child = find_named_node (node, "Metadata")) == 0) {
+                       warning << _("Session: XML state has no metadata section") << endmsg;
+               } else if (_metadata->set_state (*child, version)) {
+                       goto out;
+               }
+       }
+
        if ((child = find_named_node (node, "Locations")) == 0) {
                error << _("Session: XML state has no locations section") << endmsg;
                goto out;
-       } else if (_locations.set_state (*child)) {
+       } else if (_locations.set_state (*child, version)) {
                goto out;
        }
 
@@ -1184,47 +1287,64 @@ Session::set_state (const XMLNode& node)
                goto out;
        }
 
-       if ((child = find_named_node (node, "Connections")) == 0) {
-               error << _("Session: XML state has no connections section") << endmsg;
-               goto out;
-       } else if (load_bundles (*child)) {
-               goto out;
-       }
-
-       if ((child = find_named_node (node, "EditGroups")) == 0) {
-               error << _("Session: XML state has no edit groups section") << endmsg;
-               goto out;
-       } else if (load_edit_groups (*child)) {
-               goto out;
+       if (version >= 3000) {
+               if ((child = find_named_node (node, "Bundles")) == 0) {
+                       warning << _("Session: XML state has no bundles section") << endmsg;
+                       //goto out;
+               } else {
+                       /* We can't load Bundles yet as they need to be able
+                          to convert from port names to Port objects, which can't happen until
+                          later */
+                       _bundle_xml_node = new XMLNode (*child);
+               }
        }
+       
+       if (version >= 3000) {
+               
+               if ((child = find_named_node (node, "RouteGroups")) == 0) {
+                       error << _("Session: XML state has no route groups section") << endmsg;
+                       goto out;
+               } else if (load_route_groups (*child, version)) {
+                       goto out;
+               }
+               
+       } else if (version < 3000) {
+               
+               if ((child = find_named_node (node, "EditGroups")) == 0) {
+                       error << _("Session: XML state has no edit groups section") << endmsg;
+                       goto out;
+               } else if (load_route_groups (*child, version)) {
+                       goto out;
+               }
 
-       if ((child = find_named_node (node, "MixGroups")) == 0) {
-               error << _("Session: XML state has no mix groups section") << endmsg;
-               goto out;
-       } else if (load_mix_groups (*child)) {
-               goto out;
+               if ((child = find_named_node (node, "MixGroups")) == 0) {
+                       error << _("Session: XML state has no mix groups section") << endmsg;
+                       goto out;
+               } else if (load_route_groups (*child, version)) {
+                       goto out;
+               }
        }
 
        if ((child = find_named_node (node, "TempoMap")) == 0) {
                error << _("Session: XML state has no Tempo Map section") << endmsg;
                goto out;
-       } else if (_tempo_map->set_state (*child)) {
+       } else if (_tempo_map->set_state (*child, version)) {
                goto out;
        }
 
        if ((child = find_named_node (node, "Routes")) == 0) {
                error << _("Session: XML state has no routes section") << endmsg;
                goto out;
-       } else if (load_routes (*child)) {
+       } else if (load_routes (*child, version)) {
                goto out;
        }
 
        if ((child = find_named_node (node, "Click")) == 0) {
                warning << _("Session: XML state has no click section") << endmsg;
        } else if (_click_io) {
-               _click_io->set_state (*child);
+               _click_io->set_state (*child, version);
        }
-       
+
        if ((child = find_named_node (node, "ControlProtocols")) != 0) {
                ControlProtocolManager::instance().set_protocol_states (*child);
        }
@@ -1233,14 +1353,6 @@ Session::set_state (const XMLNode& node)
 
        StateReady (); /* EMIT SIGNAL */
 
-       _state_of_the_state = Clean;
-
-       if (state_was_pending) {
-               save_state (_current_snapshot_name);
-               remove_pending_capture_state ();
-               state_was_pending = false;
-       }
-
        return 0;
 
   out:
@@ -1248,7 +1360,7 @@ Session::set_state (const XMLNode& node)
 }
 
 int
-Session::load_routes (const XMLNode& node)
+Session::load_routes (const XMLNode& node, int version)
 {
        XMLNodeList nlist;
        XMLNodeConstIterator niter;
@@ -1260,43 +1372,47 @@ Session::load_routes (const XMLNode& node)
 
        for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
 
-               boost::shared_ptr<Route> route (XMLRouteFactory (**niter));
+               boost::shared_ptr<Route> route (XMLRouteFactory (**niter, version));
 
                if (route == 0) {
-                       error << _("Session: cannot create Route from XML description.")                              << endmsg;
+                       error << _("Session: cannot create Route from XML description.") << endmsg;
                        return -1;
                }
 
+               BootMessage (string_compose (_("Loaded track/bus %1"), route->name()));
+
                new_routes.push_back (route);
        }
 
-       add_routes (new_routes);
+       add_routes (new_routes, false);
 
        return 0;
 }
 
 boost::shared_ptr<Route>
-Session::XMLRouteFactory (const XMLNode& node)
+Session::XMLRouteFactory (const XMLNode& node, int version)
 {
        if (node.name() != "Route") {
                return boost::shared_ptr<Route> ((Route*) 0);
        }
 
        bool has_diskstream = (node.property ("diskstream") != 0 || node.property ("diskstream-id") != 0);
-       
+
        DataType type = DataType::AUDIO;
        const XMLProperty* prop = node.property("default-type");
-       if (prop)
+
+       if (prop) {
                type = DataType(prop->value());
-       
+       }
+
        assert(type != DataType::NIL);
 
        if (has_diskstream) {
                if (type == DataType::AUDIO) {
-                       boost::shared_ptr<Route> ret (new AudioTrack (*this, node));
+                       boost::shared_ptr<Route> ret (new AudioTrack (*this, node, version));
                        return ret;
                } else {
-                       boost::shared_ptr<Route> ret (new MidiTrack (*this, node));
+                       boost::shared_ptr<Route> ret (new MidiTrack (*this, node, version));
                        return ret;
                }
        } else {
@@ -1318,7 +1434,14 @@ Session::load_regions (const XMLNode& node)
 
        for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
                if ((region = XMLRegionFactory (**niter, false)) == 0) {
-                       error << _("Session: cannot create Region from XML description.") << endmsg;
+                       error << _("Session: cannot create Region from XML description.");
+                       const XMLProperty *name = (**niter).property("name");
+
+                       if (name) {
+                               error << " " << string_compose (_("Can not load state for region '%1'"), name->value());
+                       }
+
+                       error << endmsg;
                }
        }
 
@@ -1331,17 +1454,17 @@ Session::XMLRegionFactory (const XMLNode& node, bool full)
        const XMLProperty* type = node.property("type");
 
        try {
-       
+
        if ( !type || type->value() == "audio" ) {
 
                return boost::shared_ptr<Region>(XMLAudioRegionFactory (node, full));
-       
+
        } else if (type->value() == "midi") {
-               
+
                return boost::shared_ptr<Region>(XMLMidiRegionFactory (node, full));
 
        }
-       
+
        } catch (failed_constructor& err) {
                return boost::shared_ptr<Region> ();
        }
@@ -1350,15 +1473,16 @@ Session::XMLRegionFactory (const XMLNode& node, bool full)
 }
 
 boost::shared_ptr<AudioRegion>
-Session::XMLAudioRegionFactory (const XMLNode& node, bool full)
+Session::XMLAudioRegionFactory (const XMLNode& node, bool /*full*/)
 {
        const XMLProperty* prop;
        boost::shared_ptr<Source> source;
        boost::shared_ptr<AudioSource> as;
        SourceList sources;
+       SourceList master_sources;
        uint32_t nchans = 1;
        char buf[128];
-       
+
        if (node.name() != X_("Region")) {
                return boost::shared_ptr<AudioRegion>();
        }
@@ -1371,7 +1495,7 @@ Session::XMLAudioRegionFactory (const XMLNode& node, bool full)
                cerr << "no name for this region\n";
                abort ();
        }
-       
+
        if ((prop = node.property (X_("source-0"))) == 0) {
                if ((prop = node.property ("source")) == 0) {
                        error << _("Session: XMLNode describing a AudioRegion is incomplete (no source)") << endmsg;
@@ -1385,7 +1509,7 @@ Session::XMLAudioRegionFactory (const XMLNode& node, bool full)
                error << string_compose(_("Session: XMLNode describing a AudioRegion references an unknown source id =%1"), s_id) << endmsg;
                return boost::shared_ptr<AudioRegion>();
        }
-       
+
        as = boost::dynamic_pointer_cast<AudioSource>(source);
        if (!as) {
                error << string_compose(_("Session: XMLNode describing a AudioRegion references a non-audio source id =%1"), s_id) << endmsg;
@@ -1399,14 +1523,14 @@ Session::XMLAudioRegionFactory (const XMLNode& node, bool full)
        for (uint32_t n=1; n < nchans; ++n) {
                snprintf (buf, sizeof(buf), X_("source-%d"), n);
                if ((prop = node.property (buf)) != 0) {
-                       
+
                        PBD::ID id2 (prop->value());
-                       
+
                        if ((source = source_by_id (id2)) == 0) {
                                error << string_compose(_("Session: XMLNode describing a AudioRegion references an unknown source id =%1"), id2) << endmsg;
                                return boost::shared_ptr<AudioRegion>();
                        }
-                       
+
                        as = boost::dynamic_pointer_cast<AudioSource>(source);
                        if (!as) {
                                error << string_compose(_("Session: XMLNode describing a AudioRegion references a non-audio source id =%1"), id2) << endmsg;
@@ -1415,7 +1539,27 @@ Session::XMLAudioRegionFactory (const XMLNode& node, bool full)
                        sources.push_back (as);
                }
        }
-       
+
+       for (uint32_t n = 0; n < nchans; ++n) {
+               snprintf (buf, sizeof(buf), X_("master-source-%d"), n);
+               if ((prop = node.property (buf)) != 0) {
+
+                       PBD::ID id2 (prop->value());
+
+                       if ((source = source_by_id (id2)) == 0) {
+                               error << string_compose(_("Session: XMLNode describing a AudioRegion references an unknown source id =%1"), id2) << endmsg;
+                               return boost::shared_ptr<AudioRegion>();
+                       }
+
+                       as = boost::dynamic_pointer_cast<AudioSource>(source);
+                       if (!as) {
+                               error << string_compose(_("Session: XMLNode describing a AudioRegion references a non-audio source id =%1"), id2) << endmsg;
+                               return boost::shared_ptr<AudioRegion>();
+                       }
+                       master_sources.push_back (as);
+               }
+       }
+
        try {
                boost::shared_ptr<AudioRegion> region (boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (sources, node)));
 
@@ -1430,8 +1574,16 @@ Session::XMLAudioRegionFactory (const XMLNode& node, bool full)
                        }
                }
 
+               if (!master_sources.empty()) {
+                       if (master_sources.size() != nchans) {
+                               error << _("Session: XMLNode describing an AudioRegion is missing some master sources; ignored") << endmsg;
+                       } else {
+                               region->set_master_sources (master_sources);
+                       }
+               }
+
                return region;
-                                                      
+
        }
 
        catch (failed_constructor& err) {
@@ -1440,14 +1592,14 @@ Session::XMLAudioRegionFactory (const XMLNode& node, bool full)
 }
 
 boost::shared_ptr<MidiRegion>
-Session::XMLMidiRegionFactory (const XMLNode& node, bool full)
+Session::XMLMidiRegionFactory (const XMLNode& node, bool /*full*/)
 {
        const XMLProperty* prop;
        boost::shared_ptr<Source> source;
        boost::shared_ptr<MidiSource> ms;
        SourceList sources;
        uint32_t nchans = 1;
-       
+
        if (node.name() != X_("Region")) {
                return boost::shared_ptr<MidiRegion>();
        }
@@ -1455,7 +1607,7 @@ Session::XMLMidiRegionFactory (const XMLNode& node, bool full)
        if ((prop = node.property (X_("channels"))) != 0) {
                nchans = atoi (prop->value().c_str());
        }
-       
+
        if ((prop = node.property ("name")) == 0) {
                cerr << "no name for this region\n";
                abort ();
@@ -1527,23 +1679,24 @@ Session::path_from_region_name (DataType type, string name, string identifier)
        char buf[PATH_MAX+1];
        uint32_t n;
        SessionDirectory sdir(get_best_session_directory_for_new_source());
-       string sound_dir = ((type == DataType::AUDIO)
-               ? sdir.sound_path().to_string()
-               : sdir.midi_path().to_string());
+       sys::path source_dir = ((type == DataType::AUDIO)
+               ? sdir.sound_path() : sdir.midi_path());
 
        string ext = ((type == DataType::AUDIO) ? ".wav" : ".mid");
 
        for (n = 0; n < 999999; ++n) {
                if (identifier.length()) {
-                       snprintf (buf, sizeof(buf), "%s/%s%s%" PRIu32 "%s", sound_dir.c_str(), name.c_str(), 
+                       snprintf (buf, sizeof(buf), "%s%s%" PRIu32 "%s", name.c_str(),
                                  identifier.c_str(), n, ext.c_str());
                } else {
-                       snprintf (buf, sizeof(buf), "%s/%s-%" PRIu32 "%s", sound_dir.c_str(), name.c_str(),
+                       snprintf (buf, sizeof(buf), "%s-%" PRIu32 "%s", name.c_str(),
                                        n, ext.c_str());
                }
 
-               if (!Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) {
-                       return buf;
+               sys::path source_path = source_dir / buf;
+
+               if (!sys::exists (source_path)) {
+                       return source_path.to_string();
                }
        }
 
@@ -1553,7 +1706,7 @@ Session::path_from_region_name (DataType type, string name, string identifier)
 
        return "";
 }
-       
+
 
 int
 Session::load_sources (const XMLNode& node)
@@ -1567,14 +1720,11 @@ Session::load_sources (const XMLNode& node)
        set_dirty();
 
        for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
-
                try {
                        if ((source = XMLSourceFactory (**niter)) == 0) {
                                error << _("Session: cannot create Source from XML description.") << endmsg;
                        }
-               }
-
-               catch (non_existent_source& err) {
+               } catch (MissingSource& err) {
                        warning << _("A sound file is missing. It will be replaced by silence.") << endmsg;
                        source = SourceFactory::createSilent (*this, **niter, max_frames, _current_frame_rate);
                }
@@ -1591,7 +1741,8 @@ Session::XMLSourceFactory (const XMLNode& node)
        }
 
        try {
-               return SourceFactory::create (*this, node);
+               /* note: do peak building in another thread when loading session state */
+               return SourceFactory::create (*this, node, true);
        }
 
        catch (failed_constructor& err) {
@@ -1634,12 +1785,49 @@ Session::save_template (string template_name)
                return -1;
        }
 
-       if (!tree.write (template_file_path.to_string())) {
-               error << _("mix template not saved") << endmsg;
+       if (!tree.write (template_file_path.to_string())) {
+               error << _("mix template not saved") << endmsg;
+               return -1;
+       }
+
+       return 0;
+}
+
+int
+Session::rename_template (string old_name, string new_name)
+{
+       sys::path old_path (user_template_directory());
+       old_path /= old_name + template_suffix;
+
+       sys::path new_path(user_template_directory());
+       new_path /= new_name + template_suffix;
+
+       if (sys::exists (new_path)) {
+               warning << string_compose(_("Template \"%1\" already exists - template not renamed"),
+                                         new_path.to_string()) << endmsg;
+               return -1;
+       }
+
+       try {
+               sys::rename (old_path, new_path);
+               return 0;
+       } catch (...) {
+               return -1;
+       }
+}
+
+int
+Session::delete_template (string name)
+{
+       sys::path path = user_template_directory();
+       path /= name + template_suffix;
+
+       try {
+               sys::remove (path);
+               return 0;
+       } catch (...) {
                return -1;
        }
-
-       return 0;
 }
 
 void
@@ -1654,7 +1842,7 @@ Session::refresh_disk_space ()
        /* get freespace on every FS that is part of the session path */
 
        _total_free_4k_blocks = 0;
-       
+
        for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
                statfs ((*i).path.c_str(), &statfsbuf);
 
@@ -1679,8 +1867,8 @@ Session::get_best_session_directory_for_new_source ()
        }
 
        /* OK, here's the algorithm we're following here:
-          
-       We want to select which directory to use for 
+
+       We want to select which directory to use for
        the next file source to be created. Ideally,
        we'd like to use a round-robin process so as to
        get maximum performance benefits from splitting
@@ -1699,15 +1887,15 @@ Session::get_best_session_directory_for_new_source ()
 
        So, we use a user-configurable space threshold. If
        there are at least 2 filesystems with more than this
-       much space available, we use RR selection between them. 
+       much space available, we use RR selection between them.
        If not, then we pick the filesystem with the most space.
 
        This gets a good balance between the two
-       approaches.  
+       approaches.
        */
-       
+
        refresh_disk_space ();
-       
+
        int free_enough = 0;
 
        for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
@@ -1743,13 +1931,13 @@ Session::get_best_session_directory_for_new_source ()
                /* pick FS with the most freespace (and that
                   seems to actually work ...)
                */
-               
+
                vector<space_and_path> sorted;
                space_and_path_ascending_cmp cmp;
 
                sorted = session_dirs;
                sort (sorted.begin(), sorted.end(), cmp);
-               
+
                for (i = sorted.begin(); i != sorted.end(); ++i) {
                        if (create_session_directory ((*i).path)) {
                                result = (*i).path;
@@ -1774,7 +1962,7 @@ Session::load_playlists (const XMLNode& node)
        set_dirty();
 
        for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
-               
+
                if ((playlist = XMLPlaylistFactory (**niter)) == 0) {
                        error << _("Session: cannot create Playlist from XML description.") << endmsg;
                }
@@ -1795,7 +1983,7 @@ Session::load_unused_playlists (const XMLNode& node)
        set_dirty();
 
        for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
-               
+
                if ((playlist = XMLPlaylistFactory (**niter)) == 0) {
                        error << _("Session: cannot create Playlist from XML description.") << endmsg;
                        continue;
@@ -1833,7 +2021,7 @@ Session::load_named_selections (const XMLNode& node)
        set_dirty();
 
        for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
-               
+
                if ((ns = XMLNamedSelectionFactory (**niter)) == 0) {
                        error << _("Session: cannot create Named Selection from XML description.") << endmsg;
                }
@@ -1857,13 +2045,17 @@ Session::XMLNamedSelectionFactory (const XMLNode& node)
 string
 Session::automation_dir () const
 {
-       string res = _path;
-       res += "automation/";
-       return res;
+       return Glib::build_filename (_path, "automation");
+}
+
+string
+Session::analysis_dir () const
+{
+       return Glib::build_filename (_path, "analysis");
 }
 
 int
-Session::load_bundles (const XMLNode& node)
+Session::load_bundles (XMLNode const & node)
 {
        XMLNodeList nlist = node.children();
        XMLNodeConstIterator niter;
@@ -1871,54 +2063,50 @@ Session::load_bundles (const XMLNode& node)
        set_dirty();
 
        for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
-               if ((*niter)->name() == "InputConnection") {
-                       add_bundle (new ARDOUR::InputBundle (**niter));
-               } else if ((*niter)->name() == "OutputConnection") {
-                       add_bundle (new ARDOUR::OutputBundle (**niter));
+               if ((*niter)->name() == "InputBundle") {
+                       add_bundle (boost::shared_ptr<UserBundle> (new UserBundle (**niter, true)));
+               } else if ((*niter)->name() == "OutputBundle") {
+                       add_bundle (boost::shared_ptr<UserBundle> (new UserBundle (**niter, false)));
                } else {
-                       error << string_compose(_("Unknown node \"%1\" found in Connections list from state file"), (*niter)->name()) << endmsg;
+                       error << string_compose(_("Unknown node \"%1\" found in Bundles list from state file"), (*niter)->name()) << endmsg;
                        return -1;
                }
        }
 
        return 0;
-}                              
-
-int
-Session::load_edit_groups (const XMLNode& node)
-{
-       return load_route_groups (node, true);
-}
-
-int
-Session::load_mix_groups (const XMLNode& node)
-{
-       return load_route_groups (node, false);
 }
 
 int
-Session::load_route_groups (const XMLNode& node, bool edit)
+Session::load_route_groups (const XMLNode& node, int version)
 {
        XMLNodeList nlist = node.children();
        XMLNodeConstIterator niter;
-       RouteGroup* rg;
 
-       set_dirty();
+       set_dirty ();
 
-       for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
-               if ((*niter)->name() == "RouteGroup") {
-                       if (edit) {
-                               rg = add_edit_group ("");
-                               rg->set_state (**niter);
-                       } else {
-                               rg = add_mix_group ("");
-                               rg->set_state (**niter);
+       if (version >= 3000) {
+               
+               for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
+                       if ((*niter)->name() == "RouteGroup") {
+                               RouteGroup* rg = new RouteGroup (*this, "");
+                               add_route_group (rg);
+                               rg->set_state (**niter, version);
+                       }
+               }
+
+       } else if (version < 3000) {
+
+               for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
+                       if ((*niter)->name() == "EditGroup" || (*niter)->name() == "MixGroup") {
+                               RouteGroup* rg = new RouteGroup (*this, "");
+                               add_route_group (rg);
+                               rg->set_state (**niter, version);
                        }
                }
        }
-       
+
        return 0;
-}                              
+}
 
 void
 Session::auto_save()
@@ -1926,73 +2114,85 @@ Session::auto_save()
        save_state (_current_snapshot_name);
 }
 
-RouteGroup *
-Session::add_edit_group (string name)
+static bool
+state_file_filter (const string &str, void */*arg*/)
 {
-       RouteGroup* rg = new RouteGroup (*this, name);
-       edit_groups.push_back (rg);
-       edit_group_added (rg); /* EMIT SIGNAL */
-       set_dirty();
-       return rg;
+       return (str.length() > strlen(statefile_suffix) &&
+               str.find (statefile_suffix) == (str.length() - strlen (statefile_suffix)));
 }
 
-RouteGroup *
-Session::add_mix_group (string name)
+struct string_cmp {
+       bool operator()(const string* a, const string* b) {
+               return *a < *b;
+       }
+};
+
+static string*
+remove_end(string* state)
 {
-       RouteGroup* rg = new RouteGroup (*this, name, RouteGroup::Relative);
-       mix_groups.push_back (rg);
-       mix_group_added (rg); /* EMIT SIGNAL */
-       set_dirty();
-       return rg;
+       string statename(*state);
+
+       string::size_type start,end;
+       if ((start = statename.find_last_of ('/')) != string::npos) {
+               statename = statename.substr (start+1);
+       }
+
+       if ((end = statename.rfind(".ardour")) == string::npos) {
+               end = statename.length();
+       }
+
+       return new string(statename.substr (0, end));
 }
 
-void
-Session::remove_edit_group (RouteGroup& rg)
+vector<string *> *
+Session::possible_states (string path)
 {
-       list<RouteGroup*>::iterator i;
+       PathScanner scanner;
+       vector<string*>* states = scanner (path, state_file_filter, 0, false, false);
 
-       if ((i = find (edit_groups.begin(), edit_groups.end(), &rg)) != edit_groups.end()) {
-               (*i)->apply (&Route::drop_edit_group, this);
-               edit_groups.erase (i);
-               edit_group_removed (); /* EMIT SIGNAL */
-       }
+       transform(states->begin(), states->end(), states->begin(), remove_end);
 
-       delete &rg;
+       string_cmp cmp;
+       sort (states->begin(), states->end(), cmp);
+
+       return states;
+}
+
+vector<string *> *
+Session::possible_states () const
+{
+       return possible_states(_path);
+}
+
+void
+Session::add_route_group (RouteGroup* g)
+{
+       _route_groups.push_back (g);
+       route_group_added (g); /* EMIT SIGNAL */
+       set_dirty ();
 }
 
 void
-Session::remove_mix_group (RouteGroup& rg)
+Session::remove_route_group (RouteGroup& rg)
 {
        list<RouteGroup*>::iterator i;
 
-       if ((i = find (mix_groups.begin(), mix_groups.end(), &rg)) != mix_groups.end()) {
-               (*i)->apply (&Route::drop_mix_group, this);
-               mix_groups.erase (i);
-               mix_group_removed (); /* EMIT SIGNAL */
+       if ((i = find (_route_groups.begin(), _route_groups.end(), &rg)) != _route_groups.end()) {
+               (*i)->apply (&Route::drop_route_group, this);
+               _route_groups.erase (i);
+               route_group_removed (); /* EMIT SIGNAL */
        }
 
        delete &rg;
 }
 
-RouteGroup *
-Session::mix_group_by_name (string name)
-{
-       list<RouteGroup *>::iterator i;
-
-       for (i = mix_groups.begin(); i != mix_groups.end(); ++i) {
-               if ((*i)->name() == name) {
-                       return* i;
-               }
-       }
-       return 0;
-}
 
 RouteGroup *
-Session::edit_group_by_name (string name)
+Session::route_group_by_name (string name)
 {
        list<RouteGroup *>::iterator i;
 
-       for (i = edit_groups.begin(); i != edit_groups.end(); ++i) {
+       for (i = _route_groups.begin(); i != _route_groups.end(); ++i) {
                if ((*i)->name() == name) {
                        return* i;
                }
@@ -2001,28 +2201,41 @@ Session::edit_group_by_name (string name)
 }
 
 void
-Session::begin_reversible_command (const string& name)
+Session::begin_reversible_command(const string& name)
 {
-       current_trans = new UndoTransaction;
-       current_trans->set_name (name);
+       UndoTransaction* trans = new UndoTransaction();
+       trans->set_name(name);
+
+       if (!_current_trans.empty()) {
+               _current_trans.top()->add_command (trans);
+       } else {
+               _current_trans.push(trans);
+       }
 }
 
 void
-Session::commit_reversible_command (Command *cmd)
+Session::commit_reversible_command(Command *cmd)
 {
+       assert(!_current_trans.empty());
        struct timeval now;
 
        if (cmd) {
-               current_trans->add_command (cmd);
+               _current_trans.top()->add_command(cmd);
+       }
+
+       if (_current_trans.top()->empty()) {
+               _current_trans.pop();
+               return;
        }
 
-       gettimeofday (&now, 0);
-       current_trans->set_timestamp (now);
+       gettimeofday(&now, 0);
+       _current_trans.top()->set_timestamp(now);
 
-       _history.add (current_trans);
+       _history.add(_current_trans.top());
+       _current_trans.pop();
 }
 
-Session::GlobalRouteBooleanState 
+Session::GlobalRouteBooleanState
 Session::get_global_route_boolean (bool (Route::*method)(void) const)
 {
        GlobalRouteBooleanState s;
@@ -2031,11 +2244,11 @@ Session::get_global_route_boolean (bool (Route::*method)(void) const)
        for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
                if (!(*i)->is_hidden()) {
                        RouteBooleanState v;
-                       
+
                        v.first =* i;
                        Route* r = (*i).get();
                        v.second = (r->*method)();
-                       
+
                        s.push_back (v);
                }
        }
@@ -2052,10 +2265,10 @@ Session::get_global_route_metering ()
        for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
                if (!(*i)->is_hidden()) {
                        RouteMeterState v;
-                       
+
                        v.first =* i;
                        v.second = (*i)->meter_point();
-                       
+
                        s.push_back (v);
                }
        }
@@ -2064,7 +2277,7 @@ Session::get_global_route_metering ()
 }
 
 void
-Session::set_global_route_metering (GlobalRouteMeterState s, void* arg) 
+Session::set_global_route_metering (GlobalRouteMeterState s, void* arg)
 {
        for (GlobalRouteMeterState::iterator i = s.begin(); i != s.end(); ++i) {
 
@@ -2108,45 +2321,19 @@ Session::set_global_record_enable (GlobalRouteBooleanState s, void* src)
        set_global_route_boolean (s, &Route::set_record_enable, src);
 }
 
-#if 0
-UndoAction
-Session::global_mute_memento (void* src)
-{
-       return sigc::bind (mem_fun (*this, &Session::set_global_mute), get_global_route_boolean (&Route::muted), src);
-}
-
-UndoAction
-Session::global_metering_memento (void* src)
-{
-       return sigc::bind (mem_fun (*this, &Session::set_global_route_metering), get_global_route_metering (), src);
-}
-
-UndoAction
-Session::global_solo_memento (void* src)
-{
-       return sigc::bind (mem_fun (*this, &Session::set_global_solo), get_global_route_boolean (&Route::soloed), src);
-}
-
-UndoAction
-Session::global_record_enable_memento (void* src)
-{
-       return sigc::bind (mem_fun (*this, &Session::set_global_record_enable), get_global_route_boolean (&Route::record_enabled), src);
-}
-#endif
-
 static bool
-accept_all_non_peak_files (const string& path, void *arg)
+accept_all_non_peak_files (const string& path, void */*arg*/)
 {
        return (path.length() > 5 && path.find (peakfile_suffix) != (path.length() - 5));
 }
 
 static bool
-accept_all_state_files (const string& path, void *arg)
+accept_all_state_files (const string& path, void */*arg*/)
 {
        return (path.length() > 7 && path.find (".ardour") == (path.length() - 7));
 }
 
-int 
+int
 Session::find_all_sources (string path, set<string>& result)
 {
        XMLTree tree;
@@ -2168,9 +2355,15 @@ Session::find_all_sources (string path, set<string>& result)
        set_dirty();
 
        for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
-               
+
                XMLProperty* prop;
 
+               if ((prop = (*niter)->property (X_("type"))) == 0) {
+                       continue;
+               }
+
+               DataType type (prop->value());
+
                if ((prop = (*niter)->property (X_("name"))) == 0) {
                        continue;
                }
@@ -2180,11 +2373,13 @@ Session::find_all_sources (string path, set<string>& result)
                        continue;
                }
 
-               sys::path source_path = _session_dir->sound_path ();
+               Glib::ustring found_path;
+               bool is_new;
+               uint16_t chan;
 
-               source_path /= prop->value ();
-
-               result.insert (source_path.to_string ());
+               if (FileSource::find (type, prop->value(), true, is_new, chan, found_path)) {
+                       result.insert (found_path);
+               }
        }
 
        return 0;
@@ -2207,14 +2402,14 @@ Session::find_all_sources_across_snapshots (set<string>& result, bool exclude_th
        }
 
        state_files = scanner (ripped, accept_all_state_files, (void *) 0, false, true);
-       
+
        if (state_files == 0) {
                /* impossible! */
                return 0;
        }
 
        this_snapshot_path = _path;
-       this_snapshot_path += _current_snapshot_name;
+       this_snapshot_path += legalize_for_path (_current_snapshot_name);
        this_snapshot_path += statefile_suffix;
 
        for (vector<string*>::iterator i = state_files->begin(); i != state_files->end(); ++i) {
@@ -2236,7 +2431,7 @@ struct RegionCounter {
     AudioSourceList::iterator iter;
     boost::shared_ptr<Region> region;
     uint32_t count;
-    
+
     RegionCounter() : count (0) {}
 };
 
@@ -2244,7 +2439,7 @@ int
 Session::cleanup_sources (Session::cleanup_report& rep)
 {
        // FIXME: needs adaptation to midi
-       
+
        vector<boost::shared_ptr<Source> > dead_sources;
        vector<boost::shared_ptr<Playlist> > playlists_tbd;
        PathScanner scanner;
@@ -2257,9 +2452,10 @@ Session::cleanup_sources (Session::cleanup_report& rep)
        bool used;
        string spath;
        int ret = -1;
-               
+
        _state_of_the_state = (StateOfTheState) (_state_of_the_state | InCleanup);
-       
+
+
        /* step 1: consider deleting all unused playlists */
 
        for (PlaylistList::iterator x = unused_playlists.begin(); x != unused_playlists.end(); ++x) {
@@ -2297,7 +2493,7 @@ Session::cleanup_sources (Session::cleanup_report& rep)
        rep.space = 0;
 
        for (SourceMap::iterator i = sources.begin(); i != sources.end(); ) {
-               
+
                SourceMap::iterator tmp;
 
                tmp = i;
@@ -2307,10 +2503,10 @@ Session::cleanup_sources (Session::cleanup_report& rep)
                   capture files.
                */
 
-               if (!i->second->used() && i->second->length() > 0) {
+               if (!i->second->used() && i->second->length(i->second->timeline_position()) > 0) {
                        dead_sources.push_back (i->second);
                        i->second->GoingAway();
-               } 
+               }
 
                i = tmp;
        }
@@ -2332,7 +2528,7 @@ Session::cleanup_sources (Session::cleanup_report& rep)
                i = nexti;
        }
 
-       /* now do the same thing for the files that ended up in the sounds dir(s) 
+       /* now do the same thing for the files that ended up in the sounds dir(s)
           but are not referenced as sources in any snapshot.
        */
 
@@ -2346,23 +2542,23 @@ Session::cleanup_sources (Session::cleanup_report& rep)
           state file on disk still references sources we may have already
           dropped.
        */
-       
+
        find_all_sources_across_snapshots (all_sources, true);
 
        /*  add our current source list
         */
-       
+
        for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
-               boost::shared_ptr<AudioFileSource> fs;
-               
-               if ((fs = boost::dynamic_pointer_cast<AudioFileSource> (i->second)) != 0) {
+               boost::shared_ptr<FileSource> fs;
+
+               if ((fs = boost::dynamic_pointer_cast<FileSource> (i->second)) != 0) {
                        all_sources.insert (fs->path());
-               } 
+               }
        }
 
        char tmppath1[PATH_MAX+1];
        char tmppath2[PATH_MAX+1];
-       
+
        for (vector<string*>::iterator x = soundfiles->begin(); x != soundfiles->end(); ++x) {
 
                used = false;
@@ -2395,7 +2591,7 @@ Session::cleanup_sources (Session::cleanup_report& rep)
                }
 
                string newpath;
-               
+
                /* don't move the file across filesystems, just
                   stick it in the `dead_sound_dir_name' directory
                   on whichever filesystem it was already on.
@@ -2405,14 +2601,14 @@ Session::cleanup_sources (Session::cleanup_report& rep)
 
                        /* old school, go up 1 level */
 
-                       newpath = Glib::path_get_dirname (*x);      // "sounds" 
+                       newpath = Glib::path_get_dirname (*x);      // "sounds"
                        newpath = Glib::path_get_dirname (newpath); // "session-name"
 
                } else {
 
                        /* new school, go up 4 levels */
-                       
-                       newpath = Glib::path_get_dirname (*x);      // "audiofiles" 
+
+                       newpath = Glib::path_get_dirname (*x);      // "audiofiles"
                        newpath = Glib::path_get_dirname (newpath); // "session-name"
                        newpath = Glib::path_get_dirname (newpath); // "interchange"
                        newpath = Glib::path_get_dirname (newpath); // "session-dir"
@@ -2422,21 +2618,21 @@ Session::cleanup_sources (Session::cleanup_report& rep)
                newpath += dead_sound_dir_name;
 
                if (g_mkdir_with_parents (newpath.c_str(), 0755) < 0) {
-                       error << string_compose(_("Session: cannot create session peakfile dir \"%1\" (%2)"), newpath, strerror (errno)) << endmsg;
+                       error << string_compose(_("Session: cannot create session peakfile folder \"%1\" (%2)"), newpath, strerror (errno)) << endmsg;
                        return -1;
                }
 
                newpath += '/';
                newpath += Glib::path_get_basename ((*x));
-               
+
                if (access (newpath.c_str(), F_OK) == 0) {
-                       
+
                        /* the new path already exists, try versioning */
-                       
+
                        char buf[PATH_MAX+1];
                        int version = 1;
                        string newpath_v;
-                       
+
                        snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), version);
                        newpath_v = buf;
 
@@ -2444,7 +2640,7 @@ Session::cleanup_sources (Session::cleanup_report& rep)
                                snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), ++version);
                                newpath_v = buf;
                        }
-                       
+
                        if (version == 999) {
                                error << string_compose (_("there are already 1000 files with names like %1; versioning discontinued"),
                                                  newpath)
@@ -2452,11 +2648,11 @@ Session::cleanup_sources (Session::cleanup_report& rep)
                        } else {
                                newpath = newpath_v;
                        }
-                       
+
                } else {
-                       
+
                        /* it doesn't exist, or we can't read it or something */
-                       
+
                }
 
                if (::rename ((*x).c_str(), newpath.c_str()) != 0) {
@@ -2493,11 +2689,12 @@ Session::cleanup_sources (Session::cleanup_report& rep)
        /* save state so we don't end up a session file
           referring to non-existent sources.
        */
-       
+
        save_state ("");
 
   out:
        _state_of_the_state = (StateOfTheState) (_state_of_the_state & ~InCleanup);
+
        return ret;
 }
 
@@ -2505,7 +2702,7 @@ int
 Session::cleanup_trash_sources (Session::cleanup_report& rep)
 {
        // FIXME: needs adaptation for MIDI
-       
+
        vector<space_and_path>::iterator i;
        string dead_sound_dir;
        struct dirent* dentry;
@@ -2516,7 +2713,7 @@ Session::cleanup_trash_sources (Session::cleanup_report& rep)
        rep.space = 0;
 
        for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
-               
+
                dead_sound_dir = (*i).path;
                dead_sound_dir += dead_sound_dir_name;
 
@@ -2527,8 +2724,8 @@ Session::cleanup_trash_sources (Session::cleanup_report& rep)
                while ((dentry = readdir (dead)) != 0) {
 
                        /* avoid '.' and '..' */
-                       
-                       if ((dentry->d_name[0] == '.' && dentry->d_name[1] == '\0') || 
+
+                       if ((dentry->d_name[0] == '.' && dentry->d_name[1] == '\0') ||
                            (dentry->d_name[2] == '\0' && dentry->d_name[0] == '.' && dentry->d_name[1] == '.')) {
                                continue;
                        }
@@ -2558,7 +2755,7 @@ Session::cleanup_trash_sources (Session::cleanup_report& rep)
                }
 
                closedir (dead);
-               
+
        }
 
        return 0;
@@ -2571,6 +2768,7 @@ Session::set_dirty ()
 
        _state_of_the_state = StateOfTheState (_state_of_the_state | Dirty);
 
+
        if (!was_dirty) {
                DirtyChanged(); /* EMIT SIGNAL */
        }
@@ -2581,9 +2779,10 @@ void
 Session::set_clean ()
 {
        bool was_dirty = dirty();
-       
+
        _state_of_the_state = Clean;
 
+
        if (was_dirty) {
                DirtyChanged(); /* EMIT SIGNAL */
        }
@@ -2595,6 +2794,12 @@ Session::set_deletion_in_progress ()
        _state_of_the_state = StateOfTheState (_state_of_the_state | Deletion);
 }
 
+void
+Session::clear_deletion_in_progress ()
+{
+       _state_of_the_state = StateOfTheState (_state_of_the_state & (~Deletion));
+}
+
 void
 Session::add_controllable (boost::shared_ptr<Controllable> c)
 {
@@ -2607,7 +2812,7 @@ Session::add_controllable (boost::shared_ptr<Controllable> c)
        Glib::Mutex::Lock lm (controllables_lock);
        controllables.insert (c);
 }
-       
+
 struct null_deleter { void operator()(void const *) const {} };
 
 void
@@ -2625,13 +2830,13 @@ Session::remove_controllable (Controllable* c)
        if (x != controllables.end()) {
                controllables.erase (x);
        }
-}      
+}
 
 boost::shared_ptr<Controllable>
 Session::controllable_by_id (const PBD::ID& id)
 {
        Glib::Mutex::Lock lm (controllables_lock);
-       
+
        for (Controllables::iterator i = controllables.begin(); i != controllables.end(); ++i) {
                if ((*i)->id() == id) {
                        return *i;
@@ -2641,11 +2846,16 @@ Session::controllable_by_id (const PBD::ID& id)
        return boost::shared_ptr<Controllable>();
 }
 
-void 
-Session::add_instant_xml (XMLNode& node)
+void
+Session::add_instant_xml (XMLNode& node, bool write_to_config)
 {
-       Stateful::add_instant_xml (node, _path);
-       Config->add_instant_xml (node);
+       if (_writable) {
+               Stateful::add_instant_xml (node, _path);
+       }
+
+       if (write_to_config) {
+               Config->add_instant_xml (node);
+       }
 }
 
 XMLNode*
@@ -2654,20 +2864,22 @@ Session::instant_xml (const string& node_name)
        return Stateful::instant_xml (node_name, _path);
 }
 
-int 
+int
 Session::save_history (string snapshot_name)
 {
        XMLTree tree;
-       
-       tree.set_root (&_history.get_state (Config->get_saved_history_depth()));
 
-       if (snapshot_name.empty()) {
+       if (!_writable) {
+               return 0;
+       }
+
+       if (snapshot_name.empty()) {
                snapshot_name = _current_snapshot_name;
        }
-  
-       const string history_filename = snapshot_name + history_suffix;
+
+       const string history_filename = legalize_for_path (snapshot_name) + history_suffix;
        const string backup_filename = history_filename + backup_suffix;
-       const sys::path xml_path = _session_dir->root_path() / history_filename;
+       const sys::path xml_path = _session_dir->root_path() / history_filename;
        const sys::path backup_path = _session_dir->root_path() / backup_filename;
 
        if (sys::exists (xml_path)) {
@@ -2680,7 +2892,13 @@ Session::save_history (string snapshot_name)
                        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()))
        {
@@ -2712,10 +2930,10 @@ Session::restore_history (string snapshot_name)
                snapshot_name = _current_snapshot_name;
        }
 
-       const string xml_filename = snapshot_name + history_suffix;
+       const string xml_filename = legalize_for_path (snapshot_name) + history_suffix;
        const sys::path xml_path = _session_dir->root_path() / xml_filename;
 
-       info << string_compose(_("Loading history from '%1'."), xml_path.to_string()) << endmsg;
+       info << "Loading history from " << xml_path.to_string() << endmsg;
 
        if (!sys::exists (xml_path)) {
                info << string_compose (_("%1: no history file \"%2\" for this session."),
@@ -2732,168 +2950,188 @@ Session::restore_history (string snapshot_name)
        // replace history
        _history.clear();
 
-    for (XMLNodeConstIterator it  = tree.root()->children().begin(); it != tree.root()->children().end(); it++) {
-           
-           XMLNode *t = *it;
-           UndoTransaction* ut = new UndoTransaction ();
-           struct timeval tv;
-           
-           ut->set_name(t->property("name")->value());
-           stringstream ss(t->property("tv_sec")->value());
-           ss >> tv.tv_sec;
-           ss.str(t->property("tv_usec")->value());
-           ss >> tv.tv_usec;
-           ut->set_timestamp(tv);
-           
-           for (XMLNodeConstIterator child_it  = t->children().begin();
-                child_it != t->children().end();
-                child_it++)
-           {
-                   XMLNode *n = *child_it;
-                   Command *c;
-       
-                   if (n->name() == "MementoCommand" ||
-                       n->name() == "MementoUndoCommand" ||
-                       n->name() == "MementoRedoCommand") {
+       for (XMLNodeConstIterator it  = tree.root()->children().begin(); it != tree.root()->children().end(); it++) {
+
+               XMLNode *t = *it;
+               UndoTransaction* ut = new UndoTransaction ();
+               struct timeval tv;
+
+               ut->set_name(t->property("name")->value());
+               stringstream ss(t->property("tv-sec")->value());
+               ss >> tv.tv_sec;
+               ss.str(t->property("tv-usec")->value());
+               ss >> tv.tv_usec;
+               ut->set_timestamp(tv);
+
+               for (XMLNodeConstIterator child_it  = t->children().begin();
+                               child_it != t->children().end(); child_it++)
+               {
+                       XMLNode *n = *child_it;
+                       Command *c;
+
+                       if (n->name() == "MementoCommand" ||
+                                       n->name() == "MementoUndoCommand" ||
+                                       n->name() == "MementoRedoCommand") {
+
+                               if ((c = memento_command_factory(n))) {
+                                       ut->add_command(c);
+                               }
 
-                           if ((c = memento_command_factory(n))) {
-                                   ut->add_command(c);
-                           }
-                           
-                   } else if (n->name() == X_("GlobalRouteStateCommand")) {
+                       } else if (n->name() == X_("GlobalRouteStateCommand")) {
 
-                           if ((c = global_state_command_factory (*n))) {
-                                   ut->add_command (c);
-                           }
-                           
-                   } else {
+                               if ((c = global_state_command_factory (*n))) {
+                                       ut->add_command (c);
+                               }
+
+                       } else if (n->name() == "DeltaCommand") {
+                               PBD::ID  id(n->property("midi-source")->value());
+                               boost::shared_ptr<MidiSource> midi_source =
+                                       boost::dynamic_pointer_cast<MidiSource, Source>(source_by_id(id));
+                               if (midi_source) {
+                                       ut->add_command(new MidiModel::DeltaCommand(midi_source->model(), *n));
+                               } else {
+                                       error << _("Failed to downcast MidiSource for DeltaCommand") << endmsg;
+                               }
 
-                           error << string_compose(_("Couldn't figure out how to make a Command out of a %1 XMLNode."), n->name()) << endmsg;
-                   }
-           }
+                       } else if (n->name() == "DiffCommand") {
+                               PBD::ID  id(n->property("midi-source")->value());
+                               boost::shared_ptr<MidiSource> midi_source =
+                                       boost::dynamic_pointer_cast<MidiSource, Source>(source_by_id(id));
+                               if (midi_source) {
+                                       ut->add_command(new MidiModel::DiffCommand(midi_source->model(), *n));
+                               } else {
+                                       error << _("Failed to downcast MidiSource for DeltaCommand") << endmsg;
+                               }
+
+                       } else {
+                               error << string_compose(_("Couldn't figure out how to make a Command out of a %1 XMLNode."), n->name()) << endmsg;
+                       }
+               }
 
-           _history.add (ut);
-    }
+               _history.add (ut);
+       }
 
-    return 0;
+       return 0;
 }
 
 void
-Session::config_changed (const char* parameter_name)
+Session::config_changed (std::string p, bool ours)
 {
-#define PARAM_IS(x) (!strcmp (parameter_name, (x)))
+       if (ours) {
+               set_dirty ();
+       }
 
-       if (PARAM_IS ("seamless-loop")) {
-               
-       } else if (PARAM_IS ("rf-speed")) {
-               
-       } else if (PARAM_IS ("auto-loop")) {
-               
-       } else if (PARAM_IS ("auto-input")) {
+       if (p == "seamless-loop") {
+
+       } else if (p == "rf-speed") {
+
+       } else if (p == "auto-loop") {
+
+       } else if (p == "auto-input") {
 
                if (Config->get_monitoring_model() == HardwareMonitoring && transport_rolling()) {
                        /* auto-input only makes a difference if we're rolling */
-                       
+
                        boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
-                       
+
                        for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
                                if ((*i)->record_enabled ()) {
-                                       (*i)->monitor_input (!Config->get_auto_input());
+                                       (*i)->monitor_input (!config.get_auto_input());
                                }
                        }
                }
 
-       } else if (PARAM_IS ("punch-in")) {
+       } else if (p == "punch-in") {
 
                Location* location;
-               
+
                if ((location = _locations.auto_punch_location()) != 0) {
-                       
-                       if (Config->get_punch_in ()) {
+
+                       if (config.get_punch_in ()) {
                                replace_event (Event::PunchIn, location->start());
                        } else {
                                remove_event (location->start(), Event::PunchIn);
                        }
                }
-               
-       } else if (PARAM_IS ("punch-out")) {
+
+       } else if (p == "punch-out") {
 
                Location* location;
-               
+
                if ((location = _locations.auto_punch_location()) != 0) {
-                       
-                       if (Config->get_punch_out()) {
+
+                       if (config.get_punch_out()) {
                                replace_event (Event::PunchOut, location->end());
                        } else {
                                clear_events (Event::PunchOut);
                        }
                }
 
-       } else if (PARAM_IS ("edit-mode")) {
+       } else if (p == "edit-mode") {
 
                Glib::Mutex::Lock lm (playlist_lock);
-               
+
                for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i) {
                        (*i)->set_edit_mode (Config->get_edit_mode ());
                }
 
-       } else if (PARAM_IS ("use-video-sync")) {
+       } else if (p == "use-video-sync") {
 
-               waiting_for_sync_offset = Config->get_use_video_sync();
+               waiting_for_sync_offset = config.get_use_video_sync();
 
-       } else if (PARAM_IS ("mmc-control")) {
+       } else if (p == "mmc-control") {
 
                //poke_midi_thread ();
 
-       } else if (PARAM_IS ("mmc-device-id") || PARAM_IS ("mmc-receive-id")) {
+       } else if (p == "mmc-device-id" || p == "mmc-receive-id") {
 
                if (mmc) {
                        mmc->set_receive_device_id (Config->get_mmc_receive_device_id());
                }
 
-       } else if (PARAM_IS ("mmc-send-id")) {
+       } else if (p == "mmc-send-id") {
 
                if (mmc) {
                        mmc->set_send_device_id (Config->get_mmc_send_device_id());
                }
 
-       } else if (PARAM_IS ("midi-control")) {
-               
+       } else if (p == "midi-control") {
+
                //poke_midi_thread ();
 
-       } else if (PARAM_IS ("raid-path")) {
+       } else if (p == "raid-path") {
 
-               setup_raid_path (Config->get_raid_path());
+               setup_raid_path (config.get_raid_path());
 
-       } else if (PARAM_IS ("smpte-format")) {
+       } else if (p == "smpte-format") {
 
                sync_time_vars ();
 
-       } else if (PARAM_IS ("video-pullup")) {
+       } else if (p == "video-pullup") {
 
                sync_time_vars ();
 
-       } else if (PARAM_IS ("seamless-loop")) {
+       } else if (p == "seamless-loop") {
 
                if (play_loop && transport_rolling()) {
                        // to reset diskstreams etc
                        request_play_loop (true);
                }
 
-       } else if (PARAM_IS ("rf-speed")) {
+       } else if (p == "rf-speed") {
 
                cumulative_rf_motion = 0;
                reset_rf_scale (0);
 
-       } else if (PARAM_IS ("click-sound")) {
+       } else if (p == "click-sound") {
 
                setup_click_sounds (1);
 
-       } else if (PARAM_IS ("click-emphasis-sound")) {
+       } else if (p == "click-emphasis-sound") {
 
                setup_click_sounds (-1);
 
-       } else if (PARAM_IS ("clicking")) {
+       } else if (p == "clicking") {
 
                if (Config->get_clicking()) {
                        if (_click_io && click_data) { // don't require emphasis data
@@ -2903,12 +3141,12 @@ Session::config_changed (const char* parameter_name)
                        _clicking = false;
                }
 
-       } else if (PARAM_IS ("send-mtc")) {
-               
+       } else if (p == "send-mtc") {
+
                /* only set the internal flag if we have
                   a port.
                */
-               
+
                if (_mtc_port != 0) {
                        session_send_mtc = Config->get_send_mtc();
                        if (session_send_mtc) {
@@ -2919,34 +3157,34 @@ Session::config_changed (const char* parameter_name)
                        session_send_mtc = false;
                }
 
-       } else if (PARAM_IS ("send-mmc")) {
-               
+       } else if (p == "send-mmc") {
+
                /* only set the internal flag if we have
                   a port.
                */
-               
+
                if (_mmc_port != 0) {
                        session_send_mmc = Config->get_send_mmc();
                } else {
                        mmc = 0;
-                       session_send_mmc = false; 
+                       session_send_mmc = false;
                }
 
-       } else if (PARAM_IS ("midi-feedback")) {
-               
+       } else if (p == "midi-feedback") {
+
                /* only set the internal flag if we have
                   a port.
                */
-               
+
                if (_mtc_port != 0) {
                        session_midi_feedback = Config->get_midi_feedback();
                }
 
-       } else if (PARAM_IS ("jack-time-master")) {
+       } else if (p == "jack-time-master") {
 
                engine().reset_timebase ();
 
-       } else if (PARAM_IS ("native-file-header-format")) {
+       } else if (p == "native-file-header-format") {
 
                if (!first_file_header_format_reset) {
                        reset_native_file_format ();
@@ -2954,7 +3192,7 @@ Session::config_changed (const char* parameter_name)
 
                first_file_header_format_reset = false;
 
-       } else if (PARAM_IS ("native-file-data-format")) {
+       } else if (p == "native-file-data-format") {
 
                if (!first_file_data_format_reset) {
                        reset_native_file_format ();
@@ -2962,16 +3200,49 @@ Session::config_changed (const char* parameter_name)
 
                first_file_data_format_reset = false;
 
-       } else if (PARAM_IS ("slave-source")) {
-               set_slave_source (Config->get_slave_source());
-       } else if (PARAM_IS ("remote-model")) {
+       } else if (p == "slave-source") {
+                               set_slave_source (Config->get_slave_source());
+       } else if (p == "remote-model") {
                set_remote_control_ids ();
-       }  else if (PARAM_IS ("denormal-model")) {
+       }  else if (p == "denormal-model") {
                setup_fpu ();
+       } else if (p == "history-depth") {
+               set_history_depth (Config->get_history_depth());
+       } else if (p == "sync-all-route-ordering") {
+               sync_order_keys ("session");
+       } else if (p == "initial-program-change") {
+
+               if (_mmc_port && Config->get_initial_program_change() >= 0) {
+                       MIDI::byte buf[2];
+
+                       buf[0] = MIDI::program; // channel zero by default
+                       buf[1] = (Config->get_initial_program_change() & 0x7f);
+
+                       _mmc_port->midimsg (buf, sizeof (buf), 0);
+               }
+       } else if (p == "initial-program-change") {
+
+               if (_mmc_port && Config->get_initial_program_change() >= 0) {
+                       MIDI::byte* buf = new MIDI::byte[2];
+
+                       buf[0] = MIDI::program; // channel zero by default
+                       buf[1] = (Config->get_initial_program_change() & 0x7f);
+                       // deliver_midi (_mmc_port, buf, 2);
+               }
+       } else if (p == "solo-mute-override") {
+               // catch_up_on_solo_mute_override ();
+       } else if (p == "listen-position") {
+               listen_position_changed ();
+       } else if (p == "solo-control-is-listen-control") {
+               solo_control_mode_changed ();
        }
 
+
        set_dirty ();
-                  
-#undef PARAM_IS
+}
 
+void
+Session::set_history_depth (uint32_t d)
+{
+       _history.set_depth (d);
 }