libs/ardour/session_state.cc

   1 /*
   2   Copyright (C) 1999-2002 Paul Davis
   3
   4   This program is free software; you can redistribute it and/or modify
   5   it under the terms of the GNU General Public License as published by
   6   the Free Software Foundation; either version 2 of the License, or
   7   (at your option) any later version.
   8
   9  This program is distributed in the hope that it will be useful,
  10   but WITHOUT ANY WARRANTY; without even the implied warranty of
  11   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12   GNU General Public License for more details.
  13
  14   You should have received a copy of the GNU General Public License
  15   along with this program; if not, write to the Free Software
  16   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20
  21 #ifdef WAF_BUILD
  22 #include "libardour-config.h"
  23 #endif
  24
  25 #define __STDC_FORMAT_MACROS 1
  26 #include <stdint.h>
  27
  28 #include <algorithm>
  29 #include <fstream>
  30 #include <string>
  31 #include <cerrno>
  32
  33
  34 #include <cstdio> /* snprintf(3) ... grrr */
  35 #include <cmath>
  36 #include <unistd.h>
  37 #include <sys/stat.h>
  38 #include <climits>
  39 #include <fcntl.h>
  40 #include <poll.h>
  41 #include <signal.h>
  42 #include <sys/mman.h>
  43 #include <sys/time.h>
  44 #include <dirent.h>
  45
  46 #ifdef HAVE_SYS_VFS_H
  47 #include <sys/vfs.h>
  48 #else
  49 #include <sys/param.h>
  50 #include <sys/mount.h>
  51 #endif
  52
  53 #include <glibmm.h>
  54 #include <glibmm/thread.h>
  55
  56 #include "midi++/mmc.h"
  57 #include "midi++/port.h"
  58
  59 #include "pbd/boost_debug.h"
  60 #include "pbd/controllable_descriptor.h"
  61 #include "pbd/enumwriter.h"
  62 #include "pbd/error.h"
  63 #include "pbd/pathscanner.h"
  64 #include "pbd/pthread_utils.h"
  65 #include "pbd/search_path.h"
  66 #include "pbd/stacktrace.h"
  67 #include "pbd/convert.h"
  68
  69 #include "ardour/amp.h"
  70 #include "ardour/audio_diskstream.h"
  71 #include "ardour/audio_track.h"
  72 #include "ardour/audioengine.h"
  73 #include "ardour/audiofilesource.h"
  74 #include "ardour/audioplaylist.h"
  75 #include "ardour/audioregion.h"
  76 #include "ardour/auditioner.h"
  77 #include "ardour/buffer.h"
  78 #include "ardour/butler.h"
  79 #include "ardour/configuration.h"
  80 #include "ardour/control_protocol_manager.h"
  81 #include "ardour/crossfade.h"
  82 #include "ardour/cycle_timer.h"
  83 #include "ardour/directory_names.h"
  84 #include "ardour/filename_extensions.h"
  85 #include "ardour/io_processor.h"
  86 #include "ardour/location.h"
  87 #include "ardour/midi_diskstream.h"
  88 #include "ardour/midi_patch_manager.h"
  89 #include "ardour/midi_playlist.h"
  90 #include "ardour/midi_region.h"
  91 #include "ardour/midi_source.h"
  92 #include "ardour/midi_track.h"
  93 #include "ardour/named_selection.h"
  94 #include "ardour/processor.h"
  95 #include "ardour/port.h"
  96 #include "ardour/region_factory.h"
  97 #include "ardour/route_group.h"
  98 #include "ardour/send.h"
  99 #include "ardour/session.h"
 100 #include "ardour/session_directory.h"
 101 #include "ardour/session_metadata.h"
 102 #include "ardour/session_state_utils.h"
 103 #include "ardour/session_playlists.h"
 104 #include "ardour/session_utils.h"
 105 #include "ardour/silentfilesource.h"
 106 #include "ardour/slave.h"
 107 #include "ardour/smf_source.h"
 108 #include "ardour/sndfile_helpers.h"
 109 #include "ardour/sndfilesource.h"
 110 #include "ardour/source_factory.h"
 111 #include "ardour/template_utils.h"
 112 #include "ardour/tempo.h"
 113 #include "ardour/ticker.h"
 114 #include "ardour/user_bundle.h"
 115 #include "ardour/utils.h"
 116 #include "ardour/utils.h"
 117 #include "ardour/version.h"
 118 #include "ardour/playlist_factory.h"
 119
 120 #include "control_protocol/control_protocol.h"
 121
 122 #include "i18n.h"
 123 #include <locale.h>
 124
 125 using namespace std;
 126 using namespace ARDOUR;
 127 using namespace PBD;
 128
 129 void
 130 Session::first_stage_init (string fullpath, string snapshot_name)
 131 {
 132         if (fullpath.length() == 0) {
 133                 destroy ();
 134                 throw failed_constructor();
 135         }
 136
 137         char buf[PATH_MAX+1];
 138         if (!realpath (fullpath.c_str(), buf) && (errno != ENOENT)) {
 139                 error << string_compose(_("Could not use path %1 (%s)"), buf, strerror(errno)) << endmsg;
 140                 destroy ();
 141                 throw failed_constructor();
 142         }
 143
 144         _path = string(buf);
 145
 146         if (_path[_path.length()-1] != '/') {
 147                 _path += '/';
 148         }
 149
 150         if (Glib::file_test (_path, Glib::FILE_TEST_EXISTS) && ::access (_path.c_str(), W_OK)) {
 151                 _writable = false;
 152         } else {
 153                 _writable = true;
 154         }
 155
 156         /* these two are just provisional settings. set_state()
 157            will likely override them.
 158         */
 159
 160         _name = _current_snapshot_name = snapshot_name;
 161
 162         set_history_depth (Config->get_history_depth());
 163
 164         _current_frame_rate = _engine.frame_rate ();
 165         _nominal_frame_rate = _current_frame_rate;
 166         _base_frame_rate = _current_frame_rate;
 167
 168         _tempo_map = new TempoMap (_current_frame_rate);
 169         _tempo_map->PropertyChanged.connect_same_thread (*this, boost::bind (&Session::tempo_map_changed, this, _1));
 170
 171
 172         _non_soloed_outs_muted = false;
 173         _listen_cnt = 0;
 174         _solo_isolated_cnt = 0;
 175         g_atomic_int_set (&processing_prohibited, 0);
 176         _transport_speed = 0;
 177         _last_transport_speed = 0;
 178         _target_transport_speed = 0;
 179         auto_play_legal = false;
 180         transport_sub_state = 0;
 181         _transport_frame = 0;
 182         _requested_return_frame = -1;
 183         _session_range_location = 0;
 184         g_atomic_int_set (&_record_status, Disabled);
 185         loop_changing = false;
 186         play_loop = false;
 187         have_looped = false;
 188         _last_roll_location = 0;
 189         _last_roll_or_reversal_location = 0;
 190         _last_record_location = 0;
 191         pending_locate_frame = 0;
 192         pending_locate_roll = false;
 193         pending_locate_flush = false;
 194         state_was_pending = false;
 195         set_next_event ();
 196         outbound_mtc_timecode_frame = 0;
 197         next_quarter_frame_to_send = -1;
 198         current_block_size = 0;
 199         solo_update_disabled = false;
 200         _have_captured = false;
 201         _worst_output_latency = 0;
 202         _worst_input_latency = 0;
 203         _worst_track_latency = 0;
 204         _state_of_the_state = StateOfTheState(CannotSave|InitialConnecting|Loading);
 205         _was_seamless = Config->get_seamless_loop ();
 206         _slave = 0;
 207         session_send_mmc = false;
 208         session_send_mtc = false;
 209         g_atomic_int_set (&_playback_load, 100);
 210         g_atomic_int_set (&_capture_load, 100);
 211         _play_range = false;
 212         _exporting = false;
 213         pending_abort = false;
 214         destructive_index = 0;
 215         first_file_data_format_reset = true;
 216         first_file_header_format_reset = true;
 217         post_export_sync = false;
 218         midi_control_ui = 0;
 219
 220         AudioDiskstream::allocate_working_buffers();
 221
 222         /* default short fade = 15ms */
 223
 224         Crossfade::set_short_xfade_length ((nframes_t) floor (config.get_short_xfade_seconds() * frame_rate()));
 225         SndFileSource::setup_standard_crossfades (*this, frame_rate());
 226
 227         last_mmc_step.tv_sec = 0;
 228         last_mmc_step.tv_usec = 0;
 229         step_speed = 0.0;
 230
 231         /* click sounds are unset by default, which causes us to internal
 232            waveforms for clicks.
 233         */
 234
 235         click_length = 0;
 236         click_emphasis_length = 0;
 237         _clicking = false;
 238
 239         process_function = &Session::process_with_events;
 240
 241         if (config.get_use_video_sync()) {
 242                 waiting_for_sync_offset = true;
 243         } else {
 244                 waiting_for_sync_offset = false;
 245         }
 246
 247         last_timecode_when = 0;
 248         _timecode_offset = 0;
 249         _timecode_offset_negative = true;
 250         last_timecode_valid = false;
 251
 252         sync_time_vars ();
 253
 254         last_rr_session_dir = session_dirs.begin();
 255         refresh_disk_space ();
 256
 257         // set_default_fade (0.2, 5.0); /* steepness, millisecs */
 258
 259         /* slave stuff */
 260
 261         average_slave_delta = 1800; // !!! why 1800 ????
 262         have_first_delta_accumulator = false;
 263         delta_accumulator_cnt = 0;
 264         _slave_state = Stopped;
 265
 266         _engine.GraphReordered.connect_same_thread (*this, boost::bind (&Session::graph_reordered, this));
 267
 268         /* These are all static "per-class" signals */
 269
 270         SourceFactory::SourceCreated.connect_same_thread (*this, boost::bind (&Session::add_source, this, _1));
 271         PlaylistFactory::PlaylistCreated.connect_same_thread (*this, boost::bind (&Session::add_playlist, this, _1, _2));
 272         AutomationList::AutomationListCreated.connect_same_thread (*this, boost::bind (&Session::add_automation_list, this, _1));
 273         Controllable::Destroyed.connect_same_thread (*this, boost::bind (&Session::remove_controllable, this, _1));
 274         IO::PortCountChanged.connect_same_thread (*this, boost::bind (&Session::ensure_buffers, this, _1));
 275
 276         /* stop IO objects from doing stuff until we're ready for them */
 277
 278         Delivery::disable_panners ();
 279         IO::disable_connecting ();
 280 }
 281
 282 int
 283 Session::second_stage_init ()
 284 {
 285         AudioFileSource::set_peak_dir (_session_dir->peak_path().to_string());
 286
 287         if (!_is_new) {
 288                 if (load_state (_current_snapshot_name)) {
 289                         return -1;
 290                 }
 291                 remove_empty_sounds ();
 292         }
 293
 294         if (_butler->start_thread()) {
 295                 return -1;
 296         }
 297
 298         if (start_midi_thread ()) {
 299                 return -1;
 300         }
 301
 302         // set_state() will call setup_raid_path(), but if it's a new session we need
 303         // to call setup_raid_path() here.
 304
 305         if (state_tree) {
 306                 if (set_state (*state_tree->root(), Stateful::loading_state_version)) {
 307                         return -1;
 308                 }
 309         } else {
 310                 setup_raid_path(_path);
 311         }
 312
 313         /* we can't save till after ::when_engine_running() is called,
 314            because otherwise we save state with no connections made.
 315            therefore, we reset _state_of_the_state because ::set_state()
 316            will have cleared it.
 317
 318            we also have to include Loading so that any events that get
 319            generated between here and the end of ::when_engine_running()
 320            will be processed directly rather than queued.
 321         */
 322
 323         _state_of_the_state = StateOfTheState (_state_of_the_state|CannotSave|Loading);
 324
 325
 326         _locations.changed.connect_same_thread (*this, boost::bind (&Session::locations_changed, this));
 327         _locations.added.connect_same_thread (*this, boost::bind (&Session::locations_added, this, _1));
 328         setup_click_sounds (0);
 329         setup_midi_control ();
 330
 331         /* Pay attention ... */
 332
 333         _engine.Halted.connect_same_thread (*this, boost::bind (&Session::engine_halted, this));
 334         _engine.Xrun.connect_same_thread (*this, boost::bind (&Session::xrun_recovery, this));
 335
 336         try {
 337                 when_engine_running ();
 338         }
 339
 340         /* handle this one in a different way than all others, so that its clear what happened */
 341
 342         catch (AudioEngine::PortRegistrationFailure& err) {
 343                 error << err.what() << endmsg;
 344                 return -1;
 345         }
 346
 347         catch (...) {
 348                 return -1;
 349         }
 350
 351         BootMessage (_("Reset Remote Controls"));
 352
 353         send_full_time_code (0);
 354         _engine.transport_locate (0);
 355         deliver_mmc (MIDI::MachineControl::cmdMmcReset, 0);
 356         deliver_mmc (MIDI::MachineControl::cmdLocate, 0);
 357
 358         MidiClockTicker::instance().set_session (this);
 359         MIDI::Name::MidiPatchManager::instance().set_session (this);
 360
 361         /* initial program change will be delivered later; see ::config_changed() */
 362
 363         BootMessage (_("Reset Control Protocols"));
 364
 365         ControlProtocolManager::instance().set_session (this);
 366
 367         _state_of_the_state = Clean;
 368
 369         Port::set_connecting_blocked (false);
 370
 371         DirtyChanged (); /* EMIT SIGNAL */
 372
 373         if (state_was_pending) {
 374                 save_state (_current_snapshot_name);
 375                 remove_pending_capture_state ();
 376                 state_was_pending = false;
 377         }
 378
 379         BootMessage (_("Session loading complete"));
 380
 381         return 0;
 382 }
 383
 384 string
 385 Session::raid_path () const
 386 {
 387         SearchPath raid_search_path;
 388
 389         for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
 390                 raid_search_path += sys::path((*i).path);
 391         }
 392
 393         return raid_search_path.to_string ();
 394 }
 395
 396 void
 397 Session::setup_raid_path (string path)
 398 {
 399         if (path.empty()) {
 400                 return;
 401         }
 402
 403         space_and_path sp;
 404         string fspath;
 405
 406         session_dirs.clear ();
 407
 408         SearchPath search_path(path);
 409         SearchPath sound_search_path;
 410         SearchPath midi_search_path;
 411
 412         for (SearchPath::const_iterator i = search_path.begin(); i != search_path.end(); ++i) {
 413                 sp.path = (*i).to_string ();
 414                 sp.blocks = 0; // not needed
 415                 session_dirs.push_back (sp);
 416
 417                 SessionDirectory sdir(sp.path);
 418
 419                 sound_search_path += sdir.sound_path ();
 420                 midi_search_path += sdir.midi_path ();
 421         }
 422
 423         // set the search path for each data type
 424         FileSource::set_search_path (DataType::AUDIO, sound_search_path.to_string ());
 425         SMFSource::set_search_path (DataType::MIDI, midi_search_path.to_string ());
 426
 427         // reset the round-robin soundfile path thingie
 428         last_rr_session_dir = session_dirs.begin();
 429 }
 430
 431 bool
 432 Session::path_is_within_session (const std::string& path)
 433 {
 434         for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
 435                 if (path.find ((*i).path) == 0) {
 436                         return true;
 437                 }
 438         }
 439         return false;
 440 }
 441
 442 int
 443 Session::ensure_subdirs ()
 444 {
 445         string dir;
 446
 447         dir = session_directory().peak_path().to_string();
 448
 449         if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
 450                 error << string_compose(_("Session: cannot create session peakfile folder \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
 451                 return -1;
 452         }
 453
 454         dir = session_directory().sound_path().to_string();
 455
 456         if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
 457                 error << string_compose(_("Session: cannot create session sounds dir \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
 458                 return -1;
 459         }
 460
 461         dir = session_directory().midi_path().to_string();
 462
 463         if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
 464                 error << string_compose(_("Session: cannot create session midi dir \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
 465                 return -1;
 466         }
 467
 468         dir = session_directory().dead_sound_path().to_string();
 469
 470         if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
 471                 error << string_compose(_("Session: cannot create session dead sounds folder \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
 472                 return -1;
 473         }
 474
 475         dir = session_directory().export_path().to_string();
 476
 477         if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
 478                 error << string_compose(_("Session: cannot create session export folder \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
 479                 return -1;
 480         }
 481
 482         dir = analysis_dir ();
 483
 484         if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
 485                 error << string_compose(_("Session: cannot create session analysis folder \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
 486                 return -1;
 487         }
 488
 489         return 0;
 490 }
 491
 492 int
 493 Session::create (const string& mix_template, BusProfile* bus_profile)
 494 {
 495
 496         if (g_mkdir_with_parents (_path.c_str(), 0755) < 0) {
 497                 error << string_compose(_("Session: cannot create session folder \"%1\" (%2)"), _path, strerror (errno)) << endmsg;
 498                 return -1;
 499         }
 500
 501         if (ensure_subdirs ()) {
 502                 return -1;
 503         }
 504
 505         if (!mix_template.empty()) {
 506                 std::string in_path = mix_template;
 507
 508                 ifstream in(in_path.c_str());
 509
 510                 if (in){
 511                         string out_path = _path;
 512                         out_path += _name;
 513                         out_path += statefile_suffix;
 514
 515                         ofstream out(out_path.c_str());
 516
 517                         if (out){
 518                                 out << in.rdbuf();
 519                                 _is_new = false;
 520                                 return 0;
 521
 522                         } else {
 523                                 error << string_compose (_("Could not open %1 for writing mix template"), out_path)
 524                                         << endmsg;
 525                                 return -1;
 526                         }
 527
 528                 } else {
 529                         error << string_compose (_("Could not open mix template %1 for reading"), in_path)
 530                                 << endmsg;
 531                         return -1;
 532                 }
 533
 534         }
 535
 536         /* Instantiate metadata */
 537
 538         _metadata = new SessionMetadata ();
 539
 540         /* set initial start + end point */
 541
 542         _state_of_the_state = Clean;
 543
 544         /* set up Master Out and Control Out if necessary */
 545
 546         if (bus_profile) {
 547
 548                 RouteList rl;
 549                 int control_id = 1;
 550                 ChanCount count(DataType::AUDIO, bus_profile->master_out_channels);
 551
 552                 if (bus_profile->master_out_channels) {
 553                         Route* rt = new Route (*this, _("master"), Route::MasterOut, DataType::AUDIO);
 554                         if (rt->init ()) {
 555                                 delete rt;
 556                                 return -1;
 557                         }
 558                         boost_debug_shared_ptr_mark_interesting (rt, "Route");
 559                         boost::shared_ptr<Route> r (rt);
 560                         r->input()->ensure_io (count, false, this);
 561                         r->output()->ensure_io (count, false, this);
 562                         r->set_remote_control_id (control_id++);
 563
 564                         rl.push_back (r);
 565
 566                         if (Config->get_use_monitor_bus()) {
 567                                 Route* rt = new Route (*this, _("monitor"), Route::MonitorOut, DataType::AUDIO);
 568                                 if (rt->init ()) {
 569                                         delete rt;
 570                                         return -1;
 571                                 }
 572                                 boost_debug_shared_ptr_mark_interesting (rt, "Route");
 573                                 boost::shared_ptr<Route> r (rt);
 574                                 r->input()->ensure_io (count, false, this);
 575                                 r->output()->ensure_io (count, false, this);
 576                                 r->set_remote_control_id (control_id);
 577
 578                                 rl.push_back (r);
 579                         }
 580
 581                 } else {
 582                         /* prohibit auto-connect to master, because there isn't one */
 583                         bus_profile->output_ac = AutoConnectOption (bus_profile->output_ac & ~AutoConnectMaster);
 584                 }
 585
 586                 if (!rl.empty()) {
 587                         add_routes (rl, false);
 588                 }
 589
 590                 /* this allows the user to override settings with an environment variable.
 591                  */
 592
 593                 if (no_auto_connect()) {
 594                         bus_profile->input_ac = AutoConnectOption (0);
 595                         bus_profile->output_ac = AutoConnectOption (0);
 596                 }
 597
 598                 Config->set_input_auto_connect (bus_profile->input_ac);
 599                 Config->set_output_auto_connect (bus_profile->output_ac);
 600         }
 601
 602         save_state ("");
 603
 604         return 0;
 605 }
 606
 607 void
 608 Session::maybe_write_autosave()
 609 {
 610         if (dirty() && record_status() != Recording) {
 611                 save_state("", true);
 612         }
 613 }
 614
 615 void
 616 Session::remove_pending_capture_state ()
 617 {
 618         sys::path pending_state_file_path(_session_dir->root_path());
 619
 620         pending_state_file_path /= legalize_for_path (_current_snapshot_name) + pending_suffix;
 621
 622         try
 623         {
 624                 sys::remove (pending_state_file_path);
 625         }
 626         catch(sys::filesystem_error& ex)
 627         {
 628                 error << string_compose(_("Could remove pending capture state at path \"%1\" (%2)"),
 629                                 pending_state_file_path.to_string(), ex.what()) << endmsg;
 630         }
 631 }
 632
 633 /** Rename a state file.
 634  * @param snapshot_name Snapshot name.
 635  */
 636 void
 637 Session::rename_state (string old_name, string new_name)
 638 {
 639         if (old_name == _current_snapshot_name || old_name == _name) {
 640                 /* refuse to rename the current snapshot or the "main" one */
 641                 return;
 642         }
 643
 644         const string old_xml_filename = legalize_for_path (old_name) + statefile_suffix;
 645         const string new_xml_filename = legalize_for_path (new_name) + statefile_suffix;
 646
 647         const sys::path old_xml_path = _session_dir->root_path() / old_xml_filename;
 648         const sys::path new_xml_path = _session_dir->root_path() / new_xml_filename;
 649
 650         try
 651         {
 652                 sys::rename (old_xml_path, new_xml_path);
 653         }
 654         catch (const sys::filesystem_error& err)
 655         {
 656                 error << string_compose(_("could not rename snapshot %1 to %2 (%3)"),
 657                                 old_name, new_name, err.what()) << endmsg;
 658         }
 659 }
 660
 661 /** Remove a state file.
 662  * @param snapshot_name Snapshot name.
 663  */
 664 void
 665 Session::remove_state (string snapshot_name)
 666 {
 667         if (snapshot_name == _current_snapshot_name || snapshot_name == _name) {
 668                 // refuse to remove the current snapshot or the "main" one
 669                 return;
 670         }
 671
 672         sys::path xml_path(_session_dir->root_path());
 673
 674         xml_path /= legalize_for_path (snapshot_name) + statefile_suffix;
 675
 676         if (!create_backup_file (xml_path)) {
 677                 // don't remove it if a backup can't be made
 678                 // create_backup_file will log the error.
 679                 return;
 680         }
 681
 682         // and delete it
 683         sys::remove (xml_path);
 684 }
 685
 686 #ifdef HAVE_JACK_SESSION
 687 void
 688 Session::jack_session_event (jack_session_event_t * event)
 689 {
 690         char timebuf[128];
 691         time_t n;
 692         struct tm local_time;
 693
 694         time (&n);
 695         localtime_r (&n, &local_time);
 696         strftime (timebuf, sizeof(timebuf), "JS_%FT%T", &local_time);
 697
 698         if (event->type == JackSessionSaveTemplate)
 699         {
 700                 if (save_template( timebuf )) {
 701                         event->flags = JackSessionSaveError;
 702                 } else {
 703                         string cmd ("ardour3 -P -U ");
 704                         cmd += event->client_uuid;
 705                         cmd += " -T ";
 706                         cmd += timebuf;
 707
 708                         event->command_line = strdup (cmd.c_str());
 709                 }
 710         }
 711         else
 712         {
 713                 if (save_state (timebuf)) {
 714                         event->flags = JackSessionSaveError;
 715                 } else {
 716                         sys::path xml_path (_session_dir->root_path());
 717                         xml_path /= legalize_for_path (timebuf) + statefile_suffix;
 718
 719                         string cmd ("ardour3 -P -U ");
 720                         cmd += event->client_uuid;
 721                         cmd += " \"";
 722                         cmd += xml_path.to_string();
 723                         cmd += '\"';
 724
 725                         event->command_line = strdup (cmd.c_str());
 726                 }
 727         }
 728
 729         jack_session_reply (_engine.jack(), event);
 730
 731         if (event->type == JackSessionSaveAndQuit) {
 732                 // TODO: make ardour quit.
 733         }
 734
 735         jack_session_event_free( event );
 736 }
 737 #endif
 738
 739 int
 740 Session::save_state (string snapshot_name, bool pending, bool switch_to_snapshot)
 741 {
 742         XMLTree tree;
 743         sys::path xml_path(_session_dir->root_path());
 744
 745         if (!_writable || (_state_of_the_state & CannotSave)) {
 746                 return 1;
 747         }
 748
 749         if (!_engine.connected ()) {
 750                 error << string_compose (_("the %1 audio engine is not connected and state saving would lose all I/O connections. Session not saved"),
 751                                          PROGRAM_NAME)
 752                       << endmsg;
 753                 return 1;
 754         }
 755
 756         /* tell sources we're saving first, in case they write out to a new file
 757          * which should be saved with the state rather than the old one */
 758         for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
 759                 i->second->session_saved();
 760         }
 761
 762         tree.set_root (&get_state());
 763
 764         if (snapshot_name.empty()) {
 765                 snapshot_name = _current_snapshot_name;
 766         } else if (switch_to_snapshot) {
 767                 _current_snapshot_name = snapshot_name;
 768         }
 769
 770         if (!pending) {
 771
 772                 /* proper save: use statefile_suffix (.ardour in English) */
 773
 774                 xml_path /= legalize_for_path (snapshot_name) + statefile_suffix;
 775
 776                 /* make a backup copy of the old file */
 777
 778                 if (sys::exists(xml_path) && !create_backup_file (xml_path)) {
 779                         // create_backup_file will log the error
 780                         return -1;
 781                 }
 782
 783         } else {
 784
 785                 /* pending save: use pending_suffix (.pending in English) */
 786                 xml_path /= legalize_for_path (snapshot_name) + pending_suffix;
 787         }
 788
 789         sys::path tmp_path(_session_dir->root_path());
 790
 791         tmp_path /= legalize_for_path (snapshot_name) + temp_suffix;
 792
 793         // cerr << "actually writing state to " << xml_path.to_string() << endl;
 794
 795         if (!tree.write (tmp_path.to_string())) {
 796                 error << string_compose (_("state could not be saved to %1"), tmp_path.to_string()) << endmsg;
 797                 sys::remove (tmp_path);
 798                 return -1;
 799
 800         } else {
 801
 802                 if (rename (tmp_path.to_string().c_str(), xml_path.to_string().c_str()) != 0) {
 803                         error << string_compose (_("could not rename temporary session file %1 to %2"),
 804                                         tmp_path.to_string(), xml_path.to_string()) << endmsg;
 805                         sys::remove (tmp_path);
 806                         return -1;
 807                 }
 808         }
 809
 810         if (!pending) {
 811
 812                 save_history (snapshot_name);
 813
 814                 bool was_dirty = dirty();
 815
 816                 _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
 817
 818                 if (was_dirty) {
 819                         DirtyChanged (); /* EMIT SIGNAL */
 820                 }
 821
 822                 StateSaved (snapshot_name); /* EMIT SIGNAL */
 823         }
 824
 825         return 0;
 826 }
 827
 828 int
 829 Session::restore_state (string snapshot_name)
 830 {
 831         if (load_state (snapshot_name) == 0) {
 832                 set_state (*state_tree->root(), Stateful::loading_state_version);
 833         }
 834
 835         return 0;
 836 }
 837
 838 int
 839 Session::load_state (string snapshot_name)
 840 {
 841         delete state_tree;
 842         state_tree = 0;
 843
 844         state_was_pending = false;
 845
 846         /* check for leftover pending state from a crashed capture attempt */
 847
 848         sys::path xmlpath(_session_dir->root_path());
 849         xmlpath /= legalize_for_path (snapshot_name) + pending_suffix;
 850
 851         if (sys::exists (xmlpath)) {
 852
 853                 /* there is pending state from a crashed capture attempt */
 854
 855                 boost::optional<int> r = AskAboutPendingState();
 856                 if (r.get_value_or (1)) {
 857                         state_was_pending = true;
 858                 }
 859         }
 860
 861         if (!state_was_pending) {
 862                 xmlpath = _session_dir->root_path();
 863                 xmlpath /= snapshot_name;
 864         }
 865
 866         if (!sys::exists (xmlpath)) {
 867                 xmlpath = _session_dir->root_path();
 868                 xmlpath /= legalize_for_path (snapshot_name) + statefile_suffix;
 869                 if (!sys::exists (xmlpath)) {
 870                         error << string_compose(_("%1: session state information file \"%2\" doesn't exist!"), _name, xmlpath.to_string()) << endmsg;
 871                         return 1;
 872                 }
 873         }
 874
 875         state_tree = new XMLTree;
 876
 877         set_dirty();
 878
 879         /* writable() really reflects the whole folder, but if for any
 880            reason the session state file can't be written to, still
 881            make us unwritable.
 882         */
 883
 884         if (::access (xmlpath.to_string().c_str(), W_OK) != 0) {
 885                 _writable = false;
 886         }
 887
 888         if (!state_tree->read (xmlpath.to_string())) {
 889                 error << string_compose(_("Could not understand ardour file %1"), xmlpath.to_string()) << endmsg;
 890                 delete state_tree;
 891                 state_tree = 0;
 892                 return -1;
 893         }
 894
 895         XMLNode& root (*state_tree->root());
 896
 897         if (root.name() != X_("Session")) {
 898                 error << string_compose (_("Session file %1 is not a session"), xmlpath.to_string()) << endmsg;
 899                 delete state_tree;
 900                 state_tree = 0;
 901                 return -1;
 902         }
 903
 904         const XMLProperty* prop;
 905
 906         if ((prop = root.property ("version")) == 0) {
 907                 /* no version implies very old version of Ardour */
 908                 Stateful::loading_state_version = 1000;
 909         } else {
 910                 int major;
 911                 int minor;
 912                 int micro;
 913
 914                 sscanf (prop->value().c_str(), "%d.%d.%d", &major, &minor, &micro);
 915                 Stateful::loading_state_version = (major * 1000) + minor;
 916         }
 917
 918         if (Stateful::loading_state_version < CURRENT_SESSION_FILE_VERSION) {
 919
 920                 sys::path backup_path(_session_dir->root_path());
 921
 922                 backup_path /= legalize_for_path (snapshot_name) + "-1" + statefile_suffix;
 923
 924                 // only create a backup once
 925                 if (sys::exists (backup_path)) {
 926                         return 0;
 927                 }
 928
 929                 info << string_compose (_("Copying old session file %1 to %2\nUse %2 with %3 versions before 2.0 from now on"),
 930                                         xmlpath.to_string(), backup_path.to_string(), PROGRAM_NAME)
 931                      << endmsg;
 932
 933                 try
 934                 {
 935                         sys::copy_file (xmlpath, backup_path);
 936                 }
 937                 catch(sys::filesystem_error& ex)
 938                 {
 939                         error << string_compose (_("Unable to make backup of state file %1 (%2)"),
 940                                         xmlpath.to_string(), ex.what())
 941                                 << endmsg;
 942                         return -1;
 943                 }
 944         }
 945
 946         return 0;
 947 }
 948
 949 int
 950 Session::load_options (const XMLNode& node)
 951 {
 952         LocaleGuard lg (X_("POSIX"));
 953         config.set_variables (node);
 954         return 0;
 955 }
 956
 957 XMLNode&
 958 Session::get_state()
 959 {
 960         return state(true);
 961 }
 962
 963 XMLNode&
 964 Session::get_template()
 965 {
 966         /* if we don't disable rec-enable, diskstreams
 967            will believe they need to store their capture
 968            sources in their state node.
 969         */
 970
 971         disable_record (false);
 972
 973         return state(false);
 974 }
 975
 976 XMLNode&
 977 Session::state(bool full_state)
 978 {
 979         XMLNode* node = new XMLNode("Session");
 980         XMLNode* child;
 981
 982         // store libardour version, just in case
 983         char buf[16];
 984         snprintf(buf, sizeof(buf), "%d.%d.%d", libardour3_major_version, libardour3_minor_version, libardour3_micro_version);
 985         node->add_property("version", string(buf));
 986
 987         /* store configuration settings */
 988
 989         if (full_state) {
 990
 991                 node->add_property ("name", _name);
 992                 snprintf (buf, sizeof (buf), "%" PRId32, _nominal_frame_rate);
 993                 node->add_property ("sample-rate", buf);
 994
 995                 if (session_dirs.size() > 1) {
 996
 997                         string p;
 998
 999                         vector<space_and_path>::iterator i = session_dirs.begin();
1000                         vector<space_and_path>::iterator next;
1001
1002                         ++i; /* skip the first one */
1003                         next = i;
1004                         ++next;
1005
1006                         while (i != session_dirs.end()) {
1007
1008                                 p += (*i).path;
1009
1010                                 if (next != session_dirs.end()) {
1011                                         p += ':';
1012                                 } else {
1013                                         break;
1014                                 }
1015
1016                                 ++next;
1017                                 ++i;
1018                         }
1019
1020                         child = node->add_child ("Path");
1021                         child->add_content (p);
1022                 }
1023         }
1024
1025         /* save the ID counter */
1026
1027         snprintf (buf, sizeof (buf), "%" PRIu64, ID::counter());
1028         node->add_property ("id-counter", buf);
1029
1030         /* various options */
1031
1032         node->add_child_nocopy (config.get_variables ());
1033
1034         node->add_child_nocopy (_metadata->get_state());
1035
1036         child = node->add_child ("Sources");
1037
1038         if (full_state) {
1039                 Glib::Mutex::Lock sl (source_lock);
1040
1041                 for (SourceMap::iterator siter = sources.begin(); siter != sources.end(); ++siter) {
1042
1043                         /* Don't save information about non-destructive file sources that are empty
1044                            and unused by any regions.
1045                         */
1046
1047                         boost::shared_ptr<FileSource> fs;
1048                         if ((fs = boost::dynamic_pointer_cast<FileSource> (siter->second)) != 0) {
1049                                 if (!fs->destructive()) {
1050                                         if (fs->empty() && !fs->used()) {
1051                                                 continue;
1052                                         }
1053                                 }
1054                         }
1055
1056                         child->add_child_nocopy (siter->second->get_state());
1057                 }
1058         }
1059
1060         child = node->add_child ("Regions");
1061
1062         if (full_state) {
1063                 Glib::Mutex::Lock rl (region_lock);
1064                 const RegionFactory::RegionMap& region_map (RegionFactory::all_regions());
1065                 for (RegionFactory::RegionMap::const_iterator i = region_map.begin(); i != region_map.end(); ++i) {
1066                         boost::shared_ptr<Region> r = i->second;
1067                         /* only store regions not attached to playlists */
1068                         if (r->playlist() == 0) {
1069                                 child->add_child_nocopy (r->state (true));
1070                         }
1071                 }
1072         }
1073
1074         if (full_state) {
1075                 node->add_child_nocopy (_locations.get_state());
1076         } else {
1077                 // for a template, just create a new Locations, populate it
1078                 // with the default start and end, and get the state for that.
1079                 Locations loc;
1080                 Location* range = new Location (0, 0, _("session"), Location::IsSessionRange);
1081                 range->set (max_frames, 0);
1082                 loc.add (range);
1083                 node->add_child_nocopy (loc.get_state());
1084         }
1085
1086         child = node->add_child ("Bundles");
1087         {
1088                 boost::shared_ptr<BundleList> bundles = _bundles.reader ();
1089                 for (BundleList::iterator i = bundles->begin(); i != bundles->end(); ++i) {
1090                         boost::shared_ptr<UserBundle> b = boost::dynamic_pointer_cast<UserBundle> (*i);
1091                         if (b) {
1092                                 child->add_child_nocopy (b->get_state());
1093                         }
1094                 }
1095         }
1096
1097         child = node->add_child ("Routes");
1098         {
1099                 boost::shared_ptr<RouteList> r = routes.reader ();
1100
1101                 RoutePublicOrderSorter cmp;
1102                 RouteList public_order (*r);
1103                 public_order.sort (cmp);
1104
1105                 /* the sort should have put control outs first */
1106
1107                 if (_monitor_out) {
1108                         assert (_monitor_out == public_order.front());
1109                 }
1110
1111                 for (RouteList::iterator i = public_order.begin(); i != public_order.end(); ++i) {
1112                         if (!(*i)->is_hidden()) {
1113                                 if (full_state) {
1114                                         child->add_child_nocopy ((*i)->get_state());
1115                                 } else {
1116                                         child->add_child_nocopy ((*i)->get_template());
1117                                 }
1118                         }
1119                 }
1120         }
1121
1122         playlists->add_state (node, full_state);
1123
1124         child = node->add_child ("RouteGroups");
1125         for (list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
1126                 child->add_child_nocopy ((*i)->get_state());
1127         }
1128
1129         if (_click_io) {
1130                 child = node->add_child ("Click");
1131                 child->add_child_nocopy (_click_io->state (full_state));
1132         }
1133
1134         if (full_state) {
1135                 child = node->add_child ("NamedSelections");
1136                 for (NamedSelectionList::iterator i = named_selections.begin(); i != named_selections.end(); ++i) {
1137                         if (full_state) {
1138                                 child->add_child_nocopy ((*i)->get_state());
1139                         }
1140                 }
1141         }
1142
1143         node->add_child_nocopy (_tempo_map->get_state());
1144
1145         node->add_child_nocopy (get_control_protocol_state());
1146
1147         if (_extra_xml) {
1148                 node->add_child_copy (*_extra_xml);
1149         }
1150
1151         return *node;
1152 }
1153
1154 XMLNode&
1155 Session::get_control_protocol_state ()
1156 {
1157         ControlProtocolManager& cpm (ControlProtocolManager::instance());
1158         return cpm.get_state();
1159 }
1160
1161 int
1162 Session::set_state (const XMLNode& node, int version)
1163 {
1164         XMLNodeList nlist;
1165         XMLNode* child;
1166         const XMLProperty* prop;
1167         int ret = -1;
1168
1169         _state_of_the_state = StateOfTheState (_state_of_the_state|CannotSave);
1170
1171         if (node.name() != X_("Session")){
1172                 fatal << _("programming error: Session: incorrect XML node sent to set_state()") << endmsg;
1173                 return -1;
1174         }
1175
1176         if ((prop = node.property ("version")) != 0) {
1177                 version = atoi (prop->value ()) * 1000;
1178         }
1179
1180         if ((prop = node.property ("name")) != 0) {
1181                 _name = prop->value ();
1182         }
1183
1184         if ((prop = node.property (X_("sample-rate"))) != 0) {
1185
1186                 _nominal_frame_rate = atoi (prop->value());
1187
1188                 if (_nominal_frame_rate != _current_frame_rate) {
1189                         boost::optional<int> r = AskAboutSampleRateMismatch (_nominal_frame_rate, _current_frame_rate);
1190                         if (r.get_value_or (0)) {
1191                                 return -1;
1192                         }
1193                 }
1194         }
1195
1196         setup_raid_path(_session_dir->root_path().to_string());
1197
1198         if ((prop = node.property (X_("id-counter"))) != 0) {
1199                 uint64_t x;
1200                 sscanf (prop->value().c_str(), "%" PRIu64, &x);
1201                 ID::init_counter (x);
1202         } else {
1203                 /* old sessions used a timebased counter, so fake
1204                    the startup ID counter based on a standard
1205                    timestamp.
1206                 */
1207                 time_t now;
1208                 time (&now);
1209                 ID::init_counter (now);
1210         }
1211
1212
1213         IO::disable_connecting ();
1214
1215         /* Object loading order:
1216
1217         Path
1218         Extra
1219         Options/Config
1220         MIDI Control // relies on data from Options/Config
1221         Metadata
1222         Locations
1223         Sources
1224         AudioRegions
1225         Connections
1226         Routes
1227         RouteGroups
1228         MixGroups
1229         Click
1230         ControlProtocols
1231         */
1232
1233         if ((child = find_named_node (node, "Extra")) != 0) {
1234                 _extra_xml = new XMLNode (*child);
1235         }
1236
1237         if (((child = find_named_node (node, "Options")) != 0)) { /* old style */
1238                 load_options (*child);
1239         } else if ((child = find_named_node (node, "Config")) != 0) { /* new style */
1240                 load_options (*child);
1241         } else {
1242                 error << _("Session: XML state has no options section") << endmsg;
1243         }
1244
1245         if (use_config_midi_ports ()) {
1246         }
1247
1248         if (version >= 3000) {
1249                 if ((child = find_named_node (node, "Metadata")) == 0) {
1250                         warning << _("Session: XML state has no metadata section") << endmsg;
1251                 } else if (_metadata->set_state (*child, version)) {
1252                         goto out;
1253                 }
1254         }
1255
1256         if ((child = find_named_node (node, "Locations")) == 0) {
1257                 error << _("Session: XML state has no locations section") << endmsg;
1258                 goto out;
1259         } else if (_locations.set_state (*child, version)) {
1260                 goto out;
1261         }
1262
1263         Location* location;
1264
1265         if ((location = _locations.auto_loop_location()) != 0) {
1266                 set_auto_loop_location (location);
1267         }
1268
1269         if ((location = _locations.auto_punch_location()) != 0) {
1270                 set_auto_punch_location (location);
1271         }
1272
1273         if ((location = _locations.session_range_location()) != 0) {
1274                 delete _session_range_location;
1275                 _session_range_location = location;
1276         }
1277
1278         if (_session_range_location) {
1279                 AudioFileSource::set_header_position_offset (_session_range_location->start());
1280         }
1281
1282         if ((child = find_named_node (node, "Sources")) == 0) {
1283                 error << _("Session: XML state has no sources section") << endmsg;
1284                 goto out;
1285         } else if (load_sources (*child)) {
1286                 goto out;
1287         }
1288
1289         if ((child = find_named_node (node, "Regions")) == 0) {
1290                 error << _("Session: XML state has no Regions section") << endmsg;
1291                 goto out;
1292         } else if (load_regions (*child)) {
1293                 goto out;
1294         }
1295
1296         if ((child = find_named_node (node, "Playlists")) == 0) {
1297                 error << _("Session: XML state has no playlists section") << endmsg;
1298                 goto out;
1299         } else if (playlists->load (*this, *child)) {
1300                 goto out;
1301         }
1302
1303         if ((child = find_named_node (node, "UnusedPlaylists")) == 0) {
1304                 // this is OK
1305         } else if (playlists->load_unused (*this, *child)) {
1306                 goto out;
1307         }
1308
1309         if ((child = find_named_node (node, "NamedSelections")) != 0) {
1310                 if (load_named_selections (*child)) {
1311                         goto out;
1312                 }
1313         }
1314
1315         if (version >= 3000) {
1316                 if ((child = find_named_node (node, "Bundles")) == 0) {
1317                         warning << _("Session: XML state has no bundles section") << endmsg;
1318                         //goto out;
1319                 } else {
1320                         /* We can't load Bundles yet as they need to be able
1321                            to convert from port names to Port objects, which can't happen until
1322                            later */
1323                         _bundle_xml_node = new XMLNode (*child);
1324                 }
1325         }
1326
1327         if ((child = find_named_node (node, "TempoMap")) == 0) {
1328                 error << _("Session: XML state has no Tempo Map section") << endmsg;
1329                 goto out;
1330         } else if (_tempo_map->set_state (*child, version)) {
1331                 goto out;
1332         }
1333
1334         if (version < 3000) {
1335                 if ((child = find_named_node (node, X_("DiskStreams"))) == 0) {
1336                         error << _("Session: XML state has no diskstreams section") << endmsg;
1337                         goto out;
1338                 } else if (load_diskstreams_2X (*child, version)) {
1339                         goto out;
1340                 }
1341         }
1342
1343         if ((child = find_named_node (node, "Routes")) == 0) {
1344                 error << _("Session: XML state has no routes section") << endmsg;
1345                 goto out;
1346         } else if (load_routes (*child, version)) {
1347                 goto out;
1348         }
1349
1350         /* our diskstreams list is no longer needed as they are now all owned by their Route */
1351         _diskstreams_2X.clear ();
1352
1353         if (version >= 3000) {
1354
1355                 if ((child = find_named_node (node, "RouteGroups")) == 0) {
1356                         error << _("Session: XML state has no route groups section") << endmsg;
1357                         goto out;
1358                 } else if (load_route_groups (*child, version)) {
1359                         goto out;
1360                 }
1361
1362         } else if (version < 3000) {
1363
1364                 if ((child = find_named_node (node, "EditGroups")) == 0) {
1365                         error << _("Session: XML state has no edit groups section") << endmsg;
1366                         goto out;
1367                 } else if (load_route_groups (*child, version)) {
1368                         goto out;
1369                 }
1370
1371                 if ((child = find_named_node (node, "MixGroups")) == 0) {
1372                         error << _("Session: XML state has no mix groups section") << endmsg;
1373                         goto out;
1374                 } else if (load_route_groups (*child, version)) {
1375                         goto out;
1376                 }
1377         }
1378
1379         if ((child = find_named_node (node, "Click")) == 0) {
1380                 warning << _("Session: XML state has no click section") << endmsg;
1381         } else if (_click_io) {
1382                 _click_io->set_state (*child, version);
1383         }
1384
1385         if ((child = find_named_node (node, "ControlProtocols")) != 0) {
1386                 ControlProtocolManager::instance().set_protocol_states (*child);
1387         }
1388
1389         /* here beginneth the second phase ... */
1390
1391         StateReady (); /* EMIT SIGNAL */
1392
1393         return 0;
1394
1395   out:
1396         return ret;
1397 }
1398
1399 int
1400 Session::load_routes (const XMLNode& node, int version)
1401 {
1402         XMLNodeList nlist;
1403         XMLNodeConstIterator niter;
1404         RouteList new_routes;
1405
1406         nlist = node.children();
1407
1408         set_dirty();
1409
1410         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1411
1412                 boost::shared_ptr<Route> route;
1413                 if (version < 3000) {
1414                         route = XMLRouteFactory_2X (**niter, version);
1415                 } else {
1416                         route = XMLRouteFactory (**niter, version);
1417                 }
1418
1419                 if (route == 0) {
1420                         error << _("Session: cannot create Route from XML description.") << endmsg;
1421                         return -1;
1422                 }
1423
1424                 BootMessage (string_compose (_("Loaded track/bus %1"), route->name()));
1425
1426                 new_routes.push_back (route);
1427         }
1428
1429         add_routes (new_routes, false);
1430
1431         return 0;
1432 }
1433
1434 boost::shared_ptr<Route>
1435 Session::XMLRouteFactory (const XMLNode& node, int version)
1436 {
1437         boost::shared_ptr<Route> ret;
1438
1439         if (node.name() != "Route") {
1440                 return ret;
1441         }
1442
1443         XMLNode* ds_child = find_named_node (node, X_("Diskstream"));
1444
1445         DataType type = DataType::AUDIO;
1446         const XMLProperty* prop = node.property("default-type");
1447
1448         if (prop) {
1449                 type = DataType (prop->value());
1450         }
1451
1452         assert (type != DataType::NIL);
1453
1454         if (ds_child) {
1455
1456                 Track* track;
1457
1458                 if (type == DataType::AUDIO) {
1459                         track = new AudioTrack (*this, X_("toBeResetFroXML"));
1460
1461                 } else {
1462                         track = new MidiTrack (*this, X_("toBeResetFroXML"));
1463                 }
1464
1465                 if (track->init()) {
1466                         delete track;
1467                         return ret;
1468                 }
1469
1470                 if (track->set_state (node, version)) {
1471                         delete track;
1472                         return ret;
1473                 }
1474
1475                 boost_debug_shared_ptr_mark_interesting (track, "Track");
1476                 ret.reset (track);
1477
1478         } else {
1479                 Route* rt = new Route (*this, X_("toBeResetFroXML"));
1480
1481                 if (rt->init () == 0 && rt->set_state (node, version) == 0) {
1482                         boost_debug_shared_ptr_mark_interesting (rt, "Route");
1483                         ret.reset (rt);
1484                 } else {
1485                         delete rt;
1486                 }
1487         }
1488
1489         return ret;
1490 }
1491
1492 boost::shared_ptr<Route>
1493 Session::XMLRouteFactory_2X (const XMLNode& node, int version)
1494 {
1495         boost::shared_ptr<Route> ret;
1496
1497         if (node.name() != "Route") {
1498                 return ret;
1499         }
1500
1501         XMLProperty const * ds_prop = node.property (X_("diskstream-id"));
1502         if (!ds_prop) {
1503                 ds_prop = node.property (X_("diskstream"));
1504         }
1505
1506         DataType type = DataType::AUDIO;
1507         const XMLProperty* prop = node.property("default-type");
1508
1509         if (prop) {
1510                 type = DataType (prop->value());
1511         }
1512
1513         assert (type != DataType::NIL);
1514
1515         if (ds_prop) {
1516
1517                 list<boost::shared_ptr<Diskstream> >::iterator i = _diskstreams_2X.begin ();
1518                 while (i != _diskstreams_2X.end() && (*i)->id() != ds_prop->value()) {
1519                         ++i;
1520                 }
1521
1522                 if (i == _diskstreams_2X.end()) {
1523                         error << _("Could not find diskstream for route") << endmsg;
1524                         return boost::shared_ptr<Route> ();
1525                 }
1526
1527                 Track* track;
1528
1529                 if (type == DataType::AUDIO) {
1530                         track = new AudioTrack (*this, X_("toBeResetFroXML"));
1531
1532                 } else {
1533                         track = new MidiTrack (*this, X_("toBeResetFroXML"));
1534                 }
1535
1536                 if (track->init()) {
1537                         delete track;
1538                         return ret;
1539                 }
1540
1541                 if (track->set_state (node, version)) {
1542                         delete track;
1543                         return ret;
1544                 }
1545
1546                 track->set_diskstream (*i);
1547
1548                 boost_debug_shared_ptr_mark_interesting (track, "Track");
1549                 ret.reset (track);
1550
1551         } else {
1552                 Route* rt = new Route (*this, X_("toBeResetFroXML"));
1553
1554                 if (rt->init () == 0 && rt->set_state (node, version) == 0) {
1555                         boost_debug_shared_ptr_mark_interesting (rt, "Route");
1556                         ret.reset (rt);
1557                 } else {
1558                         delete rt;
1559                 }
1560         }
1561
1562         return ret;
1563 }
1564
1565 int
1566 Session::load_regions (const XMLNode& node)
1567 {
1568         XMLNodeList nlist;
1569         XMLNodeConstIterator niter;
1570         boost::shared_ptr<Region> region;
1571
1572         nlist = node.children();
1573
1574         set_dirty();
1575
1576         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1577                 if ((region = XMLRegionFactory (**niter, false)) == 0) {
1578                         error << _("Session: cannot create Region from XML description.");
1579                         const XMLProperty *name = (**niter).property("name");
1580
1581                         if (name) {
1582                                 error << " " << string_compose (_("Can not load state for region '%1'"), name->value());
1583                         }
1584
1585                         error << endmsg;
1586                 }
1587         }
1588
1589         return 0;
1590 }
1591
1592 boost::shared_ptr<Region>
1593 Session::XMLRegionFactory (const XMLNode& node, bool full)
1594 {
1595         const XMLProperty* type = node.property("type");
1596
1597         try {
1598
1599         if ( !type || type->value() == "audio" ) {
1600
1601                 return boost::shared_ptr<Region>(XMLAudioRegionFactory (node, full));
1602
1603         } else if (type->value() == "midi") {
1604
1605                 return boost::shared_ptr<Region>(XMLMidiRegionFactory (node, full));
1606
1607         }
1608
1609         } catch (failed_constructor& err) {
1610                 return boost::shared_ptr<Region> ();
1611         }
1612
1613         return boost::shared_ptr<Region> ();
1614 }
1615
1616 boost::shared_ptr<AudioRegion>
1617 Session::XMLAudioRegionFactory (const XMLNode& node, bool /*full*/)
1618 {
1619         const XMLProperty* prop;
1620         boost::shared_ptr<Source> source;
1621         boost::shared_ptr<AudioSource> as;
1622         SourceList sources;
1623         SourceList master_sources;
1624         uint32_t nchans = 1;
1625         char buf[128];
1626
1627         if (node.name() != X_("Region")) {
1628                 return boost::shared_ptr<AudioRegion>();
1629         }
1630
1631         if ((prop = node.property (X_("channels"))) != 0) {
1632                 nchans = atoi (prop->value().c_str());
1633         }
1634
1635         if ((prop = node.property ("name")) == 0) {
1636                 cerr << "no name for this region\n";
1637                 abort ();
1638         }
1639
1640         if ((prop = node.property (X_("source-0"))) == 0) {
1641                 if ((prop = node.property ("source")) == 0) {
1642                         error << _("Session: XMLNode describing a AudioRegion is incomplete (no source)") << endmsg;
1643                         return boost::shared_ptr<AudioRegion>();
1644                 }
1645         }
1646
1647         PBD::ID s_id (prop->value());
1648
1649         if ((source = source_by_id (s_id)) == 0) {
1650                 error << string_compose(_("Session: XMLNode describing a AudioRegion references an unknown source id =%1"), s_id) << endmsg;
1651                 return boost::shared_ptr<AudioRegion>();
1652         }
1653
1654         as = boost::dynamic_pointer_cast<AudioSource>(source);
1655         if (!as) {
1656                 error << string_compose(_("Session: XMLNode describing a AudioRegion references a non-audio source id =%1"), s_id) << endmsg;
1657                 return boost::shared_ptr<AudioRegion>();
1658         }
1659
1660         sources.push_back (as);
1661
1662         /* pickup other channels */
1663
1664         for (uint32_t n=1; n < nchans; ++n) {
1665                 snprintf (buf, sizeof(buf), X_("source-%d"), n);
1666                 if ((prop = node.property (buf)) != 0) {
1667
1668                         PBD::ID id2 (prop->value());
1669
1670                         if ((source = source_by_id (id2)) == 0) {
1671                                 error << string_compose(_("Session: XMLNode describing a AudioRegion references an unknown source id =%1"), id2) << endmsg;
1672                                 return boost::shared_ptr<AudioRegion>();
1673                         }
1674
1675                         as = boost::dynamic_pointer_cast<AudioSource>(source);
1676                         if (!as) {
1677                                 error << string_compose(_("Session: XMLNode describing a AudioRegion references a non-audio source id =%1"), id2) << endmsg;
1678                                 return boost::shared_ptr<AudioRegion>();
1679                         }
1680                         sources.push_back (as);
1681                 }
1682         }
1683
1684         for (uint32_t n = 0; n < nchans; ++n) {
1685                 snprintf (buf, sizeof(buf), X_("master-source-%d"), n);
1686                 if ((prop = node.property (buf)) != 0) {
1687
1688                         PBD::ID id2 (prop->value());
1689
1690                         if ((source = source_by_id (id2)) == 0) {
1691                                 error << string_compose(_("Session: XMLNode describing a AudioRegion references an unknown source id =%1"), id2) << endmsg;
1692                                 return boost::shared_ptr<AudioRegion>();
1693                         }
1694
1695                         as = boost::dynamic_pointer_cast<AudioSource>(source);
1696                         if (!as) {
1697                                 error << string_compose(_("Session: XMLNode describing a AudioRegion references a non-audio source id =%1"), id2) << endmsg;
1698                                 return boost::shared_ptr<AudioRegion>();
1699                         }
1700                         master_sources.push_back (as);
1701                 }
1702         }
1703
1704         try {
1705                 boost::shared_ptr<AudioRegion> region (boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (sources, node)));
1706
1707                 /* a final detail: this is the one and only place that we know how long missing files are */
1708
1709                 if (region->whole_file()) {
1710                         for (SourceList::iterator sx = sources.begin(); sx != sources.end(); ++sx) {
1711                                 boost::shared_ptr<SilentFileSource> sfp = boost::dynamic_pointer_cast<SilentFileSource> (*sx);
1712                                 if (sfp) {
1713                                         sfp->set_length (region->length());
1714                                 }
1715                         }
1716                 }
1717
1718                 if (!master_sources.empty()) {
1719                         if (master_sources.size() != nchans) {
1720                                 error << _("Session: XMLNode describing an AudioRegion is missing some master sources; ignored") << endmsg;
1721                         } else {
1722                                 region->set_master_sources (master_sources);
1723                         }
1724                 }
1725
1726                 return region;
1727
1728         }
1729
1730         catch (failed_constructor& err) {
1731                 return boost::shared_ptr<AudioRegion>();
1732         }
1733 }
1734
1735 boost::shared_ptr<MidiRegion>
1736 Session::XMLMidiRegionFactory (const XMLNode& node, bool /*full*/)
1737 {
1738         const XMLProperty* prop;
1739         boost::shared_ptr<Source> source;
1740         boost::shared_ptr<MidiSource> ms;
1741         SourceList sources;
1742         uint32_t nchans = 1;
1743
1744         if (node.name() != X_("Region")) {
1745                 return boost::shared_ptr<MidiRegion>();
1746         }
1747
1748         if ((prop = node.property (X_("channels"))) != 0) {
1749                 nchans = atoi (prop->value().c_str());
1750         }
1751
1752         if ((prop = node.property ("name")) == 0) {
1753                 cerr << "no name for this region\n";
1754                 abort ();
1755         }
1756
1757         // Multiple midi channels?  that's just crazy talk
1758         assert(nchans == 1);
1759
1760         if ((prop = node.property (X_("source-0"))) == 0) {
1761                 if ((prop = node.property ("source")) == 0) {
1762                         error << _("Session: XMLNode describing a MidiRegion is incomplete (no source)") << endmsg;
1763                         return boost::shared_ptr<MidiRegion>();
1764                 }
1765         }
1766
1767         PBD::ID s_id (prop->value());
1768
1769         if ((source = source_by_id (s_id)) == 0) {
1770                 error << string_compose(_("Session: XMLNode describing a MidiRegion references an unknown source id =%1"), s_id) << endmsg;
1771                 return boost::shared_ptr<MidiRegion>();
1772         }
1773
1774         ms = boost::dynamic_pointer_cast<MidiSource>(source);
1775         if (!ms) {
1776                 error << string_compose(_("Session: XMLNode describing a MidiRegion references a non-midi source id =%1"), s_id) << endmsg;
1777                 return boost::shared_ptr<MidiRegion>();
1778         }
1779
1780         sources.push_back (ms);
1781
1782         try {
1783                 boost::shared_ptr<MidiRegion> region (boost::dynamic_pointer_cast<MidiRegion> (RegionFactory::create (sources, node)));
1784                 /* a final detail: this is the one and only place that we know how long missing files are */
1785
1786                 if (region->whole_file()) {
1787                         for (SourceList::iterator sx = sources.begin(); sx != sources.end(); ++sx) {
1788                                 boost::shared_ptr<SilentFileSource> sfp = boost::dynamic_pointer_cast<SilentFileSource> (*sx);
1789                                 if (sfp) {
1790                                         sfp->set_length (region->length());
1791                                 }
1792                         }
1793                 }
1794
1795                 return region;
1796         }
1797
1798         catch (failed_constructor& err) {
1799                 return boost::shared_ptr<MidiRegion>();
1800         }
1801 }
1802
1803 XMLNode&
1804 Session::get_sources_as_xml ()
1805
1806 {
1807         XMLNode* node = new XMLNode (X_("Sources"));
1808         Glib::Mutex::Lock lm (source_lock);
1809
1810         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
1811                 node->add_child_nocopy (i->second->get_state());
1812         }
1813
1814         return *node;
1815 }
1816
1817 string
1818 Session::path_from_region_name (DataType type, string name, string identifier)
1819 {
1820         char buf[PATH_MAX+1];
1821         uint32_t n;
1822         SessionDirectory sdir(get_best_session_directory_for_new_source());
1823         sys::path source_dir = ((type == DataType::AUDIO)
1824                 ? sdir.sound_path() : sdir.midi_path());
1825
1826         string ext = ((type == DataType::AUDIO) ? ".wav" : ".mid");
1827
1828         for (n = 0; n < 999999; ++n) {
1829                 if (identifier.length()) {
1830                         snprintf (buf, sizeof(buf), "%s%s%" PRIu32 "%s", name.c_str(),
1831                                   identifier.c_str(), n, ext.c_str());
1832                 } else {
1833                         snprintf (buf, sizeof(buf), "%s-%" PRIu32 "%s", name.c_str(),
1834                                         n, ext.c_str());
1835                 }
1836
1837                 sys::path source_path = source_dir / buf;
1838
1839                 if (!sys::exists (source_path)) {
1840                         return source_path.to_string();
1841                 }
1842         }
1843
1844         error << string_compose (_("cannot create new file from region name \"%1\" with ident = \"%2\": too many existing files with similar names"),
1845                                  name, identifier)
1846               << endmsg;
1847
1848         return "";
1849 }
1850
1851
1852 int
1853 Session::load_sources (const XMLNode& node)
1854 {
1855         XMLNodeList nlist;
1856         XMLNodeConstIterator niter;
1857         boost::shared_ptr<Source> source;
1858
1859         nlist = node.children();
1860
1861         set_dirty();
1862
1863         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1864                 try {
1865                         if ((source = XMLSourceFactory (**niter)) == 0) {
1866                                 error << _("Session: cannot create Source from XML description.") << endmsg;
1867                         }
1868                 } catch (MissingSource& err) {
1869                         warning << _("A sound file is missing. It will be replaced by silence.") << endmsg;
1870                         source = SourceFactory::createSilent (*this, **niter, max_frames, _current_frame_rate);
1871                 }
1872         }
1873
1874         return 0;
1875 }
1876
1877 boost::shared_ptr<Source>
1878 Session::XMLSourceFactory (const XMLNode& node)
1879 {
1880         if (node.name() != "Source") {
1881                 return boost::shared_ptr<Source>();
1882         }
1883
1884         try {
1885                 /* note: do peak building in another thread when loading session state */
1886                 return SourceFactory::create (*this, node, true);
1887         }
1888
1889         catch (failed_constructor& err) {
1890                 error << string_compose (_("Found a sound file that cannot be used by %1. Talk to the progammers."), PROGRAM_NAME) << endmsg;
1891                 return boost::shared_ptr<Source>();
1892         }
1893 }
1894
1895 int
1896 Session::save_template (string template_name)
1897 {
1898         XMLTree tree;
1899
1900         if (_state_of_the_state & CannotSave) {
1901                 return -1;
1902         }
1903
1904         sys::path user_template_dir(user_template_directory());
1905
1906         try
1907         {
1908                 sys::create_directories (user_template_dir);
1909         }
1910         catch(sys::filesystem_error& ex)
1911         {
1912                 error << string_compose(_("Could not create mix templates directory \"%1\" (%2)"),
1913                                 user_template_dir.to_string(), ex.what()) << endmsg;
1914                 return -1;
1915         }
1916
1917         tree.set_root (&get_template());
1918
1919         sys::path template_file_path(user_template_dir);
1920         template_file_path /= template_name + template_suffix;
1921
1922         if (sys::exists (template_file_path))
1923         {
1924                 warning << string_compose(_("Template \"%1\" already exists - new version not created"),
1925                                 template_file_path.to_string()) << endmsg;
1926                 return -1;
1927         }
1928
1929         if (!tree.write (template_file_path.to_string())) {
1930                 error << _("mix template not saved") << endmsg;
1931                 return -1;
1932         }
1933
1934         return 0;
1935 }
1936
1937 int
1938 Session::rename_template (string old_name, string new_name)
1939 {
1940         sys::path old_path (user_template_directory());
1941         old_path /= old_name + template_suffix;
1942
1943         sys::path new_path(user_template_directory());
1944         new_path /= new_name + template_suffix;
1945
1946         if (sys::exists (new_path)) {
1947                 warning << string_compose(_("Template \"%1\" already exists - template not renamed"),
1948                                           new_path.to_string()) << endmsg;
1949                 return -1;
1950         }
1951
1952         try {
1953                 sys::rename (old_path, new_path);
1954                 return 0;
1955         } catch (...) {
1956                 return -1;
1957         }
1958 }
1959
1960 int
1961 Session::delete_template (string name)
1962 {
1963         sys::path path = user_template_directory();
1964         path /= name + template_suffix;
1965
1966         try {
1967                 sys::remove (path);
1968                 return 0;
1969         } catch (...) {
1970                 return -1;
1971         }
1972 }
1973
1974 void
1975 Session::refresh_disk_space ()
1976 {
1977 #if HAVE_SYS_VFS_H
1978         struct statfs statfsbuf;
1979         vector<space_and_path>::iterator i;
1980         Glib::Mutex::Lock lm (space_lock);
1981         double scale;
1982
1983         /* get freespace on every FS that is part of the session path */
1984
1985         _total_free_4k_blocks = 0;
1986
1987         for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
1988                 statfs ((*i).path.c_str(), &statfsbuf);
1989
1990                 scale = statfsbuf.f_bsize/4096.0;
1991
1992                 (*i).blocks = (uint32_t) floor (statfsbuf.f_bavail * scale);
1993                 _total_free_4k_blocks += (*i).blocks;
1994         }
1995 #endif
1996 }
1997
1998 string
1999 Session::get_best_session_directory_for_new_source ()
2000 {
2001         vector<space_and_path>::iterator i;
2002         string result = _session_dir->root_path().to_string();
2003
2004         /* handle common case without system calls */
2005
2006         if (session_dirs.size() == 1) {
2007                 return result;
2008         }
2009
2010         /* OK, here's the algorithm we're following here:
2011
2012         We want to select which directory to use for
2013         the next file source to be created. Ideally,
2014         we'd like to use a round-robin process so as to
2015         get maximum performance benefits from splitting
2016         the files across multiple disks.
2017
2018         However, in situations without much diskspace, an
2019         RR approach may end up filling up a filesystem
2020         with new files while others still have space.
2021         Its therefore important to pay some attention to
2022         the freespace in the filesystem holding each
2023         directory as well. However, if we did that by
2024         itself, we'd keep creating new files in the file
2025         system with the most space until it was as full
2026         as all others, thus negating any performance
2027         benefits of this RAID-1 like approach.
2028
2029         So, we use a user-configurable space threshold. If
2030         there are at least 2 filesystems with more than this
2031         much space available, we use RR selection between them.
2032         If not, then we pick the filesystem with the most space.
2033
2034         This gets a good balance between the two
2035         approaches.
2036         */
2037
2038         refresh_disk_space ();
2039
2040         int free_enough = 0;
2041
2042         for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
2043                 if ((*i).blocks * 4096 >= Config->get_disk_choice_space_threshold()) {
2044                         free_enough++;
2045                 }
2046         }
2047
2048         if (free_enough >= 2) {
2049                 /* use RR selection process, ensuring that the one
2050                    picked works OK.
2051                 */
2052
2053                 i = last_rr_session_dir;
2054
2055                 do {
2056                         if (++i == session_dirs.end()) {
2057                                 i = session_dirs.begin();
2058                         }
2059
2060                         if ((*i).blocks * 4096 >= Config->get_disk_choice_space_threshold()) {
2061                                 if (create_session_directory ((*i).path)) {
2062                                         result = (*i).path;
2063                                         last_rr_session_dir = i;
2064                                         return result;
2065                                 }
2066                         }
2067
2068                 } while (i != last_rr_session_dir);
2069
2070         } else {
2071
2072                 /* pick FS with the most freespace (and that
2073                    seems to actually work ...)
2074                 */
2075
2076                 vector<space_and_path> sorted;
2077                 space_and_path_ascending_cmp cmp;
2078
2079                 sorted = session_dirs;
2080                 sort (sorted.begin(), sorted.end(), cmp);
2081
2082                 for (i = sorted.begin(); i != sorted.end(); ++i) {
2083                         if (create_session_directory ((*i).path)) {
2084                                 result = (*i).path;
2085                                 last_rr_session_dir = i;
2086                                 return result;
2087                         }
2088                 }
2089         }
2090
2091         return result;
2092 }
2093
2094 int
2095 Session::load_named_selections (const XMLNode& node)
2096 {
2097         XMLNodeList nlist;
2098         XMLNodeConstIterator niter;
2099         NamedSelection *ns;
2100
2101         nlist = node.children();
2102
2103         set_dirty();
2104
2105         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2106
2107                 if ((ns = XMLNamedSelectionFactory (**niter)) == 0) {
2108                         error << _("Session: cannot create Named Selection from XML description.") << endmsg;
2109                 }
2110         }
2111
2112         return 0;
2113 }
2114
2115 NamedSelection *
2116 Session::XMLNamedSelectionFactory (const XMLNode& node)
2117 {
2118         try {
2119                 return new NamedSelection (*this, node);
2120         }
2121
2122         catch (failed_constructor& err) {
2123                 return 0;
2124         }
2125 }
2126
2127 string
2128 Session::automation_dir () const
2129 {
2130         return Glib::build_filename (_path, "automation");
2131 }
2132
2133 string
2134 Session::analysis_dir () const
2135 {
2136         return Glib::build_filename (_path, "analysis");
2137 }
2138
2139 int
2140 Session::load_bundles (XMLNode const & node)
2141 {
2142         XMLNodeList nlist = node.children();
2143         XMLNodeConstIterator niter;
2144
2145         set_dirty();
2146
2147         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2148                 if ((*niter)->name() == "InputBundle") {
2149                         add_bundle (boost::shared_ptr<UserBundle> (new UserBundle (**niter, true)));
2150                 } else if ((*niter)->name() == "OutputBundle") {
2151                         add_bundle (boost::shared_ptr<UserBundle> (new UserBundle (**niter, false)));
2152                 } else {
2153                         error << string_compose(_("Unknown node \"%1\" found in Bundles list from state file"), (*niter)->name()) << endmsg;
2154                         return -1;
2155                 }
2156         }
2157
2158         return 0;
2159 }
2160
2161 int
2162 Session::load_route_groups (const XMLNode& node, int version)
2163 {
2164         XMLNodeList nlist = node.children();
2165         XMLNodeConstIterator niter;
2166
2167         set_dirty ();
2168
2169         if (version >= 3000) {
2170
2171                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2172                         if ((*niter)->name() == "RouteGroup") {
2173                                 RouteGroup* rg = new RouteGroup (*this, "");
2174                                 add_route_group (rg);
2175                                 rg->set_state (**niter, version);
2176                         }
2177                 }
2178
2179         } else if (version < 3000) {
2180
2181                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2182                         if ((*niter)->name() == "EditGroup" || (*niter)->name() == "MixGroup") {
2183                                 RouteGroup* rg = new RouteGroup (*this, "");
2184                                 add_route_group (rg);
2185                                 rg->set_state (**niter, version);
2186                         }
2187                 }
2188         }
2189
2190         return 0;
2191 }
2192
2193 void
2194 Session::auto_save()
2195 {
2196         save_state (_current_snapshot_name);
2197 }
2198
2199 static bool
2200 state_file_filter (const string &str, void */*arg*/)
2201 {
2202         return (str.length() > strlen(statefile_suffix) &&
2203                 str.find (statefile_suffix) == (str.length() - strlen (statefile_suffix)));
2204 }
2205
2206 struct string_cmp {
2207         bool operator()(const string* a, const string* b) {
2208                 return *a < *b;
2209         }
2210 };
2211
2212 static string*
2213 remove_end(string* state)
2214 {
2215         string statename(*state);
2216
2217         string::size_type start,end;
2218         if ((start = statename.find_last_of ('/')) != string::npos) {
2219                 statename = statename.substr (start+1);
2220         }
2221
2222         if ((end = statename.rfind(".ardour")) == string::npos) {
2223                 end = statename.length();
2224         }
2225
2226         return new string(statename.substr (0, end));
2227 }
2228
2229 vector<string *> *
2230 Session::possible_states (string path)
2231 {
2232         PathScanner scanner;
2233         vector<string*>* states = scanner (path, state_file_filter, 0, false, false);
2234
2235         transform(states->begin(), states->end(), states->begin(), remove_end);
2236
2237         string_cmp cmp;
2238         sort (states->begin(), states->end(), cmp);
2239
2240         return states;
2241 }
2242
2243 vector<string *> *
2244 Session::possible_states () const
2245 {
2246         return possible_states(_path);
2247 }
2248
2249 void
2250 Session::add_route_group (RouteGroup* g)
2251 {
2252         _route_groups.push_back (g);
2253         route_group_added (g); /* EMIT SIGNAL */
2254         set_dirty ();
2255 }
2256
2257 void
2258 Session::remove_route_group (RouteGroup& rg)
2259 {
2260         list<RouteGroup*>::iterator i;
2261
2262         if ((i = find (_route_groups.begin(), _route_groups.end(), &rg)) != _route_groups.end()) {
2263                 _route_groups.erase (i);
2264                 delete &rg;
2265
2266                 route_group_removed (); /* EMIT SIGNAL */
2267         }
2268
2269 }
2270
2271 RouteGroup *
2272 Session::route_group_by_name (string name)
2273 {
2274         list<RouteGroup *>::iterator i;
2275
2276         for (i = _route_groups.begin(); i != _route_groups.end(); ++i) {
2277                 if ((*i)->name() == name) {
2278                         return* i;
2279                 }
2280         }
2281         return 0;
2282 }
2283
2284 UndoTransaction*
2285 Session::start_reversible_command (const string& name)
2286 {
2287         UndoTransaction* trans = new UndoTransaction();
2288         trans->set_name(name);
2289         return trans;
2290 }
2291
2292 void
2293 Session::finish_reversible_command (UndoTransaction& ut)
2294 {
2295         struct timeval now;
2296         gettimeofday(&now, 0);
2297         ut.set_timestamp(now);
2298         _history.add (&ut);
2299 }
2300
2301 void
2302 Session::begin_reversible_command(const string& name)
2303 {
2304         UndoTransaction* trans = new UndoTransaction();
2305         trans->set_name(name);
2306
2307         if (!_current_trans.empty()) {
2308                 _current_trans.top()->add_command (trans);
2309         } else {
2310                 _current_trans.push(trans);
2311         }
2312 }
2313
2314 void
2315 Session::commit_reversible_command(Command *cmd)
2316 {
2317         assert(!_current_trans.empty());
2318         struct timeval now;
2319
2320         if (cmd) {
2321                 _current_trans.top()->add_command(cmd);
2322         }
2323
2324         if (_current_trans.top()->empty()) {
2325                 _current_trans.pop();
2326                 return;
2327         }
2328
2329         gettimeofday(&now, 0);
2330         _current_trans.top()->set_timestamp(now);
2331
2332         _history.add(_current_trans.top());
2333         _current_trans.pop();
2334 }
2335
2336 static bool
2337 accept_all_non_peak_files (const string& path, void */*arg*/)
2338 {
2339         return (path.length() > 5 && path.find (peakfile_suffix) != (path.length() - 5));
2340 }
2341
2342 static bool
2343 accept_all_state_files (const string& path, void */*arg*/)
2344 {
2345         return (path.length() > 7 && path.find (".ardour") == (path.length() - 7));
2346 }
2347
2348 int
2349 Session::find_all_sources (string path, set<string>& result)
2350 {
2351         XMLTree tree;
2352         XMLNode* node;
2353
2354         if (!tree.read (path)) {
2355                 return -1;
2356         }
2357
2358         if ((node = find_named_node (*tree.root(), "Sources")) == 0) {
2359                 return -2;
2360         }
2361
2362         XMLNodeList nlist;
2363         XMLNodeConstIterator niter;
2364
2365         nlist = node->children();
2366
2367         set_dirty();
2368
2369         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2370
2371                 XMLProperty* prop;
2372
2373                 if ((prop = (*niter)->property (X_("type"))) == 0) {
2374                         continue;
2375                 }
2376
2377                 DataType type (prop->value());
2378
2379                 if ((prop = (*niter)->property (X_("name"))) == 0) {
2380                         continue;
2381                 }
2382
2383                 if (prop->value()[0] == '/') {
2384                         /* external file, ignore */
2385                         continue;
2386                 }
2387
2388                 Glib::ustring found_path;
2389                 bool is_new;
2390                 uint16_t chan;
2391
2392                 if (FileSource::find (type, prop->value(), true, is_new, chan, found_path)) {
2393                         result.insert (found_path);
2394                 }
2395         }
2396
2397         return 0;
2398 }
2399
2400 int
2401 Session::find_all_sources_across_snapshots (set<string>& result, bool exclude_this_snapshot)
2402 {
2403         PathScanner scanner;
2404         vector<string*>* state_files;
2405         string ripped;
2406         string this_snapshot_path;
2407
2408         result.clear ();
2409
2410         ripped = _path;
2411
2412         if (ripped[ripped.length()-1] == '/') {
2413                 ripped = ripped.substr (0, ripped.length() - 1);
2414         }
2415
2416         state_files = scanner (ripped, accept_all_state_files, (void *) 0, false, true);
2417
2418         if (state_files == 0) {
2419                 /* impossible! */
2420                 return 0;
2421         }
2422
2423         this_snapshot_path = _path;
2424         this_snapshot_path += legalize_for_path (_current_snapshot_name);
2425         this_snapshot_path += statefile_suffix;
2426
2427         for (vector<string*>::iterator i = state_files->begin(); i != state_files->end(); ++i) {
2428
2429                 if (exclude_this_snapshot && **i == this_snapshot_path) {
2430                         continue;
2431                 }
2432
2433                 if (find_all_sources (**i, result) < 0) {
2434                         return -1;
2435                 }
2436         }
2437
2438         return 0;
2439 }
2440
2441 struct RegionCounter {
2442     typedef std::map<PBD::ID,boost::shared_ptr<AudioSource> > AudioSourceList;
2443     AudioSourceList::iterator iter;
2444     boost::shared_ptr<Region> region;
2445     uint32_t count;
2446
2447     RegionCounter() : count (0) {}
2448 };
2449
2450 int
2451 Session::ask_about_playlist_deletion (boost::shared_ptr<Playlist> p)
2452 {
2453         boost::optional<int> r = AskAboutPlaylistDeletion (p);
2454         return r.get_value_or (1);
2455 }
2456
2457 int
2458 Session::cleanup_sources (CleanupReport& rep)
2459 {
2460         // FIXME: needs adaptation to midi
2461
2462         vector<boost::shared_ptr<Source> > dead_sources;
2463         PathScanner scanner;
2464         string sound_path;
2465         vector<space_and_path>::iterator i;
2466         vector<space_and_path>::iterator nexti;
2467         vector<string*>* soundfiles;
2468         vector<string> unused;
2469         set<string> all_sources;
2470         bool used;
2471         string spath;
2472         int ret = -1;
2473
2474         _state_of_the_state = (StateOfTheState) (_state_of_the_state | InCleanup);
2475
2476         /* step 1: consider deleting all unused playlists */
2477
2478         if (playlists->maybe_delete_unused (boost::bind (Session::ask_about_playlist_deletion, _1))) {
2479                 ret = 0;
2480                 goto out;
2481         }
2482
2483         /* step 2: find all un-used sources */
2484
2485         rep.paths.clear ();
2486         rep.space = 0;
2487
2488         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ) {
2489
2490                 SourceMap::iterator tmp;
2491
2492                 tmp = i;
2493                 ++tmp;
2494
2495                 /* do not bother with files that are zero size, otherwise we remove the current "nascent"
2496                    capture files.
2497                 */
2498
2499                 if (!i->second->used() && (i->second->length(i->second->timeline_position() > 0))) {
2500                         dead_sources.push_back (i->second);
2501                         i->second->drop_references ();
2502                 }
2503
2504                 i = tmp;
2505         }
2506
2507         /* build a list of all the possible sound directories for the session */
2508
2509         for (i = session_dirs.begin(); i != session_dirs.end(); ) {
2510
2511                 nexti = i;
2512                 ++nexti;
2513
2514                 SessionDirectory sdir ((*i).path);
2515                 sound_path += sdir.sound_path().to_string();
2516
2517                 if (nexti != session_dirs.end()) {
2518                         sound_path += ':';
2519                 }
2520
2521                 i = nexti;
2522         }
2523
2524         /* now do the same thing for the files that ended up in the sounds dir(s)
2525            but are not referenced as sources in any snapshot.
2526         */
2527
2528         soundfiles = scanner (sound_path, accept_all_non_peak_files, (void *) 0, false, true);
2529
2530         if (soundfiles == 0) {
2531                 return 0;
2532         }
2533
2534         /* find all sources, but don't use this snapshot because the
2535            state file on disk still references sources we may have already
2536            dropped.
2537         */
2538
2539         find_all_sources_across_snapshots (all_sources, true);
2540
2541         /*  add our current source list
2542          */
2543
2544         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
2545                 boost::shared_ptr<FileSource> fs;
2546
2547                 if ((fs = boost::dynamic_pointer_cast<FileSource> (i->second)) != 0) {
2548                         all_sources.insert (fs->path());
2549                 }
2550         }
2551
2552         char tmppath1[PATH_MAX+1];
2553         char tmppath2[PATH_MAX+1];
2554
2555         for (vector<string*>::iterator x = soundfiles->begin(); x != soundfiles->end(); ++x) {
2556
2557                 used = false;
2558                 spath = **x;
2559
2560                 for (set<string>::iterator i = all_sources.begin(); i != all_sources.end(); ++i) {
2561
2562                         realpath(spath.c_str(), tmppath1);
2563                         realpath((*i).c_str(),  tmppath2);
2564
2565                         if (strcmp(tmppath1, tmppath2) == 0) {
2566                                 used = true;
2567                                 break;
2568                         }
2569                 }
2570
2571                 if (!used) {
2572                         unused.push_back (spath);
2573                 }
2574         }
2575
2576         /* now try to move all unused files into the "dead_sounds" directory(ies) */
2577
2578         for (vector<string>::iterator x = unused.begin(); x != unused.end(); ++x) {
2579                 struct stat statbuf;
2580
2581                 rep.paths.push_back (*x);
2582                 if (stat ((*x).c_str(), &statbuf) == 0) {
2583                         rep.space += statbuf.st_size;
2584                 }
2585
2586                 string newpath;
2587
2588                 /* don't move the file across filesystems, just
2589                    stick it in the `dead_sound_dir_name' directory
2590                    on whichever filesystem it was already on.
2591                 */
2592
2593                 if ((*x).find ("/sounds/") != string::npos) {
2594
2595                         /* old school, go up 1 level */
2596
2597                         newpath = Glib::path_get_dirname (*x);      // "sounds"
2598                         newpath = Glib::path_get_dirname (newpath); // "session-name"
2599
2600                 } else {
2601
2602                         /* new school, go up 4 levels */
2603
2604                         newpath = Glib::path_get_dirname (*x);      // "audiofiles"
2605                         newpath = Glib::path_get_dirname (newpath); // "session-name"
2606                         newpath = Glib::path_get_dirname (newpath); // "interchange"
2607                         newpath = Glib::path_get_dirname (newpath); // "session-dir"
2608                 }
2609
2610                 newpath += '/';
2611                 newpath += dead_sound_dir_name;
2612
2613                 if (g_mkdir_with_parents (newpath.c_str(), 0755) < 0) {
2614                         error << string_compose(_("Session: cannot create session peakfile folder \"%1\" (%2)"), newpath, strerror (errno)) << endmsg;
2615                         return -1;
2616                 }
2617
2618                 newpath += '/';
2619                 newpath += Glib::path_get_basename ((*x));
2620
2621                 if (access (newpath.c_str(), F_OK) == 0) {
2622
2623                         /* the new path already exists, try versioning */
2624
2625                         char buf[PATH_MAX+1];
2626                         int version = 1;
2627                         string newpath_v;
2628
2629                         snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), version);
2630                         newpath_v = buf;
2631
2632                         while (access (newpath_v.c_str(), F_OK) == 0 && version < 999) {
2633                                 snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), ++version);
2634                                 newpath_v = buf;
2635                         }
2636
2637                         if (version == 999) {
2638                                 error << string_compose (_("there are already 1000 files with names like %1; versioning discontinued"),
2639                                                   newpath)
2640                                       << endmsg;
2641                         } else {
2642                                 newpath = newpath_v;
2643                         }
2644
2645                 } else {
2646
2647                         /* it doesn't exist, or we can't read it or something */
2648
2649                 }
2650
2651                 if (::rename ((*x).c_str(), newpath.c_str()) != 0) {
2652                         error << string_compose (_("cannot rename audio file source from %1 to %2 (%3)"),
2653                                           (*x), newpath, strerror (errno))
2654                               << endmsg;
2655                         goto out;
2656                 }
2657
2658                 /* see if there an easy to find peakfile for this file, and remove it.
2659                  */
2660
2661                 string peakpath = (*x).substr (0, (*x).find_last_of ('.'));
2662                 peakpath += peakfile_suffix;
2663
2664                 if (access (peakpath.c_str(), W_OK) == 0) {
2665                         if (::unlink (peakpath.c_str()) != 0) {
2666                                 error << string_compose (_("cannot remove peakfile %1 for %2 (%3)"),
2667                                                   peakpath, _path, strerror (errno))
2668                                       << endmsg;
2669                                 /* try to back out */
2670                                 rename (newpath.c_str(), _path.c_str());
2671                                 goto out;
2672                         }
2673                 }
2674         }
2675
2676         ret = 0;
2677
2678         /* dump the history list */
2679
2680         _history.clear ();
2681
2682         /* save state so we don't end up a session file
2683            referring to non-existent sources.
2684         */
2685
2686         save_state ("");
2687
2688   out:
2689         _state_of_the_state = (StateOfTheState) (_state_of_the_state & ~InCleanup);
2690
2691         return ret;
2692 }
2693
2694 int
2695 Session::cleanup_trash_sources (CleanupReport& rep)
2696 {
2697         // FIXME: needs adaptation for MIDI
2698
2699         vector<space_and_path>::iterator i;
2700         string dead_sound_dir;
2701         struct dirent* dentry;
2702         struct stat statbuf;
2703         DIR* dead;
2704
2705         rep.paths.clear ();
2706         rep.space = 0;
2707
2708         for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
2709
2710                 dead_sound_dir = (*i).path;
2711                 dead_sound_dir += dead_sound_dir_name;
2712
2713                 if ((dead = opendir (dead_sound_dir.c_str())) == 0) {
2714                         continue;
2715                 }
2716
2717                 while ((dentry = readdir (dead)) != 0) {
2718
2719                         /* avoid '.' and '..' */
2720
2721                         if ((dentry->d_name[0] == '.' && dentry->d_name[1] == '\0') ||
2722                             (dentry->d_name[2] == '\0' && dentry->d_name[0] == '.' && dentry->d_name[1] == '.')) {
2723                                 continue;
2724                         }
2725
2726                         string fullpath;
2727
2728                         fullpath = dead_sound_dir;
2729                         fullpath += '/';
2730                         fullpath += dentry->d_name;
2731
2732                         if (stat (fullpath.c_str(), &statbuf)) {
2733                                 continue;
2734                         }
2735
2736                         if (!S_ISREG (statbuf.st_mode)) {
2737                                 continue;
2738                         }
2739
2740                         if (unlink (fullpath.c_str())) {
2741                                 error << string_compose (_("cannot remove dead sound file %1 (%2)"),
2742                                                   fullpath, strerror (errno))
2743                                       << endmsg;
2744                         }
2745
2746                         rep.paths.push_back (dentry->d_name);
2747                         rep.space += statbuf.st_size;
2748                 }
2749
2750                 closedir (dead);
2751
2752         }
2753
2754         return 0;
2755 }
2756
2757 void
2758 Session::set_dirty ()
2759 {
2760         bool was_dirty = dirty();
2761
2762         _state_of_the_state = StateOfTheState (_state_of_the_state | Dirty);
2763
2764
2765         if (!was_dirty) {
2766                 DirtyChanged(); /* EMIT SIGNAL */
2767         }
2768 }
2769
2770
2771 void
2772 Session::set_clean ()
2773 {
2774         bool was_dirty = dirty();
2775
2776         _state_of_the_state = Clean;
2777
2778
2779         if (was_dirty) {
2780                 DirtyChanged(); /* EMIT SIGNAL */
2781         }
2782 }
2783
2784 void
2785 Session::set_deletion_in_progress ()
2786 {
2787         _state_of_the_state = StateOfTheState (_state_of_the_state | Deletion);
2788 }
2789
2790 void
2791 Session::clear_deletion_in_progress ()
2792 {
2793         _state_of_the_state = StateOfTheState (_state_of_the_state & (~Deletion));
2794 }
2795
2796 void
2797 Session::add_controllable (boost::shared_ptr<Controllable> c)
2798 {
2799         /* this adds a controllable to the list managed by the Session.
2800            this is a subset of those managed by the Controllable class
2801            itself, and represents the only ones whose state will be saved
2802            as part of the session.
2803         */
2804
2805         Glib::Mutex::Lock lm (controllables_lock);
2806         controllables.insert (c);
2807 }
2808
2809 struct null_deleter { void operator()(void const *) const {} };
2810
2811 void
2812 Session::remove_controllable (Controllable* c)
2813 {
2814         if (_state_of_the_state | Deletion) {
2815                 return;
2816         }
2817
2818         Glib::Mutex::Lock lm (controllables_lock);
2819
2820         Controllables::iterator x = controllables.find (boost::shared_ptr<Controllable>(c, null_deleter()));
2821
2822         if (x != controllables.end()) {
2823                 controllables.erase (x);
2824         }
2825 }
2826
2827 boost::shared_ptr<Controllable>
2828 Session::controllable_by_id (const PBD::ID& id)
2829 {
2830         Glib::Mutex::Lock lm (controllables_lock);
2831
2832         for (Controllables::iterator i = controllables.begin(); i != controllables.end(); ++i) {
2833                 if ((*i)->id() == id) {
2834                         return *i;
2835                 }
2836         }
2837
2838         return boost::shared_ptr<Controllable>();
2839 }
2840
2841 boost::shared_ptr<Controllable>
2842 Session::controllable_by_descriptor (const ControllableDescriptor& desc)
2843 {
2844         boost::shared_ptr<Controllable> c;
2845         boost::shared_ptr<Route> r;
2846
2847         switch (desc.top_level_type()) {
2848         case ControllableDescriptor::NamedRoute:
2849         {
2850                 std::string str = desc.top_level_name();
2851                 if (str == "master") {
2852                         r = _master_out;
2853                 } else if (str == "control" || str == "listen") {
2854                         r = _monitor_out;
2855                 } else {
2856                         r = route_by_name (desc.top_level_name());
2857                 }
2858                 break;
2859         }
2860
2861         case ControllableDescriptor::RemoteControlID:
2862                 r = route_by_remote_id (desc.rid());
2863                 break;
2864         }
2865
2866         if (!r) {
2867                 return c;
2868         }
2869
2870         switch (desc.subtype()) {
2871         case ControllableDescriptor::Gain:
2872                 c = r->gain_control ();
2873                 break;
2874
2875         case ControllableDescriptor::Solo:
2876                 c = r->solo_control();
2877                 break;
2878
2879         case ControllableDescriptor::Mute:
2880                 c = r->mute_control();
2881                 break;
2882
2883         case ControllableDescriptor::Recenable:
2884         {
2885                 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track>(r);
2886
2887                 if (t) {
2888                         c = t->rec_enable_control ();
2889                 }
2890                 break;
2891         }
2892
2893         case ControllableDescriptor::Pan:
2894                 /* XXX pan control */
2895                 break;
2896
2897         case ControllableDescriptor::Balance:
2898                 /* XXX simple pan control */
2899                 break;
2900
2901         case ControllableDescriptor::PluginParameter:
2902         {
2903                 uint32_t plugin = desc.target (0);
2904                 uint32_t parameter_index = desc.target (1);
2905
2906                 /* revert to zero based counting */
2907
2908                 if (plugin > 0) {
2909                         --plugin;
2910                 }
2911
2912                 if (parameter_index > 0) {
2913                         --parameter_index;
2914                 }
2915
2916                 boost::shared_ptr<Processor> p = r->nth_plugin (plugin);
2917
2918                 if (p) {
2919                         c = boost::dynamic_pointer_cast<ARDOUR::AutomationControl>(
2920                                 p->control(Evoral::Parameter(PluginAutomation, 0, parameter_index)));
2921                 }
2922                 break;
2923         }
2924
2925         case ControllableDescriptor::SendGain:
2926         {
2927                 uint32_t send = desc.target (0);
2928
2929                 /* revert to zero-based counting */
2930
2931                 if (send > 0) {
2932                         --send;
2933                 }
2934
2935                 boost::shared_ptr<Processor> p = r->nth_send (send);
2936
2937                 if (p) {
2938                         boost::shared_ptr<Send> s = boost::dynamic_pointer_cast<Send>(p);
2939                         boost::shared_ptr<Amp> a = s->amp();
2940
2941                         if (a) {
2942                                 c = s->amp()->gain_control();
2943                         }
2944                 }
2945                 break;
2946         }
2947
2948         default:
2949                 /* relax and return a null pointer */
2950                 break;
2951         }
2952
2953         return c;
2954 }
2955
2956 void
2957 Session::add_instant_xml (XMLNode& node, bool write_to_config)
2958 {
2959         if (_writable) {
2960                 Stateful::add_instant_xml (node, _path);
2961         }
2962
2963         if (write_to_config) {
2964                 Config->add_instant_xml (node);
2965         }
2966 }
2967
2968 XMLNode*
2969 Session::instant_xml (const string& node_name)
2970 {
2971         return Stateful::instant_xml (node_name, _path);
2972 }
2973
2974 int
2975 Session::save_history (string snapshot_name)
2976 {
2977         XMLTree tree;
2978
2979         if (!_writable) {
2980                 return 0;
2981         }
2982
2983         if (snapshot_name.empty()) {
2984                 snapshot_name = _current_snapshot_name;
2985         }
2986
2987         const string history_filename = legalize_for_path (snapshot_name) + history_suffix;
2988         const string backup_filename = history_filename + backup_suffix;
2989         const sys::path xml_path = _session_dir->root_path() / history_filename;
2990         const sys::path backup_path = _session_dir->root_path() / backup_filename;
2991
2992         if (sys::exists (xml_path)) {
2993                 try
2994                 {
2995                         sys::rename (xml_path, backup_path);
2996                 }
2997                 catch (const sys::filesystem_error& err)
2998                 {
2999                         error << _("could not backup old history file, current history not saved") << endmsg;
3000                         return -1;
3001                 }
3002         }
3003
3004         if (!Config->get_save_history() || Config->get_saved_history_depth() < 0) {
3005                 return 0;
3006         }
3007
3008         tree.set_root (&_history.get_state (Config->get_saved_history_depth()));
3009
3010         if (!tree.write (xml_path.to_string()))
3011         {
3012                 error << string_compose (_("history could not be saved to %1"), xml_path.to_string()) << endmsg;
3013
3014                 try
3015                 {
3016                         sys::remove (xml_path);
3017                         sys::rename (backup_path, xml_path);
3018                 }
3019                 catch (const sys::filesystem_error& err)
3020                 {
3021                         error << string_compose (_("could not restore history file from backup %1 (%2)"),
3022                                         backup_path.to_string(), err.what()) << endmsg;
3023                 }
3024
3025                 return -1;
3026         }
3027
3028         return 0;
3029 }
3030
3031 int
3032 Session::restore_history (string snapshot_name)
3033 {
3034         XMLTree tree;
3035
3036         if (snapshot_name.empty()) {
3037                 snapshot_name = _current_snapshot_name;
3038         }
3039
3040         const string xml_filename = legalize_for_path (snapshot_name) + history_suffix;
3041         const sys::path xml_path = _session_dir->root_path() / xml_filename;
3042
3043         info << "Loading history from " << xml_path.to_string() << endmsg;
3044
3045         if (!sys::exists (xml_path)) {
3046                 info << string_compose (_("%1: no history file \"%2\" for this session."),
3047                                 _name, xml_path.to_string()) << endmsg;
3048                 return 1;
3049         }
3050
3051         if (!tree.read (xml_path.to_string())) {
3052                 error << string_compose (_("Could not understand session history file \"%1\""),
3053                                 xml_path.to_string()) << endmsg;
3054                 return -1;
3055         }
3056
3057         // replace history
3058         _history.clear();
3059
3060         for (XMLNodeConstIterator it  = tree.root()->children().begin(); it != tree.root()->children().end(); it++) {
3061
3062                 XMLNode *t = *it;
3063                 UndoTransaction* ut = new UndoTransaction ();
3064                 struct timeval tv;
3065
3066                 ut->set_name(t->property("name")->value());
3067                 stringstream ss(t->property("tv-sec")->value());
3068                 ss >> tv.tv_sec;
3069                 ss.str(t->property("tv-usec")->value());
3070                 ss >> tv.tv_usec;
3071                 ut->set_timestamp(tv);
3072
3073                 for (XMLNodeConstIterator child_it  = t->children().begin();
3074                                 child_it != t->children().end(); child_it++)
3075                 {
3076                         XMLNode *n = *child_it;
3077                         Command *c;
3078
3079                         if (n->name() == "MementoCommand" ||
3080                                         n->name() == "MementoUndoCommand" ||
3081                                         n->name() == "MementoRedoCommand") {
3082
3083                                 if ((c = memento_command_factory(n))) {
3084                                         ut->add_command(c);
3085                                 }
3086
3087                         } else if (n->name() == "DiffCommand") {
3088                                 PBD::ID  id(n->property("midi-source")->value());
3089                                 boost::shared_ptr<MidiSource> midi_source =
3090                                         boost::dynamic_pointer_cast<MidiSource, Source>(source_by_id(id));
3091                                 if (midi_source) {
3092                                         ut->add_command(new MidiModel::DiffCommand(midi_source->model(), *n));
3093                                 } else {
3094                                         error << _("Failed to downcast MidiSource for DiffCommand") << endmsg;
3095                                 }
3096
3097                         } else if (n->name() == "StatefulDiffCommand") {
3098                                 if ((c = stateful_diff_command_factory (n))) {
3099                                         ut->add_command (c);
3100                                 }
3101                         } else {
3102                                 error << string_compose(_("Couldn't figure out how to make a Command out of a %1 XMLNode."), n->name()) << endmsg;
3103                         }
3104                 }
3105
3106                 _history.add (ut);
3107         }
3108
3109         return 0;
3110 }
3111
3112 void
3113 Session::config_changed (std::string p, bool ours)
3114 {
3115         if (ours) {
3116                 set_dirty ();
3117         }
3118
3119         if (p == "seamless-loop") {
3120
3121         } else if (p == "rf-speed") {
3122
3123         } else if (p == "auto-loop") {
3124
3125         } else if (p == "auto-input") {
3126
3127                 if (Config->get_monitoring_model() == HardwareMonitoring && transport_rolling()) {
3128                         /* auto-input only makes a difference if we're rolling */
3129
3130                         boost::shared_ptr<RouteList> rl = routes.reader ();
3131                         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3132                                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3133                                 if (tr && tr->record_enabled ()) {
3134                                         tr->monitor_input (!config.get_auto_input());
3135                                 }
3136                         }
3137                 }
3138
3139         } else if (p == "punch-in") {
3140
3141                 Location* location;
3142
3143                 if ((location = _locations.auto_punch_location()) != 0) {
3144
3145                         if (config.get_punch_in ()) {
3146                                 replace_event (SessionEvent::PunchIn, location->start());
3147                         } else {
3148                                 remove_event (location->start(), SessionEvent::PunchIn);
3149                         }
3150                 }
3151
3152         } else if (p == "punch-out") {
3153
3154                 Location* location;
3155
3156                 if ((location = _locations.auto_punch_location()) != 0) {
3157
3158                         if (config.get_punch_out()) {
3159                                 replace_event (SessionEvent::PunchOut, location->end());
3160                         } else {
3161                                 clear_events (SessionEvent::PunchOut);
3162                         }
3163                 }
3164
3165         } else if (p == "edit-mode") {
3166
3167                 Glib::Mutex::Lock lm (playlists->lock);
3168
3169                 for (SessionPlaylists::List::iterator i = playlists->playlists.begin(); i != playlists->playlists.end(); ++i) {
3170                         (*i)->set_edit_mode (Config->get_edit_mode ());
3171                 }
3172
3173         } else if (p == "use-video-sync") {
3174
3175                 waiting_for_sync_offset = config.get_use_video_sync();
3176
3177         } else if (p == "mmc-control") {
3178
3179                 //poke_midi_thread ();
3180
3181         } else if (p == "mmc-device-id" || p == "mmc-receive-id") {
3182
3183                 if (mmc) {
3184                         mmc->set_receive_device_id (Config->get_mmc_receive_device_id());
3185                 }
3186
3187         } else if (p == "mmc-send-id") {
3188
3189                 if (mmc) {
3190                         mmc->set_send_device_id (Config->get_mmc_send_device_id());
3191                 }
3192
3193         } else if (p == "midi-control") {
3194
3195                 //poke_midi_thread ();
3196
3197         } else if (p == "raid-path") {
3198
3199                 setup_raid_path (config.get_raid_path());
3200
3201         } else if (p == "timecode-format") {
3202
3203                 sync_time_vars ();
3204
3205         } else if (p == "video-pullup") {
3206
3207                 sync_time_vars ();
3208
3209         } else if (p == "seamless-loop") {
3210
3211                 if (play_loop && transport_rolling()) {
3212                         // to reset diskstreams etc
3213                         request_play_loop (true);
3214                 }
3215
3216         } else if (p == "rf-speed") {
3217
3218                 cumulative_rf_motion = 0;
3219                 reset_rf_scale (0);
3220
3221         } else if (p == "click-sound") {
3222
3223                 setup_click_sounds (1);
3224
3225         } else if (p == "click-emphasis-sound") {
3226
3227                 setup_click_sounds (-1);
3228
3229         } else if (p == "clicking") {
3230
3231                 if (Config->get_clicking()) {
3232                         if (_click_io && click_data) { // don't require emphasis data
3233                                 _clicking = true;
3234                         }
3235                 } else {
3236                         _clicking = false;
3237                 }
3238
3239         } else if (p == "send-mtc") {
3240
3241                 /* only set the internal flag if we have
3242                    a port.
3243                 */
3244
3245                 if (_mtc_port != 0) {
3246                         session_send_mtc = Config->get_send_mtc();
3247                         if (session_send_mtc) {
3248                                 /* mark us ready to send */
3249                                 next_quarter_frame_to_send = 0;
3250                         }
3251                 } else {
3252                         session_send_mtc = false;
3253                 }
3254
3255         } else if (p == "send-mmc") {
3256
3257                 /* only set the internal flag if we have
3258                    a port.
3259                 */
3260
3261                 if (_mmc_port != 0) {
3262                         session_send_mmc = Config->get_send_mmc();
3263                 } else {
3264                         mmc = 0;
3265                         session_send_mmc = false;
3266                 }
3267
3268         } else if (p == "midi-feedback") {
3269
3270                 /* only set the internal flag if we have
3271                    a port.
3272                 */
3273
3274                 if (_mtc_port != 0) {
3275                         session_midi_feedback = Config->get_midi_feedback();
3276                 }
3277
3278         } else if (p == "jack-time-master") {
3279
3280                 engine().reset_timebase ();
3281
3282         } else if (p == "native-file-header-format") {
3283
3284                 if (!first_file_header_format_reset) {
3285                         reset_native_file_format ();
3286                 }
3287
3288                 first_file_header_format_reset = false;
3289
3290         } else if (p == "native-file-data-format") {
3291
3292                 if (!first_file_data_format_reset) {
3293                         reset_native_file_format ();
3294                 }
3295
3296                 first_file_data_format_reset = false;
3297
3298         } else if (p == "external-sync") {
3299                 if (!config.get_external_sync()) {
3300                         drop_sync_source ();
3301                 } else {
3302                         switch_to_sync_source (config.get_sync_source());
3303                 }
3304         } else if (p == "remote-model") {
3305                 set_remote_control_ids ();
3306         }  else if (p == "denormal-model") {
3307                 setup_fpu ();
3308         } else if (p == "history-depth") {
3309                 set_history_depth (Config->get_history_depth());
3310         } else if (p == "sync-all-route-ordering") {
3311                 sync_order_keys ("session");
3312         } else if (p == "initial-program-change") {
3313
3314                 if (_mmc_port && Config->get_initial_program_change() >= 0) {
3315                         MIDI::byte buf[2];
3316
3317                         buf[0] = MIDI::program; // channel zero by default
3318                         buf[1] = (Config->get_initial_program_change() & 0x7f);
3319
3320                         _mmc_port->midimsg (buf, sizeof (buf), 0);
3321                 }
3322         } else if (p == "initial-program-change") {
3323
3324                 if (_mmc_port && Config->get_initial_program_change() >= 0) {
3325                         MIDI::byte* buf = new MIDI::byte[2];
3326
3327                         buf[0] = MIDI::program; // channel zero by default
3328                         buf[1] = (Config->get_initial_program_change() & 0x7f);
3329                         // deliver_midi (_mmc_port, buf, 2);
3330                 }
3331         } else if (p == "solo-mute-override") {
3332                 // catch_up_on_solo_mute_override ();
3333         } else if (p == "listen-position") {
3334                 listen_position_changed ();
3335         } else if (p == "solo-control-is-listen-control") {
3336                 solo_control_mode_changed ();
3337         }
3338
3339
3340         set_dirty ();
3341 }
3342
3343 void
3344 Session::set_history_depth (uint32_t d)
3345 {
3346         _history.set_depth (d);
3347 }
3348
3349 int
3350 Session::load_diskstreams_2X (XMLNode const & node, int)
3351 {
3352         XMLNodeList          clist;
3353         XMLNodeConstIterator citer;
3354
3355         clist = node.children();
3356
3357         for (citer = clist.begin(); citer != clist.end(); ++citer) {
3358
3359                 try {
3360                         /* diskstreams added automatically by DiskstreamCreated handler */
3361                         if ((*citer)->name() == "AudioDiskstream" || (*citer)->name() == "DiskStream") {
3362                                 boost::shared_ptr<AudioDiskstream> dsp (new AudioDiskstream (*this, **citer));
3363                                 _diskstreams_2X.push_back (dsp);
3364                         } else {
3365                                 error << _("Session: unknown diskstream type in XML") << endmsg;
3366                         }
3367                 }
3368
3369                 catch (failed_constructor& err) {
3370                         error << _("Session: could not load diskstream via XML state") << endmsg;
3371                         return -1;
3372                 }
3373         }
3374
3375         return 0;
3376 }