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