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