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/audio_diskstream.h>
48 #include <ardour/utils.h>
49 #include <ardour/audioplaylist.h>
50 #include <ardour/audioregion.h>
51 #include <ardour/audiofilesource.h>
52 #include <ardour/auditioner.h>
53 #include <ardour/recent_sessions.h>
54 #include <ardour/redirect.h>
55 #include <ardour/send.h>
56 #include <ardour/insert.h>
57 #include <ardour/connection.h>
58 #include <ardour/slave.h>
59 #include <ardour/tempo.h>
60 #include <ardour/audio_track.h>
61 #include <ardour/cycle_timer.h>
62 #include <ardour/named_selection.h>
63 #include <ardour/crossfade.h>
64 #include <ardour/playlist.h>
65 #include <ardour/click.h>
66 #include <ardour/data_type.h>
67 #include <ardour/source_factory.h>
68 #include <ardour/region_factory.h>
71 #include <ardour/osc.h>
77 using namespace ARDOUR;
79 using boost::shared_ptr;
82 static const int CPU_CACHE_ALIGN = 64;
84 static const int CPU_CACHE_ALIGN = 16; /* arguably 32 on most arches, but it matters less */
87 const char* Session::_template_suffix = X_(".template");
88 const char* Session::_statefile_suffix = X_(".ardour");
89 const char* Session::_pending_suffix = X_(".pending");
90 const char* Session::old_sound_dir_name = X_("sounds");
91 const char* Session::sound_dir_name = X_("audiofiles");
92 const char* Session::peak_dir_name = X_("peaks");
93 const char* Session::dead_sound_dir_name = X_("dead_sounds");
94 const char* Session::interchange_dir_name = X_("interchange");
95 const char* Session::export_dir_name = X_("export");
97 Session::compute_peak_t Session::compute_peak = 0;
98 Session::find_peaks_t Session::find_peaks = 0;
99 Session::apply_gain_to_buffer_t Session::apply_gain_to_buffer = 0;
100 Session::mix_buffers_with_gain_t Session::mix_buffers_with_gain = 0;
101 Session::mix_buffers_no_gain_t Session::mix_buffers_no_gain = 0;
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 _mmc_port (default_mmc_port),
267 _mtc_port (default_mtc_port),
268 _midi_port (default_midi_port),
269 pending_events (2048),
270 midi_requests (128), // the size of this should match the midi request pool size
271 diskstreams (new DiskstreamList),
272 diskstreams_input_pending (new DiskstreamList),
273 routes (new RouteList),
274 auditioner ((Auditioner*) 0),
280 if (!eng.connected()) {
281 throw failed_constructor();
284 cerr << "Loading session " << fullpath << " using snapshot " << snapshot_name << " (1)" << endl;
286 n_physical_outputs = _engine.n_physical_outputs();
287 n_physical_inputs = _engine.n_physical_inputs();
289 first_stage_init (fullpath, snapshot_name);
291 new_session = !g_file_test (_path.c_str(), GFileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR));
293 if (create (new_session, mix_template, compute_initial_length())) {
294 cerr << "create failed\n";
296 throw failed_constructor ();
300 if (second_stage_init (new_session)) {
302 throw failed_constructor ();
305 store_recent_sessions(_name, _path);
307 bool was_dirty = dirty();
309 _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
311 Config->ParameterChanged.connect (mem_fun (*this, &Session::config_changed));
314 DirtyChanged (); /* EMIT SIGNAL */
318 Session::Session (AudioEngine &eng,
320 string snapshot_name,
321 AutoConnectOption input_ac,
322 AutoConnectOption output_ac,
323 uint32_t control_out_channels,
324 uint32_t master_out_channels,
325 uint32_t requested_physical_in,
326 uint32_t requested_physical_out,
327 nframes_t initial_length)
330 _mmc_port (default_mmc_port),
331 _mtc_port (default_mtc_port),
332 _midi_port (default_midi_port),
333 pending_events (2048),
335 diskstreams (new DiskstreamList),
336 diskstreams_input_pending (new DiskstreamList),
337 routes (new RouteList),
343 if (!eng.connected()) {
344 throw failed_constructor();
347 cerr << "Loading session " << fullpath << " using snapshot " << snapshot_name << " (2)" << endl;
349 n_physical_outputs = _engine.n_physical_outputs();
350 n_physical_inputs = _engine.n_physical_inputs();
352 if (n_physical_inputs) {
353 n_physical_inputs = max (requested_physical_in, n_physical_inputs);
356 if (n_physical_outputs) {
357 n_physical_outputs = max (requested_physical_out, n_physical_outputs);
360 first_stage_init (fullpath, snapshot_name);
362 new_session = !g_file_test (_path.c_str(), GFileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR));
365 if (create (new_session, 0, initial_length)) {
367 throw failed_constructor ();
372 /* set up Master Out and Control Out if necessary */
377 if (control_out_channels) {
378 shared_ptr<Route> r (new Route (*this, _("monitor"), -1, control_out_channels, -1, control_out_channels, Route::ControlOut));
379 r->set_remote_control_id (control_id++);
384 if (master_out_channels) {
385 shared_ptr<Route> r (new Route (*this, _("master"), -1, master_out_channels, -1, master_out_channels, Route::MasterOut));
386 r->set_remote_control_id (control_id);
390 /* prohibit auto-connect to master, because there isn't one */
391 output_ac = AutoConnectOption (output_ac & ~AutoConnectMaster);
400 Config->set_input_auto_connect (input_ac);
401 Config->set_output_auto_connect (output_ac);
403 if (second_stage_init (new_session)) {
405 throw failed_constructor ();
408 store_recent_sessions(_name, _path);
410 bool was_dirty = dirty ();
412 _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
414 Config->ParameterChanged.connect (mem_fun (*this, &Session::config_changed));
417 DirtyChanged (); /* EMIT SIGNAL */
429 /* if we got to here, leaving pending capture state around
433 remove_pending_capture_state ();
435 _state_of_the_state = StateOfTheState (CannotSave|Deletion);
436 _engine.remove_session ();
438 GoingAway (); /* EMIT SIGNAL */
444 /* clear history so that no references to objects are held any more */
448 /* clear state tree so that no references to objects are held any more */
454 terminate_butler_thread ();
455 terminate_midi_thread ();
457 if (click_data && click_data != default_click) {
458 delete [] click_data;
461 if (click_emphasis_data && click_emphasis_data != default_click_emphasis) {
462 delete [] click_emphasis_data;
467 for (vector<Sample*>::iterator i = _passthru_buffers.begin(); i != _passthru_buffers.end(); ++i) {
471 for (vector<Sample*>::iterator i = _silent_buffers.begin(); i != _silent_buffers.end(); ++i) {
475 for (vector<Sample*>::iterator i = _send_buffers.begin(); i != _send_buffers.end(); ++i) {
479 AudioDiskstream::free_working_buffers();
481 /* this should cause deletion of the auditioner */
483 // auditioner.reset ();
485 #undef TRACK_DESTRUCTION
486 #ifdef TRACK_DESTRUCTION
487 cerr << "delete named selections\n";
488 #endif /* TRACK_DESTRUCTION */
489 for (NamedSelectionList::iterator i = named_selections.begin(); i != named_selections.end(); ) {
490 NamedSelectionList::iterator tmp;
499 #ifdef TRACK_DESTRUCTION
500 cerr << "delete playlists\n";
501 #endif /* TRACK_DESTRUCTION */
502 for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ) {
503 PlaylistList::iterator tmp;
508 (*i)->drop_references ();
513 for (PlaylistList::iterator i = unused_playlists.begin(); i != unused_playlists.end(); ) {
514 PlaylistList::iterator tmp;
519 (*i)->drop_references ();
525 unused_playlists.clear ();
527 #ifdef TRACK_DESTRUCTION
528 cerr << "delete audio regions\n";
529 #endif /* TRACK_DESTRUCTION */
531 for (AudioRegionList::iterator i = audio_regions.begin(); i != audio_regions.end(); ) {
532 AudioRegionList::iterator tmp;
537 i->second->drop_references ();
542 audio_regions.clear ();
544 #ifdef TRACK_DESTRUCTION
545 cerr << "delete routes\n";
546 #endif /* TRACK_DESTRUCTION */
548 RCUWriter<RouteList> writer (routes);
549 boost::shared_ptr<RouteList> r = writer.get_copy ();
550 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
551 (*i)->drop_references ();
554 /* writer goes out of scope and updates master */
559 #ifdef TRACK_DESTRUCTION
560 cerr << "delete diskstreams\n";
561 #endif /* TRACK_DESTRUCTION */
563 RCUWriter<DiskstreamList> dwriter (diskstreams);
564 boost::shared_ptr<DiskstreamList> dsl = dwriter.get_copy();
565 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
566 (*i)->drop_references ();
570 diskstreams.flush ();
572 #ifdef TRACK_DESTRUCTION
573 cerr << "delete audio sources\n";
574 #endif /* TRACK_DESTRUCTION */
575 for (AudioSourceList::iterator i = audio_sources.begin(); i != audio_sources.end(); ) {
576 AudioSourceList::iterator tmp;
581 i->second->drop_references ();
586 audio_sources.clear ();
588 #ifdef TRACK_DESTRUCTION
589 cerr << "delete mix groups\n";
590 #endif /* TRACK_DESTRUCTION */
591 for (list<RouteGroup *>::iterator i = mix_groups.begin(); i != mix_groups.end(); ) {
592 list<RouteGroup*>::iterator tmp;
602 #ifdef TRACK_DESTRUCTION
603 cerr << "delete edit groups\n";
604 #endif /* TRACK_DESTRUCTION */
605 for (list<RouteGroup *>::iterator i = edit_groups.begin(); i != edit_groups.end(); ) {
606 list<RouteGroup*>::iterator tmp;
616 #ifdef TRACK_DESTRUCTION
617 cerr << "delete connections\n";
618 #endif /* TRACK_DESTRUCTION */
619 for (ConnectionList::iterator i = _connections.begin(); i != _connections.end(); ) {
620 ConnectionList::iterator tmp;
630 if (butler_mixdown_buffer) {
631 delete [] butler_mixdown_buffer;
634 if (butler_gain_buffer) {
635 delete [] butler_gain_buffer;
638 Crossfade::set_buffer_size (0);
646 Session::set_worst_io_latencies ()
648 _worst_output_latency = 0;
649 _worst_input_latency = 0;
651 if (!_engine.connected()) {
655 boost::shared_ptr<RouteList> r = routes.reader ();
657 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
658 _worst_output_latency = max (_worst_output_latency, (*i)->output_latency());
659 _worst_input_latency = max (_worst_input_latency, (*i)->input_latency());
664 Session::when_engine_running ()
666 string first_physical_output;
668 /* we don't want to run execute this again */
670 set_block_size (_engine.frames_per_cycle());
671 set_frame_rate (_engine.frame_rate());
673 Config->map_parameters (mem_fun (*this, &Session::config_changed));
675 /* every time we reconnect, recompute worst case output latencies */
677 _engine.Running.connect (mem_fun (*this, &Session::set_worst_io_latencies));
679 if (synced_to_jack()) {
680 _engine.transport_stop ();
683 if (Config->get_jack_time_master()) {
684 _engine.transport_locate (_transport_frame);
692 _click_io.reset (new ClickIO (*this, "click", 0, 0, -1, -1));
694 if (state_tree && (child = find_named_node (*state_tree->root(), "Click")) != 0) {
696 /* existing state for Click */
698 if (_click_io->set_state (*child->children().front()) == 0) {
700 _clicking = Config->get_clicking ();
704 error << _("could not setup Click I/O") << endmsg;
710 /* default state for Click */
712 first_physical_output = _engine.get_nth_physical_output (0);
714 if (first_physical_output.length()) {
715 if (_click_io->add_output_port (first_physical_output, this)) {
716 // relax, even though its an error
718 _clicking = Config->get_clicking ();
724 catch (failed_constructor& err) {
725 error << _("cannot setup Click I/O") << endmsg;
728 set_worst_io_latencies ();
731 // XXX HOW TO ALERT UI TO THIS ? DO WE NEED TO?
734 /* Create a set of Connection objects that map
735 to the physical outputs currently available
740 for (uint32_t np = 0; np < n_physical_outputs; ++np) {
742 snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
744 Connection* c = new OutputConnection (buf, true);
747 c->add_connection (0, _engine.get_nth_physical_output (np));
752 for (uint32_t np = 0; np < n_physical_inputs; ++np) {
754 snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
756 Connection* c = new InputConnection (buf, true);
759 c->add_connection (0, _engine.get_nth_physical_input (np));
766 for (uint32_t np = 0; np < n_physical_outputs; np +=2) {
768 snprintf (buf, sizeof (buf), _("out %" PRIu32 "+%" PRIu32), np+1, np+2);
770 Connection* c = new OutputConnection (buf, true);
774 c->add_connection (0, _engine.get_nth_physical_output (np));
775 c->add_connection (1, _engine.get_nth_physical_output (np+1));
780 for (uint32_t np = 0; np < n_physical_inputs; np +=2) {
782 snprintf (buf, sizeof (buf), _("in %" PRIu32 "+%" PRIu32), np+1, np+2);
784 Connection* c = new InputConnection (buf, true);
788 c->add_connection (0, _engine.get_nth_physical_input (np));
789 c->add_connection (1, _engine.get_nth_physical_input (np+1));
798 /* create master/control ports */
803 /* force the master to ignore any later call to this */
805 if (_master_out->pending_state_node) {
806 _master_out->ports_became_legal();
809 /* no panner resets till we are through */
811 _master_out->defer_pan_reset ();
813 while ((int) _master_out->n_inputs() < _master_out->input_maximum()) {
814 if (_master_out->add_input_port ("", this)) {
815 error << _("cannot setup master inputs")
821 while ((int) _master_out->n_outputs() < _master_out->output_maximum()) {
822 if (_master_out->add_output_port (_engine.get_nth_physical_output (n), this)) {
823 error << _("cannot setup master outputs")
830 _master_out->allow_pan_reset ();
834 Connection* c = new OutputConnection (_("Master Out"), true);
836 for (uint32_t n = 0; n < _master_out->n_inputs (); ++n) {
838 c->add_connection ((int) n, _master_out->input(n)->name());
845 /* catch up on send+insert cnts */
849 for (list<PortInsert*>::iterator i = _port_inserts.begin(); i != _port_inserts.end(); ++i) {
852 if (sscanf ((*i)->name().c_str(), "%*s %u", &id) == 1) {
853 if (id > insert_cnt) {
861 for (list<Send*>::iterator i = _sends.begin(); i != _sends.end(); ++i) {
864 if (sscanf ((*i)->name().c_str(), "%*s %u", &id) == 1) {
872 _state_of_the_state = StateOfTheState (_state_of_the_state & ~(CannotSave|Dirty));
874 /* hook us up to the engine */
876 _engine.set_session (this);
881 osc->set_session (*this);
884 _state_of_the_state = Clean;
886 DirtyChanged (); /* EMIT SIGNAL */
890 Session::hookup_io ()
892 /* stop graph reordering notifications from
893 causing resorts, etc.
896 _state_of_the_state = StateOfTheState (_state_of_the_state | InitialConnecting);
898 if (auditioner == 0) {
900 /* we delay creating the auditioner till now because
901 it makes its own connections to ports.
902 the engine has to be running for this to work.
906 auditioner.reset (new Auditioner (*this));
909 catch (failed_constructor& err) {
910 warning << _("cannot create Auditioner: no auditioning of regions possible") << endmsg;
914 /* Tell all IO objects to create their ports */
921 while ((int) _control_out->n_inputs() < _control_out->input_maximum()) {
922 if (_control_out->add_input_port ("", this)) {
923 error << _("cannot setup control inputs")
929 while ((int) _control_out->n_outputs() < _control_out->output_maximum()) {
930 if (_control_out->add_output_port (_engine.get_nth_physical_output (n), this)) {
931 error << _("cannot set up master outputs")
939 /* Tell all IO objects to connect themselves together */
941 IO::enable_connecting ();
943 /* Now reset all panners */
945 IO::reset_panners ();
947 /* Anyone who cares about input state, wake up and do something */
949 IOConnectionsComplete (); /* EMIT SIGNAL */
951 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InitialConnecting);
953 /* now handle the whole enchilada as if it was one
959 /* update mixer solo state */
965 Session::playlist_length_changed ()
967 /* we can't just increase end_location->end() if pl->get_maximum_extent()
968 if larger. if the playlist used to be the longest playlist,
969 and its now shorter, we have to decrease end_location->end(). hence,
970 we have to iterate over all diskstreams and check the
971 playlists currently in use.
977 Session::diskstream_playlist_changed (boost::shared_ptr<Diskstream> dstream)
979 boost::shared_ptr<Playlist> playlist;
981 if ((playlist = dstream->playlist()) != 0) {
982 playlist->LengthChanged.connect (mem_fun (this, &Session::playlist_length_changed));
985 /* see comment in playlist_length_changed () */
990 Session::record_enabling_legal () const
992 /* this used to be in here, but survey says.... we don't need to restrict it */
993 // if (record_status() == Recording) {
997 if (Config->get_all_safe()) {
1004 Session::reset_input_monitor_state ()
1006 if (transport_rolling()) {
1008 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
1010 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
1011 if ((*i)->record_enabled ()) {
1012 //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
1013 (*i)->monitor_input (Config->get_monitoring_model() == HardwareMonitoring && !Config->get_auto_input());
1017 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
1019 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
1020 if ((*i)->record_enabled ()) {
1021 //cerr << "switching to input = " << !Config->get_auto_input() << __FILE__ << __LINE__ << endl << endl;
1022 (*i)->monitor_input (Config->get_monitoring_model() == HardwareMonitoring);
1029 Session::auto_punch_start_changed (Location* location)
1031 replace_event (Event::PunchIn, location->start());
1033 if (get_record_enabled() && Config->get_punch_in()) {
1034 /* capture start has been changed, so save new pending state */
1035 save_state ("", true);
1040 Session::auto_punch_end_changed (Location* location)
1042 nframes_t when_to_stop = location->end();
1043 // when_to_stop += _worst_output_latency + _worst_input_latency;
1044 replace_event (Event::PunchOut, when_to_stop);
1048 Session::auto_punch_changed (Location* location)
1050 nframes_t when_to_stop = location->end();
1052 replace_event (Event::PunchIn, location->start());
1053 //when_to_stop += _worst_output_latency + _worst_input_latency;
1054 replace_event (Event::PunchOut, when_to_stop);
1058 Session::auto_loop_changed (Location* location)
1060 replace_event (Event::AutoLoop, location->end(), location->start());
1062 if (transport_rolling() && play_loop) {
1064 //if (_transport_frame < location->start() || _transport_frame > location->end()) {
1066 if (_transport_frame > location->end()) {
1067 // relocate to beginning of loop
1068 clear_events (Event::LocateRoll);
1070 request_locate (location->start(), true);
1073 else if (Config->get_seamless_loop() && !loop_changing) {
1075 // schedule a locate-roll to refill the diskstreams at the
1076 // previous loop end
1077 loop_changing = true;
1079 if (location->end() > last_loopend) {
1080 clear_events (Event::LocateRoll);
1081 Event *ev = new Event (Event::LocateRoll, Event::Add, last_loopend, last_loopend, 0, true);
1088 last_loopend = location->end();
1093 Session::set_auto_punch_location (Location* location)
1097 if ((existing = _locations.auto_punch_location()) != 0 && existing != location) {
1098 auto_punch_start_changed_connection.disconnect();
1099 auto_punch_end_changed_connection.disconnect();
1100 auto_punch_changed_connection.disconnect();
1101 existing->set_auto_punch (false, this);
1102 remove_event (existing->start(), Event::PunchIn);
1103 clear_events (Event::PunchOut);
1104 auto_punch_location_changed (0);
1109 if (location == 0) {
1113 if (location->end() <= location->start()) {
1114 error << _("Session: you can't use that location for auto punch (start <= end)") << endmsg;
1118 auto_punch_start_changed_connection.disconnect();
1119 auto_punch_end_changed_connection.disconnect();
1120 auto_punch_changed_connection.disconnect();
1122 auto_punch_start_changed_connection = location->start_changed.connect (mem_fun (this, &Session::auto_punch_start_changed));
1123 auto_punch_end_changed_connection = location->end_changed.connect (mem_fun (this, &Session::auto_punch_end_changed));
1124 auto_punch_changed_connection = location->changed.connect (mem_fun (this, &Session::auto_punch_changed));
1126 location->set_auto_punch (true, this);
1127 auto_punch_location_changed (location);
1131 Session::set_auto_loop_location (Location* location)
1135 if ((existing = _locations.auto_loop_location()) != 0 && existing != location) {
1136 auto_loop_start_changed_connection.disconnect();
1137 auto_loop_end_changed_connection.disconnect();
1138 auto_loop_changed_connection.disconnect();
1139 existing->set_auto_loop (false, this);
1140 remove_event (existing->end(), Event::AutoLoop);
1141 auto_loop_location_changed (0);
1146 if (location == 0) {
1150 if (location->end() <= location->start()) {
1151 error << _("Session: you can't use a mark for auto loop") << endmsg;
1155 last_loopend = location->end();
1157 auto_loop_start_changed_connection.disconnect();
1158 auto_loop_end_changed_connection.disconnect();
1159 auto_loop_changed_connection.disconnect();
1161 auto_loop_start_changed_connection = location->start_changed.connect (mem_fun (this, &Session::auto_loop_changed));
1162 auto_loop_end_changed_connection = location->end_changed.connect (mem_fun (this, &Session::auto_loop_changed));
1163 auto_loop_changed_connection = location->changed.connect (mem_fun (this, &Session::auto_loop_changed));
1165 location->set_auto_loop (true, this);
1166 auto_loop_location_changed (location);
1170 Session::locations_added (Location* ignored)
1176 Session::locations_changed ()
1178 _locations.apply (*this, &Session::handle_locations_changed);
1182 Session::handle_locations_changed (Locations::LocationList& locations)
1184 Locations::LocationList::iterator i;
1186 bool set_loop = false;
1187 bool set_punch = false;
1189 for (i = locations.begin(); i != locations.end(); ++i) {
1193 if (location->is_auto_punch()) {
1194 set_auto_punch_location (location);
1197 if (location->is_auto_loop()) {
1198 set_auto_loop_location (location);
1205 set_auto_loop_location (0);
1208 set_auto_punch_location (0);
1215 Session::enable_record ()
1217 /* XXX really atomic compare+swap here */
1218 if (g_atomic_int_get (&_record_status) != Recording) {
1219 g_atomic_int_set (&_record_status, Recording);
1220 _last_record_location = _transport_frame;
1221 send_mmc_in_another_thread (MIDI::MachineControl::cmdRecordStrobe);
1223 if (Config->get_monitoring_model() == HardwareMonitoring && Config->get_auto_input()) {
1224 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
1225 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
1226 if ((*i)->record_enabled ()) {
1227 (*i)->monitor_input (true);
1232 RecordStateChanged ();
1237 Session::disable_record (bool rt_context, bool force)
1241 if ((rs = (RecordState) g_atomic_int_get (&_record_status)) != Disabled) {
1243 if (!Config->get_latched_record_enable () || force) {
1244 g_atomic_int_set (&_record_status, Disabled);
1246 if (rs == Recording) {
1247 g_atomic_int_set (&_record_status, Enabled);
1251 send_mmc_in_another_thread (MIDI::MachineControl::cmdRecordExit);
1253 if (Config->get_monitoring_model() == HardwareMonitoring && Config->get_auto_input()) {
1254 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
1256 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
1257 if ((*i)->record_enabled ()) {
1258 (*i)->monitor_input (false);
1263 RecordStateChanged (); /* emit signal */
1266 remove_pending_capture_state ();
1272 Session::step_back_from_record ()
1274 g_atomic_int_set (&_record_status, Enabled);
1276 if (Config->get_monitoring_model() == HardwareMonitoring) {
1277 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
1279 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
1280 if (Config->get_auto_input() && (*i)->record_enabled ()) {
1281 //cerr << "switching from input" << __FILE__ << __LINE__ << endl << endl;
1282 (*i)->monitor_input (false);
1289 Session::maybe_enable_record ()
1291 g_atomic_int_set (&_record_status, Enabled);
1293 /* this function is currently called from somewhere other than an RT thread.
1294 this save_state() call therefore doesn't impact anything.
1297 save_state ("", true);
1299 if (_transport_speed) {
1300 if (!Config->get_punch_in()) {
1304 send_mmc_in_another_thread (MIDI::MachineControl::cmdRecordPause);
1305 RecordStateChanged (); /* EMIT SIGNAL */
1312 Session::audible_frame () const
1318 /* the first of these two possible settings for "offset"
1319 mean that the audible frame is stationary until
1320 audio emerges from the latency compensation
1323 the second means that the audible frame is stationary
1324 until audio would emerge from a physical port
1325 in the absence of any plugin latency compensation
1328 offset = _worst_output_latency;
1330 if (offset > current_block_size) {
1331 offset -= current_block_size;
1333 /* XXX is this correct? if we have no external
1334 physical connections and everything is internal
1335 then surely this is zero? still, how
1336 likely is that anyway?
1338 offset = current_block_size;
1341 if (synced_to_jack()) {
1342 tf = _engine.transport_frame();
1344 tf = _transport_frame;
1347 if (_transport_speed == 0) {
1357 if (!non_realtime_work_pending()) {
1361 /* take latency into account */
1370 Session::set_frame_rate (nframes_t frames_per_second)
1372 /** \fn void Session::set_frame_size(nframes_t)
1373 the AudioEngine object that calls this guarantees
1374 that it will not be called while we are also in
1375 ::process(). Its fine to do things that block
1379 _base_frame_rate = frames_per_second;
1383 Route::set_automation_interval ((jack_nframes_t) ceil ((double) frames_per_second * 0.25));
1385 // XXX we need some equivalent to this, somehow
1386 // SndFileSource::setup_standard_crossfades (frames_per_second);
1390 /* XXX need to reset/reinstantiate all LADSPA plugins */
1394 Session::set_block_size (nframes_t nframes)
1396 /* the AudioEngine guarantees
1397 that it will not be called while we are also in
1398 ::process(). It is therefore fine to do things that block
1403 vector<Sample*>::iterator i;
1406 current_block_size = nframes;
1408 for (np = 0, i = _passthru_buffers.begin(); i != _passthru_buffers.end(); ++i, ++np) {
1412 for (vector<Sample*>::iterator i = _silent_buffers.begin(); i != _silent_buffers.end(); ++i) {
1416 _passthru_buffers.clear ();
1417 _silent_buffers.clear ();
1419 ensure_passthru_buffers (np);
1421 for (vector<Sample*>::iterator i = _send_buffers.begin(); i != _send_buffers.end(); ++i) {
1425 #ifdef NO_POSIX_MEMALIGN
1426 buf = (Sample *) malloc(current_block_size * sizeof(Sample));
1428 posix_memalign((void **)&buf,CPU_CACHE_ALIGN,current_block_size * sizeof(Sample));
1432 memset (*i, 0, sizeof (Sample) * current_block_size);
1436 if (_gain_automation_buffer) {
1437 delete [] _gain_automation_buffer;
1439 _gain_automation_buffer = new gain_t[nframes];
1441 allocate_pan_automation_buffers (nframes, _npan_buffers, true);
1443 boost::shared_ptr<RouteList> r = routes.reader ();
1445 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1446 (*i)->set_block_size (nframes);
1449 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
1450 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
1451 (*i)->set_block_size (nframes);
1454 set_worst_io_latencies ();
1459 Session::set_default_fade (float steepness, float fade_msecs)
1462 nframes_t fade_frames;
1464 /* Don't allow fade of less 1 frame */
1466 if (fade_msecs < (1000.0 * (1.0/_current_frame_rate))) {
1473 fade_frames = (nframes_t) floor (fade_msecs * _current_frame_rate * 0.001);
1477 default_fade_msecs = fade_msecs;
1478 default_fade_steepness = steepness;
1481 // jlc, WTF is this!
1482 Glib::RWLock::ReaderLock lm (route_lock);
1483 AudioRegion::set_default_fade (steepness, fade_frames);
1488 /* XXX have to do this at some point */
1489 /* foreach region using default fade, reset, then
1490 refill_all_diskstream_buffers ();
1495 struct RouteSorter {
1496 bool operator() (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> r2) {
1497 if (r1->fed_by.find (r2) != r1->fed_by.end()) {
1499 } else if (r2->fed_by.find (r1) != r2->fed_by.end()) {
1502 if (r1->fed_by.empty()) {
1503 if (r2->fed_by.empty()) {
1504 /* no ardour-based connections inbound to either route. just use signal order */
1505 return r1->order_key(N_("signal")) < r2->order_key(N_("signal"));
1507 /* r2 has connections, r1 does not; run r1 early */
1511 return r1->order_key(N_("signal")) < r2->order_key(N_("signal"));
1518 trace_terminal (shared_ptr<Route> r1, shared_ptr<Route> rbase)
1520 shared_ptr<Route> r2;
1522 if ((r1->fed_by.find (rbase) != r1->fed_by.end()) && (rbase->fed_by.find (r1) != rbase->fed_by.end())) {
1523 info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
1527 /* make a copy of the existing list of routes that feed r1 */
1529 set<shared_ptr<Route> > existing = r1->fed_by;
1531 /* for each route that feeds r1, recurse, marking it as feeding
1535 for (set<shared_ptr<Route> >::iterator i = existing.begin(); i != existing.end(); ++i) {
1538 /* r2 is a route that feeds r1 which somehow feeds base. mark
1539 base as being fed by r2
1542 rbase->fed_by.insert (r2);
1546 /* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
1550 if ((r1->fed_by.find (r2) != r1->fed_by.end()) && (r2->fed_by.find (r1) != r2->fed_by.end())) {
1554 /* now recurse, so that we can mark base as being fed by
1555 all routes that feed r2
1558 trace_terminal (r2, rbase);
1565 Session::resort_routes ()
1567 /* don't do anything here with signals emitted
1568 by Routes while we are being destroyed.
1571 if (_state_of_the_state & Deletion) {
1578 RCUWriter<RouteList> writer (routes);
1579 shared_ptr<RouteList> r = writer.get_copy ();
1580 resort_routes_using (r);
1581 /* writer goes out of scope and forces update */
1586 Session::resort_routes_using (shared_ptr<RouteList> r)
1588 RouteList::iterator i, j;
1590 for (i = r->begin(); i != r->end(); ++i) {
1592 (*i)->fed_by.clear ();
1594 for (j = r->begin(); j != r->end(); ++j) {
1596 /* although routes can feed themselves, it will
1597 cause an endless recursive descent if we
1598 detect it. so don't bother checking for
1606 if ((*j)->feeds (*i)) {
1607 (*i)->fed_by.insert (*j);
1612 for (i = r->begin(); i != r->end(); ++i) {
1613 trace_terminal (*i, *i);
1619 /* don't leave dangling references to routes in Route::fed_by */
1621 for (i = r->begin(); i != r->end(); ++i) {
1622 (*i)->fed_by.clear ();
1626 cerr << "finished route resort\n";
1628 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1629 cerr << " " << (*i)->name() << " signal order = " << (*i)->order_key ("signal") << endl;
1636 list<boost::shared_ptr<AudioTrack> >
1637 Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, uint32_t how_many)
1639 char track_name[32];
1640 uint32_t track_id = 0;
1642 uint32_t channels_used = 0;
1644 RouteList new_routes;
1645 list<boost::shared_ptr<AudioTrack> > ret;
1646 uint32_t control_id;
1648 /* count existing audio tracks */
1651 shared_ptr<RouteList> r = routes.reader ();
1653 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1654 if (dynamic_cast<AudioTrack*>((*i).get()) != 0) {
1655 if (!(*i)->hidden()) {
1657 channels_used += (*i)->n_inputs();
1663 vector<string> physinputs;
1664 vector<string> physoutputs;
1665 uint32_t nphysical_in;
1666 uint32_t nphysical_out;
1668 _engine.get_physical_outputs (physoutputs);
1669 _engine.get_physical_inputs (physinputs);
1670 control_id = ntracks() + nbusses() + 1;
1674 /* check for duplicate route names, since we might have pre-existing
1675 routes with this name (e.g. create Audio1, Audio2, delete Audio1,
1676 save, close,restart,add new route - first named route is now
1684 snprintf (track_name, sizeof(track_name), "Audio %" PRIu32, track_id);
1686 if (route_by_name (track_name) == 0) {
1690 } while (track_id < (UINT_MAX-1));
1692 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
1693 nphysical_in = min (n_physical_inputs, (uint32_t) physinputs.size());
1698 if (Config->get_output_auto_connect() & AutoConnectPhysical) {
1699 nphysical_out = min (n_physical_outputs, (uint32_t) physinputs.size());
1704 shared_ptr<AudioTrack> track;
1707 track = boost::shared_ptr<AudioTrack>((new AudioTrack (*this, track_name, Route::Flag (0), mode)));
1709 if (track->ensure_io (input_channels, output_channels, false, this)) {
1710 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
1711 input_channels, output_channels)
1717 for (uint32_t x = 0; x < track->n_inputs() && x < nphysical_in; ++x) {
1721 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
1722 port = physinputs[(channels_used+x)%nphysical_in];
1725 if (port.length() && track->connect_input (track->input (x), port, this)) {
1731 for (uint32_t x = 0; x < track->n_outputs(); ++x) {
1735 if (nphysical_out && (Config->get_output_auto_connect() & AutoConnectPhysical)) {
1736 port = physoutputs[(channels_used+x)%nphysical_out];
1737 } else if (Config->get_output_auto_connect() & AutoConnectMaster) {
1739 port = _master_out->input (x%_master_out->n_inputs())->name();
1743 if (port.length() && track->connect_output (track->output (x), port, this)) {
1748 channels_used += track->n_inputs ();
1751 vector<string> cports;
1752 uint32_t ni = _control_out->n_inputs();
1754 for (n = 0; n < ni; ++n) {
1755 cports.push_back (_control_out->input(n)->name());
1758 track->set_control_outs (cports);
1761 // assert (current_thread != RT_thread)
1763 track->audio_diskstream()->non_realtime_input_change();
1765 track->DiskstreamChanged.connect (mem_fun (this, &Session::resort_routes));
1766 track->set_remote_control_id (control_id);
1769 new_routes.push_back (track);
1770 ret.push_back (track);
1773 catch (failed_constructor &err) {
1774 error << _("Session: could not create new audio track.") << endmsg;
1777 /* we need to get rid of this, since the track failed to be created */
1778 /* XXX arguably, AudioTrack::AudioTrack should not do the Session::add_diskstream() */
1781 RCUWriter<DiskstreamList> writer (diskstreams);
1782 boost::shared_ptr<DiskstreamList> ds = writer.get_copy();
1783 ds->remove (track->audio_diskstream());
1790 catch (AudioEngine::PortRegistrationFailure& pfe) {
1792 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;
1795 /* we need to get rid of this, since the track failed to be created */
1796 /* XXX arguably, AudioTrack::AudioTrack should not do the Session::add_diskstream() */
1799 RCUWriter<DiskstreamList> writer (diskstreams);
1800 boost::shared_ptr<DiskstreamList> ds = writer.get_copy();
1801 ds->remove (track->audio_diskstream());
1812 if (!new_routes.empty()) {
1813 add_routes (new_routes, false);
1814 save_state (_current_snapshot_name);
1821 Session::set_remote_control_ids ()
1823 RemoteModel m = Config->get_remote_model();
1825 shared_ptr<RouteList> r = routes.reader ();
1827 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1828 if ( MixerOrdered == m) {
1829 long order = (*i)->order_key(N_("signal"));
1830 (*i)->set_remote_control_id( order+1 );
1831 } else if ( EditorOrdered == m) {
1832 long order = (*i)->order_key(N_("editor"));
1833 (*i)->set_remote_control_id( order+1 );
1834 } else if ( UserOrdered == m) {
1835 //do nothing ... only changes to remote id's are initiated by user
1842 Session::new_audio_route (int input_channels, int output_channels, uint32_t how_many)
1845 uint32_t bus_id = 1;
1849 uint32_t control_id;
1851 /* count existing audio busses */
1854 shared_ptr<RouteList> r = routes.reader ();
1856 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1857 if (dynamic_cast<AudioTrack*>((*i).get()) == 0) {
1858 if (!(*i)->hidden()) {
1865 vector<string> physinputs;
1866 vector<string> physoutputs;
1868 _engine.get_physical_outputs (physoutputs);
1869 _engine.get_physical_inputs (physinputs);
1870 control_id = ntracks() + nbusses() + 1;
1877 snprintf (bus_name, sizeof(bus_name), "Bus %" PRIu32, bus_id);
1879 if (route_by_name (bus_name) == 0) {
1883 } while (bus_id < (UINT_MAX-1));
1886 shared_ptr<Route> bus (new Route (*this, bus_name, -1, -1, -1, -1, Route::Flag(0), DataType::AUDIO));
1888 if (bus->ensure_io (input_channels, output_channels, false, this)) {
1889 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
1890 input_channels, output_channels)
1895 for (uint32_t x = 0; n_physical_inputs && x < bus->n_inputs(); ++x) {
1899 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
1900 port = physinputs[((n+x)%n_physical_inputs)];
1903 if (port.length() && bus->connect_input (bus->input (x), port, this)) {
1908 for (uint32_t x = 0; n_physical_outputs && x < bus->n_outputs(); ++x) {
1912 if (Config->get_output_auto_connect() & AutoConnectPhysical) {
1913 port = physoutputs[((n+x)%n_physical_outputs)];
1914 } else if (Config->get_output_auto_connect() & AutoConnectMaster) {
1916 port = _master_out->input (x%_master_out->n_inputs())->name();
1920 if (port.length() && bus->connect_output (bus->output (x), port, this)) {
1926 vector<string> cports;
1927 uint32_t ni = _control_out->n_inputs();
1929 for (uint32_t n = 0; n < ni; ++n) {
1930 cports.push_back (_control_out->input(n)->name());
1932 bus->set_control_outs (cports);
1935 bus->set_remote_control_id (control_id);
1938 ret.push_back (bus);
1942 catch (failed_constructor &err) {
1943 error << _("Session: could not create new audio route.") << endmsg;
1947 catch (AudioEngine::PortRegistrationFailure& pfe) {
1948 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;
1958 add_routes (ret, false);
1959 save_state (_current_snapshot_name);
1967 Session::add_routes (RouteList& new_routes, bool save)
1970 RCUWriter<RouteList> writer (routes);
1971 shared_ptr<RouteList> r = writer.get_copy ();
1972 r->insert (r->end(), new_routes.begin(), new_routes.end());
1973 resort_routes_using (r);
1976 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
1978 boost::weak_ptr<Route> wpr (*x);
1980 (*x)->solo_changed.connect (sigc::bind (mem_fun (*this, &Session::route_solo_changed), wpr));
1981 (*x)->mute_changed.connect (mem_fun (*this, &Session::route_mute_changed));
1982 (*x)->output_changed.connect (mem_fun (*this, &Session::set_worst_io_latencies_x));
1983 (*x)->redirects_changed.connect (mem_fun (*this, &Session::update_latency_compensation_proxy));
1985 if ((*x)->master()) {
1989 if ((*x)->control()) {
1990 _control_out = (*x);
1997 save_state (_current_snapshot_name);
2000 RouteAdded (new_routes); /* EMIT SIGNAL */
2004 Session::add_diskstream (boost::shared_ptr<Diskstream> dstream)
2006 /* need to do this in case we're rolling at the time, to prevent false underruns */
2007 dstream->do_refill_with_alloc ();
2009 dstream->set_block_size (current_block_size);
2011 if (_state_of_the_state & InitialConnecting) {
2012 RCUWriter<DiskstreamList> writer (diskstreams);
2013 boost::shared_ptr<DiskstreamList> ds = writer.get_copy();
2014 ds->push_back (dstream);
2015 /* writer goes out of scope, copies ds back to main */
2018 dstream->PlaylistChanged.connect (sigc::bind (mem_fun (*this, &Session::diskstream_playlist_changed), dstream));
2019 /* this will connect to future changes, and check the current length */
2020 diskstream_playlist_changed (dstream);
2022 dstream->prepare ();
2027 Session::remove_route (shared_ptr<Route> route)
2030 RCUWriter<RouteList> writer (routes);
2031 shared_ptr<RouteList> rs = writer.get_copy ();
2035 /* deleting the master out seems like a dumb
2036 idea, but its more of a UI policy issue
2040 if (route == _master_out) {
2041 _master_out = shared_ptr<Route> ();
2044 if (route == _control_out) {
2045 _control_out = shared_ptr<Route> ();
2047 /* cancel control outs for all routes */
2049 vector<string> empty;
2051 for (RouteList::iterator r = rs->begin(); r != rs->end(); ++r) {
2052 (*r)->set_control_outs (empty);
2056 update_route_solo_state ();
2058 /* writer goes out of scope, forces route list update */
2061 // FIXME: audio specific
2063 boost::shared_ptr<AudioDiskstream> ds;
2065 if ((at = dynamic_cast<AudioTrack*>(route.get())) != 0) {
2066 ds = at->audio_diskstream();
2072 RCUWriter<DiskstreamList> dsl (diskstreams);
2073 boost::shared_ptr<DiskstreamList> d = dsl.get_copy();
2078 find_current_end ();
2080 update_latency_compensation (false, false);
2083 // We need to disconnect the routes inputs and outputs
2084 route->disconnect_inputs(NULL);
2085 route->disconnect_outputs(NULL);
2087 /* get rid of it from the dead wood collection in the route list manager */
2089 /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
2093 /* try to cause everyone to drop their references */
2095 route->drop_references ();
2097 /* save the new state of the world */
2099 if (save_state (_current_snapshot_name)) {
2100 save_history (_current_snapshot_name);
2105 Session::route_mute_changed (void* src)
2111 Session::route_solo_changed (void* src, boost::weak_ptr<Route> wpr)
2113 if (solo_update_disabled) {
2119 boost::shared_ptr<Route> route = wpr.lock ();
2122 /* should not happen */
2123 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2127 is_track = (boost::dynamic_pointer_cast<AudioTrack>(route) != 0);
2129 shared_ptr<RouteList> r = routes.reader ();
2131 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2133 /* soloing a track mutes all other tracks, soloing a bus mutes all other busses */
2137 /* don't mess with busses */
2139 if (dynamic_cast<AudioTrack*>((*i).get()) == 0) {
2145 /* don't mess with tracks */
2147 if (dynamic_cast<AudioTrack*>((*i).get()) != 0) {
2152 if ((*i) != route &&
2153 ((*i)->mix_group () == 0 ||
2154 (*i)->mix_group () != route->mix_group () ||
2155 !route->mix_group ()->is_active())) {
2157 if ((*i)->soloed()) {
2159 /* if its already soloed, and solo latching is enabled,
2160 then leave it as it is.
2163 if (Config->get_solo_latched()) {
2170 solo_update_disabled = true;
2171 (*i)->set_solo (false, src);
2172 solo_update_disabled = false;
2176 bool something_soloed = false;
2177 bool same_thing_soloed = false;
2178 bool signal = false;
2180 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2181 if ((*i)->soloed()) {
2182 something_soloed = true;
2183 if (dynamic_cast<AudioTrack*>((*i).get())) {
2185 same_thing_soloed = true;
2190 same_thing_soloed = true;
2198 if (something_soloed != currently_soloing) {
2200 currently_soloing = something_soloed;
2203 modify_solo_mute (is_track, same_thing_soloed);
2206 SoloActive (currently_soloing); /* EMIT SIGNAL */
2209 SoloChanged (); /* EMIT SIGNAL */
2215 Session::update_route_solo_state ()
2218 bool is_track = false;
2219 bool signal = false;
2221 /* caller must hold RouteLock */
2223 /* this is where we actually implement solo by changing
2224 the solo mute setting of each track.
2227 shared_ptr<RouteList> r = routes.reader ();
2229 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2230 if ((*i)->soloed()) {
2232 if (dynamic_cast<AudioTrack*>((*i).get())) {
2239 if (mute != currently_soloing) {
2241 currently_soloing = mute;
2244 if (!is_track && !mute) {
2246 /* nothing is soloed */
2248 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2249 (*i)->set_solo_mute (false);
2259 modify_solo_mute (is_track, mute);
2262 SoloActive (currently_soloing);
2267 Session::modify_solo_mute (bool is_track, bool mute)
2269 shared_ptr<RouteList> r = routes.reader ();
2271 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2275 /* only alter track solo mute */
2277 if (dynamic_cast<AudioTrack*>((*i).get())) {
2278 if ((*i)->soloed()) {
2279 (*i)->set_solo_mute (!mute);
2281 (*i)->set_solo_mute (mute);
2287 /* only alter bus solo mute */
2289 if (!dynamic_cast<AudioTrack*>((*i).get())) {
2291 if ((*i)->soloed()) {
2293 (*i)->set_solo_mute (false);
2297 /* don't mute master or control outs
2298 in response to another bus solo
2301 if ((*i) != _master_out &&
2302 (*i) != _control_out) {
2303 (*i)->set_solo_mute (mute);
2314 Session::catch_up_on_solo ()
2316 /* this is called after set_state() to catch the full solo
2317 state, which can't be correctly determined on a per-route
2318 basis, but needs the global overview that only the session
2321 update_route_solo_state();
2325 Session::route_by_name (string name)
2327 shared_ptr<RouteList> r = routes.reader ();
2329 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2330 if ((*i)->name() == name) {
2335 return shared_ptr<Route> ((Route*) 0);
2339 Session::route_by_id (PBD::ID id)
2341 shared_ptr<RouteList> r = routes.reader ();
2343 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2344 if ((*i)->id() == id) {
2349 return shared_ptr<Route> ((Route*) 0);
2353 Session::route_by_remote_id (uint32_t id)
2355 shared_ptr<RouteList> r = routes.reader ();
2357 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2358 if ((*i)->remote_control_id() == id) {
2363 return shared_ptr<Route> ((Route*) 0);
2367 Session::find_current_end ()
2369 if (_state_of_the_state & Loading) {
2373 nframes_t max = get_maximum_extent ();
2375 if (max > end_location->end()) {
2376 end_location->set_end (max);
2378 DurationChanged(); /* EMIT SIGNAL */
2383 Session::get_maximum_extent () const
2388 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
2390 for (DiskstreamList::const_iterator i = dsl->begin(); i != dsl->end(); ++i) {
2391 boost::shared_ptr<Playlist> pl = (*i)->playlist();
2392 if ((me = pl->get_maximum_extent()) > max) {
2400 boost::shared_ptr<Diskstream>
2401 Session::diskstream_by_name (string name)
2403 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
2405 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
2406 if ((*i)->name() == name) {
2411 return boost::shared_ptr<Diskstream>((Diskstream*) 0);
2414 boost::shared_ptr<Diskstream>
2415 Session::diskstream_by_id (const PBD::ID& id)
2417 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
2419 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
2420 if ((*i)->id() == id) {
2425 return boost::shared_ptr<Diskstream>((Diskstream*) 0);
2428 /* AudioRegion management */
2431 Session::new_region_name (string old)
2433 string::size_type last_period;
2435 string::size_type len = old.length() + 64;
2438 if ((last_period = old.find_last_of ('.')) == string::npos) {
2440 /* no period present - add one explicitly */
2443 last_period = old.length() - 1;
2448 number = atoi (old.substr (last_period+1).c_str());
2452 while (number < (UINT_MAX-1)) {
2454 AudioRegionList::const_iterator i;
2459 snprintf (buf, len, "%s%" PRIu32, old.substr (0, last_period + 1).c_str(), number);
2462 for (i = audio_regions.begin(); i != audio_regions.end(); ++i) {
2463 if (i->second->name() == sbuf) {
2468 if (i == audio_regions.end()) {
2473 if (number != (UINT_MAX-1)) {
2477 error << string_compose (_("cannot create new name for region \"%1\""), old) << endmsg;
2482 Session::region_name (string& result, string base, bool newlevel) const
2489 Glib::Mutex::Lock lm (region_lock);
2491 snprintf (buf, sizeof (buf), "%d", (int)audio_regions.size() + 1);
2499 /* XXX this is going to be slow. optimize me later */
2504 string::size_type pos;
2506 pos = base.find_last_of ('.');
2508 /* pos may be npos, but then we just use entire base */
2510 subbase = base.substr (0, pos);
2514 bool name_taken = true;
2517 Glib::Mutex::Lock lm (region_lock);
2519 for (int n = 1; n < 5000; ++n) {
2522 snprintf (buf, sizeof (buf), ".%d", n);
2527 for (AudioRegionList::const_iterator i = audio_regions.begin(); i != audio_regions.end(); ++i) {
2528 if (i->second->name() == result) {
2541 fatal << string_compose(_("too many regions with names like %1"), base) << endmsg;
2549 Session::add_region (boost::shared_ptr<Region> region)
2551 boost::shared_ptr<AudioRegion> ar;
2552 boost::shared_ptr<AudioRegion> oar;
2556 Glib::Mutex::Lock lm (region_lock);
2558 if ((ar = boost::dynamic_pointer_cast<AudioRegion> (region)) != 0) {
2560 AudioRegionList::iterator x;
2562 for (x = audio_regions.begin(); x != audio_regions.end(); ++x) {
2564 oar = boost::dynamic_pointer_cast<AudioRegion> (x->second);
2566 if (ar->region_list_equivalent (oar)) {
2571 if (x == audio_regions.end()) {
2573 pair<AudioRegionList::key_type,AudioRegionList::mapped_type> entry;
2575 entry.first = region->id();
2578 pair<AudioRegionList::iterator,bool> x = audio_regions.insert (entry);
2590 fatal << _("programming error: ")
2591 << X_("unknown region type passed to Session::add_region()")
2598 /* mark dirty because something has changed even if we didn't
2599 add the region to the region list.
2605 region->GoingAway.connect (sigc::bind (mem_fun (*this, &Session::remove_region), boost::weak_ptr<Region>(region)));
2606 region->StateChanged.connect (sigc::bind (mem_fun (*this, &Session::region_changed), boost::weak_ptr<Region>(region)));
2607 AudioRegionAdded (ar); /* EMIT SIGNAL */
2612 Session::region_changed (Change what_changed, boost::weak_ptr<Region> weak_region)
2614 boost::shared_ptr<Region> region (weak_region.lock ());
2620 if (what_changed & Region::HiddenChanged) {
2621 /* relay hidden changes */
2622 RegionHiddenChange (region);
2627 Session::remove_region (boost::weak_ptr<Region> weak_region)
2629 AudioRegionList::iterator i;
2630 boost::shared_ptr<Region> region (weak_region.lock ());
2636 boost::shared_ptr<AudioRegion> ar;
2637 bool removed = false;
2640 Glib::Mutex::Lock lm (region_lock);
2642 if ((ar = boost::dynamic_pointer_cast<AudioRegion> (region)) != 0) {
2643 if ((i = audio_regions.find (region->id())) != audio_regions.end()) {
2644 audio_regions.erase (i);
2650 fatal << _("programming error: ")
2651 << X_("unknown region type passed to Session::remove_region()")
2657 /* mark dirty because something has changed even if we didn't
2658 remove the region from the region list.
2664 AudioRegionRemoved (ar); /* EMIT SIGNAL */
2668 boost::shared_ptr<AudioRegion>
2669 Session::find_whole_file_parent (boost::shared_ptr<AudioRegion const> child)
2671 AudioRegionList::iterator i;
2672 boost::shared_ptr<AudioRegion> region;
2673 Glib::Mutex::Lock lm (region_lock);
2675 for (i = audio_regions.begin(); i != audio_regions.end(); ++i) {
2679 if (region->whole_file()) {
2681 if (child->source_equivalent (region)) {
2687 return boost::shared_ptr<AudioRegion> ();
2691 Session::find_equivalent_playlist_regions (boost::shared_ptr<Region> region, vector<boost::shared_ptr<Region> >& result)
2693 for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i)
2694 (*i)->get_region_list_equivalent_regions (region, result);
2698 Session::destroy_region (boost::shared_ptr<Region> region)
2700 vector<boost::shared_ptr<Source> > srcs;
2703 boost::shared_ptr<AudioRegion> aregion;
2705 if ((aregion = boost::dynamic_pointer_cast<AudioRegion> (region)) == 0) {
2709 if (aregion->playlist()) {
2710 aregion->playlist()->destroy_region (region);
2713 for (uint32_t n = 0; n < aregion->n_channels(); ++n) {
2714 srcs.push_back (aregion->source (n));
2718 region->drop_references ();
2720 for (vector<boost::shared_ptr<Source> >::iterator i = srcs.begin(); i != srcs.end(); ++i) {
2722 if (!(*i)->used()) {
2723 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*i);
2726 (afs)->mark_for_remove ();
2729 (*i)->drop_references ();
2731 cerr << "source was not used by any playlist\n";
2739 Session::destroy_regions (list<boost::shared_ptr<Region> > regions)
2741 for (list<boost::shared_ptr<Region> >::iterator i = regions.begin(); i != regions.end(); ++i) {
2742 destroy_region (*i);
2748 Session::remove_last_capture ()
2750 list<boost::shared_ptr<Region> > r;
2752 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
2754 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
2755 list<boost::shared_ptr<Region> >& l = (*i)->last_capture_regions();
2758 r.insert (r.end(), l.begin(), l.end());
2763 destroy_regions (r);
2768 Session::remove_region_from_region_list (boost::shared_ptr<Region> r)
2774 /* Source Management */
2777 Session::add_source (boost::shared_ptr<Source> source)
2779 boost::shared_ptr<AudioFileSource> afs;
2781 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
2783 pair<AudioSourceList::key_type, AudioSourceList::mapped_type> entry;
2784 pair<AudioSourceList::iterator,bool> result;
2786 entry.first = source->id();
2790 Glib::Mutex::Lock lm (audio_source_lock);
2791 result = audio_sources.insert (entry);
2794 if (result.second) {
2795 source->GoingAway.connect (sigc::bind (mem_fun (this, &Session::remove_source), boost::weak_ptr<Source> (source)));
2803 Session::remove_source (boost::weak_ptr<Source> src)
2805 AudioSourceList::iterator i;
2806 boost::shared_ptr<Source> source = src.lock();
2813 Glib::Mutex::Lock lm (audio_source_lock);
2815 if ((i = audio_sources.find (source->id())) != audio_sources.end()) {
2816 audio_sources.erase (i);
2820 if (!_state_of_the_state & InCleanup) {
2822 /* save state so we don't end up with a session file
2823 referring to non-existent sources.
2826 save_state (_current_snapshot_name);
2830 boost::shared_ptr<Source>
2831 Session::source_by_id (const PBD::ID& id)
2833 Glib::Mutex::Lock lm (audio_source_lock);
2834 AudioSourceList::iterator i;
2835 boost::shared_ptr<Source> source;
2837 if ((i = audio_sources.find (id)) != audio_sources.end()) {
2841 /* XXX search MIDI or other searches here */
2847 boost::shared_ptr<Source>
2848 Session::source_by_path_and_channel (const Glib::ustring& path, uint16_t chn)
2850 Glib::Mutex::Lock lm (audio_source_lock);
2852 for (AudioSourceList::iterator i = audio_sources.begin(); i != audio_sources.end(); ++i) {
2853 cerr << "comparing " << path << " with " << i->second->name() << endl;
2854 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
2856 if (afs && afs->path() == path && chn == afs->channel()) {
2861 return boost::shared_ptr<Source>();
2865 Session::peak_path_from_audio_path (string audio_path) const
2870 res += PBD::basename_nosuffix (audio_path);
2877 Session::change_audio_path_by_name (string path, string oldname, string newname, bool destructive)
2880 string old_basename = PBD::basename_nosuffix (oldname);
2881 string new_legalized = legalize_for_path (newname);
2883 /* note: we know (or assume) the old path is already valid */
2887 /* destructive file sources have a name of the form:
2889 /path/to/Tnnnn-NAME(%[LR])?.wav
2891 the task here is to replace NAME with the new name.
2894 /* find last slash */
2898 string::size_type slash;
2899 string::size_type dash;
2901 if ((slash = path.find_last_of ('/')) == string::npos) {
2905 dir = path.substr (0, slash+1);
2907 /* '-' is not a legal character for the NAME part of the path */
2909 if ((dash = path.find_last_of ('-')) == string::npos) {
2913 prefix = path.substr (slash+1, dash-(slash+1));
2918 path += new_legalized;
2919 path += ".wav"; /* XXX gag me with a spoon */
2923 /* non-destructive file sources have a name of the form:
2925 /path/to/NAME-nnnnn(%[LR])?.wav
2927 the task here is to replace NAME with the new name.
2932 string::size_type slash;
2933 string::size_type dash;
2934 string::size_type postfix;
2936 /* find last slash */
2938 if ((slash = path.find_last_of ('/')) == string::npos) {
2942 dir = path.substr (0, slash+1);
2944 /* '-' is not a legal character for the NAME part of the path */
2946 if ((dash = path.find_last_of ('-')) == string::npos) {
2950 suffix = path.substr (dash+1);
2952 // Suffix is now everything after the dash. Now we need to eliminate
2953 // the nnnnn part, which is done by either finding a '%' or a '.'
2955 postfix = suffix.find_last_of ("%");
2956 if (postfix == string::npos) {
2957 postfix = suffix.find_last_of ('.');
2960 if (postfix != string::npos) {
2961 suffix = suffix.substr (postfix);
2963 error << "Logic error in Session::change_audio_path_by_name(), please report to the developers" << endl;
2967 const uint32_t limit = 10000;
2968 char buf[PATH_MAX+1];
2970 for (uint32_t cnt = 1; cnt <= limit; ++cnt) {
2972 snprintf (buf, sizeof(buf), "%s%s-%u%s", dir.c_str(), newname.c_str(), cnt, suffix.c_str());
2974 if (access (buf, F_OK) != 0) {
2982 error << "FATAL ERROR! Could not find a " << endl;
2991 Session::audio_path_from_name (string name, uint32_t nchan, uint32_t chan, bool destructive)
2995 char buf[PATH_MAX+1];
2996 const uint32_t limit = 10000;
3000 legalized = legalize_for_path (name);
3002 /* find a "version" of the file name that doesn't exist in
3003 any of the possible directories.
3006 for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
3008 vector<space_and_path>::iterator i;
3009 uint32_t existing = 0;
3011 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3015 spath += sound_dir (false);
3019 snprintf (buf, sizeof(buf), "%s/T%04d-%s.wav", spath.c_str(), cnt, legalized.c_str());
3020 } else if (nchan == 2) {
3022 snprintf (buf, sizeof(buf), "%s/T%04d-%s%%L.wav", spath.c_str(), cnt, legalized.c_str());
3024 snprintf (buf, sizeof(buf), "%s/T%04d-%s%%R.wav", spath.c_str(), cnt, legalized.c_str());
3026 } else if (nchan < 26) {
3027 snprintf (buf, sizeof(buf), "%s/T%04d-%s%%%c.wav", spath.c_str(), cnt, legalized.c_str(), 'a' + chan);
3029 snprintf (buf, sizeof(buf), "%s/T%04d-%s.wav", spath.c_str(), cnt, legalized.c_str());
3038 snprintf (buf, sizeof(buf), "%s-%u.wav", spath.c_str(), cnt);
3039 } else if (nchan == 2) {
3041 snprintf (buf, sizeof(buf), "%s-%u%%L.wav", spath.c_str(), cnt);
3043 snprintf (buf, sizeof(buf), "%s-%u%%R.wav", spath.c_str(), cnt);
3045 } else if (nchan < 26) {
3046 snprintf (buf, sizeof(buf), "%s-%u%%%c.wav", spath.c_str(), cnt, 'a' + chan);
3048 snprintf (buf, sizeof(buf), "%s-%u.wav", spath.c_str(), cnt);
3052 if (g_file_test (buf, G_FILE_TEST_EXISTS)) {
3058 if (existing == 0) {
3063 error << string_compose(_("There are already %1 recordings for %2, which I consider too many."), limit, name) << endmsg;
3065 throw failed_constructor();
3069 /* we now have a unique name for the file, but figure out where to
3075 spath = discover_best_sound_dir ();
3078 string::size_type pos = foo.find_last_of ('/');
3080 if (pos == string::npos) {
3083 spath += foo.substr (pos + 1);
3089 boost::shared_ptr<AudioFileSource>
3090 Session::create_audio_source_for_session (AudioDiskstream& ds, uint32_t chan, bool destructive)
3092 string spath = audio_path_from_name (ds.name(), ds.n_channels(), chan, destructive);
3093 return boost::dynamic_pointer_cast<AudioFileSource> (SourceFactory::createWritable (*this, spath, destructive, frame_rate()));
3096 /* Playlist management */
3098 boost::shared_ptr<Playlist>
3099 Session::playlist_by_name (string name)
3101 Glib::Mutex::Lock lm (playlist_lock);
3102 for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i) {
3103 if ((*i)->name() == name) {
3107 for (PlaylistList::iterator i = unused_playlists.begin(); i != unused_playlists.end(); ++i) {
3108 if ((*i)->name() == name) {
3113 return boost::shared_ptr<Playlist>();
3117 Session::add_playlist (boost::shared_ptr<Playlist> playlist)
3119 if (playlist->hidden()) {
3124 Glib::Mutex::Lock lm (playlist_lock);
3125 if (find (playlists.begin(), playlists.end(), playlist) == playlists.end()) {
3126 playlists.insert (playlists.begin(), playlist);
3127 playlist->InUse.connect (sigc::bind (mem_fun (*this, &Session::track_playlist), boost::weak_ptr<Playlist>(playlist)));
3128 playlist->GoingAway.connect (sigc::bind (mem_fun (*this, &Session::remove_playlist), boost::weak_ptr<Playlist>(playlist)));
3134 PlaylistAdded (playlist); /* EMIT SIGNAL */
3138 Session::get_playlists (vector<boost::shared_ptr<Playlist> >& s)
3141 Glib::Mutex::Lock lm (playlist_lock);
3142 for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i) {
3145 for (PlaylistList::iterator i = unused_playlists.begin(); i != unused_playlists.end(); ++i) {
3152 Session::track_playlist (bool inuse, boost::weak_ptr<Playlist> wpl)
3154 boost::shared_ptr<Playlist> pl(wpl.lock());
3160 PlaylistList::iterator x;
3163 /* its not supposed to be visible */
3168 Glib::Mutex::Lock lm (playlist_lock);
3172 unused_playlists.insert (pl);
3174 if ((x = playlists.find (pl)) != playlists.end()) {
3175 playlists.erase (x);
3181 playlists.insert (pl);
3183 if ((x = unused_playlists.find (pl)) != unused_playlists.end()) {
3184 unused_playlists.erase (x);
3191 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
3193 if (_state_of_the_state & Deletion) {
3197 boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
3204 Glib::Mutex::Lock lm (playlist_lock);
3206 PlaylistList::iterator i;
3208 i = find (playlists.begin(), playlists.end(), playlist);
3209 if (i != playlists.end()) {
3210 playlists.erase (i);
3213 i = find (unused_playlists.begin(), unused_playlists.end(), playlist);
3214 if (i != unused_playlists.end()) {
3215 unused_playlists.erase (i);
3222 PlaylistRemoved (playlist); /* EMIT SIGNAL */
3226 Session::set_audition (boost::shared_ptr<Region> r)
3228 pending_audition_region = r;
3229 post_transport_work = PostTransportWork (post_transport_work | PostTransportAudition);
3230 schedule_butler_transport_work ();
3234 Session::audition_playlist ()
3236 Event* ev = new Event (Event::Audition, Event::Add, Event::Immediate, 0, 0.0);
3237 ev->region.reset ();
3242 Session::non_realtime_set_audition ()
3244 if (!pending_audition_region) {
3245 auditioner->audition_current_playlist ();
3247 auditioner->audition_region (pending_audition_region);
3248 pending_audition_region.reset ();
3250 AuditionActive (true); /* EMIT SIGNAL */
3254 Session::audition_region (boost::shared_ptr<Region> r)
3256 Event* ev = new Event (Event::Audition, Event::Add, Event::Immediate, 0, 0.0);
3262 Session::cancel_audition ()
3264 if (auditioner->active()) {
3265 auditioner->cancel_audition ();
3266 AuditionActive (false); /* EMIT SIGNAL */
3271 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
3273 return a->order_key(N_("signal")) < b->order_key(N_("signal"));
3277 Session::remove_empty_sounds ()
3279 PathScanner scanner;
3281 vector<string *>* possible_audiofiles = scanner (sound_dir(), "\\.(wav|aiff|caf|w64)$", false, true);
3283 Glib::Mutex::Lock lm (audio_source_lock);
3285 regex_t compiled_tape_track_pattern;
3288 if ((err = regcomp (&compiled_tape_track_pattern, "/T[0-9][0-9][0-9][0-9]-", REG_EXTENDED|REG_NOSUB))) {
3292 regerror (err, &compiled_tape_track_pattern, msg, sizeof (msg));
3294 error << string_compose (_("Cannot compile tape track regexp for use (%1)"), msg) << endmsg;
3298 for (vector<string *>::iterator i = possible_audiofiles->begin(); i != possible_audiofiles->end(); ++i) {
3300 /* never remove files that appear to be a tape track */
3302 if (regexec (&compiled_tape_track_pattern, (*i)->c_str(), 0, 0, 0) == 0) {
3307 if (AudioFileSource::is_empty (*this, *(*i))) {
3309 unlink ((*i)->c_str());
3311 string peak_path = peak_path_from_audio_path (**i);
3312 unlink (peak_path.c_str());
3318 delete possible_audiofiles;
3322 Session::is_auditioning () const
3324 /* can be called before we have an auditioner object */
3326 return auditioner->active();
3333 Session::set_all_solo (bool yn)
3335 shared_ptr<RouteList> r = routes.reader ();
3337 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3338 if (!(*i)->hidden()) {
3339 (*i)->set_solo (yn, this);
3347 Session::set_all_mute (bool yn)
3349 shared_ptr<RouteList> r = routes.reader ();
3351 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3352 if (!(*i)->hidden()) {
3353 (*i)->set_mute (yn, this);
3361 Session::n_diskstreams () const
3365 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
3367 for (DiskstreamList::const_iterator i = dsl->begin(); i != dsl->end(); ++i) {
3368 if (!(*i)->hidden()) {
3376 Session::graph_reordered ()
3378 /* don't do this stuff if we are setting up connections
3379 from a set_state() call or creating new tracks.
3382 if (_state_of_the_state & InitialConnecting) {
3386 /* every track/bus asked for this to be handled but it was deferred because
3387 we were connecting. do it now.
3390 boost::shared_ptr<DiskstreamList> ds = diskstreams.reader();
3392 for (DiskstreamList::iterator i = ds->begin(); i != ds->end(); ++i) {
3393 request_input_change_handling (*i);
3398 /* force all diskstreams to update their capture offset values to
3399 reflect any changes in latencies within the graph.
3402 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
3404 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
3405 (*i)->set_capture_offset ();
3410 Session::record_disenable_all ()
3412 record_enable_change_all (false);
3416 Session::record_enable_all ()
3418 record_enable_change_all (true);
3422 Session::record_enable_change_all (bool yn)
3424 shared_ptr<RouteList> r = routes.reader ();
3426 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3429 if ((at = dynamic_cast<AudioTrack*>((*i).get())) != 0) {
3430 at->set_record_enable (yn, this);
3434 /* since we don't keep rec-enable state, don't mark session dirty */
3438 Session::add_redirect (Redirect* redirect)
3442 PortInsert* port_insert;
3443 PluginInsert* plugin_insert;
3445 if ((insert = dynamic_cast<Insert *> (redirect)) != 0) {
3446 if ((port_insert = dynamic_cast<PortInsert *> (insert)) != 0) {
3447 _port_inserts.insert (_port_inserts.begin(), port_insert);
3448 } else if ((plugin_insert = dynamic_cast<PluginInsert *> (insert)) != 0) {
3449 _plugin_inserts.insert (_plugin_inserts.begin(), plugin_insert);
3451 fatal << _("programming error: unknown type of Insert created!") << endmsg;
3454 } else if ((send = dynamic_cast<Send *> (redirect)) != 0) {
3455 _sends.insert (_sends.begin(), send);
3457 fatal << _("programming error: unknown type of Redirect created!") << endmsg;
3461 redirect->GoingAway.connect (sigc::bind (mem_fun (*this, &Session::remove_redirect), redirect));
3467 Session::remove_redirect (Redirect* redirect)
3471 PortInsert* port_insert;
3472 PluginInsert* plugin_insert;
3474 if ((insert = dynamic_cast<Insert *> (redirect)) != 0) {
3475 if ((port_insert = dynamic_cast<PortInsert *> (insert)) != 0) {
3476 list<PortInsert*>::iterator x = find (_port_inserts.begin(), _port_inserts.end(), port_insert);
3477 if (x != _port_inserts.end()) {
3478 insert_bitset[port_insert->bit_slot()] = false;
3479 _port_inserts.erase (x);
3481 } else if ((plugin_insert = dynamic_cast<PluginInsert *> (insert)) != 0) {
3482 _plugin_inserts.remove (plugin_insert);
3484 fatal << string_compose (_("programming error: %1"),
3485 X_("unknown type of Insert deleted!"))
3489 } else if ((send = dynamic_cast<Send *> (redirect)) != 0) {
3490 list<Send*>::iterator x = find (_sends.begin(), _sends.end(), send);
3491 if (x != _sends.end()) {
3492 send_bitset[send->bit_slot()] = false;
3496 fatal << _("programming error: unknown type of Redirect deleted!") << endmsg;
3504 Session::available_capture_duration ()
3506 float sample_bytes_on_disk = 4.0; // keep gcc happy
3508 switch (Config->get_native_file_data_format()) {
3510 sample_bytes_on_disk = 4.0;
3514 sample_bytes_on_disk = 3.0;
3518 /* impossible, but keep some gcc versions happy */
3519 fatal << string_compose (_("programming error: %1"),
3520 X_("illegal native file data format"))
3525 double scale = 4096.0 / sample_bytes_on_disk;
3527 if (_total_free_4k_blocks * scale > (double) max_frames) {
3531 return (nframes_t) floor (_total_free_4k_blocks * scale);
3535 Session::add_connection (ARDOUR::Connection* connection)
3538 Glib::Mutex::Lock guard (connection_lock);
3539 _connections.push_back (connection);
3542 ConnectionAdded (connection); /* EMIT SIGNAL */
3548 Session::remove_connection (ARDOUR::Connection* connection)
3550 bool removed = false;
3553 Glib::Mutex::Lock guard (connection_lock);
3554 ConnectionList::iterator i = find (_connections.begin(), _connections.end(), connection);
3556 if (i != _connections.end()) {
3557 _connections.erase (i);
3563 ConnectionRemoved (connection); /* EMIT SIGNAL */
3569 ARDOUR::Connection *
3570 Session::connection_by_name (string name) const
3572 Glib::Mutex::Lock lm (connection_lock);
3574 for (ConnectionList::const_iterator i = _connections.begin(); i != _connections.end(); ++i) {
3575 if ((*i)->name() == name) {
3584 Session::tempo_map_changed (Change ignored)
3591 Session::ensure_passthru_buffers (uint32_t howmany)
3593 while (howmany > _passthru_buffers.size()) {
3595 #ifdef NO_POSIX_MEMALIGN
3596 p = (Sample *) malloc(current_block_size * sizeof(Sample));
3598 posix_memalign((void **)&p,CPU_CACHE_ALIGN,current_block_size * sizeof(Sample));
3600 _passthru_buffers.push_back (p);
3604 #ifdef NO_POSIX_MEMALIGN
3605 p = (Sample *) malloc(current_block_size * sizeof(Sample));
3607 posix_memalign((void **)&p,CPU_CACHE_ALIGN,current_block_size * 4);
3609 memset (p, 0, sizeof (Sample) * current_block_size);
3610 _silent_buffers.push_back (p);
3614 #ifdef NO_POSIX_MEMALIGN
3615 p = (Sample *) malloc(current_block_size * sizeof(Sample));
3617 posix_memalign((void **)&p,CPU_CACHE_ALIGN,current_block_size * sizeof(Sample));
3619 memset (p, 0, sizeof (Sample) * current_block_size);
3620 _send_buffers.push_back (p);
3623 allocate_pan_automation_buffers (current_block_size, howmany, false);
3627 Session::next_insert_id ()
3629 /* this doesn't really loop forever. just think about it */
3632 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
3633 if (!insert_bitset[n]) {
3634 insert_bitset[n] = true;
3635 cerr << "Returning " << n << " as insert ID\n";
3641 /* none available, so resize and try again */
3643 insert_bitset.resize (insert_bitset.size() + 16, false);
3648 Session::next_send_id ()
3650 /* this doesn't really loop forever. just think about it */
3653 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
3654 if (!send_bitset[n]) {
3655 send_bitset[n] = true;
3656 cerr << "Returning " << n << " as send ID\n";
3662 /* none available, so resize and try again */
3664 send_bitset.resize (send_bitset.size() + 16, false);
3669 Session::mark_send_id (uint32_t id)
3671 if (id >= send_bitset.size()) {
3672 send_bitset.resize (id+16, false);
3674 if (send_bitset[id]) {
3675 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
3677 send_bitset[id] = true;
3681 Session::mark_insert_id (uint32_t id)
3683 if (id >= insert_bitset.size()) {
3684 insert_bitset.resize (id+16, false);
3686 if (insert_bitset[id]) {
3687 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
3689 insert_bitset[id] = true;
3692 /* Named Selection management */
3695 Session::named_selection_by_name (string name)
3697 Glib::Mutex::Lock lm (named_selection_lock);
3698 for (NamedSelectionList::iterator i = named_selections.begin(); i != named_selections.end(); ++i) {
3699 if ((*i)->name == name) {
3707 Session::add_named_selection (NamedSelection* named_selection)
3710 Glib::Mutex::Lock lm (named_selection_lock);
3711 named_selections.insert (named_selections.begin(), named_selection);
3714 for (list<boost::shared_ptr<Playlist> >::iterator i = named_selection->playlists.begin(); i != named_selection->playlists.end(); ++i) {
3720 NamedSelectionAdded (); /* EMIT SIGNAL */
3724 Session::remove_named_selection (NamedSelection* named_selection)
3726 bool removed = false;
3729 Glib::Mutex::Lock lm (named_selection_lock);
3731 NamedSelectionList::iterator i = find (named_selections.begin(), named_selections.end(), named_selection);
3733 if (i != named_selections.end()) {
3735 named_selections.erase (i);
3742 NamedSelectionRemoved (); /* EMIT SIGNAL */
3747 Session::reset_native_file_format ()
3749 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
3751 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
3752 (*i)->reset_write_sources (false);
3757 Session::route_name_unique (string n) const
3759 shared_ptr<RouteList> r = routes.reader ();
3761 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
3762 if ((*i)->name() == n) {
3771 Session::n_playlists () const
3773 Glib::Mutex::Lock lm (playlist_lock);
3774 return playlists.size();
3778 Session::allocate_pan_automation_buffers (nframes_t nframes, uint32_t howmany, bool force)
3780 if (!force && howmany <= _npan_buffers) {
3784 if (_pan_automation_buffer) {
3786 for (uint32_t i = 0; i < _npan_buffers; ++i) {
3787 delete [] _pan_automation_buffer[i];
3790 delete [] _pan_automation_buffer;
3793 _pan_automation_buffer = new pan_t*[howmany];
3795 for (uint32_t i = 0; i < howmany; ++i) {
3796 _pan_automation_buffer[i] = new pan_t[nframes];
3799 _npan_buffers = howmany;
3803 Session::freeze (InterThreadInfo& itt)
3805 shared_ptr<RouteList> r = routes.reader ();
3807 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3811 if ((at = dynamic_cast<AudioTrack*>((*i).get())) != 0) {
3812 /* XXX this is wrong because itt.progress will keep returning to zero at the start
3823 Session::write_one_audio_track (AudioTrack& track, nframes_t start, nframes_t len,
3824 bool overwrite, vector<boost::shared_ptr<AudioSource> >& srcs, InterThreadInfo& itt)
3827 boost::shared_ptr<Playlist> playlist;
3828 boost::shared_ptr<AudioFileSource> fsource;
3830 char buf[PATH_MAX+1];
3834 nframes_t this_chunk;
3836 vector<Sample*> buffers;
3838 // any bigger than this seems to cause stack overflows in called functions
3839 const nframes_t chunk_size = (128 * 1024)/4;
3841 g_atomic_int_set (&processing_prohibited, 1);
3843 /* call tree *MUST* hold route_lock */
3845 if ((playlist = track.diskstream()->playlist()) == 0) {
3849 /* external redirects will be a problem */
3851 if (track.has_external_redirects()) {
3855 nchans = track.audio_diskstream()->n_channels();
3857 dir = discover_best_sound_dir ();
3859 for (uint32_t chan_n=0; chan_n < nchans; ++chan_n) {
3861 for (x = 0; x < 99999; ++x) {
3862 snprintf (buf, sizeof(buf), "%s/%s-%d-bounce-%" PRIu32 ".wav", dir.c_str(), playlist->name().c_str(), chan_n, x+1);
3863 if (access (buf, F_OK) != 0) {
3869 error << string_compose (_("too many bounced versions of playlist \"%1\""), playlist->name()) << endmsg;
3874 fsource = boost::dynamic_pointer_cast<AudioFileSource> (SourceFactory::createWritable (*this, buf, false, frame_rate()));
3877 catch (failed_constructor& err) {
3878 error << string_compose (_("cannot create new audio file \"%1\" for %2"), buf, track.name()) << endmsg;
3882 srcs.push_back (fsource);
3885 /* XXX need to flush all redirects */
3890 /* create a set of reasonably-sized buffers */
3892 for (vector<Sample*>::iterator i = _passthru_buffers.begin(); i != _passthru_buffers.end(); ++i) {
3894 #ifdef NO_POSIX_MEMALIGN
3895 b = (Sample *) malloc(chunk_size * sizeof(Sample));
3897 posix_memalign((void **)&b,4096,chunk_size * sizeof(Sample));
3899 buffers.push_back (b);
3902 for (vector<boost::shared_ptr<AudioSource> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
3903 (*src)->prepare_for_peakfile_writes ();
3906 while (to_do && !itt.cancel) {
3908 this_chunk = min (to_do, chunk_size);
3910 if (track.export_stuff (buffers, nchans, start, this_chunk)) {
3915 for (vector<boost::shared_ptr<AudioSource> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
3916 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3919 if (afs->write (buffers[n], this_chunk) != this_chunk) {
3925 start += this_chunk;
3926 to_do -= this_chunk;
3928 itt.progress = (float) (1.0 - ((double) to_do / len));
3937 xnow = localtime (&now);
3939 for (vector<boost::shared_ptr<AudioSource> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
3940 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3943 afs->update_header (position, *xnow, now);
3944 afs->flush_header ();
3948 /* construct a region to represent the bounced material */
3950 boost::shared_ptr<Region> aregion = RegionFactory::create (srcs, 0, srcs.front()->length(),
3951 region_name_from_path (srcs.front()->name(), true));
3958 for (vector<boost::shared_ptr<AudioSource> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
3959 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
3962 afs->mark_for_remove ();
3965 (*src)->drop_references ();
3969 for (vector<boost::shared_ptr<AudioSource> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
3970 (*src)->done_with_peakfile_writes ();
3974 for (vector<Sample*>::iterator i = buffers.begin(); i != buffers.end(); ++i) {
3978 g_atomic_int_set (&processing_prohibited, 0);
3986 Session::get_silent_buffers (uint32_t howmany)
3988 for (uint32_t i = 0; i < howmany; ++i) {
3989 memset (_silent_buffers[i], 0, sizeof (Sample) * current_block_size);
3991 return _silent_buffers;
3995 Session::ntracks () const
3998 shared_ptr<RouteList> r = routes.reader ();
4000 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4001 if (dynamic_cast<AudioTrack*> ((*i).get())) {
4010 Session::nbusses () const
4013 shared_ptr<RouteList> r = routes.reader ();
4015 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4016 if (dynamic_cast<AudioTrack*> ((*i).get()) == 0) {
4025 Session::add_automation_list(AutomationList *al)
4027 automation_lists[al->id()] = al;
4031 Session::compute_initial_length ()
4033 return _engine.frame_rate() * 60 * 5;