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