libs/ardour/session_state.cc

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