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