2 Copyright (C) 1999-2004 Paul Davis
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.
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.
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.
25 #include <cstdio> /* sprintf(3) ... grrr */
31 #include <sigc++/bind.h>
32 #include <sigc++/retype.h>
34 #include <glibmm/thread.h>
35 #include <glibmm/miscutils.h>
37 #include <pbd/error.h>
38 #include <glibmm/thread.h>
39 #include <pbd/pathscanner.h>
40 #include <pbd/stl_delete.h>
41 #include <pbd/basename.h>
42 #include <pbd/stacktrace.h>
44 #include <ardour/audioengine.h>
45 #include <ardour/configuration.h>
46 #include <ardour/session.h>
47 #include <ardour/utils.h>
48 #include <ardour/audio_diskstream.h>
49 #include <ardour/audioplaylist.h>
50 #include <ardour/audioregion.h>
51 #include <ardour/audiofilesource.h>
52 #include <ardour/midi_diskstream.h>
53 #include <ardour/midi_playlist.h>
54 #include <ardour/midi_region.h>
55 #include <ardour/smf_source.h>
56 #include <ardour/auditioner.h>
57 #include <ardour/recent_sessions.h>
58 #include <ardour/redirect.h>
59 #include <ardour/send.h>
60 #include <ardour/insert.h>
61 #include <ardour/connection.h>
62 #include <ardour/slave.h>
63 #include <ardour/tempo.h>
64 #include <ardour/audio_track.h>
65 #include <ardour/midi_track.h>
66 #include <ardour/cycle_timer.h>
67 #include <ardour/named_selection.h>
68 #include <ardour/crossfade.h>
69 #include <ardour/playlist.h>
70 #include <ardour/click.h>
71 #include <ardour/data_type.h>
72 #include <ardour/buffer_set.h>
73 #include <ardour/source_factory.h>
74 #include <ardour/region_factory.h>
77 #include <ardour/osc.h>
83 using namespace ARDOUR;
85 using boost::shared_ptr;
88 static const int CPU_CACHE_ALIGN = 64;
90 static const int CPU_CACHE_ALIGN = 16; /* arguably 32 on most arches, but it matters less */
93 const char* Session::_template_suffix = X_(".template");
94 const char* Session::_statefile_suffix = X_(".ardour");
95 const char* Session::_pending_suffix = X_(".pending");
96 const char* Session::old_sound_dir_name = X_("sounds");
97 const char* Session::sound_dir_name = X_("audiofiles");
98 const char* Session::peak_dir_name = X_("peaks");
99 const char* Session::dead_sound_dir_name = X_("dead_sounds");
100 const char* Session::interchange_dir_name = X_("interchange");
101 const char* Session::export_dir_name = X_("export");
103 sigc::signal<int> Session::AskAboutPendingState;
104 sigc::signal<void> Session::SendFeedback;
106 sigc::signal<void> Session::SMPTEOffsetChanged;
107 sigc::signal<void> Session::StartTimeChanged;
108 sigc::signal<void> Session::EndTimeChanged;
111 Session::find_session (string str, string& path, string& snapshot, bool& isnew)
114 char buf[PATH_MAX+1];
118 if (!realpath (str.c_str(), buf) && (errno != ENOENT && errno != ENOTDIR)) {
119 error << string_compose (_("Could not resolve path: %1 (%2)"), buf, strerror(errno)) << endmsg;
125 /* check to see if it exists, and what it is */
127 if (stat (str.c_str(), &statbuf)) {
128 if (errno == ENOENT) {
131 error << string_compose (_("cannot check session path %1 (%2)"), str, strerror (errno))
139 /* it exists, so it must either be the name
140 of the directory, or the name of the statefile
144 if (S_ISDIR (statbuf.st_mode)) {
146 string::size_type slash = str.find_last_of ('/');
148 if (slash == string::npos) {
150 /* a subdirectory of cwd, so statefile should be ... */
156 tmp += _statefile_suffix;
160 if (stat (tmp.c_str(), &statbuf)) {
161 error << string_compose (_("cannot check statefile %1 (%2)"), tmp, strerror (errno))
171 /* some directory someplace in the filesystem.
172 the snapshot name is the directory name
177 snapshot = str.substr (slash+1);
181 } else if (S_ISREG (statbuf.st_mode)) {
183 string::size_type slash = str.find_last_of ('/');
184 string::size_type suffix;
186 /* remove the suffix */
188 if (slash != string::npos) {
189 snapshot = str.substr (slash+1);
194 suffix = snapshot.find (_statefile_suffix);
196 if (suffix == string::npos) {
197 error << string_compose (_("%1 is not an Ardour snapshot file"), str) << endmsg;
203 snapshot = snapshot.substr (0, suffix);
205 if (slash == string::npos) {
207 /* we must be in the directory where the
208 statefile lives. get it using cwd().
211 char cwd[PATH_MAX+1];
213 if (getcwd (cwd, sizeof (cwd)) == 0) {
214 error << string_compose (_("cannot determine current working directory (%1)"), strerror (errno))
223 /* full path to the statefile */
225 path = str.substr (0, slash);
230 /* what type of file is it? */
231 error << string_compose (_("unknown file type for session %1"), str) << endmsg;
237 /* its the name of a new directory. get the name
241 string::size_type slash = str.find_last_of ('/');
243 if (slash == string::npos) {
245 /* no slash, just use the name, but clean it up */
247 path = legalize_for_path (str);
253 snapshot = str.substr (slash+1);
260 Session::Session (AudioEngine &eng,
262 string snapshot_name,
263 string* mix_template)
266 _scratch_buffers(new BufferSet()),
267 _silent_buffers(new BufferSet()),
268 _send_buffers(new BufferSet()),
269 _mmc_port (default_mmc_port),
270 _mtc_port (default_mtc_port),
271 _midi_port (default_midi_port),
272 pending_events (2048),
273 //midi_requests (128), // the size of this should match the midi request pool size
274 _send_smpte_update (false),
275 diskstreams (new DiskstreamList),
276 routes (new RouteList),
277 auditioner ((Auditioner*) 0),
283 if (!eng.connected()) {
284 throw failed_constructor();
287 cerr << "Loading session " << fullpath << " using snapshot " << snapshot_name << " (1)" << endl;
289 n_physical_outputs = _engine.n_physical_outputs();
290 n_physical_inputs = _engine.n_physical_inputs();
292 first_stage_init (fullpath, snapshot_name);
294 new_session = !g_file_test (_path.c_str(), GFileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR));
296 if (create (new_session, mix_template, compute_initial_length())) {
297 cerr << "create failed\n";
299 throw failed_constructor ();
303 if (second_stage_init (new_session)) {
305 throw failed_constructor ();
308 store_recent_sessions(_name, _path);
310 bool was_dirty = dirty();
312 _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
314 Config->ParameterChanged.connect (mem_fun (*this, &Session::config_changed));
317 DirtyChanged (); /* EMIT SIGNAL */
321 Session::Session (AudioEngine &eng,
323 string snapshot_name,
324 AutoConnectOption input_ac,
325 AutoConnectOption output_ac,
326 uint32_t control_out_channels,
327 uint32_t master_out_channels,
328 uint32_t requested_physical_in,
329 uint32_t requested_physical_out,
330 nframes_t initial_length)
333 _scratch_buffers(new BufferSet()),
334 _silent_buffers(new BufferSet()),
335 _send_buffers(new BufferSet()),
336 _mmc_port (default_mmc_port),
337 _mtc_port (default_mtc_port),
338 _midi_port (default_midi_port),
339 pending_events (2048),
340 //midi_requests (16),
341 _send_smpte_update (false),
342 diskstreams (new DiskstreamList),
343 routes (new RouteList),
349 if (!eng.connected()) {
350 throw failed_constructor();
353 cerr << "Loading session " << fullpath << " using snapshot " << snapshot_name << " (2)" << endl;
355 n_physical_outputs = _engine.n_physical_outputs();
356 n_physical_inputs = _engine.n_physical_inputs();
358 if (n_physical_inputs) {
359 n_physical_inputs = max (requested_physical_in, n_physical_inputs);
362 if (n_physical_outputs) {
363 n_physical_outputs = max (requested_physical_out, n_physical_outputs);
366 first_stage_init (fullpath, snapshot_name);
368 new_session = !g_file_test (_path.c_str(), GFileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR));
371 if (create (new_session, 0, initial_length)) {
373 throw failed_constructor ();
378 /* set up Master Out and Control Out if necessary */
383 if (control_out_channels) {
384 shared_ptr<Route> r (new Route (*this, _("monitor"), -1, control_out_channels, -1, control_out_channels, Route::ControlOut));
385 r->set_remote_control_id (control_id++);
390 if (master_out_channels) {
391 shared_ptr<Route> r (new Route (*this, _("master"), -1, master_out_channels, -1, master_out_channels, Route::MasterOut));
392 r->set_remote_control_id (control_id);
396 /* prohibit auto-connect to master, because there isn't one */
397 output_ac = AutoConnectOption (output_ac & ~AutoConnectMaster);
406 Config->set_input_auto_connect (input_ac);
407 Config->set_output_auto_connect (output_ac);
409 if (second_stage_init (new_session)) {
411 throw failed_constructor ();
414 store_recent_sessions(_name, _path);
416 bool was_dirty = dirty ();
418 _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
420 Config->ParameterChanged.connect (mem_fun (*this, &Session::config_changed));
423 DirtyChanged (); /* EMIT SIGNAL */
435 /* if we got to here, leaving pending capture state around
439 remove_pending_capture_state ();
441 _state_of_the_state = StateOfTheState (CannotSave|Deletion);
442 _engine.remove_session ();
444 GoingAway (); /* EMIT SIGNAL */
450 /* clear history so that no references to objects are held any more */
454 /* clear state tree so that no references to objects are held any more */
460 terminate_butler_thread ();
461 //terminate_midi_thread ();
463 if (click_data && click_data != default_click) {
464 delete [] click_data;
467 if (click_emphasis_data && click_emphasis_data != default_click_emphasis) {
468 delete [] click_emphasis_data;
473 delete _scratch_buffers;
474 delete _silent_buffers;
475 delete _send_buffers;
477 AudioDiskstream::free_working_buffers();
479 #undef TRACK_DESTRUCTION
480 #ifdef TRACK_DESTRUCTION
481 cerr << "delete named selections\n";
482 #endif /* TRACK_DESTRUCTION */
483 for (NamedSelectionList::iterator i = named_selections.begin(); i != named_selections.end(); ) {
484 NamedSelectionList::iterator tmp;
493 #ifdef TRACK_DESTRUCTION
494 cerr << "delete playlists\n";
495 #endif /* TRACK_DESTRUCTION */
496 for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ) {
497 PlaylistList::iterator tmp;
502 (*i)->drop_references ();
507 for (PlaylistList::iterator i = unused_playlists.begin(); i != unused_playlists.end(); ) {
508 PlaylistList::iterator tmp;
513 (*i)->drop_references ();
519 unused_playlists.clear ();
521 #ifdef TRACK_DESTRUCTION
522 cerr << "delete regions\n";
523 #endif /* TRACK_DESTRUCTION */
525 for (RegionList::iterator i = regions.begin(); i != regions.end(); ) {
526 RegionList::iterator tmp;
531 i->second->drop_references ();
538 #ifdef TRACK_DESTRUCTION
539 cerr << "delete routes\n";
540 #endif /* TRACK_DESTRUCTION */
542 RCUWriter<RouteList> writer (routes);
543 boost::shared_ptr<RouteList> r = writer.get_copy ();
544 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
545 (*i)->drop_references ();
548 /* writer goes out of scope and updates master */
553 #ifdef TRACK_DESTRUCTION
554 cerr << "delete diskstreams\n";
555 #endif /* TRACK_DESTRUCTION */
557 RCUWriter<DiskstreamList> dwriter (diskstreams);
558 boost::shared_ptr<DiskstreamList> dsl = dwriter.get_copy();
559 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
560 (*i)->drop_references ();
564 diskstreams.flush ();
566 #ifdef TRACK_DESTRUCTION
567 cerr << "delete audio sources\n";
568 #endif /* TRACK_DESTRUCTION */
569 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ) {
570 SourceMap::iterator tmp;
575 i->second->drop_references ();
582 #ifdef TRACK_DESTRUCTION
583 cerr << "delete mix groups\n";
584 #endif /* TRACK_DESTRUCTION */
585 for (list<RouteGroup *>::iterator i = mix_groups.begin(); i != mix_groups.end(); ) {
586 list<RouteGroup*>::iterator tmp;
596 #ifdef TRACK_DESTRUCTION
597 cerr << "delete edit groups\n";
598 #endif /* TRACK_DESTRUCTION */
599 for (list<RouteGroup *>::iterator i = edit_groups.begin(); i != edit_groups.end(); ) {
600 list<RouteGroup*>::iterator tmp;
610 #ifdef TRACK_DESTRUCTION
611 cerr << "delete connections\n";
612 #endif /* TRACK_DESTRUCTION */
613 for (ConnectionList::iterator i = _connections.begin(); i != _connections.end(); ) {
614 ConnectionList::iterator tmp;
624 if (butler_mixdown_buffer) {
625 delete [] butler_mixdown_buffer;
628 if (butler_gain_buffer) {
629 delete [] butler_gain_buffer;
632 Crossfade::set_buffer_size (0);
640 Session::set_worst_io_latencies ()
642 _worst_output_latency = 0;
643 _worst_input_latency = 0;
645 if (!_engine.connected()) {
649 boost::shared_ptr<RouteList> r = routes.reader ();
651 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
652 _worst_output_latency = max (_worst_output_latency, (*i)->output_latency());
653 _worst_input_latency = max (_worst_input_latency, (*i)->input_latency());
658 Session::when_engine_running ()
660 string first_physical_output;
662 /* we don't want to run execute this again */
664 set_block_size (_engine.frames_per_cycle());
665 set_frame_rate (_engine.frame_rate());
667 Config->map_parameters (mem_fun (*this, &Session::config_changed));
669 /* every time we reconnect, recompute worst case output latencies */
671 _engine.Running.connect (mem_fun (*this, &Session::set_worst_io_latencies));
673 if (synced_to_jack()) {
674 _engine.transport_stop ();
677 if (Config->get_jack_time_master()) {
678 _engine.transport_locate (_transport_frame);
686 _click_io.reset (new ClickIO (*this, "click", 0, 0, -1, -1));
688 if (state_tree && (child = find_named_node (*state_tree->root(), "Click")) != 0) {
690 /* existing state for Click */
692 if (_click_io->set_state (*child->children().front()) == 0) {
694 _clicking = Config->get_clicking ();
698 error << _("could not setup Click I/O") << endmsg;
704 /* default state for Click */
706 first_physical_output = _engine.get_nth_physical_output (DataType::AUDIO, 0);
708 if (first_physical_output.length()) {
709 if (_click_io->add_output_port (first_physical_output, this)) {
710 // relax, even though its an error
712 _clicking = Config->get_clicking ();
718 catch (failed_constructor& err) {
719 error << _("cannot setup Click I/O") << endmsg;
722 set_worst_io_latencies ();
725 // XXX HOW TO ALERT UI TO THIS ? DO WE NEED TO?
728 /* Create a set of Connection objects that map
729 to the physical outputs currently available
734 for (uint32_t np = 0; np < n_physical_outputs; ++np) {
736 snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
738 Connection* c = new OutputConnection (buf, true);
741 c->add_connection (0, _engine.get_nth_physical_output (DataType::AUDIO, np));
746 for (uint32_t np = 0; np < n_physical_inputs; ++np) {
748 snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
750 Connection* c = new InputConnection (buf, true);
753 c->add_connection (0, _engine.get_nth_physical_input (DataType::AUDIO, np));
760 for (uint32_t np = 0; np < n_physical_outputs; np +=2) {
762 snprintf (buf, sizeof (buf), _("out %" PRIu32 "+%" PRIu32), np+1, np+2);
764 Connection* c = new OutputConnection (buf, true);
768 c->add_connection (0, _engine.get_nth_physical_output (DataType::AUDIO, np));
769 c->add_connection (1, _engine.get_nth_physical_output (DataType::AUDIO, np+1));
774 for (uint32_t np = 0; np < n_physical_inputs; np +=2) {
776 snprintf (buf, sizeof (buf), _("in %" PRIu32 "+%" PRIu32), np+1, np+2);
778 Connection* c = new InputConnection (buf, true);
782 c->add_connection (0, _engine.get_nth_physical_input (DataType::AUDIO, np));
783 c->add_connection (1, _engine.get_nth_physical_input (DataType::AUDIO, np+1));
792 /* create master/control ports */
797 /* force the master to ignore any later call to this */
799 if (_master_out->pending_state_node) {
800 _master_out->ports_became_legal();
803 /* no panner resets till we are through */
805 _master_out->defer_pan_reset ();
807 while (_master_out->n_inputs().n_audio()
808 < _master_out->input_maximum().n_audio()) {
809 if (_master_out->add_input_port ("", this, DataType::AUDIO)) {
810 error << _("cannot setup master inputs")
816 while (_master_out->n_outputs().n_audio()
817 < _master_out->output_maximum().n_audio()) {
818 if (_master_out->add_output_port (_engine.get_nth_physical_output (DataType::AUDIO, n), this, DataType::AUDIO)) {
819 error << _("cannot setup master outputs")
826 _master_out->allow_pan_reset ();
830 Connection* c = new OutputConnection (_("Master Out"), true);
832 for (uint32_t n = 0; n < _master_out->n_inputs ().get_total(); ++n) {
834 c->add_connection ((int) n, _master_out->input(n)->name());
841 /* catch up on send+insert cnts */
845 for (list<PortInsert*>::iterator i = _port_inserts.begin(); i != _port_inserts.end(); ++i) {
848 if (sscanf ((*i)->name().c_str(), "%*s %u", &id) == 1) {
849 if (id > insert_cnt) {
857 for (list<Send*>::iterator i = _sends.begin(); i != _sends.end(); ++i) {
860 if (sscanf ((*i)->name().c_str(), "%*s %u", &id) == 1) {
868 _state_of_the_state = StateOfTheState (_state_of_the_state & ~(CannotSave|Dirty));
870 /* hook us up to the engine */
872 _engine.set_session (this);
877 osc->set_session (*this);
880 _state_of_the_state = Clean;
882 DirtyChanged (); /* EMIT SIGNAL */
886 Session::hookup_io ()
888 /* stop graph reordering notifications from
889 causing resorts, etc.
892 _state_of_the_state = StateOfTheState (_state_of_the_state | InitialConnecting);
894 if (auditioner == 0) {
896 /* we delay creating the auditioner till now because
897 it makes its own connections to ports.
898 the engine has to be running for this to work.
902 auditioner.reset (new Auditioner (*this));
905 catch (failed_constructor& err) {
906 warning << _("cannot create Auditioner: no auditioning of regions possible") << endmsg;
910 /* Tell all IO objects to create their ports */
916 vector<string> cports;
918 while (_control_out->n_inputs().n_audio() < _control_out->input_maximum().n_audio()) {
919 if (_control_out->add_input_port ("", this)) {
920 error << _("cannot setup control inputs")
926 while (_control_out->n_outputs().n_audio() < _control_out->output_maximum().n_audio()) {
927 if (_control_out->add_output_port (_engine.get_nth_physical_output (DataType::AUDIO, n), this)) {
928 error << _("cannot set up master outputs")
936 uint32_t ni = _control_out->n_inputs().get (DataType::AUDIO);
938 for (n = 0; n < ni; ++n) {
939 cports.push_back (_control_out->input(n)->name());
942 boost::shared_ptr<RouteList> r = routes.reader ();
944 for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
945 (*x)->set_control_outs (cports);
949 /* Tell all IO objects to connect themselves together */
951 IO::enable_connecting ();
953 /* Now reset all panners */
955 IO::reset_panners ();
957 /* Anyone who cares about input state, wake up and do something */
959 IOConnectionsComplete (); /* EMIT SIGNAL */
961 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InitialConnecting);
963 /* now handle the whole enchilada as if it was one
969 /* update mixer solo state */
975 Session::playlist_length_changed ()
977 /* we can't just increase end_location->end() if pl->get_maximum_extent()
978 if larger. if the playlist used to be the longest playlist,
979 and its now shorter, we have to decrease end_location->end(). hence,
980 we have to iterate over all diskstreams and check the
981 playlists currently in use.
987 Session::diskstream_playlist_changed (boost::shared_ptr<Diskstream> dstream)
989 boost::shared_ptr<Playlist> playlist;
991 if ((playlist = dstream->playlist()) != 0) {
992 playlist->LengthChanged.connect (mem_fun (this, &Session::playlist_length_changed));
995 /* see comment in playlist_length_changed () */
1000 Session::record_enabling_legal () const
1002 /* this used to be in here, but survey says.... we don't need to restrict it */
1003 // if (record_status() == Recording) {
1007 if (Config->get_all_safe()) {
1014 Session::reset_input_monitor_state ()
1016 if (transport_rolling()) {
1018 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
1020 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
1021 if ((*i)->record_enabled ()) {
1022 //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
1023 (*i)->monitor_input (Config->get_monitoring_model() == HardwareMonitoring && !Config->get_auto_input());
1027 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
1029 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
1030 if ((*i)->record_enabled ()) {
1031 //cerr << "switching to input = " << !Config->get_auto_input() << __FILE__ << __LINE__ << endl << endl;
1032 (*i)->monitor_input (Config->get_monitoring_model() == HardwareMonitoring);
1039 Session::auto_punch_start_changed (Location* location)
1041 replace_event (Event::PunchIn, location->start());
1043 if (get_record_enabled() && Config->get_punch_in()) {
1044 /* capture start has been changed, so save new pending state */
1045 save_state ("", true);
1050 Session::auto_punch_end_changed (Location* location)
1052 nframes_t when_to_stop = location->end();
1053 // when_to_stop += _worst_output_latency + _worst_input_latency;
1054 replace_event (Event::PunchOut, when_to_stop);
1058 Session::auto_punch_changed (Location* location)
1060 nframes_t when_to_stop = location->end();
1062 replace_event (Event::PunchIn, location->start());
1063 //when_to_stop += _worst_output_latency + _worst_input_latency;
1064 replace_event (Event::PunchOut, when_to_stop);
1068 Session::auto_loop_changed (Location* location)
1070 replace_event (Event::AutoLoop, location->end(), location->start());
1072 if (transport_rolling() && play_loop) {
1074 //if (_transport_frame < location->start() || _transport_frame > location->end()) {
1076 if (_transport_frame > location->end()) {
1077 // relocate to beginning of loop
1078 clear_events (Event::LocateRoll);
1080 request_locate (location->start(), true);
1083 else if (Config->get_seamless_loop() && !loop_changing) {
1085 // schedule a locate-roll to refill the diskstreams at the
1086 // previous loop end
1087 loop_changing = true;
1089 if (location->end() > last_loopend) {
1090 clear_events (Event::LocateRoll);
1091 Event *ev = new Event (Event::LocateRoll, Event::Add, last_loopend, last_loopend, 0, true);
1098 last_loopend = location->end();
1103 Session::set_auto_punch_location (Location* location)
1107 if ((existing = _locations.auto_punch_location()) != 0 && existing != location) {
1108 auto_punch_start_changed_connection.disconnect();
1109 auto_punch_end_changed_connection.disconnect();
1110 auto_punch_changed_connection.disconnect();
1111 existing->set_auto_punch (false, this);
1112 remove_event (existing->start(), Event::PunchIn);
1113 clear_events (Event::PunchOut);
1114 auto_punch_location_changed (0);
1119 if (location == 0) {
1123 if (location->end() <= location->start()) {
1124 error << _("Session: you can't use that location for auto punch (start <= end)") << endmsg;
1128 auto_punch_start_changed_connection.disconnect();
1129 auto_punch_end_changed_connection.disconnect();
1130 auto_punch_changed_connection.disconnect();
1132 auto_punch_start_changed_connection = location->start_changed.connect (mem_fun (this, &Session::auto_punch_start_changed));
1133 auto_punch_end_changed_connection = location->end_changed.connect (mem_fun (this, &Session::auto_punch_end_changed));
1134 auto_punch_changed_connection = location->changed.connect (mem_fun (this, &Session::auto_punch_changed));
1136 location->set_auto_punch (true, this);
1137 auto_punch_location_changed (location);
1141 Session::set_auto_loop_location (Location* location)
1145 if ((existing = _locations.auto_loop_location()) != 0 && existing != location) {
1146 auto_loop_start_changed_connection.disconnect();
1147 auto_loop_end_changed_connection.disconnect();
1148 auto_loop_changed_connection.disconnect();
1149 existing->set_auto_loop (false, this);
1150 remove_event (existing->end(), Event::AutoLoop);
1151 auto_loop_location_changed (0);
1156 if (location == 0) {
1160 if (location->end() <= location->start()) {
1161 error << _("Session: you can't use a mark for auto loop") << endmsg;
1165 last_loopend = location->end();
1167 auto_loop_start_changed_connection.disconnect();
1168 auto_loop_end_changed_connection.disconnect();
1169 auto_loop_changed_connection.disconnect();
1171 auto_loop_start_changed_connection = location->start_changed.connect (mem_fun (this, &Session::auto_loop_changed));
1172 auto_loop_end_changed_connection = location->end_changed.connect (mem_fun (this, &Session::auto_loop_changed));
1173 auto_loop_changed_connection = location->changed.connect (mem_fun (this, &Session::auto_loop_changed));
1175 location->set_auto_loop (true, this);
1176 auto_loop_location_changed (location);
1180 Session::locations_added (Location* ignored)
1186 Session::locations_changed ()
1188 _locations.apply (*this, &Session::handle_locations_changed);
1192 Session::handle_locations_changed (Locations::LocationList& locations)
1194 Locations::LocationList::iterator i;
1196 bool set_loop = false;
1197 bool set_punch = false;
1199 for (i = locations.begin(); i != locations.end(); ++i) {
1203 if (location->is_auto_punch()) {
1204 set_auto_punch_location (location);
1207 if (location->is_auto_loop()) {
1208 set_auto_loop_location (location);
1215 set_auto_loop_location (0);
1218 set_auto_punch_location (0);
1225 Session::enable_record ()
1227 /* XXX really atomic compare+swap here */
1228 if (g_atomic_int_get (&_record_status) != Recording) {
1229 g_atomic_int_set (&_record_status, Recording);
1230 _last_record_location = _transport_frame;
1231 deliver_mmc(MIDI::MachineControl::cmdRecordStrobe, _last_record_location);
1233 if (Config->get_monitoring_model() == HardwareMonitoring && Config->get_auto_input()) {
1234 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
1235 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
1236 if ((*i)->record_enabled ()) {
1237 (*i)->monitor_input (true);
1242 RecordStateChanged ();
1247 Session::disable_record (bool rt_context, bool force)
1251 if ((rs = (RecordState) g_atomic_int_get (&_record_status)) != Disabled) {
1253 if (!Config->get_latched_record_enable () || force) {
1254 g_atomic_int_set (&_record_status, Disabled);
1256 if (rs == Recording) {
1257 g_atomic_int_set (&_record_status, Enabled);
1261 // FIXME: timestamp correct? [DR]
1262 // FIXME FIXME FIXME: rt_context? this must be called in the process thread.
1263 // does this /need/ to be sent in all cases?
1265 deliver_mmc (MIDI::MachineControl::cmdRecordExit, _transport_frame);
1267 if (Config->get_monitoring_model() == HardwareMonitoring && Config->get_auto_input()) {
1268 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
1270 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
1271 if ((*i)->record_enabled ()) {
1272 (*i)->monitor_input (false);
1277 RecordStateChanged (); /* emit signal */
1280 remove_pending_capture_state ();
1286 Session::step_back_from_record ()
1288 g_atomic_int_set (&_record_status, Enabled);
1290 if (Config->get_monitoring_model() == HardwareMonitoring) {
1291 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
1293 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
1294 if (Config->get_auto_input() && (*i)->record_enabled ()) {
1295 //cerr << "switching from input" << __FILE__ << __LINE__ << endl << endl;
1296 (*i)->monitor_input (false);
1303 Session::maybe_enable_record ()
1305 g_atomic_int_set (&_record_status, Enabled);
1307 /* this function is currently called from somewhere other than an RT thread.
1308 this save_state() call therefore doesn't impact anything.
1311 save_state ("", true);
1313 if (_transport_speed) {
1314 if (!Config->get_punch_in()) {
1318 deliver_mmc (MIDI::MachineControl::cmdRecordPause, _transport_frame);
1319 RecordStateChanged (); /* EMIT SIGNAL */
1326 Session::audible_frame () const
1332 /* the first of these two possible settings for "offset"
1333 mean that the audible frame is stationary until
1334 audio emerges from the latency compensation
1337 the second means that the audible frame is stationary
1338 until audio would emerge from a physical port
1339 in the absence of any plugin latency compensation
1342 offset = _worst_output_latency;
1344 if (offset > current_block_size) {
1345 offset -= current_block_size;
1347 /* XXX is this correct? if we have no external
1348 physical connections and everything is internal
1349 then surely this is zero? still, how
1350 likely is that anyway?
1352 offset = current_block_size;
1355 if (synced_to_jack()) {
1356 tf = _engine.transport_frame();
1358 tf = _transport_frame;
1361 if (_transport_speed == 0) {
1371 if (!non_realtime_work_pending()) {
1375 /* take latency into account */
1384 Session::set_frame_rate (nframes_t frames_per_second)
1386 /** \fn void Session::set_frame_size(nframes_t)
1387 the AudioEngine object that calls this guarantees
1388 that it will not be called while we are also in
1389 ::process(). Its fine to do things that block
1393 _base_frame_rate = frames_per_second;
1397 Route::set_automation_interval ((nframes_t) ceil ((double) frames_per_second * 0.25));
1399 // XXX we need some equivalent to this, somehow
1400 // SndFileSource::setup_standard_crossfades (frames_per_second);
1404 /* XXX need to reset/reinstantiate all LADSPA plugins */
1408 Session::set_block_size (nframes_t nframes)
1410 /* the AudioEngine guarantees
1411 that it will not be called while we are also in
1412 ::process(). It is therefore fine to do things that block
1418 current_block_size = nframes;
1420 ensure_buffers(_scratch_buffers->available());
1422 if (_gain_automation_buffer) {
1423 delete [] _gain_automation_buffer;
1425 _gain_automation_buffer = new gain_t[nframes];
1427 allocate_pan_automation_buffers (nframes, _npan_buffers, true);
1429 boost::shared_ptr<RouteList> r = routes.reader ();
1431 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1432 (*i)->set_block_size (nframes);
1435 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
1436 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
1437 (*i)->set_block_size (nframes);
1440 set_worst_io_latencies ();
1445 Session::set_default_fade (float steepness, float fade_msecs)
1448 nframes_t fade_frames;
1450 /* Don't allow fade of less 1 frame */
1452 if (fade_msecs < (1000.0 * (1.0/_current_frame_rate))) {
1459 fade_frames = (nframes_t) floor (fade_msecs * _current_frame_rate * 0.001);
1463 default_fade_msecs = fade_msecs;
1464 default_fade_steepness = steepness;
1467 // jlc, WTF is this!
1468 Glib::RWLock::ReaderLock lm (route_lock);
1469 AudioRegion::set_default_fade (steepness, fade_frames);
1474 /* XXX have to do this at some point */
1475 /* foreach region using default fade, reset, then
1476 refill_all_diskstream_buffers ();
1481 struct RouteSorter {
1482 bool operator() (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> r2) {
1483 if (r1->fed_by.find (r2) != r1->fed_by.end()) {
1485 } else if (r2->fed_by.find (r1) != r2->fed_by.end()) {
1488 if (r1->fed_by.empty()) {
1489 if (r2->fed_by.empty()) {
1490 /* no ardour-based connections inbound to either route. just use signal order */
1491 return r1->order_key(N_("signal")) < r2->order_key(N_("signal"));
1493 /* r2 has connections, r1 does not; run r1 early */
1497 return r1->order_key(N_("signal")) < r2->order_key(N_("signal"));
1504 trace_terminal (shared_ptr<Route> r1, shared_ptr<Route> rbase)
1506 shared_ptr<Route> r2;
1508 if ((r1->fed_by.find (rbase) != r1->fed_by.end()) && (rbase->fed_by.find (r1) != rbase->fed_by.end())) {
1509 info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
1513 /* make a copy of the existing list of routes that feed r1 */
1515 set<shared_ptr<Route> > existing = r1->fed_by;
1517 /* for each route that feeds r1, recurse, marking it as feeding
1521 for (set<shared_ptr<Route> >::iterator i = existing.begin(); i != existing.end(); ++i) {
1524 /* r2 is a route that feeds r1 which somehow feeds base. mark
1525 base as being fed by r2
1528 rbase->fed_by.insert (r2);
1532 /* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
1536 if ((r1->fed_by.find (r2) != r1->fed_by.end()) && (r2->fed_by.find (r1) != r2->fed_by.end())) {
1540 /* now recurse, so that we can mark base as being fed by
1541 all routes that feed r2
1544 trace_terminal (r2, rbase);
1551 Session::resort_routes ()
1553 /* don't do anything here with signals emitted
1554 by Routes while we are being destroyed.
1557 if (_state_of_the_state & Deletion) {
1564 RCUWriter<RouteList> writer (routes);
1565 shared_ptr<RouteList> r = writer.get_copy ();
1566 resort_routes_using (r);
1567 /* writer goes out of scope and forces update */
1572 Session::resort_routes_using (shared_ptr<RouteList> r)
1574 RouteList::iterator i, j;
1576 for (i = r->begin(); i != r->end(); ++i) {
1578 (*i)->fed_by.clear ();
1580 for (j = r->begin(); j != r->end(); ++j) {
1582 /* although routes can feed themselves, it will
1583 cause an endless recursive descent if we
1584 detect it. so don't bother checking for
1592 if ((*j)->feeds (*i)) {
1593 (*i)->fed_by.insert (*j);
1598 for (i = r->begin(); i != r->end(); ++i) {
1599 trace_terminal (*i, *i);
1606 cerr << "finished route resort\n";
1608 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1609 cerr << " " << (*i)->name() << " signal order = " << (*i)->order_key ("signal") << endl;
1616 list<boost::shared_ptr<MidiTrack> >
1617 Session::new_midi_track (TrackMode mode, uint32_t how_many)
1619 char track_name[32];
1620 uint32_t track_id = 0;
1622 uint32_t channels_used = 0;
1624 RouteList new_routes;
1625 list<boost::shared_ptr<MidiTrack> > ret;
1627 /* count existing midi tracks */
1630 shared_ptr<RouteList> r = routes.reader ();
1632 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1633 if (dynamic_cast<MidiTrack*>((*i).get()) != 0) {
1634 if (!(*i)->hidden()) {
1636 channels_used += (*i)->n_inputs().n_midi();
1644 /* check for duplicate route names, since we might have pre-existing
1645 routes with this name (e.g. create Midi1, Midi2, delete Midi1,
1646 save, close,restart,add new route - first named route is now
1654 snprintf (track_name, sizeof(track_name), "Midi %" PRIu32, track_id);
1656 if (route_by_name (track_name) == 0) {
1660 } while (track_id < (UINT_MAX-1));
1663 shared_ptr<MidiTrack> track (new MidiTrack (*this, track_name, Route::Flag (0), mode));
1665 if (track->ensure_io (ChanCount(DataType::MIDI, 1), ChanCount(DataType::MIDI, 1), false, this)) {
1666 error << "cannot configure 1 in/1 out configuration for new midi track" << endmsg;
1669 channels_used += track->n_inputs ().n_midi();
1671 track->DiskstreamChanged.connect (mem_fun (this, &Session::resort_routes));
1672 track->set_remote_control_id (ntracks());
1674 new_routes.push_back (track);
1675 ret.push_back (track);
1678 catch (failed_constructor &err) {
1679 error << _("Session: could not create new midi track.") << endmsg;
1680 // XXX should we delete the tracks already created?
1688 if (!new_routes.empty()) {
1689 add_routes (new_routes, false);
1690 save_state (_current_snapshot_name);
1696 list<boost::shared_ptr<AudioTrack> >
1697 Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, uint32_t how_many)
1699 char track_name[32];
1700 uint32_t track_id = 0;
1702 uint32_t channels_used = 0;
1704 RouteList new_routes;
1705 list<boost::shared_ptr<AudioTrack> > ret;
1706 uint32_t control_id;
1708 /* count existing audio tracks */
1711 shared_ptr<RouteList> r = routes.reader ();
1713 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1714 if (dynamic_cast<AudioTrack*>((*i).get()) != 0) {
1715 if (!(*i)->hidden()) {
1717 channels_used += (*i)->n_inputs().n_audio();
1723 vector<string> physinputs;
1724 vector<string> physoutputs;
1725 uint32_t nphysical_in;
1726 uint32_t nphysical_out;
1728 _engine.get_physical_outputs (physoutputs);
1729 _engine.get_physical_inputs (physinputs);
1730 control_id = ntracks() + nbusses() + 1;
1734 /* check for duplicate route names, since we might have pre-existing
1735 routes with this name (e.g. create Audio1, Audio2, delete Audio1,
1736 save, close,restart,add new route - first named route is now
1744 snprintf (track_name, sizeof(track_name), "Audio %" PRIu32, track_id);
1746 if (route_by_name (track_name) == 0) {
1750 } while (track_id < (UINT_MAX-1));
1752 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
1753 nphysical_in = min (n_physical_inputs, (uint32_t) physinputs.size());
1758 if (Config->get_output_auto_connect() & AutoConnectPhysical) {
1759 nphysical_out = min (n_physical_outputs, (uint32_t) physinputs.size());
1764 shared_ptr<AudioTrack> track;
1767 track = boost::shared_ptr<AudioTrack>((new AudioTrack (*this, track_name, Route::Flag (0), mode)));
1769 if (track->ensure_io (ChanCount(DataType::AUDIO, input_channels), ChanCount(DataType::AUDIO, output_channels), false, this)) {
1770 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
1771 input_channels, output_channels)
1777 for (uint32_t x = 0; x < track->n_inputs().n_audio() && x < nphysical_in; ++x) {
1781 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
1782 port = physinputs[(channels_used+x)%nphysical_in];
1785 if (port.length() && track->connect_input (track->input (x), port, this)) {
1791 for (uint32_t x = 0; x < track->n_outputs().n_midi(); ++x) {
1795 if (nphysical_out && (Config->get_output_auto_connect() & AutoConnectPhysical)) {
1796 port = physoutputs[(channels_used+x)%nphysical_out];
1797 } else if (Config->get_output_auto_connect() & AutoConnectMaster) {
1799 port = _master_out->input (x%_master_out->n_inputs().n_audio())->name();
1803 if (port.length() && track->connect_output (track->output (x), port, this)) {
1808 channels_used += track->n_inputs ().n_audio();
1810 track->audio_diskstream()->non_realtime_input_change();
1812 track->DiskstreamChanged.connect (mem_fun (this, &Session::resort_routes));
1813 track->set_remote_control_id (control_id);
1816 new_routes.push_back (track);
1817 ret.push_back (track);
1820 catch (failed_constructor &err) {
1821 error << _("Session: could not create new audio track.") << endmsg;
1824 /* we need to get rid of this, since the track failed to be created */
1825 /* XXX arguably, AudioTrack::AudioTrack should not do the Session::add_diskstream() */
1828 RCUWriter<DiskstreamList> writer (diskstreams);
1829 boost::shared_ptr<DiskstreamList> ds = writer.get_copy();
1830 ds->remove (track->audio_diskstream());
1837 catch (AudioEngine::PortRegistrationFailure& pfe) {
1839 error << _("No more JACK ports are available. You will need to stop Ardour and restart JACK with ports if you need this many tracks.") << endmsg;
1842 /* we need to get rid of this, since the track failed to be created */
1843 /* XXX arguably, AudioTrack::AudioTrack should not do the Session::add_diskstream() */
1846 RCUWriter<DiskstreamList> writer (diskstreams);
1847 boost::shared_ptr<DiskstreamList> ds = writer.get_copy();
1848 ds->remove (track->audio_diskstream());
1859 if (!new_routes.empty()) {
1860 add_routes (new_routes, false);
1861 save_state (_current_snapshot_name);
1868 Session::set_remote_control_ids ()
1870 RemoteModel m = Config->get_remote_model();
1872 shared_ptr<RouteList> r = routes.reader ();
1874 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1875 if ( MixerOrdered == m) {
1876 long order = (*i)->order_key(N_("signal"));
1877 (*i)->set_remote_control_id( order+1 );
1878 } else if ( EditorOrdered == m) {
1879 long order = (*i)->order_key(N_("editor"));
1880 (*i)->set_remote_control_id( order+1 );
1881 } else if ( UserOrdered == m) {
1882 //do nothing ... only changes to remote id's are initiated by user
1889 Session::new_audio_route (int input_channels, int output_channels, uint32_t how_many)
1892 uint32_t bus_id = 1;
1896 uint32_t control_id;
1898 /* count existing audio busses */
1901 shared_ptr<RouteList> r = routes.reader ();
1903 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1904 if (dynamic_cast<AudioTrack*>((*i).get()) == 0) {
1905 if (!(*i)->hidden() && (*i)->name() != _("master")) {
1912 vector<string> physinputs;
1913 vector<string> physoutputs;
1915 _engine.get_physical_outputs (physoutputs);
1916 _engine.get_physical_inputs (physinputs);
1917 control_id = ntracks() + nbusses() + 1;
1922 snprintf (bus_name, sizeof(bus_name), "Bus %" PRIu32, bus_id);
1926 if (route_by_name (bus_name) == 0) {
1930 } while (bus_id < (UINT_MAX-1));
1933 shared_ptr<Route> bus (new Route (*this, bus_name, -1, -1, -1, -1, Route::Flag(0), DataType::AUDIO));
1935 if (bus->ensure_io (ChanCount(DataType::AUDIO, input_channels), ChanCount(DataType::AUDIO, output_channels), false, this)) {
1936 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
1937 input_channels, output_channels)
1942 for (uint32_t x = 0; n_physical_inputs && x < bus->n_inputs().n_audio(); ++x) {
1946 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
1947 port = physinputs[((n+x)%n_physical_inputs)];
1950 if (port.length() && bus->connect_input (bus->input (x), port, this)) {
1955 for (uint32_t x = 0; n_physical_outputs && x < bus->n_outputs().n_audio(); ++x) {
1959 if (Config->get_output_auto_connect() & AutoConnectPhysical) {
1960 port = physoutputs[((n+x)%n_physical_outputs)];
1961 } else if (Config->get_output_auto_connect() & AutoConnectMaster) {
1963 port = _master_out->input (x%_master_out->n_inputs().n_audio())->name();
1967 if (port.length() && bus->connect_output (bus->output (x), port, this)) {
1972 bus->set_remote_control_id (control_id);
1975 ret.push_back (bus);
1979 catch (failed_constructor &err) {
1980 error << _("Session: could not create new audio route.") << endmsg;
1984 catch (AudioEngine::PortRegistrationFailure& pfe) {
1985 error << _("No more JACK ports are available. You will need to stop Ardour and restart JACK with ports if you need this many tracks.") << endmsg;
1995 add_routes (ret, false);
1996 save_state (_current_snapshot_name);
2004 Session::add_routes (RouteList& new_routes, bool save)
2007 RCUWriter<RouteList> writer (routes);
2008 shared_ptr<RouteList> r = writer.get_copy ();
2009 r->insert (r->end(), new_routes.begin(), new_routes.end());
2010 resort_routes_using (r);
2013 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2015 boost::weak_ptr<Route> wpr (*x);
2017 (*x)->solo_changed.connect (sigc::bind (mem_fun (*this, &Session::route_solo_changed), wpr));
2018 (*x)->mute_changed.connect (mem_fun (*this, &Session::route_mute_changed));
2019 (*x)->output_changed.connect (mem_fun (*this, &Session::set_worst_io_latencies_x));
2020 (*x)->redirects_changed.connect (mem_fun (*this, &Session::update_latency_compensation_proxy));
2022 if ((*x)->master()) {
2026 if ((*x)->control()) {
2027 _control_out = (*x);
2031 if (_control_out && IO::connecting_legal) {
2033 vector<string> cports;
2034 uint32_t ni = _control_out->n_inputs().n_audio();
2036 for (uint32_t n = 0; n < ni; ++n) {
2037 cports.push_back (_control_out->input(n)->name());
2040 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
2041 (*x)->set_control_outs (cports);
2048 save_state (_current_snapshot_name);
2051 RouteAdded (new_routes); /* EMIT SIGNAL */
2055 Session::add_diskstream (boost::shared_ptr<Diskstream> dstream)
2057 /* need to do this in case we're rolling at the time, to prevent false underruns */
2058 dstream->do_refill_with_alloc ();
2060 dstream->set_block_size (current_block_size);
2063 RCUWriter<DiskstreamList> writer (diskstreams);
2064 boost::shared_ptr<DiskstreamList> ds = writer.get_copy();
2065 ds->push_back (dstream);
2066 /* writer goes out of scope, copies ds back to main */
2069 dstream->PlaylistChanged.connect (sigc::bind (mem_fun (*this, &Session::diskstream_playlist_changed), dstream));
2070 /* this will connect to future changes, and check the current length */
2071 diskstream_playlist_changed (dstream);
2073 dstream->prepare ();
2078 Session::remove_route (shared_ptr<Route> route)
2081 RCUWriter<RouteList> writer (routes);
2082 shared_ptr<RouteList> rs = writer.get_copy ();
2086 /* deleting the master out seems like a dumb
2087 idea, but its more of a UI policy issue
2091 if (route == _master_out) {
2092 _master_out = shared_ptr<Route> ();
2095 if (route == _control_out) {
2096 _control_out = shared_ptr<Route> ();
2098 /* cancel control outs for all routes */
2100 vector<string> empty;
2102 for (RouteList::iterator r = rs->begin(); r != rs->end(); ++r) {
2103 (*r)->set_control_outs (empty);
2107 update_route_solo_state ();
2109 /* writer goes out of scope, forces route list update */
2113 boost::shared_ptr<Diskstream> ds;
2115 if ((t = dynamic_cast<Track*>(route.get())) != 0) {
2116 ds = t->diskstream();
2122 RCUWriter<DiskstreamList> dsl (diskstreams);
2123 boost::shared_ptr<DiskstreamList> d = dsl.get_copy();
2128 find_current_end ();
2130 update_latency_compensation (false, false);
2133 // We need to disconnect the routes inputs and outputs
2134 route->disconnect_inputs(NULL);
2135 route->disconnect_outputs(NULL);
2137 /* get rid of it from the dead wood collection in the route list manager */
2139 /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
2143 /* try to cause everyone to drop their references */
2145 route->drop_references ();
2147 /* save the new state of the world */
2149 if (save_state (_current_snapshot_name)) {
2150 save_history (_current_snapshot_name);
2155 Session::route_mute_changed (void* src)
2161 Session::route_solo_changed (void* src, boost::weak_ptr<Route> wpr)
2163 if (solo_update_disabled) {
2169 boost::shared_ptr<Route> route = wpr.lock ();
2172 /* should not happen */
2173 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2177 is_track = (boost::dynamic_pointer_cast<AudioTrack>(route) != 0);
2179 shared_ptr<RouteList> r = routes.reader ();
2181 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2183 /* soloing a track mutes all other tracks, soloing a bus mutes all other busses */
2187 /* don't mess with busses */
2189 if (dynamic_cast<Track*>((*i).get()) == 0) {
2195 /* don't mess with tracks */
2197 if (dynamic_cast<Track*>((*i).get()) != 0) {
2202 if ((*i) != route &&
2203 ((*i)->mix_group () == 0 ||
2204 (*i)->mix_group () != route->mix_group () ||
2205 !route->mix_group ()->is_active())) {
2207 if ((*i)->soloed()) {
2209 /* if its already soloed, and solo latching is enabled,
2210 then leave it as it is.
2213 if (Config->get_solo_latched()) {
2220 solo_update_disabled = true;
2221 (*i)->set_solo (false, src);
2222 solo_update_disabled = false;
2226 bool something_soloed = false;
2227 bool same_thing_soloed = false;
2228 bool signal = false;
2230 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2231 if ((*i)->soloed()) {
2232 something_soloed = true;
2233 if (dynamic_cast<Track*>((*i).get())) {
2235 same_thing_soloed = true;
2240 same_thing_soloed = true;
2248 if (something_soloed != currently_soloing) {
2250 currently_soloing = something_soloed;
2253 modify_solo_mute (is_track, same_thing_soloed);
2256 SoloActive (currently_soloing); /* EMIT SIGNAL */
2259 SoloChanged (); /* EMIT SIGNAL */
2265 Session::update_route_solo_state ()
2268 bool is_track = false;
2269 bool signal = false;
2271 /* caller must hold RouteLock */
2273 /* this is where we actually implement solo by changing
2274 the solo mute setting of each track.
2277 shared_ptr<RouteList> r = routes.reader ();
2279 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2280 if ((*i)->soloed()) {
2282 if (dynamic_cast<Track*>((*i).get())) {
2289 if (mute != currently_soloing) {
2291 currently_soloing = mute;
2294 if (!is_track && !mute) {
2296 /* nothing is soloed */
2298 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2299 (*i)->set_solo_mute (false);
2309 modify_solo_mute (is_track, mute);
2312 SoloActive (currently_soloing);
2317 Session::modify_solo_mute (bool is_track, bool mute)
2319 shared_ptr<RouteList> r = routes.reader ();
2321 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2325 /* only alter track solo mute */
2327 if (dynamic_cast<Track*>((*i).get())) {
2328 if ((*i)->soloed()) {
2329 (*i)->set_solo_mute (!mute);
2331 (*i)->set_solo_mute (mute);
2337 /* only alter bus solo mute */
2339 if (!dynamic_cast<Track*>((*i).get())) {
2341 if ((*i)->soloed()) {
2343 (*i)->set_solo_mute (false);
2347 /* don't mute master or control outs
2348 in response to another bus solo
2351 if ((*i) != _master_out &&
2352 (*i) != _control_out) {
2353 (*i)->set_solo_mute (mute);
2364 Session::catch_up_on_solo ()
2366 /* this is called after set_state() to catch the full solo
2367 state, which can't be correctly determined on a per-route
2368 basis, but needs the global overview that only the session
2371 update_route_solo_state();
2375 Session::route_by_name (string name)
2377 shared_ptr<RouteList> r = routes.reader ();
2379 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2380 if ((*i)->name() == name) {
2385 return shared_ptr<Route> ((Route*) 0);
2389 Session::route_by_id (PBD::ID id)
2391 shared_ptr<RouteList> r = routes.reader ();
2393 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2394 if ((*i)->id() == id) {
2399 return shared_ptr<Route> ((Route*) 0);
2403 Session::route_by_remote_id (uint32_t id)
2405 shared_ptr<RouteList> r = routes.reader ();
2407 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2408 if ((*i)->remote_control_id() == id) {
2413 return shared_ptr<Route> ((Route*) 0);
2417 Session::find_current_end ()
2419 if (_state_of_the_state & Loading) {
2423 nframes_t max = get_maximum_extent ();
2425 if (max > end_location->end()) {
2426 end_location->set_end (max);
2428 DurationChanged(); /* EMIT SIGNAL */
2433 Session::get_maximum_extent () const
2438 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
2440 for (DiskstreamList::const_iterator i = dsl->begin(); i != dsl->end(); ++i) {
2441 boost::shared_ptr<Playlist> pl = (*i)->playlist();
2442 if ((me = pl->get_maximum_extent()) > max) {
2450 boost::shared_ptr<Diskstream>
2451 Session::diskstream_by_name (string name)
2453 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
2455 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
2456 if ((*i)->name() == name) {
2461 return boost::shared_ptr<Diskstream>((Diskstream*) 0);
2464 boost::shared_ptr<Diskstream>
2465 Session::diskstream_by_id (const PBD::ID& id)
2467 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
2469 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
2470 if ((*i)->id() == id) {
2475 return boost::shared_ptr<Diskstream>((Diskstream*) 0);
2478 /* Region management */
2481 Session::new_region_name (string old)
2483 string::size_type last_period;
2485 string::size_type len = old.length() + 64;
2488 if ((last_period = old.find_last_of ('.')) == string::npos) {
2490 /* no period present - add one explicitly */
2493 last_period = old.length() - 1;
2498 number = atoi (old.substr (last_period+1).c_str());
2502 while (number < (UINT_MAX-1)) {
2504 RegionList::const_iterator i;
2509 snprintf (buf, len, "%s%" PRIu32, old.substr (0, last_period + 1).c_str(), number);
2512 for (i = regions.begin(); i != regions.end(); ++i) {
2513 if (i->second->name() == sbuf) {
2518 if (i == regions.end()) {
2523 if (number != (UINT_MAX-1)) {
2527 error << string_compose (_("cannot create new name for region \"%1\""), old) << endmsg;
2532 Session::region_name (string& result, string base, bool newlevel) const
2537 assert(base.find("/") == string::npos);
2541 Glib::Mutex::Lock lm (region_lock);
2543 snprintf (buf, sizeof (buf), "%d", (int)regions.size() + 1);
2551 /* XXX this is going to be slow. optimize me later */
2556 string::size_type pos;
2558 pos = base.find_last_of ('.');
2560 /* pos may be npos, but then we just use entire base */
2562 subbase = base.substr (0, pos);
2566 bool name_taken = true;
2569 Glib::Mutex::Lock lm (region_lock);
2571 for (int n = 1; n < 5000; ++n) {
2574 snprintf (buf, sizeof (buf), ".%d", n);
2579 for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
2580 if (i->second->name() == result) {
2593 fatal << string_compose(_("too many regions with names like %1"), base) << endmsg;
2601 Session::add_region (boost::shared_ptr<Region> region)
2603 boost::shared_ptr<Region> other;
2607 Glib::Mutex::Lock lm (region_lock);
2609 RegionList::iterator x;
2611 for (x = regions.begin(); x != regions.end(); ++x) {
2615 if (region->region_list_equivalent (other)) {
2620 if (x == regions.end()) {
2622 pair<RegionList::key_type,RegionList::mapped_type> entry;
2624 entry.first = region->id();
2625 entry.second = region;
2627 pair<RegionList::iterator,bool> x = regions.insert (entry);
2639 /* mark dirty because something has changed even if we didn't
2640 add the region to the region list.
2646 region->GoingAway.connect (sigc::bind (mem_fun (*this, &Session::remove_region), boost::weak_ptr<Region>(region)));
2647 region->StateChanged.connect (sigc::bind (mem_fun (*this, &Session::region_changed), boost::weak_ptr<Region>(region)));
2648 RegionAdded (region); /* EMIT SIGNAL */
2653 Session::region_changed (Change what_changed, boost::weak_ptr<Region> weak_region)
2655 boost::shared_ptr<Region> region (weak_region.lock ());
2661 if (what_changed & Region::HiddenChanged) {
2662 /* relay hidden changes */
2663 RegionHiddenChange (region);
2668 Session::remove_region (boost::weak_ptr<Region> weak_region)
2670 RegionList::iterator i;
2671 boost::shared_ptr<Region> region (weak_region.lock ());
2677 bool removed = false;
2680 Glib::Mutex::Lock lm (region_lock);
2682 if ((i = regions.find (region->id())) != regions.end()) {
2688 /* mark dirty because something has changed even if we didn't
2689 remove the region from the region list.
2695 RegionRemoved(region); /* EMIT SIGNAL */
2699 boost::shared_ptr<Region>
2700 Session::find_whole_file_parent (boost::shared_ptr<Region const> child)
2702 RegionList::iterator i;
2703 boost::shared_ptr<Region> region;
2705 Glib::Mutex::Lock lm (region_lock);
2707 for (i = regions.begin(); i != regions.end(); ++i) {
2711 if (region->whole_file()) {
2713 if (child->source_equivalent (region)) {
2719 return boost::shared_ptr<Region> ();
2723 Session::find_equivalent_playlist_regions (boost::shared_ptr<Region> region, vector<boost::shared_ptr<Region> >& result)
2725 for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i)
2726 (*i)->get_region_list_equivalent_regions (region, result);
2730 Session::destroy_region (boost::shared_ptr<Region> region)
2732 vector<boost::shared_ptr<Source> > srcs;
2735 boost::shared_ptr<AudioRegion> aregion;
2737 if ((aregion = boost::dynamic_pointer_cast<AudioRegion> (region)) == 0) {
2741 if (aregion->playlist()) {
2742 aregion->playlist()->destroy_region (region);
2745 for (uint32_t n = 0; n < aregion->n_channels(); ++n) {
2746 srcs.push_back (aregion->source (n));
2750 region->drop_references ();
2752 for (vector<boost::shared_ptr<Source> >::iterator i = srcs.begin(); i != srcs.end(); ++i) {
2754 if (!(*i)->used()) {
2755 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*i);
2758 (afs)->mark_for_remove ();
2761 (*i)->drop_references ();
2763 cerr << "source was not used by any playlist\n";
2771 Session::destroy_regions (list<boost::shared_ptr<Region> > regions)
2773 for (list<boost::shared_ptr<Region> >::iterator i = regions.begin(); i != regions.end(); ++i) {
2774 destroy_region (*i);
2780 Session::remove_last_capture ()
2782 list<boost::shared_ptr<Region> > r;
2784 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
2786 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
2787 list<boost::shared_ptr<Region> >& l = (*i)->last_capture_regions();
2790 r.insert (r.end(), l.begin(), l.end());
2795 destroy_regions (r);
2797 save_state (_current_snapshot_name);
2803 Session::remove_region_from_region_list (boost::shared_ptr<Region> r)
2809 /* Source Management */
2811 Session::add_source (boost::shared_ptr<Source> source)
2813 pair<SourceMap::key_type, SourceMap::mapped_type> entry;
2814 pair<SourceMap::iterator,bool> result;
2816 entry.first = source->id();
2817 entry.second = source;
2820 Glib::Mutex::Lock lm (source_lock);
2821 result = sources.insert (entry);
2824 if (result.second) {
2825 source->GoingAway.connect (sigc::bind (mem_fun (this, &Session::remove_source), boost::weak_ptr<Source> (source)));
2831 Session::remove_source (boost::weak_ptr<Source> src)
2833 SourceMap::iterator i;
2834 boost::shared_ptr<Source> source = src.lock();
2841 Glib::Mutex::Lock lm (source_lock);
2844 Glib::Mutex::Lock lm (source_lock);
2846 if ((i = sources.find (source->id())) != sources.end()) {
2852 if (!_state_of_the_state & InCleanup) {
2854 /* save state so we don't end up with a session file
2855 referring to non-existent sources.
2858 save_state (_current_snapshot_name);
2862 boost::shared_ptr<Source>
2863 Session::source_by_id (const PBD::ID& id)
2865 Glib::Mutex::Lock lm (source_lock);
2866 SourceMap::iterator i;
2867 boost::shared_ptr<Source> source;
2869 if ((i = sources.find (id)) != sources.end()) {
2873 /* XXX search MIDI or other searches here */
2879 boost::shared_ptr<Source>
2880 Session::source_by_path_and_channel (const Glib::ustring& path, uint16_t chn)
2882 Glib::Mutex::Lock lm (source_lock);
2884 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
2885 cerr << "comparing " << path << " with " << i->second->name() << endl;
2886 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
2888 if (afs && afs->path() == path && chn == afs->channel()) {
2893 return boost::shared_ptr<Source>();
2897 Session::peak_path_from_audio_path (string audio_path) const
2902 res += PBD::basename_nosuffix (audio_path);
2909 Session::change_audio_path_by_name (string path, string oldname, string newname, bool destructive)
2912 string old_basename = PBD::basename_nosuffix (oldname);
2913 string new_legalized = legalize_for_path (newname);
2915 /* note: we know (or assume) the old path is already valid */
2919 /* destructive file sources have a name of the form:
2921 /path/to/Tnnnn-NAME(%[LR])?.wav
2923 the task here is to replace NAME with the new name.
2926 /* find last slash */
2930 string::size_type slash;
2931 string::size_type dash;
2933 if ((slash = path.find_last_of ('/')) == string::npos) {
2937 dir = path.substr (0, slash+1);
2939 /* '-' is not a legal character for the NAME part of the path */
2941 if ((dash = path.find_last_of ('-')) == string::npos) {
2945 prefix = path.substr (slash+1, dash-(slash+1));
2950 path += new_legalized;
2951 path += ".wav"; /* XXX gag me with a spoon */
2955 /* non-destructive file sources have a name of the form:
2957 /path/to/NAME-nnnnn(%[LR])?.wav
2959 the task here is to replace NAME with the new name.
2964 string::size_type slash;
2965 string::size_type dash;
2966 string::size_type postfix;
2968 /* find last slash */
2970 if ((slash = path.find_last_of ('/')) == string::npos) {
2974 dir = path.substr (0, slash+1);
2976 /* '-' is not a legal character for the NAME part of the path */
2978 if ((dash = path.find_last_of ('-')) == string::npos) {
2982 suffix = path.substr (dash+1);
2984 // Suffix is now everything after the dash. Now we need to eliminate
2985 // the nnnnn part, which is done by either finding a '%' or a '.'
2987 postfix = suffix.find_last_of ("%");
2988 if (postfix == string::npos) {
2989 postfix = suffix.find_last_of ('.');
2992 if (postfix != string::npos) {
2993 suffix = suffix.substr (postfix);
2995 error << "Logic error in Session::change_audio_path_by_name(), please report to the developers" << endl;
2999 const uint32_t limit = 10000;
3000 char buf[PATH_MAX+1];
3002 for (uint32_t cnt = 1; cnt <= limit; ++cnt) {
3004 snprintf (buf, sizeof(buf), "%s%s-%u%s", dir.c_str(), newname.c_str(), cnt, suffix.c_str());
3006 if (access (buf, F_OK) != 0) {
3014 error << "FATAL ERROR! Could not find a " << endl;
3023 Session::audio_path_from_name (string name, uint32_t nchan, uint32_t chan, bool destructive)
3027 char buf[PATH_MAX+1];
3028 const uint32_t limit = 10000;
3032 legalized = legalize_for_path (name);
3034 /* find a "version" of the file name that doesn't exist in
3035 any of the possible directories.
3038 for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
3040 vector<space_and_path>::iterator i;
3041 uint32_t existing = 0;
3043 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3047 spath += sound_dir (false);
3051 snprintf (buf, sizeof(buf), "%s/T%04d-%s.wav", spath.c_str(), cnt, legalized.c_str());
3052 } else if (nchan == 2) {
3054 snprintf (buf, sizeof(buf), "%s/T%04d-%s%%L.wav", spath.c_str(), cnt, legalized.c_str());
3056 snprintf (buf, sizeof(buf), "%s/T%04d-%s%%R.wav", spath.c_str(), cnt, legalized.c_str());
3058 } else if (nchan < 26) {
3059 snprintf (buf, sizeof(buf), "%s/T%04d-%s%%%c.wav", spath.c_str(), cnt, legalized.c_str(), 'a' + chan);
3061 snprintf (buf, sizeof(buf), "%s/T%04d-%s.wav", spath.c_str(), cnt, legalized.c_str());
3070 snprintf (buf, sizeof(buf), "%s-%u.wav", spath.c_str(), cnt);
3071 } else if (nchan == 2) {
3073 snprintf (buf, sizeof(buf), "%s-%u%%L.wav", spath.c_str(), cnt);
3075 snprintf (buf, sizeof(buf), "%s-%u%%R.wav", spath.c_str(), cnt);
3077 } else if (nchan < 26) {
3078 snprintf (buf, sizeof(buf), "%s-%u%%%c.wav", spath.c_str(), cnt, 'a' + chan);
3080 snprintf (buf, sizeof(buf), "%s-%u.wav", spath.c_str(), cnt);
3084 if (g_file_test (buf, G_FILE_TEST_EXISTS)) {
3090 if (existing == 0) {
3095 error << string_compose(_("There are already %1 recordings for %2, which I consider too many."), limit, name) << endmsg;
3097 throw failed_constructor();
3101 /* we now have a unique name for the file, but figure out where to
3107 spath = discover_best_sound_dir ();
3110 string::size_type pos = foo.find_last_of ('/');
3112 if (pos == string::npos) {
3115 spath += foo.substr (pos + 1);
3121 boost::shared_ptr<AudioFileSource>
3122 Session::create_audio_source_for_session (AudioDiskstream& ds, uint32_t chan, bool destructive)
3124 string spath = audio_path_from_name (ds.name(), ds.n_channels().n_audio(), chan, destructive);
3125 return boost::dynamic_pointer_cast<AudioFileSource> (
3126 SourceFactory::createWritable (DataType::AUDIO, *this, spath, destructive, frame_rate()));
3129 // FIXME: _terrible_ code duplication
3131 Session::change_midi_path_by_name (string path, string oldname, string newname, bool destructive)
3134 string old_basename = PBD::basename_nosuffix (oldname);
3135 string new_legalized = legalize_for_path (newname);
3137 /* note: we know (or assume) the old path is already valid */
3141 /* destructive file sources have a name of the form:
3143 /path/to/Tnnnn-NAME(%[LR])?.wav
3145 the task here is to replace NAME with the new name.
3148 /* find last slash */
3152 string::size_type slash;
3153 string::size_type dash;
3155 if ((slash = path.find_last_of ('/')) == string::npos) {
3159 dir = path.substr (0, slash+1);
3161 /* '-' is not a legal character for the NAME part of the path */
3163 if ((dash = path.find_last_of ('-')) == string::npos) {
3167 prefix = path.substr (slash+1, dash-(slash+1));
3172 path += new_legalized;
3173 path += ".mid"; /* XXX gag me with a spoon */
3177 /* non-destructive file sources have a name of the form:
3179 /path/to/NAME-nnnnn(%[LR])?.wav
3181 the task here is to replace NAME with the new name.
3186 string::size_type slash;
3187 string::size_type dash;
3188 string::size_type postfix;
3190 /* find last slash */
3192 if ((slash = path.find_last_of ('/')) == string::npos) {
3196 dir = path.substr (0, slash+1);
3198 /* '-' is not a legal character for the NAME part of the path */
3200 if ((dash = path.find_last_of ('-')) == string::npos) {
3204 suffix = path.substr (dash+1);
3206 // Suffix is now everything after the dash. Now we need to eliminate
3207 // the nnnnn part, which is done by either finding a '%' or a '.'
3209 postfix = suffix.find_last_of ("%");
3210 if (postfix == string::npos) {
3211 postfix = suffix.find_last_of ('.');
3214 if (postfix != string::npos) {
3215 suffix = suffix.substr (postfix);
3217 error << "Logic error in Session::change_midi_path_by_name(), please report to the developers" << endl;
3221 const uint32_t limit = 10000;
3222 char buf[PATH_MAX+1];
3224 for (uint32_t cnt = 1; cnt <= limit; ++cnt) {
3226 snprintf (buf, sizeof(buf), "%s%s-%u%s", dir.c_str(), newname.c_str(), cnt, suffix.c_str());
3228 if (access (buf, F_OK) != 0) {
3236 error << "FATAL ERROR! Could not find a " << endl;
3245 Session::midi_path_from_name (string name)
3249 char buf[PATH_MAX+1];
3250 const uint32_t limit = 10000;
3254 legalized = legalize_for_path (name);
3256 /* find a "version" of the file name that doesn't exist in
3257 any of the possible directories.
3260 for (cnt = 1; cnt <= limit; ++cnt) {
3262 vector<space_and_path>::iterator i;
3263 uint32_t existing = 0;
3265 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3269 // FIXME: different directory from audio?
3270 spath += sound_dir(false) + "/" + legalized;
3272 snprintf (buf, sizeof(buf), "%s-%u.mid", spath.c_str(), cnt);
3274 if (g_file_test (buf, G_FILE_TEST_EXISTS)) {
3279 if (existing == 0) {
3284 error << string_compose(_("There are already %1 recordings for %2, which I consider too many."), limit, name) << endmsg;
3285 throw failed_constructor();
3289 /* we now have a unique name for the file, but figure out where to
3295 // FIXME: different directory than audio?
3296 spath = discover_best_sound_dir ();
3299 string::size_type pos = foo.find_last_of ('/');
3301 if (pos == string::npos) {
3304 spath += foo.substr (pos + 1);
3310 boost::shared_ptr<MidiSource>
3311 Session::create_midi_source_for_session (MidiDiskstream& ds)
3313 string spath = midi_path_from_name (ds.name());
3315 return boost::dynamic_pointer_cast<SMFSource> (SourceFactory::createWritable (DataType::MIDI, *this, spath, false, frame_rate()));
3319 /* Playlist management */
3321 boost::shared_ptr<Playlist>
3322 Session::playlist_by_name (string name)
3324 Glib::Mutex::Lock lm (playlist_lock);
3325 for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i) {
3326 if ((*i)->name() == name) {
3330 for (PlaylistList::iterator i = unused_playlists.begin(); i != unused_playlists.end(); ++i) {
3331 if ((*i)->name() == name) {
3336 return boost::shared_ptr<Playlist>();
3340 Session::add_playlist (boost::shared_ptr<Playlist> playlist)
3342 if (playlist->hidden()) {
3347 Glib::Mutex::Lock lm (playlist_lock);
3348 if (find (playlists.begin(), playlists.end(), playlist) == playlists.end()) {
3349 playlists.insert (playlists.begin(), playlist);
3350 playlist->InUse.connect (sigc::bind (mem_fun (*this, &Session::track_playlist), boost::weak_ptr<Playlist>(playlist)));
3351 playlist->GoingAway.connect (sigc::bind (mem_fun (*this, &Session::remove_playlist), boost::weak_ptr<Playlist>(playlist)));
3357 PlaylistAdded (playlist); /* EMIT SIGNAL */
3361 Session::get_playlists (vector<boost::shared_ptr<Playlist> >& s)
3364 Glib::Mutex::Lock lm (playlist_lock);
3365 for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i) {
3368 for (PlaylistList::iterator i = unused_playlists.begin(); i != unused_playlists.end(); ++i) {
3375 Session::track_playlist (bool inuse, boost::weak_ptr<Playlist> wpl)
3377 boost::shared_ptr<Playlist> pl(wpl.lock());
3383 PlaylistList::iterator x;
3386 /* its not supposed to be visible */
3391 Glib::Mutex::Lock lm (playlist_lock);
3395 unused_playlists.insert (pl);
3397 if ((x = playlists.find (pl)) != playlists.end()) {
3398 playlists.erase (x);
3404 playlists.insert (pl);
3406 if ((x = unused_playlists.find (pl)) != unused_playlists.end()) {
3407 unused_playlists.erase (x);
3414 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
3416 if (_state_of_the_state & Deletion) {
3420 boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
3427 Glib::Mutex::Lock lm (playlist_lock);
3429 PlaylistList::iterator i;
3431 i = find (playlists.begin(), playlists.end(), playlist);
3432 if (i != playlists.end()) {
3433 playlists.erase (i);
3436 i = find (unused_playlists.begin(), unused_playlists.end(), playlist);
3437 if (i != unused_playlists.end()) {
3438 unused_playlists.erase (i);
3445 PlaylistRemoved (playlist); /* EMIT SIGNAL */
3449 Session::set_audition (boost::shared_ptr<Region> r)
3451 pending_audition_region = r;
3452 post_transport_work = PostTransportWork (post_transport_work | PostTransportAudition);
3453 schedule_butler_transport_work ();
3457 Session::audition_playlist ()
3459 Event* ev = new Event (Event::Audition, Event::Add, Event::Immediate, 0, 0.0);
3460 ev->region.reset ();
3465 Session::non_realtime_set_audition ()
3467 if (!pending_audition_region) {
3468 auditioner->audition_current_playlist ();
3470 auditioner->audition_region (pending_audition_region);
3471 pending_audition_region.reset ();
3473 AuditionActive (true); /* EMIT SIGNAL */
3477 Session::audition_region (boost::shared_ptr<Region> r)
3479 Event* ev = new Event (Event::Audition, Event::Add, Event::Immediate, 0, 0.0);
3485 Session::cancel_audition ()
3487 if (auditioner->active()) {
3488 auditioner->cancel_audition ();
3489 AuditionActive (false); /* EMIT SIGNAL */
3494 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
3496 return a->order_key(N_("signal")) < b->order_key(N_("signal"));
3500 Session::remove_empty_sounds ()
3502 PathScanner scanner;
3504 vector<string *>* possible_audiofiles = scanner (sound_dir(), Config->get_possible_audio_file_regexp (), false, true);
3506 Glib::Mutex::Lock lm (source_lock);
3508 regex_t compiled_tape_track_pattern;
3511 if ((err = regcomp (&compiled_tape_track_pattern, "/T[0-9][0-9][0-9][0-9]-", REG_EXTENDED|REG_NOSUB))) {
3515 regerror (err, &compiled_tape_track_pattern, msg, sizeof (msg));
3517 error << string_compose (_("Cannot compile tape track regexp for use (%1)"), msg) << endmsg;
3521 for (vector<string *>::iterator i = possible_audiofiles->begin(); i != possible_audiofiles->end(); ++i) {
3523 /* never remove files that appear to be a tape track */
3525 if (regexec (&compiled_tape_track_pattern, (*i)->c_str(), 0, 0, 0) == 0) {
3530 if (AudioFileSource::is_empty (*this, *(*i))) {
3532 unlink ((*i)->c_str());
3534 string peak_path = peak_path_from_audio_path (**i);
3535 unlink (peak_path.c_str());
3541 delete possible_audiofiles;
3545 Session::is_auditioning () const
3547 /* can be called before we have an auditioner object */
3549 return auditioner->active();
3556 Session::set_all_solo (bool yn)
3558 shared_ptr<RouteList> r = routes.reader ();
3560 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3561 if (!(*i)->hidden()) {
3562 (*i)->set_solo (yn, this);
3570 Session::set_all_mute (bool yn)
3572 shared_ptr<RouteList> r = routes.reader ();
3574 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3575 if (!(*i)->hidden()) {
3576 (*i)->set_mute (yn, this);
3584 Session::n_diskstreams () const
3588 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
3590 for (DiskstreamList::const_iterator i = dsl->begin(); i != dsl->end(); ++i) {
3591 if (!(*i)->hidden()) {
3599 Session::graph_reordered ()
3601 /* don't do this stuff if we are setting up connections
3602 from a set_state() call or creating new tracks.
3605 if (_state_of_the_state & InitialConnecting) {
3609 /* every track/bus asked for this to be handled but it was deferred because
3610 we were connecting. do it now.
3613 request_input_change_handling ();
3617 /* force all diskstreams to update their capture offset values to
3618 reflect any changes in latencies within the graph.
3621 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
3623 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
3624 (*i)->set_capture_offset ();
3629 Session::record_disenable_all ()
3631 record_enable_change_all (false);
3635 Session::record_enable_all ()
3637 record_enable_change_all (true);
3641 Session::record_enable_change_all (bool yn)
3643 shared_ptr<RouteList> r = routes.reader ();
3645 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3648 if ((at = dynamic_cast<Track*>((*i).get())) != 0) {
3649 at->set_record_enable (yn, this);
3653 /* since we don't keep rec-enable state, don't mark session dirty */
3657 Session::add_redirect (Redirect* redirect)
3661 PortInsert* port_insert;
3662 PluginInsert* plugin_insert;
3664 if ((insert = dynamic_cast<Insert *> (redirect)) != 0) {
3665 if ((port_insert = dynamic_cast<PortInsert *> (insert)) != 0) {
3666 _port_inserts.insert (_port_inserts.begin(), port_insert);
3667 } else if ((plugin_insert = dynamic_cast<PluginInsert *> (insert)) != 0) {
3668 _plugin_inserts.insert (_plugin_inserts.begin(), plugin_insert);
3670 fatal << _("programming error: unknown type of Insert created!") << endmsg;
3673 } else if ((send = dynamic_cast<Send *> (redirect)) != 0) {
3674 _sends.insert (_sends.begin(), send);
3676 fatal << _("programming error: unknown type of Redirect created!") << endmsg;
3680 redirect->GoingAway.connect (sigc::bind (mem_fun (*this, &Session::remove_redirect), redirect));
3686 Session::remove_redirect (Redirect* redirect)
3690 PortInsert* port_insert;
3691 PluginInsert* plugin_insert;
3693 if ((insert = dynamic_cast<Insert *> (redirect)) != 0) {
3694 if ((port_insert = dynamic_cast<PortInsert *> (insert)) != 0) {
3695 list<PortInsert*>::iterator x = find (_port_inserts.begin(), _port_inserts.end(), port_insert);
3696 if (x != _port_inserts.end()) {
3697 insert_bitset[port_insert->bit_slot()] = false;
3698 _port_inserts.erase (x);
3700 } else if ((plugin_insert = dynamic_cast<PluginInsert *> (insert)) != 0) {
3701 _plugin_inserts.remove (plugin_insert);
3703 fatal << string_compose (_("programming error: %1"),
3704 X_("unknown type of Insert deleted!"))
3708 } else if ((send = dynamic_cast<Send *> (redirect)) != 0) {
3709 list<Send*>::iterator x = find (_sends.begin(), _sends.end(), send);
3710 if (x != _sends.end()) {
3711 send_bitset[send->bit_slot()] = false;
3715 fatal << _("programming error: unknown type of Redirect deleted!") << endmsg;
3723 Session::available_capture_duration ()
3725 float sample_bytes_on_disk = 4.0; // keep gcc happy
3727 switch (Config->get_native_file_data_format()) {
3729 sample_bytes_on_disk = 4.0;
3733 sample_bytes_on_disk = 3.0;
3737 /* impossible, but keep some gcc versions happy */
3738 fatal << string_compose (_("programming error: %1"),
3739 X_("illegal native file data format"))
3744 double scale = 4096.0 / sample_bytes_on_disk;
3746 if (_total_free_4k_blocks * scale > (double) max_frames) {
3750 return (nframes_t) floor (_total_free_4k_blocks * scale);
3754 Session::add_connection (ARDOUR::Connection* connection)
3757 Glib::Mutex::Lock guard (connection_lock);
3758 _connections.push_back (connection);
3761 ConnectionAdded (connection); /* EMIT SIGNAL */
3767 Session::remove_connection (ARDOUR::Connection* connection)
3769 bool removed = false;
3772 Glib::Mutex::Lock guard (connection_lock);
3773 ConnectionList::iterator i = find (_connections.begin(), _connections.end(), connection);
3775 if (i != _connections.end()) {
3776 _connections.erase (i);
3782 ConnectionRemoved (connection); /* EMIT SIGNAL */
3788 ARDOUR::Connection *
3789 Session::connection_by_name (string name) const
3791 Glib::Mutex::Lock lm (connection_lock);
3793 for (ConnectionList::const_iterator i = _connections.begin(); i != _connections.end(); ++i) {
3794 if ((*i)->name() == name) {
3803 Session::tempo_map_changed (Change ignored)
3809 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
3810 * the given count with the current block size.
3813 Session::ensure_buffers (ChanCount howmany)
3815 // FIXME: NASTY assumption (midi block size == audio block size)
3816 _scratch_buffers->ensure_buffers(howmany, current_block_size);
3817 _send_buffers->ensure_buffers(howmany, current_block_size);
3818 _silent_buffers->ensure_buffers(howmany, current_block_size);
3820 allocate_pan_automation_buffers (current_block_size, howmany.n_audio(), false);
3824 Session::next_insert_id ()
3826 /* this doesn't really loop forever. just think about it */
3829 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
3830 if (!insert_bitset[n]) {
3831 insert_bitset[n] = true;
3837 /* none available, so resize and try again */
3839 insert_bitset.resize (insert_bitset.size() + 16, false);
3844 Session::next_send_id ()
3846 /* this doesn't really loop forever. just think about it */
3849 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
3850 if (!send_bitset[n]) {
3851 send_bitset[n] = true;
3857 /* none available, so resize and try again */
3859 send_bitset.resize (send_bitset.size() + 16, false);
3864 Session::mark_send_id (uint32_t id)
3866 if (id >= send_bitset.size()) {
3867 send_bitset.resize (id+16, false);
3869 if (send_bitset[id]) {
3870 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
3872 send_bitset[id] = true;
3876 Session::mark_insert_id (uint32_t id)
3878 if (id >= insert_bitset.size()) {
3879 insert_bitset.resize (id+16, false);
3881 if (insert_bitset[id]) {
3882 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
3884 insert_bitset[id] = true;
3887 /* Named Selection management */
3890 Session::named_selection_by_name (string name)
3892 Glib::Mutex::Lock lm (named_selection_lock);
3893 for (NamedSelectionList::iterator i = named_selections.begin(); i != named_selections.end(); ++i) {
3894 if ((*i)->name == name) {
3902 Session::add_named_selection (NamedSelection* named_selection)
3905 Glib::Mutex::Lock lm (named_selection_lock);
3906 named_selections.insert (named_selections.begin(), named_selection);
3909 for (list<boost::shared_ptr<Playlist> >::iterator i = named_selection->playlists.begin(); i != named_selection->playlists.end(); ++i) {
3915 NamedSelectionAdded (); /* EMIT SIGNAL */
3919 Session::remove_named_selection (NamedSelection* named_selection)
3921 bool removed = false;
3924 Glib::Mutex::Lock lm (named_selection_lock);
3926 NamedSelectionList::iterator i = find (named_selections.begin(), named_selections.end(), named_selection);
3928 if (i != named_selections.end()) {
3930 named_selections.erase (i);
3937 NamedSelectionRemoved (); /* EMIT SIGNAL */
3942 Session::reset_native_file_format ()
3944 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
3946 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
3947 (*i)->reset_write_sources (false);
3952 Session::route_name_unique (string n) const
3954 shared_ptr<RouteList> r = routes.reader ();
3956 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
3957 if ((*i)->name() == n) {
3966 Session::n_playlists () const
3968 Glib::Mutex::Lock lm (playlist_lock);
3969 return playlists.size();
3973 Session::allocate_pan_automation_buffers (nframes_t nframes, uint32_t howmany, bool force)
3975 if (!force && howmany <= _npan_buffers) {
3979 if (_pan_automation_buffer) {
3981 for (uint32_t i = 0; i < _npan_buffers; ++i) {
3982 delete [] _pan_automation_buffer[i];
3985 delete [] _pan_automation_buffer;
3988 _pan_automation_buffer = new pan_t*[howmany];
3990 for (uint32_t i = 0; i < howmany; ++i) {
3991 _pan_automation_buffer[i] = new pan_t[nframes];
3994 _npan_buffers = howmany;
3998 Session::freeze (InterThreadInfo& itt)
4000 shared_ptr<RouteList> r = routes.reader ();
4002 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4006 if ((at = dynamic_cast<Track*>((*i).get())) != 0) {
4007 /* XXX this is wrong because itt.progress will keep returning to zero at the start
4018 Session::write_one_audio_track (AudioTrack& track, nframes_t start, nframes_t len,
4019 bool overwrite, vector<boost::shared_ptr<Source> >& srcs, InterThreadInfo& itt)
4022 boost::shared_ptr<Playlist> playlist;
4023 boost::shared_ptr<AudioFileSource> fsource;
4025 char buf[PATH_MAX+1];
4027 ChanCount nchans(track.audio_diskstream()->n_channels());
4029 nframes_t this_chunk;
4033 // any bigger than this seems to cause stack overflows in called functions
4034 const nframes_t chunk_size = (128 * 1024)/4;
4036 g_atomic_int_set (&processing_prohibited, 1);
4038 /* call tree *MUST* hold route_lock */
4040 if ((playlist = track.diskstream()->playlist()) == 0) {
4044 /* external redirects will be a problem */
4046 if (track.has_external_redirects()) {
4050 dir = discover_best_sound_dir ();
4052 for (uint32_t chan_n=0; chan_n < nchans.n_audio(); ++chan_n) {
4054 for (x = 0; x < 99999; ++x) {
4055 snprintf (buf, sizeof(buf), "%s/%s-%d-bounce-%" PRIu32 ".wav", dir.c_str(), playlist->name().c_str(), chan_n, x+1);
4056 if (access (buf, F_OK) != 0) {
4062 error << string_compose (_("too many bounced versions of playlist \"%1\""), playlist->name()) << endmsg;
4067 fsource = boost::dynamic_pointer_cast<AudioFileSource> (
4068 SourceFactory::createWritable (DataType::AUDIO, *this, buf, false, frame_rate()));
4071 catch (failed_constructor& err) {
4072 error << string_compose (_("cannot create new audio file \"%1\" for %2"), buf, track.name()) << endmsg;
4076 srcs.push_back (fsource);
4079 /* XXX need to flush all redirects */
4084 /* create a set of reasonably-sized buffers */
4085 buffers.ensure_buffers(nchans, chunk_size);
4086 buffers.set_count(nchans);
4088 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
4089 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4091 afs->prepare_for_peakfile_writes ();
4094 while (to_do && !itt.cancel) {
4096 this_chunk = min (to_do, chunk_size);
4098 if (track.export_stuff (buffers, start, this_chunk)) {
4103 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
4104 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4107 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
4113 start += this_chunk;
4114 to_do -= this_chunk;
4116 itt.progress = (float) (1.0 - ((double) to_do / len));
4125 xnow = localtime (&now);
4127 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
4128 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4131 afs->update_header (position, *xnow, now);
4132 afs->flush_header ();
4136 /* construct a region to represent the bounced material */
4138 boost::shared_ptr<Region> aregion = RegionFactory::create (srcs, 0, srcs.front()->length(),
4139 region_name_from_path (srcs.front()->name(), true));
4146 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4147 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4150 afs->mark_for_remove ();
4153 (*src)->drop_references ();
4157 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
4158 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
4161 afs->done_with_peakfile_writes ();
4165 g_atomic_int_set (&processing_prohibited, 0);
4171 Session::get_silent_buffers (ChanCount count)
4173 assert(_silent_buffers->available() >= count);
4174 _silent_buffers->set_count(count);
4176 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
4177 for (size_t i=0; i < count.get(*t); ++i) {
4178 _silent_buffers->get(*t, i).clear();
4182 return *_silent_buffers;
4186 Session::get_scratch_buffers (ChanCount count)
4188 assert(_scratch_buffers->available() >= count);
4189 _scratch_buffers->set_count(count);
4190 return *_scratch_buffers;
4194 Session::get_send_buffers (ChanCount count)
4196 assert(_send_buffers->available() >= count);
4197 _send_buffers->set_count(count);
4198 return *_send_buffers;
4202 Session::ntracks () const
4205 shared_ptr<RouteList> r = routes.reader ();
4207 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4208 if (dynamic_cast<Track*> ((*i).get())) {
4217 Session::nbusses () const
4220 shared_ptr<RouteList> r = routes.reader ();
4222 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4223 if (dynamic_cast<Track*> ((*i).get()) == 0) {
4232 Session::add_automation_list(AutomationList *al)
4234 automation_lists[al->id()] = al;
4238 Session::compute_initial_length ()
4240 return _engine.frame_rate() * 60 * 5;