libs/ardour/session_state.cc

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