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