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