libs/ardour/session_state.cc

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