libs/ardour/session_state.cc

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