libs/ardour/session_state.cc

   1 /*
   2   Copyright (C) 1999-2013 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 <string>
  29 #include <cerrno>
  30 #include <cstdio> /* snprintf(3) ... grrr */
  31 #include <cmath>
  32
  33 #include <unistd.h>
  34 #include <climits>
  35 #include <signal.h>
  36 #include <sys/time.h>
  37
  38 #ifdef HAVE_SYS_VFS_H
  39 #include <sys/vfs.h>
  40 #endif
  41
  42 #ifdef __APPLE__
  43 #include <sys/param.h>
  44 #include <sys/mount.h>
  45 #endif
  46
  47 #ifdef HAVE_SYS_STATVFS_H
  48 #include <sys/statvfs.h>
  49 #endif
  50
  51 #include <glib.h>
  52 #include "pbd/gstdio_compat.h"
  53
  54 #include <glibmm.h>
  55 #include <glibmm/threads.h>
  56 #include <glibmm/fileutils.h>
  57
  58 #include <boost/algorithm/string.hpp>
  59
  60 #include "midi++/mmc.h"
  61 #include "midi++/port.h"
  62
  63 #include "evoral/SMF.hpp"
  64
  65 #include "pbd/basename.h"
  66 #include "pbd/debug.h"
  67 #include "pbd/enumwriter.h"
  68 #include "pbd/error.h"
  69 #include "pbd/file_utils.h"
  70 #include "pbd/pathexpand.h"
  71 #include "pbd/pthread_utils.h"
  72 #include "pbd/stacktrace.h"
  73 #include "pbd/convert.h"
  74 #include "pbd/localtime_r.h"
  75 #include "pbd/unwind.h"
  76
  77 #include "ardour/amp.h"
  78 #include "ardour/async_midi_port.h"
  79 #include "ardour/audio_diskstream.h"
  80 #include "ardour/audio_track.h"
  81 #include "ardour/audioengine.h"
  82 #include "ardour/audiofilesource.h"
  83 #include "ardour/audioregion.h"
  84 #include "ardour/auditioner.h"
  85 #include "ardour/automation_control.h"
  86 #include "ardour/boost_debug.h"
  87 #include "ardour/butler.h"
  88 #include "ardour/controllable_descriptor.h"
  89 #include "ardour/control_protocol_manager.h"
  90 #include "ardour/directory_names.h"
  91 #include "ardour/filename_extensions.h"
  92 #include "ardour/graph.h"
  93 #include "ardour/location.h"
  94 #include "ardour/midi_model.h"
  95 #include "ardour/midi_patch_manager.h"
  96 #include "ardour/midi_region.h"
  97 #include "ardour/midi_scene_changer.h"
  98 #include "ardour/midi_source.h"
  99 #include "ardour/midi_track.h"
 100 #include "ardour/pannable.h"
 101 #include "ardour/playlist_factory.h"
 102 #include "ardour/playlist_source.h"
 103 #include "ardour/port.h"
 104 #include "ardour/processor.h"
 105 #include "ardour/profile.h"
 106 #include "ardour/proxy_controllable.h"
 107 #include "ardour/recent_sessions.h"
 108 #include "ardour/region_factory.h"
 109 #include "ardour/revision.h"
 110 #include "ardour/route_group.h"
 111 #include "ardour/send.h"
 112 #include "ardour/session.h"
 113 #include "ardour/session_directory.h"
 114 #include "ardour/session_metadata.h"
 115 #include "ardour/session_playlists.h"
 116 #include "ardour/session_state_utils.h"
 117 #include "ardour/silentfilesource.h"
 118 #include "ardour/sndfilesource.h"
 119 #include "ardour/source_factory.h"
 120 #include "ardour/speakers.h"
 121 #include "ardour/template_utils.h"
 122 #include "ardour/tempo.h"
 123 #include "ardour/ticker.h"
 124 #include "ardour/user_bundle.h"
 125 #include "ardour/vca.h"
 126 #include "ardour/vca_manager.h"
 127
 128 #include "control_protocol/control_protocol.h"
 129
 130 #include "LuaBridge/LuaBridge.h"
 131
 132 #include "i18n.h"
 133 #include <locale.h>
 134
 135 using namespace std;
 136 using namespace ARDOUR;
 137 using namespace PBD;
 138
 139 #define DEBUG_UNDO_HISTORY(msg) DEBUG_TRACE (PBD::DEBUG::UndoHistory, string_compose ("%1: %2\n", __LINE__, msg));
 140
 141 void
 142 Session::pre_engine_init (string fullpath)
 143 {
 144         if (fullpath.empty()) {
 145                 destroy ();
 146                 throw failed_constructor();
 147         }
 148
 149         /* discover canonical fullpath */
 150
 151         _path = canonical_path(fullpath);
 152
 153         /* is it new ? */
 154         if (Profile->get_trx() ) {
 155                 // Waves TracksLive has a usecase of session replacement with a new one.
 156                 // We should check session state file (<session_name>.ardour) existance
 157                 // to determine if the session is new or not
 158
 159                 string full_session_name = Glib::build_filename( fullpath, _name );
 160                 full_session_name += statefile_suffix;
 161
 162                 _is_new = !Glib::file_test (full_session_name, Glib::FileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR));
 163         } else {
 164                 _is_new = !Glib::file_test (_path, Glib::FileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR));
 165         }
 166
 167         /* finish initialization that can't be done in a normal C++ constructor
 168            definition.
 169         */
 170
 171         timerclear (&last_mmc_step);
 172         g_atomic_int_set (&processing_prohibited, 0);
 173         g_atomic_int_set (&_record_status, Disabled);
 174         g_atomic_int_set (&_playback_load, 100);
 175         g_atomic_int_set (&_capture_load, 100);
 176         set_next_event ();
 177         _all_route_group->set_active (true, this);
 178         interpolation.add_channel_to (0, 0);
 179
 180         if (config.get_use_video_sync()) {
 181                 waiting_for_sync_offset = true;
 182         } else {
 183                 waiting_for_sync_offset = false;
 184         }
 185
 186         last_rr_session_dir = session_dirs.begin();
 187
 188         set_history_depth (Config->get_history_depth());
 189
 190         /* default: assume simple stereo speaker configuration */
 191
 192         _speakers->setup_default_speakers (2);
 193
 194         _solo_cut_control.reset (new ProxyControllable (_("solo cut control (dB)"), PBD::Controllable::GainLike,
 195                                                         boost::bind (&RCConfiguration::set_solo_mute_gain, Config, _1),
 196                                                         boost::bind (&RCConfiguration::get_solo_mute_gain, Config)));
 197         add_controllable (_solo_cut_control);
 198
 199         /* These are all static "per-class" signals */
 200
 201         SourceFactory::SourceCreated.connect_same_thread (*this, boost::bind (&Session::add_source, this, _1));
 202         PlaylistFactory::PlaylistCreated.connect_same_thread (*this, boost::bind (&Session::add_playlist, this, _1, _2));
 203         AutomationList::AutomationListCreated.connect_same_thread (*this, boost::bind (&Session::add_automation_list, this, _1));
 204         Controllable::Destroyed.connect_same_thread (*this, boost::bind (&Session::remove_controllable, this, _1));
 205         IO::PortCountChanged.connect_same_thread (*this, boost::bind (&Session::ensure_buffers, this, _1));
 206
 207         /* stop IO objects from doing stuff until we're ready for them */
 208
 209         Delivery::disable_panners ();
 210         IO::disable_connecting ();
 211 }
 212
 213 int
 214 Session::post_engine_init ()
 215 {
 216         BootMessage (_("Set block size and sample rate"));
 217
 218         set_block_size (_engine.samples_per_cycle());
 219         set_frame_rate (_engine.sample_rate());
 220
 221         BootMessage (_("Using configuration"));
 222
 223         _midi_ports = new MidiPortManager;
 224
 225         MIDISceneChanger* msc;
 226
 227         _scene_changer = msc = new MIDISceneChanger (*this);
 228         msc->set_input_port (boost::dynamic_pointer_cast<MidiPort>(scene_input_port()));
 229         msc->set_output_port (boost::dynamic_pointer_cast<MidiPort>(scene_output_port()));
 230
 231         boost::function<framecnt_t(void)> timer_func (boost::bind (&Session::audible_frame, this));
 232         boost::dynamic_pointer_cast<AsyncMIDIPort>(scene_input_port())->set_timer (timer_func);
 233
 234         setup_midi_machine_control ();
 235
 236         if (_butler->start_thread()) {
 237                 return -1;
 238         }
 239
 240         if (start_midi_thread ()) {
 241                 return -1;
 242         }
 243
 244         setup_click_sounds (0);
 245         setup_midi_control ();
 246
 247         _engine.Halted.connect_same_thread (*this, boost::bind (&Session::engine_halted, this));
 248         _engine.Xrun.connect_same_thread (*this, boost::bind (&Session::xrun_recovery, this));
 249
 250         try {
 251                 /* tempo map requires sample rate knowledge */
 252
 253                 delete _tempo_map;
 254                 _tempo_map = new TempoMap (_current_frame_rate);
 255                 _tempo_map->PropertyChanged.connect_same_thread (*this, boost::bind (&Session::tempo_map_changed, this, _1));
 256                 _tempo_map->MetricPositionChanged.connect_same_thread (*this, boost::bind (&Session::gui_tempo_map_changed, this));
 257
 258                 /* MidiClock requires a tempo map */
 259
 260                 delete midi_clock;
 261                 midi_clock = new MidiClockTicker ();
 262                 midi_clock->set_session (this);
 263
 264                 /* crossfades require sample rate knowledge */
 265
 266                 SndFileSource::setup_standard_crossfades (*this, frame_rate());
 267                 _engine.GraphReordered.connect_same_thread (*this, boost::bind (&Session::graph_reordered, this));
 268
 269                 AudioDiskstream::allocate_working_buffers();
 270                 refresh_disk_space ();
 271
 272                 /* we're finally ready to call set_state() ... all objects have
 273                  * been created, the engine is running.
 274                  */
 275
 276                 if (state_tree) {
 277                         if (set_state (*state_tree->root(), Stateful::loading_state_version)) {
 278                                 return -1;
 279                         }
 280                 } else {
 281                         // set_state() will call setup_raid_path(), but if it's a new session we need
 282                         // to call setup_raid_path() here.
 283                         setup_raid_path (_path);
 284                 }
 285
 286                 /* ENGINE */
 287
 288                 boost::function<void (std::string)> ff (boost::bind (&Session::config_changed, this, _1, false));
 289                 boost::function<void (std::string)> ft (boost::bind (&Session::config_changed, this, _1, true));
 290
 291                 Config->map_parameters (ff);
 292                 config.map_parameters (ft);
 293                 _butler->map_parameters ();
 294
 295                 /* Reset all panners */
 296
 297                 Delivery::reset_panners ();
 298
 299                 /* this will cause the CPM to instantiate any protocols that are in use
 300                  * (or mandatory), which will pass it this Session, and then call
 301                  * set_state() on each instantiated protocol to match stored state.
 302                  */
 303
 304                 ControlProtocolManager::instance().set_session (this);
 305
 306                 /* This must be done after the ControlProtocolManager set_session above,
 307                    as it will set states for ports which the ControlProtocolManager creates.
 308                 */
 309
 310                 // XXX set state of MIDI::Port's
 311                 // MidiPortManager::instance()->set_port_states (Config->midi_port_states ());
 312
 313                 /* And this must be done after the MIDI::Manager::set_port_states as
 314                  * it will try to make connections whose details are loaded by set_port_states.
 315                  */
 316
 317                 hookup_io ();
 318
 319                 /* Let control protocols know that we are now all connected, so they
 320                  * could start talking to surfaces if they want to.
 321                  */
 322
 323                 ControlProtocolManager::instance().midi_connectivity_established ();
 324
 325                 if (_is_new && !no_auto_connect()) {
 326                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock());
 327                         auto_connect_master_bus ();
 328                 }
 329
 330                 _state_of_the_state = StateOfTheState (_state_of_the_state & ~(CannotSave|Dirty));
 331
 332                 /* update latencies */
 333
 334                 initialize_latencies ();
 335
 336                 _locations->added.connect_same_thread (*this, boost::bind (&Session::location_added, this, _1));
 337                 _locations->removed.connect_same_thread (*this, boost::bind (&Session::location_removed, this, _1));
 338                 _locations->changed.connect_same_thread (*this, boost::bind (&Session::locations_changed, this));
 339
 340         } catch (AudioEngine::PortRegistrationFailure& err) {
 341                 /* handle this one in a different way than all others, so that its clear what happened */
 342                 error << err.what() << endmsg;
 343                 return -1;
 344         } catch (...) {
 345                 return -1;
 346         }
 347
 348         BootMessage (_("Reset Remote Controls"));
 349
 350         // send_full_time_code (0);
 351         _engine.transport_locate (0);
 352
 353         send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdMmcReset));
 354         send_immediate_mmc (MIDI::MachineControlCommand (Timecode::Time ()));
 355
 356         MIDI::Name::MidiPatchManager::instance().add_search_path (session_directory().midi_patch_path() );
 357
 358         ltc_tx_initialize();
 359         /* initial program change will be delivered later; see ::config_changed() */
 360
 361         _state_of_the_state = Clean;
 362
 363         Port::set_connecting_blocked (false);
 364
 365         DirtyChanged (); /* EMIT SIGNAL */
 366
 367         if (_is_new) {
 368                 save_state ("");
 369         } else if (state_was_pending) {
 370                 save_state ("");
 371                 remove_pending_capture_state ();
 372                 state_was_pending = false;
 373         }
 374
 375         /* Now, finally, we can fill the playback buffers */
 376
 377         BootMessage (_("Filling playback buffers"));
 378
 379         boost::shared_ptr<RouteList> rl = routes.reader();
 380         for (RouteList::iterator r = rl->begin(); r != rl->end(); ++r) {
 381                 boost::shared_ptr<Track> trk = boost::dynamic_pointer_cast<Track> (*r);
 382                 if (trk && !trk->hidden()) {
 383                         trk->seek (_transport_frame, true);
 384                 }
 385         }
 386
 387         return 0;
 388 }
 389
 390 void
 391 Session::session_loaded ()
 392 {
 393         SessionLoaded();
 394
 395         _state_of_the_state = Clean;
 396
 397         DirtyChanged (); /* EMIT SIGNAL */
 398
 399         if (_is_new) {
 400                 save_state ("");
 401         } else if (state_was_pending) {
 402                 save_state ("");
 403                 remove_pending_capture_state ();
 404                 state_was_pending = false;
 405         }
 406
 407         /* Now, finally, we can fill the playback buffers */
 408
 409         BootMessage (_("Filling playback buffers"));
 410         force_locate (_transport_frame, false);
 411 }
 412
 413 string
 414 Session::raid_path () const
 415 {
 416         Searchpath raid_search_path;
 417
 418         for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
 419                 raid_search_path += (*i).path;
 420         }
 421
 422         return raid_search_path.to_string ();
 423 }
 424
 425 void
 426 Session::setup_raid_path (string path)
 427 {
 428         if (path.empty()) {
 429                 return;
 430         }
 431
 432         space_and_path sp;
 433         string fspath;
 434
 435         session_dirs.clear ();
 436
 437         Searchpath search_path(path);
 438         Searchpath sound_search_path;
 439         Searchpath midi_search_path;
 440
 441         for (Searchpath::const_iterator i = search_path.begin(); i != search_path.end(); ++i) {
 442                 sp.path = *i;
 443                 sp.blocks = 0; // not needed
 444                 session_dirs.push_back (sp);
 445
 446                 SessionDirectory sdir(sp.path);
 447
 448                 sound_search_path += sdir.sound_path ();
 449                 midi_search_path += sdir.midi_path ();
 450         }
 451
 452         // reset the round-robin soundfile path thingie
 453         last_rr_session_dir = session_dirs.begin();
 454 }
 455
 456 bool
 457 Session::path_is_within_session (const std::string& path)
 458 {
 459         for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
 460                 if (PBD::path_is_within (i->path, path)) {
 461                         return true;
 462                 }
 463         }
 464         return false;
 465 }
 466
 467 int
 468 Session::ensure_subdirs ()
 469 {
 470         string dir;
 471
 472         dir = session_directory().peak_path();
 473
 474         if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
 475                 error << string_compose(_("Session: cannot create session peakfile folder \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
 476                 return -1;
 477         }
 478
 479         dir = session_directory().sound_path();
 480
 481         if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
 482                 error << string_compose(_("Session: cannot create session sounds dir \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
 483                 return -1;
 484         }
 485
 486         dir = session_directory().midi_path();
 487
 488         if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
 489                 error << string_compose(_("Session: cannot create session midi dir \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
 490                 return -1;
 491         }
 492
 493         dir = session_directory().dead_path();
 494
 495         if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
 496                 error << string_compose(_("Session: cannot create session dead sounds folder \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
 497                 return -1;
 498         }
 499
 500         dir = session_directory().export_path();
 501
 502         if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
 503                 error << string_compose(_("Session: cannot create session export folder \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
 504                 return -1;
 505         }
 506
 507         dir = analysis_dir ();
 508
 509         if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
 510                 error << string_compose(_("Session: cannot create session analysis folder \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
 511                 return -1;
 512         }
 513
 514         dir = plugins_dir ();
 515
 516         if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
 517                 error << string_compose(_("Session: cannot create session plugins folder \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
 518                 return -1;
 519         }
 520
 521         dir = externals_dir ();
 522
 523         if (g_mkdir_with_parents (dir.c_str(), 0755) < 0) {
 524                 error << string_compose(_("Session: cannot create session externals folder \"%1\" (%2)"), dir, strerror (errno)) << endmsg;
 525                 return -1;
 526         }
 527
 528         return 0;
 529 }
 530
 531 /** @param session_template directory containing session template, or empty.
 532  *  Caller must not hold process lock.
 533  */
 534 int
 535 Session::create (const string& session_template, BusProfile* bus_profile)
 536 {
 537         if (g_mkdir_with_parents (_path.c_str(), 0755) < 0) {
 538                 error << string_compose(_("Session: cannot create session folder \"%1\" (%2)"), _path, strerror (errno)) << endmsg;
 539                 return -1;
 540         }
 541
 542         if (ensure_subdirs ()) {
 543                 return -1;
 544         }
 545
 546         _writable = exists_and_writable (_path);
 547
 548         if (!session_template.empty()) {
 549                 string in_path = (ARDOUR::Profile->get_trx () ? session_template : session_template_dir_to_file (session_template));
 550
 551                 FILE* in = g_fopen (in_path.c_str(), "rb");
 552
 553                 if (in) {
 554                         /* no need to call legalize_for_path() since the string
 555                          * in session_template is already a legal path name
 556                          */
 557                         string out_path = Glib::build_filename (_session_dir->root_path(), _name + statefile_suffix);
 558
 559                         FILE* out = g_fopen (out_path.c_str(), "wb");
 560
 561                         if (out) {
 562                                 char buf[1024];
 563                                 stringstream new_session;
 564
 565                                 while (!feof (in)) {
 566                                         size_t charsRead = fread (buf, sizeof(char), 1024, in);
 567
 568                                         if (ferror (in)) {
 569                                                 error << string_compose (_("Error reading session template file %1 (%2)"), in_path, strerror (errno)) << endmsg;
 570                                                 fclose (in);
 571                                                 fclose (out);
 572                                                 return -1;
 573                                         }
 574                                         if (charsRead == 0) {
 575                                                 break;
 576                                         }
 577                                         new_session.write (buf, charsRead);
 578                                 }
 579                                 fclose (in);
 580
 581                                 string file_contents = new_session.str();
 582                                 size_t writeSize = file_contents.length();
 583                                 if (fwrite (file_contents.c_str(), sizeof(char), writeSize, out) != writeSize) {
 584                                         error << string_compose (_("Error writing session template file %1 (%2)"), out_path, strerror (errno)) << endmsg;
 585                                         fclose (out);
 586                                         return -1;
 587                                 }
 588                                 fclose (out);
 589
 590                                 _is_new = false;
 591
 592                                 if (!ARDOUR::Profile->get_trx()) {
 593                                         /* Copy plugin state files from template to new session */
 594                                         std::string template_plugins = Glib::build_filename (session_template, X_("plugins"));
 595                                         copy_recurse (template_plugins, plugins_dir ());
 596                                 }
 597
 598                                 return 0;
 599
 600                         } else {
 601                                 error << string_compose (_("Could not open %1 for writing session template"), out_path)
 602                                         << endmsg;
 603                                 fclose(in);
 604                                 return -1;
 605                         }
 606
 607                 } else {
 608                         error << string_compose (_("Could not open session template %1 for reading"), in_path)
 609                                 << endmsg;
 610                         return -1;
 611                 }
 612
 613         }
 614
 615         if (Profile->get_trx()) {
 616
 617                 /* set initial start + end point : ARDOUR::Session::session_end_shift long.
 618                    Remember that this is a brand new session. Sessions
 619                    loaded from saved state will get this range from the saved state.
 620                 */
 621
 622                 set_session_range_location (0, 0);
 623
 624                 /* Initial loop location, from absolute zero, length 10 seconds  */
 625
 626                 Location* loc = new Location (*this, 0, 10.0 * _engine.sample_rate(), _("Loop"),  Location::IsAutoLoop);
 627                 _locations->add (loc, true);
 628                 set_auto_loop_location (loc);
 629         }
 630
 631         _state_of_the_state = Clean;
 632
 633         /* set up Master Out and Monitor Out if necessary */
 634
 635         if (bus_profile) {
 636
 637                 RouteList rl;
 638                 ChanCount count(DataType::AUDIO, bus_profile->master_out_channels);
 639
 640                 // Waves Tracks: always create master bus for Tracks
 641                 if (ARDOUR::Profile->get_trx() || bus_profile->master_out_channels) {
 642                         boost::shared_ptr<Route> r (new Route (*this, _("Master"), PresentationInfo::MasterOut, DataType::AUDIO));
 643                         if (r->init ()) {
 644                                 return -1;
 645                         }
 646
 647                         BOOST_MARK_ROUTE(r);
 648
 649                         {
 650                                 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
 651                                 r->input()->ensure_io (count, false, this);
 652                                 r->output()->ensure_io (count, false, this);
 653                         }
 654
 655                         rl.push_back (r);
 656
 657                 } else {
 658                         /* prohibit auto-connect to master, because there isn't one */
 659                         bus_profile->output_ac = AutoConnectOption (bus_profile->output_ac & ~AutoConnectMaster);
 660                 }
 661
 662                 if (!rl.empty()) {
 663                         add_routes (rl, false, false, false, PresentationInfo::max_order);
 664                 }
 665
 666                 // Waves Tracks: Skip this. Always use autoconnection for Tracks
 667                 if (!ARDOUR::Profile->get_trx()) {
 668
 669                         /* this allows the user to override settings with an environment variable.
 670                          */
 671
 672                         if (no_auto_connect()) {
 673                                 bus_profile->input_ac = AutoConnectOption (0);
 674                                 bus_profile->output_ac = AutoConnectOption (0);
 675                         }
 676
 677                         Config->set_input_auto_connect (bus_profile->input_ac);
 678                         Config->set_output_auto_connect (bus_profile->output_ac);
 679                 }
 680         }
 681
 682         if (Config->get_use_monitor_bus() && bus_profile) {
 683                 add_monitor_section ();
 684         }
 685
 686         return 0;
 687 }
 688
 689 void
 690 Session::maybe_write_autosave()
 691 {
 692         if (dirty() && record_status() != Recording) {
 693                 save_state("", true);
 694         }
 695 }
 696
 697 void
 698 Session::remove_pending_capture_state ()
 699 {
 700         std::string pending_state_file_path(_session_dir->root_path());
 701
 702         pending_state_file_path = Glib::build_filename (pending_state_file_path, legalize_for_path (_current_snapshot_name) + pending_suffix);
 703
 704         if (!Glib::file_test (pending_state_file_path, Glib::FILE_TEST_EXISTS)) return;
 705
 706         if (g_remove (pending_state_file_path.c_str()) != 0) {
 707                 error << string_compose(_("Could not remove pending capture state at path \"%1\" (%2)"),
 708                                 pending_state_file_path, g_strerror (errno)) << endmsg;
 709         }
 710 }
 711
 712 /** Rename a state file.
 713  *  @param old_name Old snapshot name.
 714  *  @param new_name New snapshot name.
 715  */
 716 void
 717 Session::rename_state (string old_name, string new_name)
 718 {
 719         if (old_name == _current_snapshot_name || old_name == _name) {
 720                 /* refuse to rename the current snapshot or the "main" one */
 721                 return;
 722         }
 723
 724         const string old_xml_filename = legalize_for_path (old_name) + statefile_suffix;
 725         const string new_xml_filename = legalize_for_path (new_name) + statefile_suffix;
 726
 727         const std::string old_xml_path(Glib::build_filename (_session_dir->root_path(), old_xml_filename));
 728         const std::string new_xml_path(Glib::build_filename (_session_dir->root_path(), new_xml_filename));
 729
 730         if (::g_rename (old_xml_path.c_str(), new_xml_path.c_str()) != 0) {
 731                 error << string_compose(_("could not rename snapshot %1 to %2 (%3)"),
 732                                 old_name, new_name, g_strerror(errno)) << endmsg;
 733         }
 734 }
 735
 736 /** Remove a state file.
 737  *  @param snapshot_name Snapshot name.
 738  */
 739 void
 740 Session::remove_state (string snapshot_name)
 741 {
 742         if (!_writable || snapshot_name == _current_snapshot_name || snapshot_name == _name) {
 743                 // refuse to remove the current snapshot or the "main" one
 744                 return;
 745         }
 746
 747         std::string xml_path(_session_dir->root_path());
 748
 749         xml_path = Glib::build_filename (xml_path, legalize_for_path (snapshot_name) + statefile_suffix);
 750
 751         if (!create_backup_file (xml_path)) {
 752                 // don't remove it if a backup can't be made
 753                 // create_backup_file will log the error.
 754                 return;
 755         }
 756
 757         // and delete it
 758         if (g_remove (xml_path.c_str()) != 0) {
 759                 error << string_compose(_("Could not remove session file at path \"%1\" (%2)"),
 760                                 xml_path, g_strerror (errno)) << endmsg;
 761         }
 762 }
 763
 764 /** @param snapshot_name Name to save under, without .ardour / .pending prefix */
 765 int
 766 Session::save_state (string snapshot_name, bool pending, bool switch_to_snapshot, bool template_only)
 767 {
 768         DEBUG_TRACE (DEBUG::Locale, string_compose ("Session::save_state locale '%1'\n", setlocale (LC_NUMERIC, NULL)));
 769
 770         XMLTree tree;
 771         std::string xml_path(_session_dir->root_path());
 772
 773         /* prevent concurrent saves from different threads */
 774
 775         Glib::Threads::Mutex::Lock lm (save_state_lock);
 776
 777         if (!_writable || (_state_of_the_state & CannotSave)) {
 778                 return 1;
 779         }
 780
 781         if (g_atomic_int_get(&_suspend_save)) {
 782                 _save_queued = true;
 783                 return 1;
 784         }
 785         _save_queued = false;
 786
 787         if (!_engine.connected ()) {
 788                 error << string_compose (_("the %1 audio engine is not connected and state saving would lose all I/O connections. Session not saved"),
 789                                          PROGRAM_NAME)
 790                       << endmsg;
 791                 return 1;
 792         }
 793
 794 #ifndef NDEBUG
 795         const int64_t save_start_time = g_get_monotonic_time();
 796 #endif
 797
 798         /* tell sources we're saving first, in case they write out to a new file
 799          * which should be saved with the state rather than the old one */
 800         for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
 801                 try {
 802                         i->second->session_saved();
 803                 } catch (Evoral::SMF::FileError& e) {
 804                         error << string_compose ("Could not write to MIDI file %1; MIDI data not saved.", e.file_name ()) << endmsg;
 805                 }
 806         }
 807
 808         SessionSaveUnderway (); /* EMIT SIGNAL */
 809
 810         bool mark_as_clean = true;
 811
 812         if (!snapshot_name.empty() && !switch_to_snapshot) {
 813                 mark_as_clean = false;
 814         }
 815
 816         if (template_only) {
 817                 mark_as_clean = false;
 818                 tree.set_root (&get_template());
 819         } else {
 820                 tree.set_root (&get_state());
 821         }
 822
 823         if (snapshot_name.empty()) {
 824                 snapshot_name = _current_snapshot_name;
 825         } else if (switch_to_snapshot) {
 826                 set_snapshot_name (snapshot_name);
 827         }
 828
 829         assert (!snapshot_name.empty());
 830
 831         if (!pending) {
 832
 833                 /* proper save: use statefile_suffix (.ardour in English) */
 834
 835                 xml_path = Glib::build_filename (xml_path, legalize_for_path (snapshot_name) + statefile_suffix);
 836
 837                 /* make a backup copy of the old file */
 838
 839                 if (Glib::file_test (xml_path, Glib::FILE_TEST_EXISTS) && !create_backup_file (xml_path)) {
 840                         // create_backup_file will log the error
 841                         return -1;
 842                 }
 843
 844         } else {
 845
 846                 /* pending save: use pending_suffix (.pending in English) */
 847                 xml_path = Glib::build_filename (xml_path, legalize_for_path (snapshot_name) + pending_suffix);
 848         }
 849
 850         std::string tmp_path(_session_dir->root_path());
 851         tmp_path = Glib::build_filename (tmp_path, legalize_for_path (snapshot_name) + temp_suffix);
 852
 853         cerr << "actually writing state to " << tmp_path << endl;
 854
 855         if (!tree.write (tmp_path)) {
 856                 error << string_compose (_("state could not be saved to %1"), tmp_path) << endmsg;
 857                 if (g_remove (tmp_path.c_str()) != 0) {
 858                         error << string_compose(_("Could not remove temporary session file at path \"%1\" (%2)"),
 859                                         tmp_path, g_strerror (errno)) << endmsg;
 860                 }
 861                 return -1;
 862
 863         } else {
 864
 865                 cerr << "renaming state to " << xml_path << endl;
 866
 867                 if (::g_rename (tmp_path.c_str(), xml_path.c_str()) != 0) {
 868                         error << string_compose (_("could not rename temporary session file %1 to %2 (%3)"),
 869                                         tmp_path, xml_path, g_strerror(errno)) << endmsg;
 870                         if (g_remove (tmp_path.c_str()) != 0) {
 871                                 error << string_compose(_("Could not remove temporary session file at path \"%1\" (%2)"),
 872                                                 tmp_path, g_strerror (errno)) << endmsg;
 873                         }
 874                         return -1;
 875                 }
 876         }
 877
 878         if (!pending) {
 879
 880                 save_history (snapshot_name);
 881
 882                 if (mark_as_clean) {
 883                         bool was_dirty = dirty();
 884
 885                         _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
 886
 887                         if (was_dirty) {
 888                                 DirtyChanged (); /* EMIT SIGNAL */
 889                         }
 890                 }
 891
 892                 StateSaved (snapshot_name); /* EMIT SIGNAL */
 893         }
 894
 895 #ifndef NDEBUG
 896         const int64_t elapsed_time_us = g_get_monotonic_time() - save_start_time;
 897         cerr << "saved state in " << fixed << setprecision (1) << elapsed_time_us / 1000. << " ms\n";
 898 #endif
 899         return 0;
 900 }
 901
 902 int
 903 Session::restore_state (string snapshot_name)
 904 {
 905         if (load_state (snapshot_name) == 0) {
 906                 set_state (*state_tree->root(), Stateful::loading_state_version);
 907         }
 908
 909         return 0;
 910 }
 911
 912 int
 913 Session::load_state (string snapshot_name)
 914 {
 915         delete state_tree;
 916         state_tree = 0;
 917
 918         state_was_pending = false;
 919
 920         /* check for leftover pending state from a crashed capture attempt */
 921
 922         std::string xmlpath(_session_dir->root_path());
 923         xmlpath = Glib::build_filename (xmlpath, legalize_for_path (snapshot_name) + pending_suffix);
 924
 925         if (Glib::file_test (xmlpath, Glib::FILE_TEST_EXISTS)) {
 926
 927                 /* there is pending state from a crashed capture attempt */
 928
 929                 boost::optional<int> r = AskAboutPendingState();
 930                 if (r.get_value_or (1)) {
 931                         state_was_pending = true;
 932                 }
 933         }
 934
 935         if (!state_was_pending) {
 936                 xmlpath = Glib::build_filename (_session_dir->root_path(), snapshot_name);
 937         }
 938
 939         if (!Glib::file_test (xmlpath, Glib::FILE_TEST_EXISTS)) {
 940                 xmlpath = Glib::build_filename (_session_dir->root_path(), legalize_for_path (snapshot_name) + statefile_suffix);
 941                 if (!Glib::file_test (xmlpath, Glib::FILE_TEST_EXISTS)) {
 942                         error << string_compose(_("%1: session file \"%2\" doesn't exist!"), _name, xmlpath) << endmsg;
 943                         return 1;
 944                 }
 945         }
 946
 947         state_tree = new XMLTree;
 948
 949         set_dirty();
 950
 951         _writable = exists_and_writable (xmlpath) && exists_and_writable(Glib::path_get_dirname(xmlpath));
 952
 953         if (!state_tree->read (xmlpath)) {
 954                 error << string_compose(_("Could not understand session file %1"), xmlpath) << endmsg;
 955                 delete state_tree;
 956                 state_tree = 0;
 957                 return -1;
 958         }
 959
 960         XMLNode const & root (*state_tree->root());
 961
 962         if (root.name() != X_("Session")) {
 963                 error << string_compose (_("Session file %1 is not a session"), xmlpath) << endmsg;
 964                 delete state_tree;
 965                 state_tree = 0;
 966                 return -1;
 967         }
 968
 969         XMLProperty const * prop;
 970
 971         if ((prop = root.property ("version")) == 0) {
 972                 /* no version implies very old version of Ardour */
 973                 Stateful::loading_state_version = 1000;
 974         } else {
 975                 if (prop->value().find ('.') != string::npos) {
 976                         /* old school version format */
 977                         if (prop->value()[0] == '2') {
 978                                 Stateful::loading_state_version = 2000;
 979                         } else {
 980                                 Stateful::loading_state_version = 3000;
 981                         }
 982                 } else {
 983                         Stateful::loading_state_version = atoi (prop->value());
 984                 }
 985         }
 986
 987         if (Stateful::loading_state_version < CURRENT_SESSION_FILE_VERSION && _writable) {
 988
 989                 std::string backup_path(_session_dir->root_path());
 990                 std::string backup_filename = string_compose ("%1-%2%3", legalize_for_path (snapshot_name), Stateful::loading_state_version, statefile_suffix);
 991                 backup_path = Glib::build_filename (backup_path, backup_filename);
 992
 993                 // only create a backup for a given statefile version once
 994
 995                 if (!Glib::file_test (backup_path, Glib::FILE_TEST_EXISTS)) {
 996
 997                         VersionMismatch (xmlpath, backup_path);
 998
 999                         if (!copy_file (xmlpath, backup_path)) {;
1000                                 return -1;
1001                         }
1002                 }
1003         }
1004
1005         save_snapshot_name (snapshot_name);
1006
1007         return 0;
1008 }
1009
1010 int
1011 Session::load_options (const XMLNode& node)
1012 {
1013         LocaleGuard lg;
1014         config.set_variables (node);
1015         return 0;
1016 }
1017
1018 bool
1019 Session::save_default_options ()
1020 {
1021         return config.save_state();
1022 }
1023
1024 XMLNode&
1025 Session::get_state()
1026 {
1027         return state(true);
1028 }
1029
1030 XMLNode&
1031 Session::get_template()
1032 {
1033         /* if we don't disable rec-enable, diskstreams
1034            will believe they need to store their capture
1035            sources in their state node.
1036         */
1037
1038         disable_record (false);
1039
1040         return state(false);
1041 }
1042
1043 XMLNode&
1044 Session::state (bool full_state)
1045 {
1046         LocaleGuard lg;
1047         XMLNode* node = new XMLNode("Session");
1048         XMLNode* child;
1049
1050         char buf[16];
1051         snprintf(buf, sizeof(buf), "%d", CURRENT_SESSION_FILE_VERSION);
1052         node->add_property("version", buf);
1053
1054         child = node->add_child ("ProgramVersion");
1055         child->add_property("created-with", created_with);
1056
1057         std::string modified_with = string_compose ("%1 %2", PROGRAM_NAME, revision);
1058         child->add_property("modified-with", modified_with);
1059
1060         /* store configuration settings */
1061
1062         if (full_state) {
1063
1064                 node->add_property ("name", _name);
1065                 snprintf (buf, sizeof (buf), "%" PRId64, _base_frame_rate);
1066                 node->add_property ("sample-rate", buf);
1067
1068                 if (session_dirs.size() > 1) {
1069
1070                         string p;
1071
1072                         vector<space_and_path>::iterator i = session_dirs.begin();
1073                         vector<space_and_path>::iterator next;
1074
1075                         ++i; /* skip the first one */
1076                         next = i;
1077                         ++next;
1078
1079                         while (i != session_dirs.end()) {
1080
1081                                 p += (*i).path;
1082
1083                                 if (next != session_dirs.end()) {
1084                                         p += G_SEARCHPATH_SEPARATOR;
1085                                 } else {
1086                                         break;
1087                                 }
1088
1089                                 ++next;
1090                                 ++i;
1091                         }
1092
1093                         child = node->add_child ("Path");
1094                         child->add_content (p);
1095                 }
1096         }
1097
1098         /* save the ID counter */
1099
1100         snprintf (buf, sizeof (buf), "%" PRIu64, ID::counter());
1101         node->add_property ("id-counter", buf);
1102
1103         snprintf (buf, sizeof (buf), "%u", name_id_counter ());
1104         node->add_property ("name-counter", buf);
1105
1106         /* save the event ID counter */
1107
1108         snprintf (buf, sizeof (buf), "%d", Evoral::event_id_counter());
1109         node->add_property ("event-counter", buf);
1110
1111         /* save the VCA counter */
1112
1113         snprintf (buf, sizeof (buf), "%" PRIu32, VCA::get_next_vca_number());
1114         node->add_property ("vca-counter", buf);
1115
1116         /* various options */
1117
1118         list<XMLNode*> midi_port_nodes = _midi_ports->get_midi_port_states();
1119         if (!midi_port_nodes.empty()) {
1120                 XMLNode* midi_port_stuff = new XMLNode ("MIDIPorts");
1121                 for (list<XMLNode*>::const_iterator n = midi_port_nodes.begin(); n != midi_port_nodes.end(); ++n) {
1122                         midi_port_stuff->add_child_nocopy (**n);
1123                 }
1124                 node->add_child_nocopy (*midi_port_stuff);
1125         }
1126
1127         node->add_child_nocopy (config.get_variables ());
1128
1129         node->add_child_nocopy (ARDOUR::SessionMetadata::Metadata()->get_state());
1130
1131         child = node->add_child ("Sources");
1132
1133         if (full_state) {
1134                 Glib::Threads::Mutex::Lock sl (source_lock);
1135
1136                 for (SourceMap::iterator siter = sources.begin(); siter != sources.end(); ++siter) {
1137
1138                         /* Don't save information about non-file Sources, or
1139                          * about non-destructive file sources that are empty
1140                          * and unused by any regions.
1141                         */
1142
1143                         boost::shared_ptr<FileSource> fs;
1144
1145                         if ((fs = boost::dynamic_pointer_cast<FileSource> (siter->second)) != 0) {
1146
1147                                 if (!fs->destructive()) {
1148                                         if (fs->empty() && !fs->used()) {
1149                                                 continue;
1150                                         }
1151                                 }
1152
1153                                 child->add_child_nocopy (siter->second->get_state());
1154                         }
1155                 }
1156         }
1157
1158         child = node->add_child ("Regions");
1159
1160         if (full_state) {
1161                 Glib::Threads::Mutex::Lock rl (region_lock);
1162                 const RegionFactory::RegionMap& region_map (RegionFactory::all_regions());
1163                 for (RegionFactory::RegionMap::const_iterator i = region_map.begin(); i != region_map.end(); ++i) {
1164                         boost::shared_ptr<Region> r = i->second;
1165                         /* only store regions not attached to playlists */
1166                         if (r->playlist() == 0) {
1167                                 if (boost::dynamic_pointer_cast<AudioRegion>(r)) {
1168                                         child->add_child_nocopy ((boost::dynamic_pointer_cast<AudioRegion>(r))->get_basic_state ());
1169                                 } else {
1170                                         child->add_child_nocopy (r->get_state ());
1171                                 }
1172                         }
1173                 }
1174
1175                 RegionFactory::CompoundAssociations& cassocs (RegionFactory::compound_associations());
1176
1177                 if (!cassocs.empty()) {
1178                         XMLNode* ca = node->add_child (X_("CompoundAssociations"));
1179
1180                         for (RegionFactory::CompoundAssociations::iterator i = cassocs.begin(); i != cassocs.end(); ++i) {
1181                                 char buf[64];
1182                                 XMLNode* can = new XMLNode (X_("CompoundAssociation"));
1183                                 i->first->id().print (buf, sizeof (buf));
1184                                 can->add_property (X_("copy"), buf);
1185                                 i->second->id().print (buf, sizeof (buf));
1186                                 can->add_property (X_("original"), buf);
1187                                 ca->add_child_nocopy (*can);
1188                         }
1189                 }
1190         }
1191
1192
1193
1194         if (full_state) {
1195
1196                 if (_locations) {
1197                         node->add_child_nocopy (_locations->get_state());
1198                 }
1199         } else {
1200                 Locations loc (*this);
1201                 // for a template, just create a new Locations, populate it
1202                 // with the default start and end, and get the state for that.
1203                 Location* range = new Location (*this, 0, 0, _("session"), Location::IsSessionRange);
1204                 range->set (max_framepos, 0);
1205                 loc.add (range);
1206                 XMLNode& locations_state = loc.get_state();
1207
1208                 if (ARDOUR::Profile->get_trx() && _locations) {
1209                         // For tracks we need stored the Auto Loop Range and all MIDI markers.
1210                         for (Locations::LocationList::const_iterator i = _locations->list ().begin (); i != _locations->list ().end (); ++i) {
1211                                 if ((*i)->is_mark () || (*i)->is_auto_loop ()) {
1212                                         locations_state.add_child_nocopy ((*i)->get_state ());
1213                                 }
1214                         }
1215                 }
1216                 node->add_child_nocopy (locations_state);
1217         }
1218
1219         child = node->add_child ("Bundles");
1220         {
1221                 boost::shared_ptr<BundleList> bundles = _bundles.reader ();
1222                 for (BundleList::iterator i = bundles->begin(); i != bundles->end(); ++i) {
1223                         boost::shared_ptr<UserBundle> b = boost::dynamic_pointer_cast<UserBundle> (*i);
1224                         if (b) {
1225                                 child->add_child_nocopy (b->get_state());
1226                         }
1227                 }
1228         }
1229
1230         node->add_child_nocopy (_vca_manager->get_state());
1231
1232         child = node->add_child ("Routes");
1233         {
1234                 boost::shared_ptr<RouteList> r = routes.reader ();
1235
1236                 RoutePublicOrderSorter cmp;
1237                 RouteList public_order (*r);
1238                 public_order.sort (cmp);
1239
1240                 /* the sort should have put the monitor out first */
1241
1242                 if (_monitor_out) {
1243                         assert (_monitor_out == public_order.front());
1244                 }
1245
1246                 for (RouteList::iterator i = public_order.begin(); i != public_order.end(); ++i) {
1247                         if (!(*i)->is_auditioner()) {
1248                                 if (full_state) {
1249                                         child->add_child_nocopy ((*i)->get_state());
1250                                 } else {
1251                                         child->add_child_nocopy ((*i)->get_template());
1252                                 }
1253                         }
1254                 }
1255         }
1256
1257         playlists->add_state (node, full_state);
1258
1259         child = node->add_child ("RouteGroups");
1260         for (list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
1261                 child->add_child_nocopy ((*i)->get_state());
1262         }
1263
1264         if (_click_io) {
1265                 XMLNode* gain_child = node->add_child ("Click");
1266                 gain_child->add_child_nocopy (_click_io->state (full_state));
1267                 gain_child->add_child_nocopy (_click_gain->state (full_state));
1268         }
1269
1270         if (_ltc_input) {
1271                 XMLNode* ltc_input_child = node->add_child ("LTC-In");
1272                 ltc_input_child->add_child_nocopy (_ltc_input->state (full_state));
1273         }
1274
1275         if (_ltc_input) {
1276                 XMLNode* ltc_output_child = node->add_child ("LTC-Out");
1277                 ltc_output_child->add_child_nocopy (_ltc_output->state (full_state));
1278         }
1279
1280         node->add_child_nocopy (_speakers->get_state());
1281         node->add_child_nocopy (_tempo_map->get_state());
1282         node->add_child_nocopy (get_control_protocol_state());
1283
1284         if (_extra_xml) {
1285                 node->add_child_copy (*_extra_xml);
1286         }
1287
1288         {
1289                 Glib::Threads::Mutex::Lock lm (lua_lock);
1290                 std::string saved;
1291                 {
1292                         luabridge::LuaRef savedstate ((*_lua_save)());
1293                         saved = savedstate.cast<std::string>();
1294                 }
1295                 lua.collect_garbage ();
1296                 lm.release ();
1297
1298                 gchar* b64 = g_base64_encode ((const guchar*)saved.c_str (), saved.size ());
1299                 std::string b64s (b64);
1300                 g_free (b64);
1301
1302                 XMLNode* script_node = new XMLNode (X_("Script"));
1303                 script_node->add_property (X_("lua"), LUA_VERSION);
1304                 script_node->add_content (b64s);
1305                 node->add_child_nocopy (*script_node);
1306         }
1307
1308         return *node;
1309 }
1310
1311 XMLNode&
1312 Session::get_control_protocol_state ()
1313 {
1314         ControlProtocolManager& cpm (ControlProtocolManager::instance());
1315         return cpm.get_state();
1316 }
1317
1318 int
1319 Session::set_state (const XMLNode& node, int version)
1320 {
1321         LocaleGuard lg;
1322         XMLNodeList nlist;
1323         XMLNode* child;
1324         XMLProperty const * prop;
1325         int ret = -1;
1326
1327         _state_of_the_state = StateOfTheState (_state_of_the_state|CannotSave);
1328
1329         if (node.name() != X_("Session")) {
1330                 fatal << _("programming error: Session: incorrect XML node sent to set_state()") << endmsg;
1331                 goto out;
1332         }
1333
1334         if ((prop = node.property ("name")) != 0) {
1335                 _name = prop->value ();
1336         }
1337
1338         if ((prop = node.property (X_("sample-rate"))) != 0) {
1339
1340                 _base_frame_rate = atoi (prop->value());
1341                 _nominal_frame_rate = _base_frame_rate;
1342
1343                 assert (AudioEngine::instance()->running ());
1344                 if (_base_frame_rate != AudioEngine::instance()->sample_rate ()) {
1345                         boost::optional<int> r = AskAboutSampleRateMismatch (_base_frame_rate, _current_frame_rate);
1346                         if (r.get_value_or (0)) {
1347                                 goto out;
1348                         }
1349                 }
1350         }
1351
1352         created_with = "unknown";
1353         if ((child = find_named_node (node, "ProgramVersion")) != 0) {
1354                 if ((prop = child->property (X_("created-with"))) != 0) {
1355                         created_with = prop->value ();
1356                 }
1357         }
1358
1359         setup_raid_path(_session_dir->root_path());
1360
1361         if ((prop = node.property (X_("id-counter"))) != 0) {
1362                 uint64_t x;
1363                 sscanf (prop->value().c_str(), "%" PRIu64, &x);
1364                 ID::init_counter (x);
1365         } else {
1366                 /* old sessions used a timebased counter, so fake
1367                    the startup ID counter based on a standard
1368                    timestamp.
1369                 */
1370                 time_t now;
1371                 time (&now);
1372                 ID::init_counter (now);
1373         }
1374
1375         if ((prop = node.property (X_("name-counter"))) != 0) {
1376                 init_name_id_counter (atoi (prop->value()));
1377         }
1378
1379         if ((prop = node.property (X_("event-counter"))) != 0) {
1380                 Evoral::init_event_id_counter (atoi (prop->value()));
1381         }
1382
1383         if ((prop = node.property (X_("vca-counter"))) != 0) {
1384                 uint32_t x;
1385                 sscanf (prop->value().c_str(), "%" PRIu32, &x);
1386                 VCA::set_next_vca_number (x);
1387         } else {
1388                 VCA::set_next_vca_number (1);
1389         }
1390
1391         if ((child = find_named_node (node, "MIDIPorts")) != 0) {
1392                 _midi_ports->set_midi_port_states (child->children());
1393         }
1394
1395         IO::disable_connecting ();
1396
1397         Stateful::save_extra_xml (node);
1398
1399         if (((child = find_named_node (node, "Options")) != 0)) { /* old style */
1400                 load_options (*child);
1401         } else if ((child = find_named_node (node, "Config")) != 0) { /* new style */
1402                 load_options (*child);
1403         } else {
1404                 error << _("Session: XML state has no options section") << endmsg;
1405         }
1406
1407         if (version >= 3000) {
1408                 if ((child = find_named_node (node, "Metadata")) == 0) {
1409                         warning << _("Session: XML state has no metadata section") << endmsg;
1410                 } else if ( ARDOUR::SessionMetadata::Metadata()->set_state (*child, version) ) {
1411                         goto out;
1412                 }
1413         }
1414
1415         if ((child = find_named_node (node, X_("Speakers"))) != 0) {
1416                 _speakers->set_state (*child, version);
1417         }
1418
1419         if ((child = find_named_node (node, "Sources")) == 0) {
1420                 error << _("Session: XML state has no sources section") << endmsg;
1421                 goto out;
1422         } else if (load_sources (*child)) {
1423                 goto out;
1424         }
1425
1426         if ((child = find_named_node (node, "TempoMap")) == 0) {
1427                 error << _("Session: XML state has no Tempo Map section") << endmsg;
1428                 goto out;
1429         } else if (_tempo_map->set_state (*child, version)) {
1430                 goto out;
1431         }
1432
1433         if ((child = find_named_node (node, "Locations")) == 0) {
1434                 error << _("Session: XML state has no locations section") << endmsg;
1435                 goto out;
1436         } else if (_locations->set_state (*child, version)) {
1437                 goto out;
1438         }
1439
1440         locations_changed ();
1441
1442         if (_session_range_location) {
1443                 AudioFileSource::set_header_position_offset (_session_range_location->start());
1444         }
1445
1446         if ((child = find_named_node (node, "Regions")) == 0) {
1447                 error << _("Session: XML state has no Regions section") << endmsg;
1448                 goto out;
1449         } else if (load_regions (*child)) {
1450                 goto out;
1451         }
1452
1453         if ((child = find_named_node (node, "Playlists")) == 0) {
1454                 error << _("Session: XML state has no playlists section") << endmsg;
1455                 goto out;
1456         } else if (playlists->load (*this, *child)) {
1457                 goto out;
1458         }
1459
1460         if ((child = find_named_node (node, "UnusedPlaylists")) == 0) {
1461                 // this is OK
1462         } else if (playlists->load_unused (*this, *child)) {
1463                 goto out;
1464         }
1465
1466         if ((child = find_named_node (node, "CompoundAssociations")) != 0) {
1467                 if (load_compounds (*child)) {
1468                         goto out;
1469                 }
1470         }
1471
1472         if (version >= 3000) {
1473                 if ((child = find_named_node (node, "Bundles")) == 0) {
1474                         warning << _("Session: XML state has no bundles section") << endmsg;
1475                         //goto out;
1476                 } else {
1477                         /* We can't load Bundles yet as they need to be able
1478                            to convert from port names to Port objects, which can't happen until
1479                            later */
1480                         _bundle_xml_node = new XMLNode (*child);
1481                 }
1482         }
1483
1484         if (version < 3000) {
1485                 if ((child = find_named_node (node, X_("DiskStreams"))) == 0) {
1486                         error << _("Session: XML state has no diskstreams section") << endmsg;
1487                         goto out;
1488                 } else if (load_diskstreams_2X (*child, version)) {
1489                         goto out;
1490                 }
1491         }
1492
1493         if ((child = find_named_node (node, VCAManager::xml_node_name)) != 0) {
1494                 _vca_manager->set_state (*child, version);
1495         }
1496
1497         if ((child = find_named_node (node, "Routes")) == 0) {
1498                 error << _("Session: XML state has no routes section") << endmsg;
1499                 goto out;
1500         } else if (load_routes (*child, version)) {
1501                 goto out;
1502         }
1503
1504         /* Now that we have Routes and masters loaded, connect them if appropriate */
1505
1506         Slavable::Assign (_vca_manager); /* EMIT SIGNAL */
1507
1508         /* our diskstreams list is no longer needed as they are now all owned by their Route */
1509         _diskstreams_2X.clear ();
1510
1511         if (version >= 3000) {
1512
1513                 if ((child = find_named_node (node, "RouteGroups")) == 0) {
1514                         error << _("Session: XML state has no route groups section") << endmsg;
1515                         goto out;
1516                 } else if (load_route_groups (*child, version)) {
1517                         goto out;
1518                 }
1519
1520         } else if (version < 3000) {
1521
1522                 if ((child = find_named_node (node, "EditGroups")) == 0) {
1523                         error << _("Session: XML state has no edit groups section") << endmsg;
1524                         goto out;
1525                 } else if (load_route_groups (*child, version)) {
1526                         goto out;
1527                 }
1528
1529                 if ((child = find_named_node (node, "MixGroups")) == 0) {
1530                         error << _("Session: XML state has no mix groups section") << endmsg;
1531                         goto out;
1532                 } else if (load_route_groups (*child, version)) {
1533                         goto out;
1534                 }
1535         }
1536
1537         if ((child = find_named_node (node, "Click")) == 0) {
1538                 warning << _("Session: XML state has no click section") << endmsg;
1539         } else if (_click_io) {
1540                 setup_click_state (&node);
1541         }
1542
1543         if ((child = find_named_node (node, ControlProtocolManager::state_node_name)) != 0) {
1544                 ControlProtocolManager::instance().set_state (*child, version);
1545         }
1546
1547         if ((child = find_named_node (node, "Script"))) {
1548                 for (XMLNodeList::const_iterator n = child->children ().begin (); n != child->children ().end (); ++n) {
1549                         if (!(*n)->is_content ()) { continue; }
1550                         gsize size;
1551                         guchar* buf = g_base64_decode ((*n)->content ().c_str (), &size);
1552                         try {
1553                                 Glib::Threads::Mutex::Lock lm (lua_lock);
1554                                 (*_lua_load)(std::string ((const char*)buf, size));
1555                         } catch (luabridge::LuaException const& e) {
1556                                 cerr << "LuaException:" << e.what () << endl;
1557                         }
1558                         g_free (buf);
1559                 }
1560         }
1561
1562         update_route_record_state ();
1563
1564         /* here beginneth the second phase ... */
1565         set_snapshot_name (_current_snapshot_name);
1566
1567         StateReady (); /* EMIT SIGNAL */
1568
1569         delete state_tree;
1570         state_tree = 0;
1571         return 0;
1572
1573   out:
1574         delete state_tree;
1575         state_tree = 0;
1576         return ret;
1577 }
1578
1579 int
1580 Session::load_routes (const XMLNode& node, int version)
1581 {
1582         XMLNodeList nlist;
1583         XMLNodeConstIterator niter;
1584         RouteList new_routes;
1585
1586         nlist = node.children();
1587
1588         set_dirty();
1589
1590         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1591
1592                 boost::shared_ptr<Route> route;
1593                 if (version < 3000) {
1594                         route = XMLRouteFactory_2X (**niter, version);
1595                 } else {
1596                         route = XMLRouteFactory (**niter, version);
1597                 }
1598
1599                 if (route == 0) {
1600                         error << _("Session: cannot create Route from XML description.") << endmsg;
1601                         return -1;
1602                 }
1603
1604                 BootMessage (string_compose (_("Loaded track/bus %1"), route->name()));
1605
1606                 new_routes.push_back (route);
1607         }
1608
1609         BootMessage (_("Tracks/busses loaded;  Adding to Session"));
1610
1611         add_routes (new_routes, false, false, false, PresentationInfo::max_order);
1612
1613         BootMessage (_("Finished adding tracks/busses"));
1614
1615         return 0;
1616 }
1617
1618 boost::shared_ptr<Route>
1619 Session::XMLRouteFactory (const XMLNode& node, int version)
1620 {
1621         boost::shared_ptr<Route> ret;
1622
1623         if (node.name() != "Route") {
1624                 return ret;
1625         }
1626
1627         XMLNode* ds_child = find_named_node (node, X_("Diskstream"));
1628
1629         DataType type = DataType::AUDIO;
1630         XMLProperty const * prop = node.property("default-type");
1631
1632         if (prop) {
1633                 type = DataType (prop->value());
1634         }
1635
1636         assert (type != DataType::NIL);
1637
1638         if (ds_child) {
1639
1640                 boost::shared_ptr<Track> track;
1641
1642                 if (type == DataType::AUDIO) {
1643                         track.reset (new AudioTrack (*this, X_("toBeResetFroXML")));
1644                 } else {
1645                         track.reset (new MidiTrack (*this, X_("toBeResetFroXML")));
1646                 }
1647
1648                 if (track->init()) {
1649                         return ret;
1650                 }
1651
1652                 if (track->set_state (node, version)) {
1653                         return ret;
1654                 }
1655
1656                 BOOST_MARK_TRACK (track);
1657                 ret = track;
1658
1659         } else {
1660                 PresentationInfo::Flag flags = PresentationInfo::get_flags (node);
1661                 boost::shared_ptr<Route> r (new Route (*this, X_("toBeResetFroXML"), flags));
1662
1663                 if (r->init () == 0 && r->set_state (node, version) == 0) {
1664                         BOOST_MARK_ROUTE (r);
1665                         ret = r;
1666                 }
1667         }
1668
1669         return ret;
1670 }
1671
1672 boost::shared_ptr<Route>
1673 Session::XMLRouteFactory_2X (const XMLNode& node, int version)
1674 {
1675         boost::shared_ptr<Route> ret;
1676
1677         if (node.name() != "Route") {
1678                 return ret;
1679         }
1680
1681         XMLProperty const * ds_prop = node.property (X_("diskstream-id"));
1682         if (!ds_prop) {
1683                 ds_prop = node.property (X_("diskstream"));
1684         }
1685
1686         DataType type = DataType::AUDIO;
1687         XMLProperty const * prop = node.property("default-type");
1688
1689         if (prop) {
1690                 type = DataType (prop->value());
1691         }
1692
1693         assert (type != DataType::NIL);
1694
1695         if (ds_prop) {
1696
1697                 list<boost::shared_ptr<Diskstream> >::iterator i = _diskstreams_2X.begin ();
1698                 while (i != _diskstreams_2X.end() && (*i)->id() != ds_prop->value()) {
1699                         ++i;
1700                 }
1701
1702                 if (i == _diskstreams_2X.end()) {
1703                         error << _("Could not find diskstream for route") << endmsg;
1704                         return boost::shared_ptr<Route> ();
1705                 }
1706
1707                 boost::shared_ptr<Track> track;
1708
1709                 if (type == DataType::AUDIO) {
1710                         track.reset (new AudioTrack (*this, X_("toBeResetFroXML")));
1711                 } else {
1712                         track.reset (new MidiTrack (*this, X_("toBeResetFroXML")));
1713                 }
1714
1715                 if (track->init()) {
1716                         return ret;
1717                 }
1718
1719                 if (track->set_state (node, version)) {
1720                         return ret;
1721                 }
1722
1723                 track->set_diskstream (*i);
1724
1725                 BOOST_MARK_TRACK (track);
1726                 ret = track;
1727
1728         } else {
1729                 PresentationInfo::Flag flags = PresentationInfo::get_flags (node);
1730                 boost::shared_ptr<Route> r (new Route (*this, X_("toBeResetFroXML"), flags));
1731
1732                 if (r->init () == 0 && r->set_state (node, version) == 0) {
1733                         BOOST_MARK_ROUTE (r);
1734                         ret = r;
1735                 }
1736         }
1737
1738         return ret;
1739 }
1740
1741 int
1742 Session::load_regions (const XMLNode& node)
1743 {
1744         XMLNodeList nlist;
1745         XMLNodeConstIterator niter;
1746         boost::shared_ptr<Region> region;
1747
1748         nlist = node.children();
1749
1750         set_dirty();
1751
1752         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1753                 if ((region = XMLRegionFactory (**niter, false)) == 0) {
1754                         error << _("Session: cannot create Region from XML description.");
1755                         XMLProperty const * name = (**niter).property("name");
1756
1757                         if (name) {
1758                                 error << " " << string_compose (_("Can not load state for region '%1'"), name->value());
1759                         }
1760
1761                         error << endmsg;
1762                 }
1763         }
1764
1765         return 0;
1766 }
1767
1768 int
1769 Session::load_compounds (const XMLNode& node)
1770 {
1771         XMLNodeList calist = node.children();
1772         XMLNodeConstIterator caiter;
1773         XMLProperty const * caprop;
1774
1775         for (caiter = calist.begin(); caiter != calist.end(); ++caiter) {
1776                 XMLNode* ca = *caiter;
1777                 ID orig_id;
1778                 ID copy_id;
1779
1780                 if ((caprop = ca->property (X_("original"))) == 0) {
1781                         continue;
1782                 }
1783                 orig_id = caprop->value();
1784
1785                 if ((caprop = ca->property (X_("copy"))) == 0) {
1786                         continue;
1787                 }
1788                 copy_id = caprop->value();
1789
1790                 boost::shared_ptr<Region> orig = RegionFactory::region_by_id (orig_id);
1791                 boost::shared_ptr<Region> copy = RegionFactory::region_by_id (copy_id);
1792
1793                 if (!orig || !copy) {
1794                         warning << string_compose (_("Regions in compound description not found (ID's %1 and %2): ignored"),
1795                                                    orig_id, copy_id)
1796                                 << endmsg;
1797                         continue;
1798                 }
1799
1800                 RegionFactory::add_compound_association (orig, copy);
1801         }
1802
1803         return 0;
1804 }
1805
1806 void
1807 Session::load_nested_sources (const XMLNode& node)
1808 {
1809         XMLNodeList nlist;
1810         XMLNodeConstIterator niter;
1811
1812         nlist = node.children();
1813
1814         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1815                 if ((*niter)->name() == "Source") {
1816
1817                         /* it may already exist, so don't recreate it unnecessarily
1818                          */
1819
1820                         XMLProperty const * prop = (*niter)->property (X_("id"));
1821                         if (!prop) {
1822                                 error << _("Nested source has no ID info in session file! (ignored)") << endmsg;
1823                                 continue;
1824                         }
1825
1826                         ID source_id (prop->value());
1827
1828                         if (!source_by_id (source_id)) {
1829
1830                                 try {
1831                                         SourceFactory::create (*this, **niter, true);
1832                                 }
1833                                 catch (failed_constructor& err) {
1834                                         error << string_compose (_("Cannot reconstruct nested source for region %1"), name()) << endmsg;
1835                                 }
1836                         }
1837                 }
1838         }
1839 }
1840
1841 boost::shared_ptr<Region>
1842 Session::XMLRegionFactory (const XMLNode& node, bool full)
1843 {
1844         XMLProperty const * type = node.property("type");
1845
1846         try {
1847
1848                 const XMLNodeList& nlist = node.children();
1849
1850                 for (XMLNodeConstIterator niter = nlist.begin(); niter != nlist.end(); ++niter) {
1851                         XMLNode *child = (*niter);
1852                         if (child->name() == "NestedSource") {
1853                                 load_nested_sources (*child);
1854                         }
1855                 }
1856
1857                 if (!type || type->value() == "audio") {
1858                         return boost::shared_ptr<Region>(XMLAudioRegionFactory (node, full));
1859                 } else if (type->value() == "midi") {
1860                         return boost::shared_ptr<Region>(XMLMidiRegionFactory (node, full));
1861                 }
1862
1863         } catch (failed_constructor& err) {
1864                 return boost::shared_ptr<Region> ();
1865         }
1866
1867         return boost::shared_ptr<Region> ();
1868 }
1869
1870 boost::shared_ptr<AudioRegion>
1871 Session::XMLAudioRegionFactory (const XMLNode& node, bool /*full*/)
1872 {
1873         XMLProperty const * prop;
1874         boost::shared_ptr<Source> source;
1875         boost::shared_ptr<AudioSource> as;
1876         SourceList sources;
1877         SourceList master_sources;
1878         uint32_t nchans = 1;
1879         char buf[128];
1880
1881         if (node.name() != X_("Region")) {
1882                 return boost::shared_ptr<AudioRegion>();
1883         }
1884
1885         if ((prop = node.property (X_("channels"))) != 0) {
1886                 nchans = atoi (prop->value().c_str());
1887         }
1888
1889         if ((prop = node.property ("name")) == 0) {
1890                 cerr << "no name for this region\n";
1891                 abort ();
1892         }
1893
1894         if ((prop = node.property (X_("source-0"))) == 0) {
1895                 if ((prop = node.property ("source")) == 0) {
1896                         error << _("Session: XMLNode describing a AudioRegion is incomplete (no source)") << endmsg;
1897                         return boost::shared_ptr<AudioRegion>();
1898                 }
1899         }
1900
1901         PBD::ID s_id (prop->value());
1902
1903         if ((source = source_by_id (s_id)) == 0) {
1904                 error << string_compose(_("Session: XMLNode describing a AudioRegion references an unknown source id =%1"), s_id) << endmsg;
1905                 return boost::shared_ptr<AudioRegion>();
1906         }
1907
1908         as = boost::dynamic_pointer_cast<AudioSource>(source);
1909         if (!as) {
1910                 error << string_compose(_("Session: XMLNode describing a AudioRegion references a non-audio source id =%1"), s_id) << endmsg;
1911                 return boost::shared_ptr<AudioRegion>();
1912         }
1913
1914         sources.push_back (as);
1915
1916         /* pickup other channels */
1917
1918         for (uint32_t n=1; n < nchans; ++n) {
1919                 snprintf (buf, sizeof(buf), X_("source-%d"), n);
1920                 if ((prop = node.property (buf)) != 0) {
1921
1922                         PBD::ID id2 (prop->value());
1923
1924                         if ((source = source_by_id (id2)) == 0) {
1925                                 error << string_compose(_("Session: XMLNode describing a AudioRegion references an unknown source id =%1"), id2) << endmsg;
1926                                 return boost::shared_ptr<AudioRegion>();
1927                         }
1928
1929                         as = boost::dynamic_pointer_cast<AudioSource>(source);
1930                         if (!as) {
1931                                 error << string_compose(_("Session: XMLNode describing a AudioRegion references a non-audio source id =%1"), id2) << endmsg;
1932                                 return boost::shared_ptr<AudioRegion>();
1933                         }
1934                         sources.push_back (as);
1935                 }
1936         }
1937
1938         for (uint32_t n = 0; n < nchans; ++n) {
1939                 snprintf (buf, sizeof(buf), X_("master-source-%d"), n);
1940                 if ((prop = node.property (buf)) != 0) {
1941
1942                         PBD::ID id2 (prop->value());
1943
1944                         if ((source = source_by_id (id2)) == 0) {
1945                                 error << string_compose(_("Session: XMLNode describing a AudioRegion references an unknown source id =%1"), id2) << endmsg;
1946                                 return boost::shared_ptr<AudioRegion>();
1947                         }
1948
1949                         as = boost::dynamic_pointer_cast<AudioSource>(source);
1950                         if (!as) {
1951                                 error << string_compose(_("Session: XMLNode describing a AudioRegion references a non-audio source id =%1"), id2) << endmsg;
1952                                 return boost::shared_ptr<AudioRegion>();
1953                         }
1954                         master_sources.push_back (as);
1955                 }
1956         }
1957
1958         try {
1959                 boost::shared_ptr<AudioRegion> region (boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (sources, node)));
1960
1961                 /* a final detail: this is the one and only place that we know how long missing files are */
1962
1963                 if (region->whole_file()) {
1964                         for (SourceList::iterator sx = sources.begin(); sx != sources.end(); ++sx) {
1965                                 boost::shared_ptr<SilentFileSource> sfp = boost::dynamic_pointer_cast<SilentFileSource> (*sx);
1966                                 if (sfp) {
1967                                         sfp->set_length (region->length());
1968                                 }
1969                         }
1970                 }
1971
1972                 if (!master_sources.empty()) {
1973                         if (master_sources.size() != nchans) {
1974                                 error << _("Session: XMLNode describing an AudioRegion is missing some master sources; ignored") << endmsg;
1975                         } else {
1976                                 region->set_master_sources (master_sources);
1977                         }
1978                 }
1979
1980                 return region;
1981
1982         }
1983
1984         catch (failed_constructor& err) {
1985                 return boost::shared_ptr<AudioRegion>();
1986         }
1987 }
1988
1989 boost::shared_ptr<MidiRegion>
1990 Session::XMLMidiRegionFactory (const XMLNode& node, bool /*full*/)
1991 {
1992         XMLProperty const * prop;
1993         boost::shared_ptr<Source> source;
1994         boost::shared_ptr<MidiSource> ms;
1995         SourceList sources;
1996
1997         if (node.name() != X_("Region")) {
1998                 return boost::shared_ptr<MidiRegion>();
1999         }
2000
2001         if ((prop = node.property ("name")) == 0) {
2002                 cerr << "no name for this region\n";
2003                 abort ();
2004         }
2005
2006         if ((prop = node.property (X_("source-0"))) == 0) {
2007                 if ((prop = node.property ("source")) == 0) {
2008                         error << _("Session: XMLNode describing a MidiRegion is incomplete (no source)") << endmsg;
2009                         return boost::shared_ptr<MidiRegion>();
2010                 }
2011         }
2012
2013         PBD::ID s_id (prop->value());
2014
2015         if ((source = source_by_id (s_id)) == 0) {
2016                 error << string_compose(_("Session: XMLNode describing a MidiRegion references an unknown source id =%1"), s_id) << endmsg;
2017                 return boost::shared_ptr<MidiRegion>();
2018         }
2019
2020         ms = boost::dynamic_pointer_cast<MidiSource>(source);
2021         if (!ms) {
2022                 error << string_compose(_("Session: XMLNode describing a MidiRegion references a non-midi source id =%1"), s_id) << endmsg;
2023                 return boost::shared_ptr<MidiRegion>();
2024         }
2025
2026         sources.push_back (ms);
2027
2028         try {
2029                 boost::shared_ptr<MidiRegion> region (boost::dynamic_pointer_cast<MidiRegion> (RegionFactory::create (sources, node)));
2030                 /* a final detail: this is the one and only place that we know how long missing files are */
2031
2032                 if (region->whole_file()) {
2033                         for (SourceList::iterator sx = sources.begin(); sx != sources.end(); ++sx) {
2034                                 boost::shared_ptr<SilentFileSource> sfp = boost::dynamic_pointer_cast<SilentFileSource> (*sx);
2035                                 if (sfp) {
2036                                         sfp->set_length (region->length());
2037                                 }
2038                         }
2039                 }
2040
2041                 return region;
2042         }
2043
2044         catch (failed_constructor& err) {
2045                 return boost::shared_ptr<MidiRegion>();
2046         }
2047 }
2048
2049 XMLNode&
2050 Session::get_sources_as_xml ()
2051
2052 {
2053         XMLNode* node = new XMLNode (X_("Sources"));
2054         Glib::Threads::Mutex::Lock lm (source_lock);
2055
2056         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
2057                 node->add_child_nocopy (i->second->get_state());
2058         }
2059
2060         return *node;
2061 }
2062
2063 void
2064 Session::reset_write_sources (bool mark_write_complete, bool force)
2065 {
2066         boost::shared_ptr<RouteList> rl = routes.reader();
2067         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2068                 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2069                 if (tr) {
2070                         _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
2071                         tr->reset_write_sources(mark_write_complete, force);
2072                         _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
2073                 }
2074         }
2075 }
2076
2077 int
2078 Session::load_sources (const XMLNode& node)
2079 {
2080         XMLNodeList nlist;
2081         XMLNodeConstIterator niter;
2082         boost::shared_ptr<Source> source; /* don't need this but it stops some
2083                                            * versions of gcc complaining about
2084                                            * discarded return values.
2085                                            */
2086
2087         nlist = node.children();
2088
2089         set_dirty();
2090
2091         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2092           retry:
2093                 try {
2094                         if ((source = XMLSourceFactory (**niter)) == 0) {
2095                                 error << _("Session: cannot create Source from XML description.") << endmsg;
2096                         }
2097
2098                 } catch (MissingSource& err) {
2099
2100                         int user_choice;
2101
2102                         if (err.type == DataType::MIDI && Glib::path_is_absolute (err.path)) {
2103                                 error << string_compose (_("A external MIDI file is missing. %1 cannot currently recover from missing external MIDI files"),
2104                                                          PROGRAM_NAME) << endmsg;
2105                                 return -1;
2106                         }
2107
2108                         if (!no_questions_about_missing_files) {
2109                                 user_choice = MissingFile (this, err.path, err.type).get_value_or (-1);
2110                         } else {
2111                                 user_choice = -2;
2112                         }
2113
2114                         switch (user_choice) {
2115                         case 0:
2116                                 /* user added a new search location, so try again */
2117                                 goto retry;
2118
2119
2120                         case 1:
2121                                 /* user asked to quit the entire session load
2122                                  */
2123                                 return -1;
2124
2125                         case 2:
2126                                 no_questions_about_missing_files = true;
2127                                 goto retry;
2128
2129                         case 3:
2130                                 no_questions_about_missing_files = true;
2131                                 /* fallthru */
2132
2133                         case -1:
2134                         default:
2135                                 switch (err.type) {
2136
2137                                 case DataType::AUDIO:
2138                                         source = SourceFactory::createSilent (*this, **niter, max_framecnt, _current_frame_rate);
2139                                         break;
2140
2141                                 case DataType::MIDI:
2142                                         /* The MIDI file is actually missing so
2143                                          * just create a new one in the same
2144                                          * location. Do not announce its
2145                                          */
2146                                         string fullpath;
2147
2148                                         if (!Glib::path_is_absolute (err.path)) {
2149                                                 fullpath = Glib::build_filename (source_search_path (DataType::MIDI).front(), err.path);
2150                                         } else {
2151                                                 /* this should be an unrecoverable error: we would be creating a MIDI file outside
2152                                                    the session tree.
2153                                                 */
2154                                                 return -1;
2155                                         }
2156                                         /* Note that we do not announce the source just yet - we need to reset its ID before we do that */
2157                                         source = SourceFactory::createWritable (DataType::MIDI, *this, fullpath, false, _current_frame_rate, false, false);
2158                                         /* reset ID to match the missing one */
2159                                         source->set_id (**niter);
2160                                         /* Now we can announce it */
2161                                         SourceFactory::SourceCreated (source);
2162                                         break;
2163                                 }
2164                                 break;
2165                         }
2166                 }
2167         }
2168
2169         return 0;
2170 }
2171
2172 boost::shared_ptr<Source>
2173 Session::XMLSourceFactory (const XMLNode& node)
2174 {
2175         if (node.name() != "Source") {
2176                 return boost::shared_ptr<Source>();
2177         }
2178
2179         try {
2180                 /* note: do peak building in another thread when loading session state */
2181                 return SourceFactory::create (*this, node, true);
2182         }
2183
2184         catch (failed_constructor& err) {
2185                 error << string_compose (_("Found a sound file that cannot be used by %1. Talk to the programmers."), PROGRAM_NAME) << endmsg;
2186                 return boost::shared_ptr<Source>();
2187         }
2188 }
2189
2190 int
2191 Session::save_template (string template_name, bool replace_existing)
2192 {
2193         if ((_state_of_the_state & CannotSave) || template_name.empty ()) {
2194                 return -1;
2195         }
2196
2197         bool absolute_path = Glib::path_is_absolute (template_name);
2198
2199         /* directory to put the template in */
2200         std::string template_dir_path;
2201
2202         if (!absolute_path) {
2203                 std::string user_template_dir(user_template_directory());
2204
2205                 if (g_mkdir_with_parents (user_template_dir.c_str(), 0755) != 0) {
2206                         error << string_compose(_("Could not create templates directory \"%1\" (%2)"),
2207                                         user_template_dir, g_strerror (errno)) << endmsg;
2208                         return -1;
2209                 }
2210
2211                 template_dir_path = Glib::build_filename (user_template_dir, template_name);
2212         } else {
2213                 template_dir_path = template_name;
2214         }
2215
2216         if (!ARDOUR::Profile->get_trx()) {
2217                 if (!replace_existing && Glib::file_test (template_dir_path, Glib::FILE_TEST_EXISTS)) {
2218                         warning << string_compose(_("Template \"%1\" already exists - new version not created"),
2219                                                                           template_dir_path) << endmsg;
2220                         return -2;
2221                 }
2222
2223                 if (g_mkdir_with_parents (template_dir_path.c_str(), 0755) != 0) {
2224                         error << string_compose(_("Could not create directory for Session template\"%1\" (%2)"),
2225                                                                         template_dir_path, g_strerror (errno)) << endmsg;
2226                         return -1;
2227                 }
2228         }
2229
2230         /* file to write */
2231         std::string template_file_path;
2232
2233         if (ARDOUR::Profile->get_trx()) {
2234                 template_file_path = template_name;
2235         } else {
2236                 if (absolute_path) {
2237                         template_file_path = Glib::build_filename (template_dir_path, Glib::path_get_basename (template_dir_path) + template_suffix);
2238                 } else {
2239                         template_file_path = Glib::build_filename (template_dir_path, template_name + template_suffix);
2240                 }
2241         }
2242
2243         SessionSaveUnderway (); /* EMIT SIGNAL */
2244
2245         XMLTree tree;
2246
2247         {
2248                 PBD::Unwinder<std::string> uw (_template_state_dir, template_dir_path);
2249                 tree.set_root (&get_template());
2250         }
2251
2252         if (!tree.write (template_file_path)) {
2253                 error << _("template not saved") << endmsg;
2254                 return -1;
2255         }
2256
2257         store_recent_templates (template_file_path);
2258
2259         return 0;
2260 }
2261
2262 void
2263 Session::refresh_disk_space ()
2264 {
2265 #if __APPLE__ || (HAVE_SYS_VFS_H && HAVE_SYS_STATVFS_H)
2266
2267         Glib::Threads::Mutex::Lock lm (space_lock);
2268
2269         /* get freespace on every FS that is part of the session path */
2270
2271         _total_free_4k_blocks = 0;
2272         _total_free_4k_blocks_uncertain = false;
2273
2274         for (vector<space_and_path>::iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
2275
2276                 struct statfs statfsbuf;
2277                 statfs (i->path.c_str(), &statfsbuf);
2278
2279                 double const scale = statfsbuf.f_bsize / 4096.0;
2280
2281                 /* See if this filesystem is read-only */
2282                 struct statvfs statvfsbuf;
2283                 statvfs (i->path.c_str(), &statvfsbuf);
2284
2285                 /* f_bavail can be 0 if it is undefined for whatever
2286                    filesystem we are looking at; Samba shares mounted
2287                    via GVFS are an example of this.
2288                 */
2289                 if (statfsbuf.f_bavail == 0) {
2290                         /* block count unknown */
2291                         i->blocks = 0;
2292                         i->blocks_unknown = true;
2293                 } else if (statvfsbuf.f_flag & ST_RDONLY) {
2294                         /* read-only filesystem */
2295                         i->blocks = 0;
2296                         i->blocks_unknown = false;
2297                 } else {
2298                         /* read/write filesystem with known space */
2299                         i->blocks = (uint32_t) floor (statfsbuf.f_bavail * scale);
2300                         i->blocks_unknown = false;
2301                 }
2302
2303                 _total_free_4k_blocks += i->blocks;
2304                 if (i->blocks_unknown) {
2305                         _total_free_4k_blocks_uncertain = true;
2306                 }
2307         }
2308 #elif defined PLATFORM_WINDOWS
2309         vector<string> scanned_volumes;
2310         vector<string>::iterator j;
2311         vector<space_and_path>::iterator i;
2312     DWORD nSectorsPerCluster, nBytesPerSector,
2313           nFreeClusters, nTotalClusters;
2314     char disk_drive[4];
2315         bool volume_found;
2316
2317         _total_free_4k_blocks = 0;
2318
2319         for (i = session_dirs.begin(); i != session_dirs.end(); i++) {
2320                 strncpy (disk_drive, (*i).path.c_str(), 3);
2321                 disk_drive[3] = 0;
2322                 strupr(disk_drive);
2323
2324                 volume_found = false;
2325                 if (0 != (GetDiskFreeSpace(disk_drive, &nSectorsPerCluster, &nBytesPerSector, &nFreeClusters, &nTotalClusters)))
2326                 {
2327                         int64_t nBytesPerCluster = nBytesPerSector * nSectorsPerCluster;
2328                         int64_t nFreeBytes = nBytesPerCluster * (int64_t)nFreeClusters;
2329                         i->blocks = (uint32_t)(nFreeBytes / 4096);
2330
2331                         for (j = scanned_volumes.begin(); j != scanned_volumes.end(); j++) {
2332                                 if (0 == j->compare(disk_drive)) {
2333                                         volume_found = true;
2334                                         break;
2335                                 }
2336                         }
2337
2338                         if (!volume_found) {
2339                                 scanned_volumes.push_back(disk_drive);
2340                                 _total_free_4k_blocks += i->blocks;
2341                         }
2342                 }
2343         }
2344
2345         if (0 == _total_free_4k_blocks) {
2346                 strncpy (disk_drive, path().c_str(), 3);
2347                 disk_drive[3] = 0;
2348
2349                 if (0 != (GetDiskFreeSpace(disk_drive, &nSectorsPerCluster, &nBytesPerSector, &nFreeClusters, &nTotalClusters)))
2350                 {
2351                         int64_t nBytesPerCluster = nBytesPerSector * nSectorsPerCluster;
2352                         int64_t nFreeBytes = nBytesPerCluster * (int64_t)nFreeClusters;
2353                         _total_free_4k_blocks = (uint32_t)(nFreeBytes / 4096);
2354                 }
2355         }
2356 #endif
2357 }
2358
2359 string
2360 Session::get_best_session_directory_for_new_audio ()
2361 {
2362         vector<space_and_path>::iterator i;
2363         string result = _session_dir->root_path();
2364
2365         /* handle common case without system calls */
2366
2367         if (session_dirs.size() == 1) {
2368                 return result;
2369         }
2370
2371         /* OK, here's the algorithm we're following here:
2372
2373         We want to select which directory to use for
2374         the next file source to be created. Ideally,
2375         we'd like to use a round-robin process so as to
2376         get maximum performance benefits from splitting
2377         the files across multiple disks.
2378
2379         However, in situations without much diskspace, an
2380         RR approach may end up filling up a filesystem
2381         with new files while others still have space.
2382         Its therefore important to pay some attention to
2383         the freespace in the filesystem holding each
2384         directory as well. However, if we did that by
2385         itself, we'd keep creating new files in the file
2386         system with the most space until it was as full
2387         as all others, thus negating any performance
2388         benefits of this RAID-1 like approach.
2389
2390         So, we use a user-configurable space threshold. If
2391         there are at least 2 filesystems with more than this
2392         much space available, we use RR selection between them.
2393         If not, then we pick the filesystem with the most space.
2394
2395         This gets a good balance between the two
2396         approaches.
2397         */
2398
2399         refresh_disk_space ();
2400
2401         int free_enough = 0;
2402
2403         for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
2404                 if ((*i).blocks * 4096 >= Config->get_disk_choice_space_threshold()) {
2405                         free_enough++;
2406                 }
2407         }
2408
2409         if (free_enough >= 2) {
2410                 /* use RR selection process, ensuring that the one
2411                    picked works OK.
2412                 */
2413
2414                 i = last_rr_session_dir;
2415
2416                 do {
2417                         if (++i == session_dirs.end()) {
2418                                 i = session_dirs.begin();
2419                         }
2420
2421                         if ((*i).blocks * 4096 >= Config->get_disk_choice_space_threshold()) {
2422                                 SessionDirectory sdir(i->path);
2423                                 if (sdir.create ()) {
2424                                         result = (*i).path;
2425                                         last_rr_session_dir = i;
2426                                         return result;
2427                                 }
2428                         }
2429
2430                 } while (i != last_rr_session_dir);
2431
2432         } else {
2433
2434                 /* pick FS with the most freespace (and that
2435                    seems to actually work ...)
2436                 */
2437
2438                 vector<space_and_path> sorted;
2439                 space_and_path_ascending_cmp cmp;
2440
2441                 sorted = session_dirs;
2442                 sort (sorted.begin(), sorted.end(), cmp);
2443
2444                 for (i = sorted.begin(); i != sorted.end(); ++i) {
2445                         SessionDirectory sdir(i->path);
2446                         if (sdir.create ()) {
2447                                 result = (*i).path;
2448                                 last_rr_session_dir = i;
2449                                 return result;
2450                         }
2451                 }
2452         }
2453
2454         return result;
2455 }
2456
2457 string
2458 Session::automation_dir () const
2459 {
2460         return Glib::build_filename (_path, automation_dir_name);
2461 }
2462
2463 string
2464 Session::analysis_dir () const
2465 {
2466         return Glib::build_filename (_path, analysis_dir_name);
2467 }
2468
2469 string
2470 Session::plugins_dir () const
2471 {
2472         return Glib::build_filename (_path, plugins_dir_name);
2473 }
2474
2475 string
2476 Session::externals_dir () const
2477 {
2478         return Glib::build_filename (_path, externals_dir_name);
2479 }
2480
2481 int
2482 Session::load_bundles (XMLNode const & node)
2483 {
2484         XMLNodeList nlist = node.children();
2485         XMLNodeConstIterator niter;
2486
2487         set_dirty();
2488
2489         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2490                 if ((*niter)->name() == "InputBundle") {
2491                         add_bundle (boost::shared_ptr<UserBundle> (new UserBundle (**niter, true)));
2492                 } else if ((*niter)->name() == "OutputBundle") {
2493                         add_bundle (boost::shared_ptr<UserBundle> (new UserBundle (**niter, false)));
2494                 } else {
2495                         error << string_compose(_("Unknown node \"%1\" found in Bundles list from session file"), (*niter)->name()) << endmsg;
2496                         return -1;
2497                 }
2498         }
2499
2500         return 0;
2501 }
2502
2503 int
2504 Session::load_route_groups (const XMLNode& node, int version)
2505 {
2506         XMLNodeList nlist = node.children();
2507         XMLNodeConstIterator niter;
2508
2509         set_dirty ();
2510
2511         if (version >= 3000) {
2512
2513                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2514                         if ((*niter)->name() == "RouteGroup") {
2515                                 RouteGroup* rg = new RouteGroup (*this, "");
2516                                 add_route_group (rg);
2517                                 rg->set_state (**niter, version);
2518                         }
2519                 }
2520
2521         } else if (version < 3000) {
2522
2523                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2524                         if ((*niter)->name() == "EditGroup" || (*niter)->name() == "MixGroup") {
2525                                 RouteGroup* rg = new RouteGroup (*this, "");
2526                                 add_route_group (rg);
2527                                 rg->set_state (**niter, version);
2528                         }
2529                 }
2530         }
2531
2532         return 0;
2533 }
2534
2535 static bool
2536 state_file_filter (const string &str, void* /*arg*/)
2537 {
2538         return (str.length() > strlen(statefile_suffix) &&
2539                 str.find (statefile_suffix) == (str.length() - strlen (statefile_suffix)));
2540 }
2541
2542 static string
2543 remove_end(string state)
2544 {
2545         string statename(state);
2546
2547         string::size_type start,end;
2548         if ((start = statename.find_last_of (G_DIR_SEPARATOR)) != string::npos) {
2549                 statename = statename.substr (start+1);
2550         }
2551
2552         if ((end = statename.rfind(statefile_suffix)) == string::npos) {
2553                 end = statename.length();
2554         }
2555
2556         return string(statename.substr (0, end));
2557 }
2558
2559 vector<string>
2560 Session::possible_states (string path)
2561 {
2562         vector<string> states;
2563         find_files_matching_filter (states, path, state_file_filter, 0, false, false);
2564
2565         transform(states.begin(), states.end(), states.begin(), remove_end);
2566
2567         sort (states.begin(), states.end());
2568
2569         return states;
2570 }
2571
2572 vector<string>
2573 Session::possible_states () const
2574 {
2575         return possible_states(_path);
2576 }
2577
2578 void
2579 Session::add_route_group (RouteGroup* g)
2580 {
2581         _route_groups.push_back (g);
2582         route_group_added (g); /* EMIT SIGNAL */
2583
2584         g->RouteAdded.connect_same_thread (*this, boost::bind (&Session::route_added_to_route_group, this, _1, _2));
2585         g->RouteRemoved.connect_same_thread (*this, boost::bind (&Session::route_removed_from_route_group, this, _1, _2));
2586         g->PropertyChanged.connect_same_thread (*this, boost::bind (&Session::route_group_property_changed, this, g));
2587
2588         set_dirty ();
2589 }
2590
2591 void
2592 Session::remove_route_group (RouteGroup& rg)
2593 {
2594         list<RouteGroup*>::iterator i;
2595
2596         if ((i = find (_route_groups.begin(), _route_groups.end(), &rg)) != _route_groups.end()) {
2597                 _route_groups.erase (i);
2598                 delete &rg;
2599
2600                 route_group_removed (); /* EMIT SIGNAL */
2601         }
2602 }
2603
2604 /** Set a new order for our route groups, without adding or removing any.
2605  *  @param groups Route group list in the new order.
2606  */
2607 void
2608 Session::reorder_route_groups (list<RouteGroup*> groups)
2609 {
2610         _route_groups = groups;
2611
2612         route_groups_reordered (); /* EMIT SIGNAL */
2613         set_dirty ();
2614 }
2615
2616
2617 RouteGroup *
2618 Session::route_group_by_name (string name)
2619 {
2620         list<RouteGroup *>::iterator i;
2621
2622         for (i = _route_groups.begin(); i != _route_groups.end(); ++i) {
2623                 if ((*i)->name() == name) {
2624                         return* i;
2625                 }
2626         }
2627         return 0;
2628 }
2629
2630 RouteGroup&
2631 Session::all_route_group() const
2632 {
2633         return *_all_route_group;
2634 }
2635
2636 void
2637 Session::add_commands (vector<Command*> const & cmds)
2638 {
2639         for (vector<Command*>::const_iterator i = cmds.begin(); i != cmds.end(); ++i) {
2640                 add_command (*i);
2641         }
2642 }
2643
2644 void
2645 Session::add_command (Command* const cmd)
2646 {
2647         assert (_current_trans);
2648         DEBUG_UNDO_HISTORY (
2649             string_compose ("Current Undo Transaction %1, adding command: %2",
2650                             _current_trans->name (),
2651                             cmd->name ()));
2652         _current_trans->add_command (cmd);
2653 }
2654
2655 PBD::StatefulDiffCommand*
2656 Session::add_stateful_diff_command (boost::shared_ptr<PBD::StatefulDestructible> sfd)
2657 {
2658         PBD::StatefulDiffCommand* cmd = new PBD::StatefulDiffCommand (sfd);
2659         add_command (cmd);
2660         return cmd;
2661 }
2662
2663 void
2664 Session::begin_reversible_command (const string& name)
2665 {
2666         begin_reversible_command (g_quark_from_string (name.c_str ()));
2667 }
2668
2669 /** Begin a reversible command using a GQuark to identify it.
2670  *  begin_reversible_command() and commit_reversible_command() calls may be nested,
2671  *  but there must be as many begin...()s as there are commit...()s.
2672  */
2673 void
2674 Session::begin_reversible_command (GQuark q)
2675 {
2676         /* If nested begin/commit pairs are used, we create just one UndoTransaction
2677            to hold all the commands that are committed.  This keeps the order of
2678            commands correct in the history.
2679         */
2680
2681         if (_current_trans == 0) {
2682                 DEBUG_UNDO_HISTORY (string_compose (
2683                     "Begin Reversible Command, new transaction: %1", g_quark_to_string (q)));
2684
2685                 /* start a new transaction */
2686                 assert (_current_trans_quarks.empty ());
2687                 _current_trans = new UndoTransaction();
2688                 _current_trans->set_name (g_quark_to_string (q));
2689         } else {
2690                 DEBUG_UNDO_HISTORY (
2691                     string_compose ("Begin Reversible Command, current transaction: %1",
2692                                     _current_trans->name ()));
2693         }
2694
2695         _current_trans_quarks.push_front (q);
2696 }
2697
2698 void
2699 Session::abort_reversible_command ()
2700 {
2701         if (_current_trans != 0) {
2702                 DEBUG_UNDO_HISTORY (
2703                     string_compose ("Abort Reversible Command: %1", _current_trans->name ()));
2704                 _current_trans->clear();
2705                 delete _current_trans;
2706                 _current_trans = 0;
2707                 _current_trans_quarks.clear();
2708         }
2709 }
2710
2711 void
2712 Session::commit_reversible_command (Command *cmd)
2713 {
2714         assert (_current_trans);
2715         assert (!_current_trans_quarks.empty ());
2716
2717         struct timeval now;
2718
2719         if (cmd) {
2720                 DEBUG_UNDO_HISTORY (
2721                     string_compose ("Current Undo Transaction %1, adding command: %2",
2722                                     _current_trans->name (),
2723                                     cmd->name ()));
2724                 _current_trans->add_command (cmd);
2725         }
2726
2727         DEBUG_UNDO_HISTORY (
2728             string_compose ("Commit Reversible Command, current transaction: %1",
2729                             _current_trans->name ()));
2730
2731         _current_trans_quarks.pop_front ();
2732
2733         if (!_current_trans_quarks.empty ()) {
2734                 DEBUG_UNDO_HISTORY (
2735                     string_compose ("Commit Reversible Command, transaction is not "
2736                                     "top-level, current transaction: %1",
2737                                     _current_trans->name ()));
2738                 /* the transaction we're committing is not the top-level one */
2739                 return;
2740         }
2741
2742         if (_current_trans->empty()) {
2743                 /* no commands were added to the transaction, so just get rid of it */
2744                 DEBUG_UNDO_HISTORY (
2745                     string_compose ("Commit Reversible Command, No commands were "
2746                                     "added to current transaction: %1",
2747                                     _current_trans->name ()));
2748                 delete _current_trans;
2749                 _current_trans = 0;
2750                 return;
2751         }
2752
2753         gettimeofday (&now, 0);
2754         _current_trans->set_timestamp (now);
2755
2756         _history.add (_current_trans);
2757         _current_trans = 0;
2758 }
2759
2760 static bool
2761 accept_all_audio_files (const string& path, void* /*arg*/)
2762 {
2763         if (!Glib::file_test (path, Glib::FILE_TEST_IS_REGULAR)) {
2764                 return false;
2765         }
2766
2767         if (!AudioFileSource::safe_audio_file_extension (path)) {
2768                 return false;
2769         }
2770
2771         return true;
2772 }
2773
2774 static bool
2775 accept_all_midi_files (const string& path, void* /*arg*/)
2776 {
2777         if (!Glib::file_test (path, Glib::FILE_TEST_IS_REGULAR)) {
2778                 return false;
2779         }
2780
2781         return ((path.length() > 4 && path.find (".mid") != (path.length() - 4)) ||
2782                 (path.length() > 4 && path.find (".smf") != (path.length() - 4)) ||
2783                 (path.length() > 5 && path.find (".midi") != (path.length() - 5)));
2784 }
2785
2786 static bool
2787 accept_all_state_files (const string& path, void* /*arg*/)
2788 {
2789         if (!Glib::file_test (path, Glib::FILE_TEST_IS_REGULAR)) {
2790                 return false;
2791         }
2792
2793         std::string const statefile_ext (statefile_suffix);
2794         if (path.length() >= statefile_ext.length()) {
2795                 return (0 == path.compare (path.length() - statefile_ext.length(), statefile_ext.length(), statefile_ext));
2796         } else {
2797                 return false;
2798         }
2799 }
2800
2801 int
2802 Session::find_all_sources (string path, set<string>& result)
2803 {
2804         XMLTree tree;
2805         XMLNode* node;
2806
2807         if (!tree.read (path)) {
2808                 return -1;
2809         }
2810
2811         if ((node = find_named_node (*tree.root(), "Sources")) == 0) {
2812                 return -2;
2813         }
2814
2815         XMLNodeList nlist;
2816         XMLNodeConstIterator niter;
2817
2818         nlist = node->children();
2819
2820         set_dirty();
2821
2822         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2823
2824                 XMLProperty const * prop;
2825
2826                 if ((prop = (*niter)->property (X_("type"))) == 0) {
2827                         continue;
2828                 }
2829
2830                 DataType type (prop->value());
2831
2832                 if ((prop = (*niter)->property (X_("name"))) == 0) {
2833                         continue;
2834                 }
2835
2836                 if (Glib::path_is_absolute (prop->value())) {
2837                         /* external file, ignore */
2838                         continue;
2839                 }
2840
2841                 string found_path;
2842                 bool is_new;
2843                 uint16_t chan;
2844
2845                 if (FileSource::find (*this, type, prop->value(), true, is_new, chan, found_path)) {
2846                         result.insert (found_path);
2847                 }
2848         }
2849
2850         return 0;
2851 }
2852
2853 int
2854 Session::find_all_sources_across_snapshots (set<string>& result, bool exclude_this_snapshot)
2855 {
2856         vector<string> state_files;
2857         string ripped;
2858         string this_snapshot_path;
2859
2860         result.clear ();
2861
2862         ripped = _path;
2863
2864         if (ripped[ripped.length()-1] == G_DIR_SEPARATOR) {
2865                 ripped = ripped.substr (0, ripped.length() - 1);
2866         }
2867
2868         find_files_matching_filter (state_files, ripped, accept_all_state_files, (void *) 0, true, true);
2869
2870         if (state_files.empty()) {
2871                 /* impossible! */
2872                 return 0;
2873         }
2874
2875         this_snapshot_path = _path;
2876         this_snapshot_path += legalize_for_path (_current_snapshot_name);
2877         this_snapshot_path += statefile_suffix;
2878
2879         for (vector<string>::iterator i = state_files.begin(); i != state_files.end(); ++i) {
2880
2881                 if (exclude_this_snapshot && *i == this_snapshot_path) {
2882                         continue;
2883                 }
2884
2885                 if (find_all_sources (*i, result) < 0) {
2886                         return -1;
2887                 }
2888         }
2889
2890         return 0;
2891 }
2892
2893 struct RegionCounter {
2894     typedef std::map<PBD::ID,boost::shared_ptr<AudioSource> > AudioSourceList;
2895     AudioSourceList::iterator iter;
2896     boost::shared_ptr<Region> region;
2897     uint32_t count;
2898
2899     RegionCounter() : count (0) {}
2900 };
2901
2902 int
2903 Session::ask_about_playlist_deletion (boost::shared_ptr<Playlist> p)
2904 {
2905         boost::optional<int> r = AskAboutPlaylistDeletion (p);
2906         return r.get_value_or (1);
2907 }
2908
2909 void
2910 Session::cleanup_regions ()
2911 {
2912         bool removed = false;
2913         const RegionFactory::RegionMap& regions (RegionFactory::regions());
2914
2915         for (RegionFactory::RegionMap::const_iterator i = regions.begin(); i != regions.end();) {
2916
2917                 uint32_t used = playlists->region_use_count (i->second);
2918
2919                 if (used == 0 && !i->second->automatic ()) {
2920                         boost::weak_ptr<Region> w = i->second;
2921                         ++i;
2922                         removed = true;
2923                         RegionFactory::map_remove (w);
2924                 } else {
2925                         ++i;
2926                 }
2927         }
2928
2929         if (removed) {
2930                 // re-check to remove parent references of compound regions
2931                 for (RegionFactory::RegionMap::const_iterator i = regions.begin(); i != regions.end();) {
2932                         if (!(i->second->whole_file() && i->second->max_source_level() > 0)) {
2933                                 ++i;
2934                                 continue;
2935                         }
2936                         assert(boost::dynamic_pointer_cast<PlaylistSource>(i->second->source (0)) != 0);
2937                         if (0 == playlists->region_use_count (i->second)) {
2938                                 boost::weak_ptr<Region> w = i->second;
2939                                 ++i;
2940                                 RegionFactory::map_remove (w);
2941                         } else {
2942                                 ++i;
2943                         }
2944                 }
2945         }
2946
2947         /* dump the history list */
2948         _history.clear ();
2949
2950         save_state ("");
2951 }
2952
2953 bool
2954 Session::can_cleanup_peakfiles () const
2955 {
2956         if (deletion_in_progress()) {
2957                 return false;
2958         }
2959         if (!_writable || (_state_of_the_state & CannotSave)) {
2960                 warning << _("Cannot cleanup peak-files for read-only session.") << endmsg;
2961                 return false;
2962         }
2963         if (record_status() == Recording) {
2964                 error << _("Cannot cleanup peak-files while recording") << endmsg;
2965                 return false;
2966         }
2967         return true;
2968 }
2969
2970 int
2971 Session::cleanup_peakfiles ()
2972 {
2973         Glib::Threads::Mutex::Lock lm (peak_cleanup_lock, Glib::Threads::TRY_LOCK);
2974         if (!lm.locked()) {
2975                 return -1;
2976         }
2977
2978         assert (can_cleanup_peakfiles ());
2979         assert (!peaks_cleanup_in_progres());
2980
2981         _state_of_the_state = StateOfTheState (_state_of_the_state | PeakCleanup);
2982
2983         int timeout = 5000; // 5 seconds
2984         while (!SourceFactory::files_with_peaks.empty()) {
2985                 Glib::usleep (1000);
2986                 if (--timeout < 0) {
2987                         warning << _("Timeout waiting for peak-file creation to terminate before cleanup, please try again later.") << endmsg;
2988                         _state_of_the_state = StateOfTheState (_state_of_the_state & (~PeakCleanup));
2989                         return -1;
2990                 }
2991         }
2992
2993         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
2994                 boost::shared_ptr<AudioSource> as;
2995                 if ((as = boost::dynamic_pointer_cast<AudioSource> (i->second)) != 0) {
2996                         as->close_peakfile();
2997                 }
2998         }
2999
3000         PBD::clear_directory (session_directory().peak_path());
3001
3002         _state_of_the_state = StateOfTheState (_state_of_the_state & (~PeakCleanup));
3003
3004         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
3005                 boost::shared_ptr<AudioSource> as;
3006                 if ((as = boost::dynamic_pointer_cast<AudioSource> (i->second)) != 0) {
3007                         SourceFactory::setup_peakfile(as, true);
3008                 }
3009         }
3010         return 0;
3011 }
3012
3013 int
3014 Session::cleanup_sources (CleanupReport& rep)
3015 {
3016         // FIXME: needs adaptation to midi
3017
3018         vector<boost::shared_ptr<Source> > dead_sources;
3019         string audio_path;
3020         string midi_path;
3021         vector<string> candidates;
3022         vector<string> unused;
3023         set<string> all_sources;
3024         bool used;
3025         string spath;
3026         int ret = -1;
3027         string tmppath1;
3028         string tmppath2;
3029         Searchpath asp;
3030         Searchpath msp;
3031
3032         _state_of_the_state = (StateOfTheState) (_state_of_the_state | InCleanup);
3033
3034         /* this is mostly for windows which doesn't allow file
3035          * renaming if the file is in use. But we don't special
3036          * case it because we need to know if this causes
3037          * problems, and the easiest way to notice that is to
3038          * keep it in place for all platforms.
3039          */
3040
3041         request_stop (false);
3042         _butler->summon ();
3043         _butler->wait_until_finished ();
3044
3045         /* consider deleting all unused playlists */
3046
3047         if (playlists->maybe_delete_unused (boost::bind (Session::ask_about_playlist_deletion, _1))) {
3048                 ret = 0;
3049                 goto out;
3050         }
3051
3052         /* sync the "all regions" property of each playlist with its current state
3053          */
3054
3055         playlists->sync_all_regions_with_regions ();
3056
3057         /* find all un-used sources */
3058
3059         rep.paths.clear ();
3060         rep.space = 0;
3061
3062         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ) {
3063
3064                 SourceMap::iterator tmp;
3065
3066                 tmp = i;
3067                 ++tmp;
3068
3069                 /* do not bother with files that are zero size, otherwise we remove the current "nascent"
3070                    capture files.
3071                 */
3072
3073                 if (!i->second->used() && (i->second->length(i->second->timeline_position() > 0))) {
3074                         dead_sources.push_back (i->second);
3075                         i->second->drop_references ();
3076                 }
3077
3078                 i = tmp;
3079         }
3080
3081         /* build a list of all the possible audio directories for the session */
3082
3083         for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3084                 SessionDirectory sdir ((*i).path);
3085                 asp += sdir.sound_path();
3086         }
3087         audio_path += asp.to_string();
3088
3089
3090         /* build a list of all the possible midi directories for the session */
3091
3092         for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3093                 SessionDirectory sdir ((*i).path);
3094                 msp += sdir.midi_path();
3095         }
3096         midi_path += msp.to_string();
3097
3098         find_files_matching_filter (candidates, audio_path, accept_all_audio_files, (void *) 0, true, true);
3099         find_files_matching_filter (candidates, midi_path, accept_all_midi_files, (void *) 0, true, true);
3100
3101         /* find all sources, but don't use this snapshot because the
3102            state file on disk still references sources we may have already
3103            dropped.
3104         */
3105
3106         find_all_sources_across_snapshots (all_sources, true);
3107
3108         /*  add our current source list
3109          */
3110
3111         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ) {
3112                 boost::shared_ptr<FileSource> fs;
3113                 SourceMap::iterator tmp = i;
3114                 ++tmp;
3115
3116                 if ((fs = boost::dynamic_pointer_cast<FileSource> (i->second)) != 0) {
3117
3118                         /* this is mostly for windows which doesn't allow file
3119                          * renaming if the file is in use. But we don't special
3120                          * case it because we need to know if this causes
3121                          * problems, and the easiest way to notice that is to
3122                          * keep it in place for all platforms.
3123                          */
3124
3125                         fs->close ();
3126
3127                         if (!fs->is_stub()) {
3128
3129                                 if (playlists->source_use_count (fs) != 0) {
3130                                         all_sources.insert (fs->path());
3131                                 } else {
3132
3133                                         /* we might not remove this source from disk, because it may be used
3134                                            by other snapshots, but its not being used in this version
3135                                            so lets get rid of it now, along with any representative regions
3136                                            in the region list.
3137                                         */
3138
3139                                         RegionFactory::remove_regions_using_source (i->second);
3140
3141                                         // also remove source from all_sources
3142
3143                                         for (set<string>::iterator j = all_sources.begin(); j != all_sources.end(); ++j) {
3144                                                 spath = Glib::path_get_basename (*j);
3145                                                 if (spath == i->second->name()) {
3146                                                         all_sources.erase (j);
3147                                                         break;
3148                                                 }
3149                                         }
3150
3151                                         sources.erase (i);
3152                                 }
3153                         }
3154                 }
3155
3156                 i = tmp;
3157         }
3158
3159         for (vector<string>::iterator x = candidates.begin(); x != candidates.end(); ++x) {
3160
3161                 used = false;
3162                 spath = *x;
3163
3164                 for (set<string>::iterator i = all_sources.begin(); i != all_sources.end(); ++i) {
3165
3166                         tmppath1 = canonical_path (spath);
3167                         tmppath2 = canonical_path ((*i));
3168
3169                         if (tmppath1 == tmppath2) {
3170                                 used = true;
3171                                 break;
3172                         }
3173                 }
3174
3175                 if (!used) {
3176                         unused.push_back (spath);
3177                 }
3178         }
3179
3180         /* now try to move all unused files into the "dead" directory(ies) */
3181
3182         for (vector<string>::iterator x = unused.begin(); x != unused.end(); ++x) {
3183                 GStatBuf statbuf;
3184
3185                 string newpath;
3186
3187                 /* don't move the file across filesystems, just
3188                    stick it in the `dead_dir_name' directory
3189                    on whichever filesystem it was already on.
3190                 */
3191
3192                 if ((*x).find ("/sounds/") != string::npos) {
3193
3194                         /* old school, go up 1 level */
3195
3196                         newpath = Glib::path_get_dirname (*x);      // "sounds"
3197                         newpath = Glib::path_get_dirname (newpath); // "session-name"
3198
3199                 } else {
3200
3201                         /* new school, go up 4 levels */
3202
3203                         newpath = Glib::path_get_dirname (*x);      // "audiofiles" or "midifiles"
3204                         newpath = Glib::path_get_dirname (newpath); // "session-name"
3205                         newpath = Glib::path_get_dirname (newpath); // "interchange"
3206                         newpath = Glib::path_get_dirname (newpath); // "session-dir"
3207                 }
3208
3209                 newpath = Glib::build_filename (newpath, dead_dir_name);
3210
3211                 if (g_mkdir_with_parents (newpath.c_str(), 0755) < 0) {
3212                         error << string_compose(_("Session: cannot create dead file folder \"%1\" (%2)"), newpath, strerror (errno)) << endmsg;
3213                         return -1;
3214                 }
3215
3216                 newpath = Glib::build_filename (newpath, Glib::path_get_basename ((*x)));
3217
3218                 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
3219
3220                         /* the new path already exists, try versioning */
3221
3222                         char buf[PATH_MAX+1];
3223                         int version = 1;
3224                         string newpath_v;
3225
3226                         snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), version);
3227                         newpath_v = buf;
3228
3229                         while (Glib::file_test (newpath_v.c_str(), Glib::FILE_TEST_EXISTS) && version < 999) {
3230                                 snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), ++version);
3231                                 newpath_v = buf;
3232                         }
3233
3234                         if (version == 999) {
3235                                 error << string_compose (_("there are already 1000 files with names like %1; versioning discontinued"),
3236                                                   newpath)
3237                                       << endmsg;
3238                         } else {
3239                                 newpath = newpath_v;
3240                         }
3241
3242                 } else {
3243
3244                         /* it doesn't exist, or we can't read it or something */
3245
3246                 }
3247
3248                 g_stat ((*x).c_str(), &statbuf);
3249
3250                 if (::rename ((*x).c_str(), newpath.c_str()) != 0) {
3251                         error << string_compose (_("cannot rename unused file source from %1 to %2 (%3)"),
3252                                           (*x), newpath, strerror (errno))
3253                               << endmsg;
3254                         goto out;
3255                 }
3256
3257                 /* see if there an easy to find peakfile for this file, and remove it.
3258                  */
3259
3260                 string base = Glib::path_get_basename (*x);
3261                 base += "%A"; /* this is what we add for the channel suffix of all native files,
3262                                  or for the first channel of embedded files. it will miss
3263                                  some peakfiles for other channels
3264                               */
3265                 string peakpath = construct_peak_filepath (base);
3266
3267                 if (Glib::file_test (peakpath.c_str(), Glib::FILE_TEST_EXISTS)) {
3268                         if (::g_unlink (peakpath.c_str()) != 0) {
3269                                 error << string_compose (_("cannot remove peakfile %1 for %2 (%3)"),
3270                                                          peakpath, _path, strerror (errno))
3271                                       << endmsg;
3272                                 /* try to back out */
3273                                 ::rename (newpath.c_str(), _path.c_str());
3274                                 goto out;
3275                         }
3276                 }
3277
3278                 rep.paths.push_back (*x);
3279                 rep.space += statbuf.st_size;
3280         }
3281
3282         /* dump the history list */
3283
3284         _history.clear ();
3285
3286         /* save state so we don't end up a session file
3287            referring to non-existent sources.
3288         */
3289
3290         save_state ("");
3291         ret = 0;
3292
3293   out:
3294         _state_of_the_state = (StateOfTheState) (_state_of_the_state & ~InCleanup);
3295
3296         return ret;
3297 }
3298
3299 int
3300 Session::cleanup_trash_sources (CleanupReport& rep)
3301 {
3302         // FIXME: needs adaptation for MIDI
3303
3304         vector<space_and_path>::iterator i;
3305         string dead_dir;
3306
3307         rep.paths.clear ();
3308         rep.space = 0;
3309
3310         for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3311
3312                 dead_dir = Glib::build_filename ((*i).path, dead_dir_name);
3313
3314                 clear_directory (dead_dir, &rep.space, &rep.paths);
3315         }
3316
3317         return 0;
3318 }
3319
3320 void
3321 Session::set_dirty ()
3322 {
3323         /* never mark session dirty during loading */
3324
3325         if (_state_of_the_state & Loading) {
3326                 return;
3327         }
3328
3329         bool was_dirty = dirty();
3330
3331         _state_of_the_state = StateOfTheState (_state_of_the_state | Dirty);
3332
3333
3334         if (!was_dirty) {
3335                 DirtyChanged(); /* EMIT SIGNAL */
3336         }
3337 }
3338
3339
3340 void
3341 Session::set_clean ()
3342 {
3343         bool was_dirty = dirty();
3344
3345         _state_of_the_state = Clean;
3346
3347
3348         if (was_dirty) {
3349                 DirtyChanged(); /* EMIT SIGNAL */
3350         }
3351 }
3352
3353 void
3354 Session::set_deletion_in_progress ()
3355 {
3356         _state_of_the_state = StateOfTheState (_state_of_the_state | Deletion);
3357 }
3358
3359 void
3360 Session::clear_deletion_in_progress ()
3361 {
3362         _state_of_the_state = StateOfTheState (_state_of_the_state & (~Deletion));
3363 }
3364
3365 void
3366 Session::add_controllable (boost::shared_ptr<Controllable> c)
3367 {
3368         /* this adds a controllable to the list managed by the Session.
3369            this is a subset of those managed by the Controllable class
3370            itself, and represents the only ones whose state will be saved
3371            as part of the session.
3372         */
3373
3374         Glib::Threads::Mutex::Lock lm (controllables_lock);
3375         controllables.insert (c);
3376 }
3377
3378 struct null_deleter { void operator()(void const *) const {} };
3379
3380 void
3381 Session::remove_controllable (Controllable* c)
3382 {
3383         if (_state_of_the_state & Deletion) {
3384                 return;
3385         }
3386
3387         Glib::Threads::Mutex::Lock lm (controllables_lock);
3388
3389         Controllables::iterator x = controllables.find (boost::shared_ptr<Controllable>(c, null_deleter()));
3390
3391         if (x != controllables.end()) {
3392                 controllables.erase (x);
3393         }
3394 }
3395
3396 boost::shared_ptr<Controllable>
3397 Session::controllable_by_id (const PBD::ID& id)
3398 {
3399         Glib::Threads::Mutex::Lock lm (controllables_lock);
3400
3401         for (Controllables::iterator i = controllables.begin(); i != controllables.end(); ++i) {
3402                 if ((*i)->id() == id) {
3403                         return *i;
3404                 }
3405         }
3406
3407         return boost::shared_ptr<Controllable>();
3408 }
3409
3410 boost::shared_ptr<Controllable>
3411 Session::controllable_by_descriptor (const ControllableDescriptor& desc)
3412 {
3413         boost::shared_ptr<Controllable> c;
3414         boost::shared_ptr<Stripable> s;
3415         boost::shared_ptr<Route> r;
3416
3417         switch (desc.top_level_type()) {
3418         case ControllableDescriptor::NamedRoute:
3419         {
3420                 std::string str = desc.top_level_name();
3421
3422                 if (str == "Master" || str == "master") {
3423                         s = _master_out;
3424                 } else if (str == "control" || str == "listen" || str == "monitor" || str == "Monitor") {
3425                         s = _monitor_out;
3426                 } else if (str == "auditioner") {
3427                         s = auditioner;
3428                 } else {
3429                         s = route_by_name (desc.top_level_name());
3430                 }
3431
3432                 break;
3433         }
3434
3435         case ControllableDescriptor::PresentationOrderRoute:
3436                 s = get_remote_nth_stripable (desc.presentation_order(), PresentationInfo::Route);
3437                 break;
3438
3439         case ControllableDescriptor::PresentationOrderTrack:
3440                 s = get_remote_nth_stripable (desc.presentation_order(), PresentationInfo::Track);
3441                 break;
3442
3443         case ControllableDescriptor::PresentationOrderBus:
3444                 s = get_remote_nth_stripable (desc.presentation_order(), PresentationInfo::Bus);
3445                 break;
3446
3447         case ControllableDescriptor::PresentationOrderVCA:
3448                 s = get_remote_nth_stripable (desc.presentation_order(), PresentationInfo::VCA);
3449                 break;
3450
3451         case ControllableDescriptor::SelectionCount:
3452                 s = route_by_selected_count (desc.selection_id());
3453                 break;
3454         }
3455
3456         if (!s) {
3457                 return c;
3458         }
3459
3460         r = boost::dynamic_pointer_cast<Route> (s);
3461
3462         switch (desc.subtype()) {
3463         case ControllableDescriptor::Gain:
3464                 c = s->gain_control ();
3465                 break;
3466
3467         case ControllableDescriptor::Trim:
3468                 c = s->trim_control ();
3469                 break;
3470
3471         case ControllableDescriptor::Solo:
3472                 c = s->solo_control();
3473                 break;
3474
3475         case ControllableDescriptor::Mute:
3476                 c = s->mute_control();
3477                 break;
3478
3479         case ControllableDescriptor::Recenable:
3480                 c = s->rec_enable_control ();
3481                 break;
3482
3483         case ControllableDescriptor::PanDirection:
3484                 c = s->pan_azimuth_control();
3485                 break;
3486
3487         case ControllableDescriptor::PanWidth:
3488                 c = s->pan_width_control();
3489                 break;
3490
3491         case ControllableDescriptor::PanElevation:
3492                 c = s->pan_elevation_control();
3493                 break;
3494
3495         case ControllableDescriptor::Balance:
3496                 /* XXX simple pan control */
3497                 break;
3498
3499         case ControllableDescriptor::PluginParameter:
3500         {
3501                 uint32_t plugin = desc.target (0);
3502                 uint32_t parameter_index = desc.target (1);
3503
3504                 /* revert to zero based counting */
3505
3506                 if (plugin > 0) {
3507                         --plugin;
3508                 }
3509
3510                 if (parameter_index > 0) {
3511                         --parameter_index;
3512                 }
3513
3514                 if (!r) {
3515                         return c;
3516                 }
3517
3518                 boost::shared_ptr<Processor> p = r->nth_plugin (plugin);
3519
3520                 if (p) {
3521                         c = boost::dynamic_pointer_cast<ARDOUR::AutomationControl>(
3522                                 p->control(Evoral::Parameter(PluginAutomation, 0, parameter_index)));
3523                 }
3524                 break;
3525         }
3526
3527         case ControllableDescriptor::SendGain: {
3528                 uint32_t send = desc.target (0);
3529                 if (send > 0) {
3530                         --send;
3531                 }
3532                 if (!r) {
3533                         return c;
3534                 }
3535                 c = r->send_level_controllable (send);
3536                 break;
3537         }
3538
3539         default:
3540                 /* relax and return a null pointer */
3541                 break;
3542         }
3543
3544         return c;
3545 }
3546
3547 void
3548 Session::add_instant_xml (XMLNode& node, bool write_to_config)
3549 {
3550         if (_writable) {
3551                 Stateful::add_instant_xml (node, _path);
3552         }
3553
3554         if (write_to_config) {
3555                 Config->add_instant_xml (node);
3556         }
3557 }
3558
3559 XMLNode*
3560 Session::instant_xml (const string& node_name)
3561 {
3562         return Stateful::instant_xml (node_name, _path);
3563 }
3564
3565 int
3566 Session::save_history (string snapshot_name)
3567 {
3568         XMLTree tree;
3569
3570         if (!_writable) {
3571                 return 0;
3572         }
3573
3574         if (!Config->get_save_history() || Config->get_saved_history_depth() < 0 ||
3575             (_history.undo_depth() == 0 && _history.redo_depth() == 0)) {
3576                 return 0;
3577         }
3578
3579         if (snapshot_name.empty()) {
3580                 snapshot_name = _current_snapshot_name;
3581         }
3582
3583         const string history_filename = legalize_for_path (snapshot_name) + history_suffix;
3584         const string backup_filename = history_filename + backup_suffix;
3585         const std::string xml_path(Glib::build_filename (_session_dir->root_path(), history_filename));
3586         const std::string backup_path(Glib::build_filename (_session_dir->root_path(), backup_filename));
3587
3588         if (Glib::file_test (xml_path, Glib::FILE_TEST_EXISTS)) {
3589                 if (::g_rename (xml_path.c_str(), backup_path.c_str()) != 0) {
3590                         error << _("could not backup old history file, current history not saved") << endmsg;
3591                         return -1;
3592                 }
3593         }
3594
3595         tree.set_root (&_history.get_state (Config->get_saved_history_depth()));
3596
3597         if (!tree.write (xml_path))
3598         {
3599                 error << string_compose (_("history could not be saved to %1"), xml_path) << endmsg;
3600
3601                 if (g_remove (xml_path.c_str()) != 0) {
3602                         error << string_compose(_("Could not remove history file at path \"%1\" (%2)"),
3603                                         xml_path, g_strerror (errno)) << endmsg;
3604                 }
3605                 if (::g_rename (backup_path.c_str(), xml_path.c_str()) != 0) {
3606                         error << string_compose (_("could not restore history file from backup %1 (%2)"),
3607                                         backup_path, g_strerror (errno)) << endmsg;
3608                 }
3609
3610                 return -1;
3611         }
3612
3613         return 0;
3614 }
3615
3616 int
3617 Session::restore_history (string snapshot_name)
3618 {
3619         XMLTree tree;
3620
3621         if (snapshot_name.empty()) {
3622                 snapshot_name = _current_snapshot_name;
3623         }
3624
3625         const std::string xml_filename = legalize_for_path (snapshot_name) + history_suffix;
3626         const std::string xml_path(Glib::build_filename (_session_dir->root_path(), xml_filename));
3627
3628         info << "Loading history from " << xml_path << endmsg;
3629
3630         if (!Glib::file_test (xml_path, Glib::FILE_TEST_EXISTS)) {
3631                 info << string_compose (_("%1: no history file \"%2\" for this session."),
3632                                 _name, xml_path) << endmsg;
3633                 return 1;
3634         }
3635
3636         if (!tree.read (xml_path)) {
3637                 error << string_compose (_("Could not understand session history file \"%1\""),
3638                                 xml_path) << endmsg;
3639                 return -1;
3640         }
3641
3642         // replace history
3643         _history.clear();
3644
3645         for (XMLNodeConstIterator it  = tree.root()->children().begin(); it != tree.root()->children().end(); it++) {
3646
3647                 XMLNode *t = *it;
3648                 UndoTransaction* ut = new UndoTransaction ();
3649                 struct timeval tv;
3650
3651                 ut->set_name(t->property("name")->value());
3652                 stringstream ss(t->property("tv-sec")->value());
3653                 ss >> tv.tv_sec;
3654                 ss.str(t->property("tv-usec")->value());
3655                 ss >> tv.tv_usec;
3656                 ut->set_timestamp(tv);
3657
3658                 for (XMLNodeConstIterator child_it  = t->children().begin();
3659                                 child_it != t->children().end(); child_it++)
3660                 {
3661                         XMLNode *n = *child_it;
3662                         Command *c;
3663
3664                         if (n->name() == "MementoCommand" ||
3665                                         n->name() == "MementoUndoCommand" ||
3666                                         n->name() == "MementoRedoCommand") {
3667
3668                                 if ((c = memento_command_factory(n))) {
3669                                         ut->add_command(c);
3670                                 }
3671
3672                         } else if (n->name() == "NoteDiffCommand") {
3673                                 PBD::ID id (n->property("midi-source")->value());
3674                                 boost::shared_ptr<MidiSource> midi_source =
3675                                         boost::dynamic_pointer_cast<MidiSource, Source>(source_by_id(id));
3676                                 if (midi_source) {
3677                                         ut->add_command (new MidiModel::NoteDiffCommand(midi_source->model(), *n));
3678                                 } else {
3679                                         error << _("Failed to downcast MidiSource for NoteDiffCommand") << endmsg;
3680                                 }
3681
3682                         } else if (n->name() == "SysExDiffCommand") {
3683
3684                                 PBD::ID id (n->property("midi-source")->value());
3685                                 boost::shared_ptr<MidiSource> midi_source =
3686                                         boost::dynamic_pointer_cast<MidiSource, Source>(source_by_id(id));
3687                                 if (midi_source) {
3688                                         ut->add_command (new MidiModel::SysExDiffCommand (midi_source->model(), *n));
3689                                 } else {
3690                                         error << _("Failed to downcast MidiSource for SysExDiffCommand") << endmsg;
3691                                 }
3692
3693                         } else if (n->name() == "PatchChangeDiffCommand") {
3694
3695                                 PBD::ID id (n->property("midi-source")->value());
3696                                 boost::shared_ptr<MidiSource> midi_source =
3697                                         boost::dynamic_pointer_cast<MidiSource, Source>(source_by_id(id));
3698                                 if (midi_source) {
3699                                         ut->add_command (new MidiModel::PatchChangeDiffCommand (midi_source->model(), *n));
3700                                 } else {
3701                                         error << _("Failed to downcast MidiSource for PatchChangeDiffCommand") << endmsg;
3702                                 }
3703
3704                         } else if (n->name() == "StatefulDiffCommand") {
3705                                 if ((c = stateful_diff_command_factory (n))) {
3706                                         ut->add_command (c);
3707                                 }
3708                         } else {
3709                                 error << string_compose(_("Couldn't figure out how to make a Command out of a %1 XMLNode."), n->name()) << endmsg;
3710                         }
3711                 }
3712
3713                 _history.add (ut);
3714         }
3715
3716         return 0;
3717 }
3718
3719 void
3720 Session::config_changed (std::string p, bool ours)
3721 {
3722         if (ours) {
3723                 set_dirty ();
3724         }
3725
3726         if (p == "seamless-loop") {
3727
3728         } else if (p == "rf-speed") {
3729
3730         } else if (p == "auto-loop") {
3731
3732         } else if (p == "auto-input") {
3733
3734                 if (Config->get_monitoring_model() == HardwareMonitoring && transport_rolling()) {
3735                         /* auto-input only makes a difference if we're rolling */
3736                         set_track_monitor_input_status (!config.get_auto_input());
3737                 }
3738
3739         } else if (p == "punch-in") {
3740
3741                 Location* location;
3742
3743                 if ((location = _locations->auto_punch_location()) != 0) {
3744
3745                         if (config.get_punch_in ()) {
3746                                 replace_event (SessionEvent::PunchIn, location->start());
3747                         } else {
3748                                 remove_event (location->start(), SessionEvent::PunchIn);
3749                         }
3750                 }
3751
3752         } else if (p == "punch-out") {
3753
3754                 Location* location;
3755
3756                 if ((location = _locations->auto_punch_location()) != 0) {
3757
3758                         if (config.get_punch_out()) {
3759                                 replace_event (SessionEvent::PunchOut, location->end());
3760                         } else {
3761                                 clear_events (SessionEvent::PunchOut);
3762                         }
3763                 }
3764
3765         } else if (p == "edit-mode") {
3766
3767                 Glib::Threads::Mutex::Lock lm (playlists->lock);
3768
3769                 for (SessionPlaylists::List::iterator i = playlists->playlists.begin(); i != playlists->playlists.end(); ++i) {
3770                         (*i)->set_edit_mode (Config->get_edit_mode ());
3771                 }
3772
3773         } else if (p == "use-video-sync") {
3774
3775                 waiting_for_sync_offset = config.get_use_video_sync();
3776
3777         } else if (p == "mmc-control") {
3778
3779                 //poke_midi_thread ();
3780
3781         } else if (p == "mmc-device-id" || p == "mmc-receive-id" || p == "mmc-receive-device-id") {
3782
3783                 _mmc->set_receive_device_id (Config->get_mmc_receive_device_id());
3784
3785         } else if (p == "mmc-send-id" || p == "mmc-send-device-id") {
3786
3787                 _mmc->set_send_device_id (Config->get_mmc_send_device_id());
3788
3789         } else if (p == "midi-control") {
3790
3791                 //poke_midi_thread ();
3792
3793         } else if (p == "raid-path") {
3794
3795                 setup_raid_path (config.get_raid_path());
3796
3797         } else if (p == "timecode-format") {
3798
3799                 sync_time_vars ();
3800
3801         } else if (p == "video-pullup") {
3802
3803                 sync_time_vars ();
3804
3805         } else if (p == "seamless-loop") {
3806
3807                 if (play_loop && transport_rolling()) {
3808                         // to reset diskstreams etc
3809                         request_play_loop (true);
3810                 }
3811
3812         } else if (p == "rf-speed") {
3813
3814                 cumulative_rf_motion = 0;
3815                 reset_rf_scale (0);
3816
3817         } else if (p == "click-sound") {
3818
3819                 setup_click_sounds (1);
3820
3821         } else if (p == "click-emphasis-sound") {
3822
3823                 setup_click_sounds (-1);
3824
3825         } else if (p == "clicking") {
3826
3827                 if (Config->get_clicking()) {
3828                         if (_click_io && click_data) { // don't require emphasis data
3829                                 _clicking = true;
3830                         }
3831                 } else {
3832                         _clicking = false;
3833                 }
3834
3835         } else if (p == "click-gain") {
3836
3837                 if (_click_gain) {
3838                         _click_gain->gain_control()->set_value (Config->get_click_gain(), Controllable::NoGroup);
3839                 }
3840
3841         } else if (p == "send-mtc") {
3842
3843                 if (Config->get_send_mtc ()) {
3844                         /* mark us ready to send */
3845                         next_quarter_frame_to_send = 0;
3846                 }
3847
3848         } else if (p == "send-mmc") {
3849
3850                 _mmc->enable_send (Config->get_send_mmc ());
3851
3852         } else if (p == "midi-feedback") {
3853
3854                 session_midi_feedback = Config->get_midi_feedback();
3855
3856         } else if (p == "jack-time-master") {
3857
3858                 engine().reset_timebase ();
3859
3860         } else if (p == "native-file-header-format") {
3861
3862                 if (!first_file_header_format_reset) {
3863                         reset_native_file_format ();
3864                 }
3865
3866                 first_file_header_format_reset = false;
3867
3868         } else if (p == "native-file-data-format") {
3869
3870                 if (!first_file_data_format_reset) {
3871                         reset_native_file_format ();
3872                 }
3873
3874                 first_file_data_format_reset = false;
3875
3876         } else if (p == "external-sync") {
3877                 if (!config.get_external_sync()) {
3878                         drop_sync_source ();
3879                 } else {
3880                         switch_to_sync_source (Config->get_sync_source());
3881                 }
3882         }  else if (p == "denormal-model") {
3883                 setup_fpu ();
3884         } else if (p == "history-depth") {
3885                 set_history_depth (Config->get_history_depth());
3886         } else if (p == "remote-model") {
3887                 /* XXX DO SOMETHING HERE TO TELL THE GUI THAT WE NEED
3888                    TO SET REMOTE ID'S
3889                 */
3890         } else if (p == "initial-program-change") {
3891
3892                 if (_mmc->output_port() && Config->get_initial_program_change() >= 0) {
3893                         MIDI::byte buf[2];
3894
3895                         buf[0] = MIDI::program; // channel zero by default
3896                         buf[1] = (Config->get_initial_program_change() & 0x7f);
3897
3898                         _mmc->output_port()->midimsg (buf, sizeof (buf), 0);
3899                 }
3900         } else if (p == "solo-mute-override") {
3901                 // catch_up_on_solo_mute_override ();
3902         } else if (p == "listen-position" || p == "pfl-position") {
3903                 listen_position_changed ();
3904         } else if (p == "solo-control-is-listen-control") {
3905                 solo_control_mode_changed ();
3906         } else if (p == "solo-mute-gain") {
3907                 _solo_cut_control->Changed (true, Controllable::NoGroup);
3908         } else if (p == "timecode-offset" || p == "timecode-offset-negative") {
3909                 last_timecode_valid = false;
3910         } else if (p == "playback-buffer-seconds") {
3911                 AudioSource::allocate_working_buffers (frame_rate());
3912         } else if (p == "ltc-source-port") {
3913                 reconnect_ltc_input ();
3914         } else if (p == "ltc-sink-port") {
3915                 reconnect_ltc_output ();
3916         } else if (p == "timecode-generator-offset") {
3917                 ltc_tx_parse_offset();
3918         } else if (p == "auto-return-target-list") {
3919                 follow_playhead_priority ();
3920         }
3921
3922         set_dirty ();
3923 }
3924
3925 void
3926 Session::set_history_depth (uint32_t d)
3927 {
3928         _history.set_depth (d);
3929 }
3930
3931 int
3932 Session::load_diskstreams_2X (XMLNode const & node, int)
3933 {
3934         XMLNodeList          clist;
3935         XMLNodeConstIterator citer;
3936
3937         clist = node.children();
3938
3939         for (citer = clist.begin(); citer != clist.end(); ++citer) {
3940
3941                 try {
3942                         /* diskstreams added automatically by DiskstreamCreated handler */
3943                         if ((*citer)->name() == "AudioDiskstream" || (*citer)->name() == "DiskStream") {
3944                                 boost::shared_ptr<AudioDiskstream> dsp (new AudioDiskstream (*this, **citer));
3945                                 _diskstreams_2X.push_back (dsp);
3946                         } else {
3947                                 error << _("Session: unknown diskstream type in XML") << endmsg;
3948                         }
3949                 }
3950
3951                 catch (failed_constructor& err) {
3952                         error << _("Session: could not load diskstream via XML state") << endmsg;
3953                         return -1;
3954                 }
3955         }
3956
3957         return 0;
3958 }
3959
3960 /** Connect things to the MMC object */
3961 void
3962 Session::setup_midi_machine_control ()
3963 {
3964         _mmc = new MIDI::MachineControl;
3965
3966         boost::shared_ptr<AsyncMIDIPort> async_in = boost::dynamic_pointer_cast<AsyncMIDIPort> (_midi_ports->mmc_input_port());
3967         boost::shared_ptr<AsyncMIDIPort> async_out = boost::dynamic_pointer_cast<AsyncMIDIPort> (_midi_ports->mmc_output_port());
3968
3969         if (!async_out || !async_out) {
3970                 return;
3971         }
3972
3973         /* XXXX argh, passing raw pointers back into libmidi++ */
3974
3975         MIDI::Port* mmc_in = async_in.get();
3976         MIDI::Port* mmc_out = async_out.get();
3977
3978         _mmc->set_ports (mmc_in, mmc_out);
3979
3980         _mmc->Play.connect_same_thread (*this, boost::bind (&Session::mmc_deferred_play, this, _1));
3981         _mmc->DeferredPlay.connect_same_thread (*this, boost::bind (&Session::mmc_deferred_play, this, _1));
3982         _mmc->Stop.connect_same_thread (*this, boost::bind (&Session::mmc_stop, this, _1));
3983         _mmc->FastForward.connect_same_thread (*this, boost::bind (&Session::mmc_fast_forward, this, _1));
3984         _mmc->Rewind.connect_same_thread (*this, boost::bind (&Session::mmc_rewind, this, _1));
3985         _mmc->Pause.connect_same_thread (*this, boost::bind (&Session::mmc_pause, this, _1));
3986         _mmc->RecordPause.connect_same_thread (*this, boost::bind (&Session::mmc_record_pause, this, _1));
3987         _mmc->RecordStrobe.connect_same_thread (*this, boost::bind (&Session::mmc_record_strobe, this, _1));
3988         _mmc->RecordExit.connect_same_thread (*this, boost::bind (&Session::mmc_record_exit, this, _1));
3989         _mmc->Locate.connect_same_thread (*this, boost::bind (&Session::mmc_locate, this, _1, _2));
3990         _mmc->Step.connect_same_thread (*this, boost::bind (&Session::mmc_step, this, _1, _2));
3991         _mmc->Shuttle.connect_same_thread (*this, boost::bind (&Session::mmc_shuttle, this, _1, _2, _3));
3992         _mmc->TrackRecordStatusChange.connect_same_thread (*this, boost::bind (&Session::mmc_record_enable, this, _1, _2, _3));
3993
3994         /* also handle MIDI SPP because its so common */
3995
3996         _mmc->SPPStart.connect_same_thread (*this, boost::bind (&Session::spp_start, this));
3997         _mmc->SPPContinue.connect_same_thread (*this, boost::bind (&Session::spp_continue, this));
3998         _mmc->SPPStop.connect_same_thread (*this, boost::bind (&Session::spp_stop, this));
3999 }
4000
4001 boost::shared_ptr<Controllable>
4002 Session::solo_cut_control() const
4003 {
4004         /* the solo cut control is a bit of an anomaly, at least as of Febrary 2011. There are no other
4005            controls in Ardour that currently get presented to the user in the GUI that require
4006            access as a Controllable and are also NOT owned by some SessionObject (e.g. Route, or MonitorProcessor).
4007
4008            its actually an RCConfiguration parameter, so we use a ProxyControllable to wrap
4009            it up as a Controllable. Changes to the Controllable will just map back to the RCConfiguration
4010            parameter.
4011         */
4012
4013         return _solo_cut_control;
4014 }
4015
4016 void
4017 Session::save_snapshot_name (const std::string & n)
4018 {
4019         /* assure Stateful::_instant_xml is loaded
4020          * add_instant_xml() only adds to existing data and defaults
4021          * to use an empty Tree otherwise
4022          */
4023         instant_xml ("LastUsedSnapshot");
4024
4025         XMLNode* last_used_snapshot = new XMLNode ("LastUsedSnapshot");
4026         last_used_snapshot->add_property ("name", string(n));
4027         add_instant_xml (*last_used_snapshot, false);
4028 }
4029
4030 void
4031 Session::set_snapshot_name (const std::string & n)
4032 {
4033         _current_snapshot_name = n;
4034         save_snapshot_name (n);
4035 }
4036
4037 int
4038 Session::rename (const std::string& new_name)
4039 {
4040         string legal_name = legalize_for_path (new_name);
4041         string new_path;
4042         string oldstr;
4043         string newstr;
4044         bool first = true;
4045
4046         string const old_sources_root = _session_dir->sources_root();
4047
4048         if (!_writable || (_state_of_the_state & CannotSave)) {
4049                 error << _("Cannot rename read-only session.") << endmsg;
4050                 return 0; // don't show "messed up" warning
4051         }
4052         if (record_status() == Recording) {
4053                 error << _("Cannot rename session while recording") << endmsg;
4054                 return 0; // don't show "messed up" warning
4055         }
4056
4057         StateProtector stp (this);
4058
4059         /* Rename:
4060
4061          * session directory
4062          * interchange subdirectory
4063          * session file
4064          * session history
4065
4066          * Backup files are left unchanged and not renamed.
4067          */
4068
4069         /* Windows requires that we close all files before attempting the
4070          * rename. This works on other platforms, but isn't necessary there.
4071          * Leave it in place for all platforms though, since it may help
4072          * catch issues that could arise if the way Source files work ever
4073          * change (since most developers are not using Windows).
4074          */
4075
4076         for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
4077                 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (i->second);
4078                 if (fs) {
4079                         fs->close ();
4080                 }
4081         }
4082
4083         /* pass one: not 100% safe check that the new directory names don't
4084          * already exist ...
4085          */
4086
4087         for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4088
4089                 oldstr = (*i).path;
4090
4091                 /* this is a stupid hack because Glib::path_get_dirname() is
4092                  * lexical-only, and so passing it /a/b/c/ gives a different
4093                  * result than passing it /a/b/c ...
4094                  */
4095
4096                 if (oldstr[oldstr.length()-1] == G_DIR_SEPARATOR) {
4097                         oldstr = oldstr.substr (0, oldstr.length() - 1);
4098                 }
4099
4100                 string base = Glib::path_get_dirname (oldstr);
4101
4102                 newstr = Glib::build_filename (base, legal_name);
4103
4104                 cerr << "Looking for " << newstr << endl;
4105
4106                 if (Glib::file_test (newstr, Glib::FILE_TEST_EXISTS)) {
4107                         cerr << " exists\n";
4108                         return -1;
4109                 }
4110         }
4111
4112         /* Session dirs */
4113
4114         first = true;
4115
4116         for (vector<space_and_path>::iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4117
4118                 vector<string> v;
4119
4120                 oldstr = (*i).path;
4121
4122                 /* this is a stupid hack because Glib::path_get_dirname() is
4123                  * lexical-only, and so passing it /a/b/c/ gives a different
4124                  * result than passing it /a/b/c ...
4125                  */
4126
4127                 if (oldstr[oldstr.length()-1] == G_DIR_SEPARATOR) {
4128                         oldstr = oldstr.substr (0, oldstr.length() - 1);
4129                 }
4130
4131                 string base = Glib::path_get_dirname (oldstr);
4132                 newstr = Glib::build_filename (base, legal_name);
4133
4134                 cerr << "for " << oldstr << " new dir = " << newstr << endl;
4135
4136                 cerr << "Rename " << oldstr << " => " << newstr << endl;
4137                 if (::g_rename (oldstr.c_str(), newstr.c_str()) != 0) {
4138                         cerr << string_compose (_("renaming %s as %2 failed (%3)"), oldstr, newstr, g_strerror (errno)) << endl;
4139                         error << string_compose (_("renaming %s as %2 failed (%3)"), oldstr, newstr, g_strerror (errno)) << endmsg;
4140                         return 1;
4141                 }
4142
4143                 /* Reset path in "session dirs" */
4144
4145                 (*i).path = newstr;
4146                 (*i).blocks = 0;
4147
4148                 /* reset primary SessionDirectory object */
4149
4150                 if (first) {
4151                         (*_session_dir) = newstr;
4152                         new_path = newstr;
4153                         first = false;
4154                 }
4155
4156                 /* now rename directory below session_dir/interchange */
4157
4158                 string old_interchange_dir;
4159                 string new_interchange_dir;
4160
4161                 /* use newstr here because we renamed the path
4162                  * (folder/directory) that used to be oldstr to newstr above
4163                  */
4164
4165                 v.push_back (newstr);
4166                 v.push_back (interchange_dir_name);
4167                 v.push_back (Glib::path_get_basename (oldstr));
4168
4169                 old_interchange_dir = Glib::build_filename (v);
4170
4171                 v.clear ();
4172                 v.push_back (newstr);
4173                 v.push_back (interchange_dir_name);
4174                 v.push_back (legal_name);
4175
4176                 new_interchange_dir = Glib::build_filename (v);
4177
4178                 cerr << "Rename " << old_interchange_dir << " => " << new_interchange_dir << endl;
4179
4180                 if (::g_rename (old_interchange_dir.c_str(), new_interchange_dir.c_str()) != 0) {
4181                         cerr << string_compose (_("renaming %s as %2 failed (%3)"),
4182                                                  old_interchange_dir, new_interchange_dir,
4183                                                  g_strerror (errno))
4184                               << endl;
4185                         error << string_compose (_("renaming %s as %2 failed (%3)"),
4186                                                  old_interchange_dir, new_interchange_dir,
4187                                                  g_strerror (errno))
4188                               << endmsg;
4189                         return 1;
4190                 }
4191         }
4192
4193         /* state file */
4194
4195         oldstr = Glib::build_filename (new_path, _current_snapshot_name + statefile_suffix);
4196         newstr= Glib::build_filename (new_path, legal_name + statefile_suffix);
4197
4198         cerr << "Rename " << oldstr << " => " << newstr << endl;
4199
4200         if (::g_rename (oldstr.c_str(), newstr.c_str()) != 0) {
4201                 cerr << string_compose (_("renaming %1 as %2 failed (%3)"), oldstr, newstr, g_strerror (errno)) << endl;
4202                 error << string_compose (_("renaming %1 as %2 failed (%3)"), oldstr, newstr, g_strerror (errno)) << endmsg;
4203                 return 1;
4204         }
4205
4206         /* history file */
4207
4208         oldstr = Glib::build_filename (new_path, _current_snapshot_name) + history_suffix;
4209
4210         if (Glib::file_test (oldstr, Glib::FILE_TEST_EXISTS))  {
4211                 newstr = Glib::build_filename (new_path, legal_name) + history_suffix;
4212
4213                 cerr << "Rename " << oldstr << " => " << newstr << endl;
4214
4215                 if (::g_rename (oldstr.c_str(), newstr.c_str()) != 0) {
4216                         cerr << string_compose (_("renaming %1 as %2 failed (%3)"), oldstr, newstr, g_strerror (errno)) << endl;
4217                         error << string_compose (_("renaming %1 as %2 failed (%3)"), oldstr, newstr, g_strerror (errno)) << endmsg;
4218                         return 1;
4219                 }
4220         }
4221
4222         /* remove old name from recent sessions */
4223         remove_recent_sessions (_path);
4224         _path = new_path;
4225
4226         /* update file source paths */
4227
4228         for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
4229                 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (i->second);
4230                 if (fs) {
4231                         string p = fs->path ();
4232                         boost::replace_all (p, old_sources_root, _session_dir->sources_root());
4233                         fs->set_path (p);
4234                         SourceFactory::setup_peakfile(i->second, true);
4235                 }
4236         }
4237
4238         set_snapshot_name (new_name);
4239         _name = new_name;
4240
4241         set_dirty ();
4242
4243         /* save state again to get everything just right */
4244
4245         save_state (_current_snapshot_name);
4246
4247         /* add to recent sessions */
4248
4249         store_recent_sessions (new_name, _path);
4250
4251         return 0;
4252 }
4253
4254 int
4255 Session::get_session_info_from_path (XMLTree& tree, const string& xmlpath)
4256 {
4257         if (!Glib::file_test (xmlpath, Glib::FILE_TEST_EXISTS)) {
4258                 return -1;
4259         }
4260
4261         if (!tree.read (xmlpath)) {
4262                 return -1;
4263         }
4264
4265         return 0;
4266 }
4267
4268 int
4269 Session::get_info_from_path (const string& xmlpath, float& sample_rate, SampleFormat& data_format)
4270 {
4271         XMLTree tree;
4272         bool found_sr = false;
4273         bool found_data_format = false;
4274
4275         if (get_session_info_from_path (tree, xmlpath)) {
4276                 return -1;
4277         }
4278
4279         /* sample rate */
4280
4281         XMLProperty const * prop;
4282         XMLNode const * root (tree.root());
4283
4284         if ((prop = root->property (X_("sample-rate"))) != 0) {
4285                 sample_rate = atoi (prop->value());
4286                 found_sr = true;
4287         }
4288
4289         const XMLNodeList& children (root->children());
4290         for (XMLNodeList::const_iterator c = children.begin(); c != children.end(); ++c) {
4291                 const XMLNode* child = *c;
4292                 if (child->name() == "Config") {
4293                         const XMLNodeList& options (child->children());
4294                         for (XMLNodeList::const_iterator oc = options.begin(); oc != options.end(); ++oc) {
4295                                 XMLNode const * option = *oc;
4296                                 XMLProperty const * name = option->property("name");
4297
4298                                 if (!name) {
4299                                         continue;
4300                                 }
4301
4302                                 if (name->value() == "native-file-data-format") {
4303                                         XMLProperty const * value = option->property ("value");
4304                                         if (value) {
4305                                                 SampleFormat fmt = (SampleFormat) string_2_enum (option->property ("value")->value(), fmt);
4306                                                 data_format = fmt;
4307                                                 found_data_format = true;
4308                                                 break;
4309                                         }
4310                                 }
4311                         }
4312                 }
4313                 if (found_data_format) {
4314                         break;
4315                 }
4316         }
4317
4318         return !(found_sr && found_data_format); // zero if they are both found
4319 }
4320
4321 std::string
4322 Session::get_snapshot_from_instant (const std::string& session_dir)
4323 {
4324         std::string instant_xml_path = Glib::build_filename (session_dir, "instant.xml");
4325
4326         if (!Glib::file_test (instant_xml_path, Glib::FILE_TEST_EXISTS)) {
4327                 return "";
4328         }
4329
4330         XMLTree tree;
4331         if (!tree.read (instant_xml_path)) {
4332                 return "";
4333         }
4334
4335         XMLProperty const * prop;
4336         XMLNode *last_used_snapshot = tree.root()->child("LastUsedSnapshot");
4337         if (last_used_snapshot && (prop = last_used_snapshot->property ("name")) != 0) {
4338                 return prop->value();
4339         }
4340
4341         return "";
4342 }
4343
4344 typedef std::vector<boost::shared_ptr<FileSource> > SeveralFileSources;
4345 typedef std::map<std::string,SeveralFileSources> SourcePathMap;
4346
4347 int
4348 Session::bring_all_sources_into_session (boost::function<void(uint32_t,uint32_t,string)> callback)
4349 {
4350         uint32_t total = 0;
4351         uint32_t n = 0;
4352         SourcePathMap source_path_map;
4353         string new_path;
4354         boost::shared_ptr<AudioFileSource> afs;
4355         int ret = 0;
4356
4357         {
4358
4359                 Glib::Threads::Mutex::Lock lm (source_lock);
4360
4361                 cerr << " total sources = " << sources.size();
4362
4363                 for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
4364                         boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (i->second);
4365
4366                         if (!fs) {
4367                                 continue;
4368                         }
4369
4370                         if (fs->within_session()) {
4371                                 continue;
4372                         }
4373
4374                         if (source_path_map.find (fs->path()) != source_path_map.end()) {
4375                                 source_path_map[fs->path()].push_back (fs);
4376                         } else {
4377                                 SeveralFileSources v;
4378                                 v.push_back (fs);
4379                                 source_path_map.insert (make_pair (fs->path(), v));
4380                         }
4381
4382                         total++;
4383                 }
4384
4385                 cerr << " fsources = " << total << endl;
4386
4387                 for (SourcePathMap::iterator i = source_path_map.begin(); i != source_path_map.end(); ++i) {
4388
4389                         /* tell caller where we are */
4390
4391                         string old_path = i->first;
4392
4393                         callback (n, total, old_path);
4394
4395                         cerr << old_path << endl;
4396
4397                         new_path.clear ();
4398
4399                         switch (i->second.front()->type()) {
4400                         case DataType::AUDIO:
4401                                 new_path = new_audio_source_path_for_embedded (old_path);
4402                                 break;
4403
4404                         case DataType::MIDI:
4405                                 /* XXX not implemented yet */
4406                                 break;
4407                         }
4408
4409                         if (new_path.empty()) {
4410                                 continue;
4411                         }
4412
4413                         cerr << "Move " << old_path << " => " << new_path << endl;
4414
4415                         if (!copy_file (old_path, new_path)) {
4416                                 cerr << "failed !\n";
4417                                 ret = -1;
4418                         }
4419
4420                         /* make sure we stop looking in the external
4421                            dir/folder. Remember, this is an all-or-nothing
4422                            operations, it doesn't merge just some files.
4423                         */
4424                         remove_dir_from_search_path (Glib::path_get_dirname (old_path), i->second.front()->type());
4425
4426                         for (SeveralFileSources::iterator f = i->second.begin(); f != i->second.end(); ++f) {
4427                                 (*f)->set_path (new_path);
4428                         }
4429                 }
4430         }
4431
4432         save_state ("", false, false);
4433
4434         return ret;
4435 }
4436
4437 static
4438 bool accept_all_files (string const &, void *)
4439 {
4440         return true;
4441 }
4442
4443 void
4444 Session::save_as_bring_callback (uint32_t,uint32_t,string)
4445 {
4446         /* It would be good if this did something useful vis-a-vis save-as, but the arguments doesn't provide the correct information right now to do this.
4447         */
4448 }
4449
4450 static string
4451 make_new_media_path (string old_path, string new_session_folder, string new_session_path)
4452 {
4453         /* typedir is the "midifiles" or "audiofiles" etc. part of the path. */
4454
4455         string typedir = Glib::path_get_basename (Glib::path_get_dirname (old_path));
4456         vector<string> v;
4457         v.push_back (new_session_folder); /* full path */
4458         v.push_back (interchange_dir_name);
4459         v.push_back (new_session_path);   /* just one directory/folder */
4460         v.push_back (typedir);
4461         v.push_back (Glib::path_get_basename (old_path));
4462
4463         return Glib::build_filename (v);
4464 }
4465
4466 int
4467 Session::save_as (SaveAs& saveas)
4468 {
4469         vector<string> files;
4470         string current_folder = Glib::path_get_dirname (_path);
4471         string new_folder = legalize_for_path (saveas.new_name);
4472         string to_dir = Glib::build_filename (saveas.new_parent_folder, new_folder);
4473         int64_t total_bytes = 0;
4474         int64_t copied = 0;
4475         int64_t cnt = 0;
4476         int64_t all = 0;
4477         int32_t internal_file_cnt = 0;
4478
4479         vector<string> do_not_copy_extensions;
4480         do_not_copy_extensions.push_back (statefile_suffix);
4481         do_not_copy_extensions.push_back (pending_suffix);
4482         do_not_copy_extensions.push_back (backup_suffix);
4483         do_not_copy_extensions.push_back (temp_suffix);
4484         do_not_copy_extensions.push_back (history_suffix);
4485
4486         /* get total size */
4487
4488         for (vector<space_and_path>::const_iterator sd = session_dirs.begin(); sd != session_dirs.end(); ++sd) {
4489
4490                 /* need to clear this because
4491                  * find_files_matching_filter() is cumulative
4492                  */
4493
4494                 files.clear ();
4495
4496                 find_files_matching_filter (files, (*sd).path, accept_all_files, 0, false, true, true);
4497
4498                 all += files.size();
4499
4500                 for (vector<string>::iterator i = files.begin(); i != files.end(); ++i) {
4501                         GStatBuf gsb;
4502                         g_stat ((*i).c_str(), &gsb);
4503                         total_bytes += gsb.st_size;
4504                 }
4505         }
4506
4507         /* save old values so we can switch back if we are not switching to the new session */
4508
4509         string old_path = _path;
4510         string old_name = _name;
4511         string old_snapshot = _current_snapshot_name;
4512         string old_sd = _session_dir->root_path();
4513         vector<string> old_search_path[DataType::num_types];
4514         string old_config_search_path[DataType::num_types];
4515
4516         old_search_path[DataType::AUDIO] = source_search_path (DataType::AUDIO);
4517         old_search_path[DataType::MIDI] = source_search_path (DataType::MIDI);
4518         old_config_search_path[DataType::AUDIO]  = config.get_audio_search_path ();
4519         old_config_search_path[DataType::MIDI]  = config.get_midi_search_path ();
4520
4521         /* switch session directory */
4522
4523         (*_session_dir) = to_dir;
4524
4525         /* create new tree */
4526
4527         if (!_session_dir->create()) {
4528                 saveas.failure_message = string_compose (_("Cannot create new session folder %1"), to_dir);
4529                 return -1;
4530         }
4531
4532         try {
4533                 /* copy all relevant files. Find each location in session_dirs,
4534                  * and copy files from there to target.
4535                  */
4536
4537                 for (vector<space_and_path>::const_iterator sd = session_dirs.begin(); sd != session_dirs.end(); ++sd) {
4538
4539                         /* need to clear this because
4540                          * find_files_matching_filter() is cumulative
4541                          */
4542
4543                         files.clear ();
4544
4545                         const size_t prefix_len = (*sd).path.size();
4546
4547                         /* Work just on the files within this session dir */
4548
4549                         find_files_matching_filter (files, (*sd).path, accept_all_files, 0, false, true, true);
4550
4551                         /* add dir separator to protect against collisions with
4552                          * track names (e.g. track named "audiofiles" or
4553                          * "analysis".
4554                          */
4555
4556                         static const std::string audiofile_dir_string = string (sound_dir_name) + G_DIR_SEPARATOR;
4557                         static const std::string midifile_dir_string = string (midi_dir_name) + G_DIR_SEPARATOR;
4558                         static const std::string analysis_dir_string = analysis_dir() + G_DIR_SEPARATOR;
4559
4560                         /* copy all the files. Handling is different for media files
4561                            than others because of the *silly* subtree we have below the interchange
4562                            folder. That really was a bad idea, but I'm not fixing it as part of
4563                            implementing ::save_as().
4564                         */
4565
4566                         for (vector<string>::iterator i = files.begin(); i != files.end(); ++i) {
4567
4568                                 std::string from = *i;
4569
4570 #ifdef __APPLE__
4571                                 string filename = Glib::path_get_basename (from);
4572                                 std::transform (filename.begin(), filename.end(), filename.begin(), ::toupper);
4573                                 if (filename == ".DS_STORE") {
4574                                         continue;
4575                                 }
4576 #endif
4577
4578                                 if (from.find (audiofile_dir_string) != string::npos) {
4579
4580                                         /* audio file: only copy if asked */
4581
4582                                         if (saveas.include_media && saveas.copy_media) {
4583
4584                                                 string to = make_new_media_path (*i, to_dir, new_folder);
4585
4586                                                 info << "media file copying from " << from << " to " << to << endmsg;
4587
4588                                                 if (!copy_file (from, to)) {
4589                                                         throw Glib::FileError (Glib::FileError::IO_ERROR,
4590                                                                                                    string_compose(_("\ncopying \"%1\" failed !"), from));
4591                                                 }
4592                                         }
4593
4594                                         /* we found media files inside the session folder */
4595
4596                                         internal_file_cnt++;
4597
4598                                 } else if (from.find (midifile_dir_string) != string::npos) {
4599
4600                                         /* midi file: always copy unless
4601                                          * creating an empty new session
4602                                          */
4603
4604                                         if (saveas.include_media) {
4605
4606                                                 string to = make_new_media_path (*i, to_dir, new_folder);
4607
4608                                                 info << "media file copying from " << from << " to " << to << endmsg;
4609
4610                                                 if (!copy_file (from, to)) {
4611                                                         throw Glib::FileError (Glib::FileError::IO_ERROR, "copy failed");
4612                                                 }
4613                                         }
4614
4615                                         /* we found media files inside the session folder */
4616
4617                                         internal_file_cnt++;
4618
4619                                 } else if (from.find (analysis_dir_string) != string::npos) {
4620
4621                                         /*  make sure analysis dir exists in
4622                                          *  new session folder, but we're not
4623                                          *  copying analysis files here, see
4624                                          *  below
4625                                          */
4626
4627                                         (void) g_mkdir_with_parents (analysis_dir().c_str(), 775);
4628                                         continue;
4629
4630                                 } else {
4631
4632                                         /* normal non-media file. Don't copy state, history, etc.
4633                                          */
4634
4635                                         bool do_copy = true;
4636
4637                                         for (vector<string>::iterator v = do_not_copy_extensions.begin(); v != do_not_copy_extensions.end(); ++v) {
4638                                                 if ((from.length() > (*v).length()) && (from.find (*v) == from.length() - (*v).length())) {
4639                                                         /* end of filename matches extension, do not copy file */
4640                                                         do_copy = false;
4641                                                         break;
4642                                                 }
4643                                         }
4644
4645                                         if (!saveas.copy_media && from.find (peakfile_suffix) != string::npos) {
4646                                                 /* don't copy peakfiles if
4647                                                  * we're not copying media
4648                                                  */
4649                                                 do_copy = false;
4650                                         }
4651
4652                                         if (do_copy) {
4653                                                 string to = Glib::build_filename (to_dir, from.substr (prefix_len));
4654
4655                                                 info << "attempting to make directory/folder " << to << endmsg;
4656
4657                                                 if (g_mkdir_with_parents (Glib::path_get_dirname (to).c_str(), 0755)) {
4658                                                         throw Glib::FileError (Glib::FileError::IO_ERROR, "cannot create required directory");
4659                                                 }
4660
4661                                                 info << "attempting to copy " << from << " to " << to << endmsg;
4662
4663                                                 if (!copy_file (from, to)) {
4664                                                         throw Glib::FileError (Glib::FileError::IO_ERROR,
4665                                                                                                    string_compose(_("\ncopying \"%1\" failed !"), from));
4666                                                 }
4667                                         }
4668                                 }
4669
4670                                 /* measure file size even if we're not going to copy so that our Progress
4671                                    signals are correct, since we included these do-not-copy files
4672                                    in the computation of the total size and file count.
4673                                 */
4674
4675                                 GStatBuf gsb;
4676                                 g_stat (from.c_str(), &gsb);
4677                                 copied += gsb.st_size;
4678                                 cnt++;
4679
4680                                 double fraction = (double) copied / total_bytes;
4681
4682                                 bool keep_going = true;
4683
4684                                 if (saveas.copy_media) {
4685
4686                                         /* no need or expectation of this if
4687                                          * media is not being copied, because
4688                                          * it will be fast(ish).
4689                                          */
4690
4691                                         /* tell someone "X percent, file M of N"; M is one-based */
4692
4693                                         boost::optional<bool> res = saveas.Progress (fraction, cnt, all);
4694
4695                                         if (res) {
4696                                                 keep_going = *res;
4697                                         }
4698                                 }
4699
4700                                 if (!keep_going) {
4701                                         throw Glib::FileError (Glib::FileError::FAILED, "copy cancelled");
4702                                 }
4703                         }
4704
4705                 }
4706
4707                 /* copy optional folders, if any */
4708
4709                 string old = plugins_dir ();
4710                 if (Glib::file_test (old, Glib::FILE_TEST_EXISTS)) {
4711                         string newdir = Glib::build_filename (to_dir, Glib::path_get_basename (old));
4712                         copy_files (old, newdir);
4713                 }
4714
4715                 old = externals_dir ();
4716                 if (Glib::file_test (old, Glib::FILE_TEST_EXISTS)) {
4717                         string newdir = Glib::build_filename (to_dir, Glib::path_get_basename (old));
4718                         copy_files (old, newdir);
4719                 }
4720
4721                 old = automation_dir ();
4722                 if (Glib::file_test (old, Glib::FILE_TEST_EXISTS)) {
4723                         string newdir = Glib::build_filename (to_dir, Glib::path_get_basename (old));
4724                         copy_files (old, newdir);
4725                 }
4726
4727                 if (saveas.include_media) {
4728
4729                         if (saveas.copy_media) {
4730 #ifndef PLATFORM_WINDOWS
4731                                 /* There are problems with analysis files on
4732                                  * Windows, because they used a colon in their
4733                                  * names as late as 4.0. Colons are not legal
4734                                  * under Windows even if NTFS allows them.
4735                                  *
4736                                  * This is a tricky problem to solve so for
4737                                  * just don't copy these files. They will be
4738                                  * regenerated as-needed anyway, subject to the
4739                                  * existing issue that the filenames will be
4740                                  * rejected by Windows, which is a separate
4741                                  * problem (though related).
4742                                  */
4743
4744                                 /* only needed if we are copying media, since the
4745                                  * analysis data refers to media data
4746                                  */
4747
4748                                 old = analysis_dir ();
4749                                 if (Glib::file_test (old, Glib::FILE_TEST_EXISTS)) {
4750                                         string newdir = Glib::build_filename (to_dir, "analysis");
4751                                         copy_files (old, newdir);
4752                                 }
4753 #endif /* PLATFORM_WINDOWS */
4754                         }
4755                 }
4756
4757
4758                 _path = to_dir;
4759                 set_snapshot_name (saveas.new_name);
4760                 _name = saveas.new_name;
4761
4762                 if (saveas.include_media && !saveas.copy_media) {
4763
4764                         /* reset search paths of the new session (which we're pretending to be right now) to
4765                            include the original session search path, so we can still find all audio.
4766                         */
4767
4768                         if (internal_file_cnt) {
4769                                 for (vector<string>::iterator s = old_search_path[DataType::AUDIO].begin(); s != old_search_path[DataType::AUDIO].end(); ++s) {
4770                                         ensure_search_path_includes (*s, DataType::AUDIO);
4771                                         cerr << "be sure to include " << *s << "  for audio" << endl;
4772                                 }
4773
4774                                 /* we do not do this for MIDI because we copy
4775                                    all MIDI files if saveas.include_media is
4776                                    true
4777                                 */
4778                         }
4779                 }
4780
4781                 bool was_dirty = dirty ();
4782
4783                 save_state ("", false, false, !saveas.include_media);
4784                 save_default_options ();
4785
4786                 if (saveas.copy_media && saveas.copy_external) {
4787                         if (bring_all_sources_into_session (boost::bind (&Session::save_as_bring_callback, this, _1, _2, _3))) {
4788                                 throw Glib::FileError (Glib::FileError::NO_SPACE_LEFT, "consolidate failed");
4789                         }
4790                 }
4791
4792                 saveas.final_session_folder_name = _path;
4793
4794                 store_recent_sessions (_name, _path);
4795
4796                 if (!saveas.switch_to) {
4797
4798                         /* switch back to the way things were */
4799
4800                         _path = old_path;
4801                         _name = old_name;
4802                         set_snapshot_name (old_snapshot);
4803
4804                         (*_session_dir) = old_sd;
4805
4806                         if (was_dirty) {
4807                                 set_dirty ();
4808                         }
4809
4810                         if (internal_file_cnt) {
4811                                 /* reset these to their original values */
4812                                 config.set_audio_search_path (old_config_search_path[DataType::AUDIO]);
4813                                 config.set_midi_search_path (old_config_search_path[DataType::MIDI]);
4814                         }
4815
4816                 } else {
4817
4818                         /* prune session dirs, and update disk space statistics
4819                          */
4820
4821                         space_and_path sp;
4822                         sp.path = _path;
4823                         session_dirs.clear ();
4824                         session_dirs.push_back (sp);
4825                         refresh_disk_space ();
4826
4827                         /* ensure that all existing tracks reset their current capture source paths
4828                          */
4829                         reset_write_sources (true, true);
4830
4831                         /* the copying above was based on actually discovering files, not just iterating over the sources list.
4832                            But if we're going to switch to the new (copied) session, we need to change the paths in the sources also.
4833                         */
4834
4835                         for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
4836                                 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (i->second);
4837
4838                                 if (!fs) {
4839                                         continue;
4840                                 }
4841
4842                                 if (fs->within_session()) {
4843                                         string newpath = make_new_media_path (fs->path(), to_dir, new_folder);
4844                                         fs->set_path (newpath);
4845                                 }
4846                         }
4847                 }
4848
4849         } catch (Glib::FileError& e) {
4850
4851                 saveas.failure_message = e.what();
4852
4853                 /* recursively remove all the directories */
4854
4855                 remove_directory (to_dir);
4856
4857                 /* return error */
4858
4859                 return -1;
4860
4861         } catch (...) {
4862
4863                 saveas.failure_message = _("unknown reason");
4864
4865                 /* recursively remove all the directories */
4866
4867                 remove_directory (to_dir);
4868
4869                 /* return error */
4870
4871                 return -1;
4872         }
4873
4874         return 0;
4875 }