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 routes (new RouteList),
273 auditioner ((Auditioner*) 0),
279 if (!eng.connected()) {
280 throw failed_constructor();
283 cerr << "Loading session " << fullpath << " using snapshot " << snapshot_name << " (1)" << endl;
285 n_physical_outputs = _engine.n_physical_outputs();
286 n_physical_inputs = _engine.n_physical_inputs();
288 first_stage_init (fullpath, snapshot_name);
290 new_session = !g_file_test (_path.c_str(), GFileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR));
292 if (create (new_session, mix_template, compute_initial_length())) {
293 cerr << "create failed\n";
295 throw failed_constructor ();
299 if (second_stage_init (new_session)) {
301 throw failed_constructor ();
304 store_recent_sessions(_name, _path);
306 bool was_dirty = dirty();
308 _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
310 Config->ParameterChanged.connect (mem_fun (*this, &Session::config_changed));
313 DirtyChanged (); /* EMIT SIGNAL */
317 Session::Session (AudioEngine &eng,
319 string snapshot_name,
320 AutoConnectOption input_ac,
321 AutoConnectOption output_ac,
322 uint32_t control_out_channels,
323 uint32_t master_out_channels,
324 uint32_t requested_physical_in,
325 uint32_t requested_physical_out,
326 nframes_t initial_length)
329 _mmc_port (default_mmc_port),
330 _mtc_port (default_mtc_port),
331 _midi_port (default_midi_port),
332 pending_events (2048),
334 diskstreams (new DiskstreamList),
335 routes (new RouteList),
341 if (!eng.connected()) {
342 throw failed_constructor();
345 cerr << "Loading session " << fullpath << " using snapshot " << snapshot_name << " (2)" << endl;
347 n_physical_outputs = _engine.n_physical_outputs();
348 n_physical_inputs = _engine.n_physical_inputs();
350 if (n_physical_inputs) {
351 n_physical_inputs = max (requested_physical_in, n_physical_inputs);
354 if (n_physical_outputs) {
355 n_physical_outputs = max (requested_physical_out, n_physical_outputs);
358 first_stage_init (fullpath, snapshot_name);
360 new_session = !g_file_test (_path.c_str(), GFileTest (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR));
363 if (create (new_session, 0, initial_length)) {
365 throw failed_constructor ();
370 /* set up Master Out and Control Out if necessary */
375 if (control_out_channels) {
376 shared_ptr<Route> r (new Route (*this, _("monitor"), -1, control_out_channels, -1, control_out_channels, Route::ControlOut));
377 r->set_remote_control_id (control_id++);
382 if (master_out_channels) {
383 shared_ptr<Route> r (new Route (*this, _("master"), -1, master_out_channels, -1, master_out_channels, Route::MasterOut));
384 r->set_remote_control_id (control_id);
388 /* prohibit auto-connect to master, because there isn't one */
389 output_ac = AutoConnectOption (output_ac & ~AutoConnectMaster);
398 Config->set_input_auto_connect (input_ac);
399 Config->set_output_auto_connect (output_ac);
401 if (second_stage_init (new_session)) {
403 throw failed_constructor ();
406 store_recent_sessions(_name, _path);
408 bool was_dirty = dirty ();
410 _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
412 Config->ParameterChanged.connect (mem_fun (*this, &Session::config_changed));
415 DirtyChanged (); /* EMIT SIGNAL */
427 /* if we got to here, leaving pending capture state around
431 remove_pending_capture_state ();
433 _state_of_the_state = StateOfTheState (CannotSave|Deletion);
434 _engine.remove_session ();
436 GoingAway (); /* EMIT SIGNAL */
442 /* clear history so that no references to objects are held any more */
446 /* clear state tree so that no references to objects are held any more */
452 terminate_butler_thread ();
453 terminate_midi_thread ();
455 if (click_data && click_data != default_click) {
456 delete [] click_data;
459 if (click_emphasis_data && click_emphasis_data != default_click_emphasis) {
460 delete [] click_emphasis_data;
465 for (vector<Sample*>::iterator i = _passthru_buffers.begin(); i != _passthru_buffers.end(); ++i) {
469 for (vector<Sample*>::iterator i = _silent_buffers.begin(); i != _silent_buffers.end(); ++i) {
473 for (vector<Sample*>::iterator i = _send_buffers.begin(); i != _send_buffers.end(); ++i) {
477 AudioDiskstream::free_working_buffers();
479 /* this should cause deletion of the auditioner */
481 // auditioner.reset ();
483 #undef TRACK_DESTRUCTION
484 #ifdef TRACK_DESTRUCTION
485 cerr << "delete named selections\n";
486 #endif /* TRACK_DESTRUCTION */
487 for (NamedSelectionList::iterator i = named_selections.begin(); i != named_selections.end(); ) {
488 NamedSelectionList::iterator tmp;
497 #ifdef TRACK_DESTRUCTION
498 cerr << "delete playlists\n";
499 #endif /* TRACK_DESTRUCTION */
500 for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ) {
501 PlaylistList::iterator tmp;
506 (*i)->drop_references ();
511 for (PlaylistList::iterator i = unused_playlists.begin(); i != unused_playlists.end(); ) {
512 PlaylistList::iterator tmp;
517 (*i)->drop_references ();
523 unused_playlists.clear ();
525 #ifdef TRACK_DESTRUCTION
526 cerr << "delete audio regions\n";
527 #endif /* TRACK_DESTRUCTION */
529 for (AudioRegionList::iterator i = audio_regions.begin(); i != audio_regions.end(); ) {
530 AudioRegionList::iterator tmp;
535 i->second->drop_references ();
540 audio_regions.clear ();
542 #ifdef TRACK_DESTRUCTION
543 cerr << "delete routes\n";
544 #endif /* TRACK_DESTRUCTION */
546 RCUWriter<RouteList> writer (routes);
547 boost::shared_ptr<RouteList> r = writer.get_copy ();
548 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
549 (*i)->drop_references ();
552 /* writer goes out of scope and updates master */
557 #ifdef TRACK_DESTRUCTION
558 cerr << "delete diskstreams\n";
559 #endif /* TRACK_DESTRUCTION */
561 RCUWriter<DiskstreamList> dwriter (diskstreams);
562 boost::shared_ptr<DiskstreamList> dsl = dwriter.get_copy();
563 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
564 (*i)->drop_references ();
568 diskstreams.flush ();
570 #ifdef TRACK_DESTRUCTION
571 cerr << "delete audio sources\n";
572 #endif /* TRACK_DESTRUCTION */
573 for (AudioSourceList::iterator i = audio_sources.begin(); i != audio_sources.end(); ) {
574 AudioSourceList::iterator tmp;
579 i->second->drop_references ();
584 audio_sources.clear ();
586 #ifdef TRACK_DESTRUCTION
587 cerr << "delete mix groups\n";
588 #endif /* TRACK_DESTRUCTION */
589 for (list<RouteGroup *>::iterator i = mix_groups.begin(); i != mix_groups.end(); ) {
590 list<RouteGroup*>::iterator tmp;
600 #ifdef TRACK_DESTRUCTION
601 cerr << "delete edit groups\n";
602 #endif /* TRACK_DESTRUCTION */
603 for (list<RouteGroup *>::iterator i = edit_groups.begin(); i != edit_groups.end(); ) {
604 list<RouteGroup*>::iterator tmp;
614 #ifdef TRACK_DESTRUCTION
615 cerr << "delete connections\n";
616 #endif /* TRACK_DESTRUCTION */
617 for (ConnectionList::iterator i = _connections.begin(); i != _connections.end(); ) {
618 ConnectionList::iterator tmp;
628 if (butler_mixdown_buffer) {
629 delete [] butler_mixdown_buffer;
632 if (butler_gain_buffer) {
633 delete [] butler_gain_buffer;
636 Crossfade::set_buffer_size (0);
644 Session::set_worst_io_latencies ()
646 _worst_output_latency = 0;
647 _worst_input_latency = 0;
649 if (!_engine.connected()) {
653 boost::shared_ptr<RouteList> r = routes.reader ();
655 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
656 _worst_output_latency = max (_worst_output_latency, (*i)->output_latency());
657 _worst_input_latency = max (_worst_input_latency, (*i)->input_latency());
662 Session::when_engine_running ()
664 string first_physical_output;
666 /* we don't want to run execute this again */
668 set_block_size (_engine.frames_per_cycle());
669 set_frame_rate (_engine.frame_rate());
671 Config->map_parameters (mem_fun (*this, &Session::config_changed));
673 /* every time we reconnect, recompute worst case output latencies */
675 _engine.Running.connect (mem_fun (*this, &Session::set_worst_io_latencies));
677 if (synced_to_jack()) {
678 _engine.transport_stop ();
681 if (Config->get_jack_time_master()) {
682 _engine.transport_locate (_transport_frame);
690 _click_io.reset (new ClickIO (*this, "click", 0, 0, -1, -1));
692 if (state_tree && (child = find_named_node (*state_tree->root(), "Click")) != 0) {
694 /* existing state for Click */
696 if (_click_io->set_state (*child->children().front()) == 0) {
698 _clicking = Config->get_clicking ();
702 error << _("could not setup Click I/O") << endmsg;
708 /* default state for Click */
710 first_physical_output = _engine.get_nth_physical_output (0);
712 if (first_physical_output.length()) {
713 if (_click_io->add_output_port (first_physical_output, this)) {
714 // relax, even though its an error
716 _clicking = Config->get_clicking ();
722 catch (failed_constructor& err) {
723 error << _("cannot setup Click I/O") << endmsg;
726 set_worst_io_latencies ();
729 // XXX HOW TO ALERT UI TO THIS ? DO WE NEED TO?
732 /* Create a set of Connection objects that map
733 to the physical outputs currently available
738 for (uint32_t np = 0; np < n_physical_outputs; ++np) {
740 snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
742 Connection* c = new OutputConnection (buf, true);
745 c->add_connection (0, _engine.get_nth_physical_output (np));
750 for (uint32_t np = 0; np < n_physical_inputs; ++np) {
752 snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
754 Connection* c = new InputConnection (buf, true);
757 c->add_connection (0, _engine.get_nth_physical_input (np));
764 for (uint32_t np = 0; np < n_physical_outputs; np +=2) {
766 snprintf (buf, sizeof (buf), _("out %" PRIu32 "+%" PRIu32), np+1, np+2);
768 Connection* c = new OutputConnection (buf, true);
772 c->add_connection (0, _engine.get_nth_physical_output (np));
773 c->add_connection (1, _engine.get_nth_physical_output (np+1));
778 for (uint32_t np = 0; np < n_physical_inputs; np +=2) {
780 snprintf (buf, sizeof (buf), _("in %" PRIu32 "+%" PRIu32), np+1, np+2);
782 Connection* c = new InputConnection (buf, true);
786 c->add_connection (0, _engine.get_nth_physical_input (np));
787 c->add_connection (1, _engine.get_nth_physical_input (np+1));
796 /* create master/control ports */
801 /* force the master to ignore any later call to this */
803 if (_master_out->pending_state_node) {
804 _master_out->ports_became_legal();
807 /* no panner resets till we are through */
809 _master_out->defer_pan_reset ();
811 while ((int) _master_out->n_inputs() < _master_out->input_maximum()) {
812 if (_master_out->add_input_port ("", this)) {
813 error << _("cannot setup master inputs")
819 while ((int) _master_out->n_outputs() < _master_out->output_maximum()) {
820 if (_master_out->add_output_port (_engine.get_nth_physical_output (n), this)) {
821 error << _("cannot setup master outputs")
828 _master_out->allow_pan_reset ();
832 Connection* c = new OutputConnection (_("Master Out"), true);
834 for (uint32_t n = 0; n < _master_out->n_inputs (); ++n) {
836 c->add_connection ((int) n, _master_out->input(n)->name());
843 /* catch up on send+insert cnts */
847 for (list<PortInsert*>::iterator i = _port_inserts.begin(); i != _port_inserts.end(); ++i) {
850 if (sscanf ((*i)->name().c_str(), "%*s %u", &id) == 1) {
851 if (id > insert_cnt) {
859 for (list<Send*>::iterator i = _sends.begin(); i != _sends.end(); ++i) {
862 if (sscanf ((*i)->name().c_str(), "%*s %u", &id) == 1) {
870 _state_of_the_state = StateOfTheState (_state_of_the_state & ~(CannotSave|Dirty));
872 /* hook us up to the engine */
874 _engine.set_session (this);
879 osc->set_session (*this);
882 _state_of_the_state = Clean;
884 DirtyChanged (); /* EMIT SIGNAL */
888 Session::hookup_io ()
890 /* stop graph reordering notifications from
891 causing resorts, etc.
894 _state_of_the_state = StateOfTheState (_state_of_the_state | InitialConnecting);
896 if (auditioner == 0) {
898 /* we delay creating the auditioner till now because
899 it makes its own connections to ports.
900 the engine has to be running for this to work.
904 auditioner.reset (new Auditioner (*this));
907 catch (failed_constructor& err) {
908 warning << _("cannot create Auditioner: no auditioning of regions possible") << endmsg;
912 /* Tell all IO objects to create their ports */
918 vector<string> cports;
920 while ((int) _control_out->n_inputs() < _control_out->input_maximum()) {
921 if (_control_out->add_input_port ("", this)) {
922 error << _("cannot setup control inputs")
928 while ((int) _control_out->n_outputs() < _control_out->output_maximum()) {
929 if (_control_out->add_output_port (_engine.get_nth_physical_output (n), this)) {
930 error << _("cannot set up master outputs")
938 uint32_t ni = _control_out->n_inputs();
940 for (n = 0; n < ni; ++n) {
941 cports.push_back (_control_out->input(n)->name());
944 boost::shared_ptr<RouteList> r = routes.reader ();
946 for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
947 (*x)->set_control_outs (cports);
951 /* Tell all IO objects to connect themselves together */
953 IO::enable_connecting ();
955 /* Now reset all panners */
957 IO::reset_panners ();
959 /* Anyone who cares about input state, wake up and do something */
961 IOConnectionsComplete (); /* EMIT SIGNAL */
963 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InitialConnecting);
965 /* now handle the whole enchilada as if it was one
971 /* update mixer solo state */
977 Session::playlist_length_changed ()
979 /* we can't just increase end_location->end() if pl->get_maximum_extent()
980 if larger. if the playlist used to be the longest playlist,
981 and its now shorter, we have to decrease end_location->end(). hence,
982 we have to iterate over all diskstreams and check the
983 playlists currently in use.
989 Session::diskstream_playlist_changed (boost::shared_ptr<Diskstream> dstream)
991 boost::shared_ptr<Playlist> playlist;
993 if ((playlist = dstream->playlist()) != 0) {
994 playlist->LengthChanged.connect (mem_fun (this, &Session::playlist_length_changed));
997 /* see comment in playlist_length_changed () */
1002 Session::record_enabling_legal () const
1004 /* this used to be in here, but survey says.... we don't need to restrict it */
1005 // if (record_status() == Recording) {
1009 if (Config->get_all_safe()) {
1016 Session::reset_input_monitor_state ()
1018 if (transport_rolling()) {
1020 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
1022 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
1023 if ((*i)->record_enabled ()) {
1024 //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
1025 (*i)->monitor_input (Config->get_monitoring_model() == HardwareMonitoring && !Config->get_auto_input());
1029 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
1031 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
1032 if ((*i)->record_enabled ()) {
1033 //cerr << "switching to input = " << !Config->get_auto_input() << __FILE__ << __LINE__ << endl << endl;
1034 (*i)->monitor_input (Config->get_monitoring_model() == HardwareMonitoring);
1041 Session::auto_punch_start_changed (Location* location)
1043 replace_event (Event::PunchIn, location->start());
1045 if (get_record_enabled() && Config->get_punch_in()) {
1046 /* capture start has been changed, so save new pending state */
1047 save_state ("", true);
1052 Session::auto_punch_end_changed (Location* location)
1054 nframes_t when_to_stop = location->end();
1055 // when_to_stop += _worst_output_latency + _worst_input_latency;
1056 replace_event (Event::PunchOut, when_to_stop);
1060 Session::auto_punch_changed (Location* location)
1062 nframes_t when_to_stop = location->end();
1064 replace_event (Event::PunchIn, location->start());
1065 //when_to_stop += _worst_output_latency + _worst_input_latency;
1066 replace_event (Event::PunchOut, when_to_stop);
1070 Session::auto_loop_changed (Location* location)
1072 replace_event (Event::AutoLoop, location->end(), location->start());
1074 if (transport_rolling() && play_loop) {
1076 //if (_transport_frame < location->start() || _transport_frame > location->end()) {
1078 if (_transport_frame > location->end()) {
1079 // relocate to beginning of loop
1080 clear_events (Event::LocateRoll);
1082 request_locate (location->start(), true);
1085 else if (Config->get_seamless_loop() && !loop_changing) {
1087 // schedule a locate-roll to refill the diskstreams at the
1088 // previous loop end
1089 loop_changing = true;
1091 if (location->end() > last_loopend) {
1092 clear_events (Event::LocateRoll);
1093 Event *ev = new Event (Event::LocateRoll, Event::Add, last_loopend, last_loopend, 0, true);
1100 last_loopend = location->end();
1105 Session::set_auto_punch_location (Location* location)
1109 if ((existing = _locations.auto_punch_location()) != 0 && existing != location) {
1110 auto_punch_start_changed_connection.disconnect();
1111 auto_punch_end_changed_connection.disconnect();
1112 auto_punch_changed_connection.disconnect();
1113 existing->set_auto_punch (false, this);
1114 remove_event (existing->start(), Event::PunchIn);
1115 clear_events (Event::PunchOut);
1116 auto_punch_location_changed (0);
1121 if (location == 0) {
1125 if (location->end() <= location->start()) {
1126 error << _("Session: you can't use that location for auto punch (start <= end)") << endmsg;
1130 auto_punch_start_changed_connection.disconnect();
1131 auto_punch_end_changed_connection.disconnect();
1132 auto_punch_changed_connection.disconnect();
1134 auto_punch_start_changed_connection = location->start_changed.connect (mem_fun (this, &Session::auto_punch_start_changed));
1135 auto_punch_end_changed_connection = location->end_changed.connect (mem_fun (this, &Session::auto_punch_end_changed));
1136 auto_punch_changed_connection = location->changed.connect (mem_fun (this, &Session::auto_punch_changed));
1138 location->set_auto_punch (true, this);
1139 auto_punch_location_changed (location);
1143 Session::set_auto_loop_location (Location* location)
1147 if ((existing = _locations.auto_loop_location()) != 0 && existing != location) {
1148 auto_loop_start_changed_connection.disconnect();
1149 auto_loop_end_changed_connection.disconnect();
1150 auto_loop_changed_connection.disconnect();
1151 existing->set_auto_loop (false, this);
1152 remove_event (existing->end(), Event::AutoLoop);
1153 auto_loop_location_changed (0);
1158 if (location == 0) {
1162 if (location->end() <= location->start()) {
1163 error << _("Session: you can't use a mark for auto loop") << endmsg;
1167 last_loopend = location->end();
1169 auto_loop_start_changed_connection.disconnect();
1170 auto_loop_end_changed_connection.disconnect();
1171 auto_loop_changed_connection.disconnect();
1173 auto_loop_start_changed_connection = location->start_changed.connect (mem_fun (this, &Session::auto_loop_changed));
1174 auto_loop_end_changed_connection = location->end_changed.connect (mem_fun (this, &Session::auto_loop_changed));
1175 auto_loop_changed_connection = location->changed.connect (mem_fun (this, &Session::auto_loop_changed));
1177 location->set_auto_loop (true, this);
1178 auto_loop_location_changed (location);
1182 Session::locations_added (Location* ignored)
1188 Session::locations_changed ()
1190 _locations.apply (*this, &Session::handle_locations_changed);
1194 Session::handle_locations_changed (Locations::LocationList& locations)
1196 Locations::LocationList::iterator i;
1198 bool set_loop = false;
1199 bool set_punch = false;
1201 for (i = locations.begin(); i != locations.end(); ++i) {
1205 if (location->is_auto_punch()) {
1206 set_auto_punch_location (location);
1209 if (location->is_auto_loop()) {
1210 set_auto_loop_location (location);
1217 set_auto_loop_location (0);
1220 set_auto_punch_location (0);
1227 Session::enable_record ()
1229 /* XXX really atomic compare+swap here */
1230 if (g_atomic_int_get (&_record_status) != Recording) {
1231 g_atomic_int_set (&_record_status, Recording);
1232 _last_record_location = _transport_frame;
1233 send_mmc_in_another_thread (MIDI::MachineControl::cmdRecordStrobe);
1235 if (Config->get_monitoring_model() == HardwareMonitoring && Config->get_auto_input()) {
1236 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
1237 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
1238 if ((*i)->record_enabled ()) {
1239 (*i)->monitor_input (true);
1244 RecordStateChanged ();
1249 Session::disable_record (bool rt_context, bool force)
1253 if ((rs = (RecordState) g_atomic_int_get (&_record_status)) != Disabled) {
1255 if (!Config->get_latched_record_enable () || force) {
1256 g_atomic_int_set (&_record_status, Disabled);
1258 if (rs == Recording) {
1259 g_atomic_int_set (&_record_status, Enabled);
1263 send_mmc_in_another_thread (MIDI::MachineControl::cmdRecordExit);
1265 if (Config->get_monitoring_model() == HardwareMonitoring && Config->get_auto_input()) {
1266 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
1268 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
1269 if ((*i)->record_enabled ()) {
1270 (*i)->monitor_input (false);
1275 RecordStateChanged (); /* emit signal */
1278 remove_pending_capture_state ();
1284 Session::step_back_from_record ()
1286 g_atomic_int_set (&_record_status, Enabled);
1288 if (Config->get_monitoring_model() == HardwareMonitoring) {
1289 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
1291 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
1292 if (Config->get_auto_input() && (*i)->record_enabled ()) {
1293 //cerr << "switching from input" << __FILE__ << __LINE__ << endl << endl;
1294 (*i)->monitor_input (false);
1301 Session::maybe_enable_record ()
1303 g_atomic_int_set (&_record_status, Enabled);
1305 /* this function is currently called from somewhere other than an RT thread.
1306 this save_state() call therefore doesn't impact anything.
1309 save_state ("", true);
1311 if (_transport_speed) {
1312 if (!Config->get_punch_in()) {
1316 send_mmc_in_another_thread (MIDI::MachineControl::cmdRecordPause);
1317 RecordStateChanged (); /* EMIT SIGNAL */
1324 Session::audible_frame () const
1330 /* the first of these two possible settings for "offset"
1331 mean that the audible frame is stationary until
1332 audio emerges from the latency compensation
1335 the second means that the audible frame is stationary
1336 until audio would emerge from a physical port
1337 in the absence of any plugin latency compensation
1340 offset = _worst_output_latency;
1342 if (offset > current_block_size) {
1343 offset -= current_block_size;
1345 /* XXX is this correct? if we have no external
1346 physical connections and everything is internal
1347 then surely this is zero? still, how
1348 likely is that anyway?
1350 offset = current_block_size;
1353 if (synced_to_jack()) {
1354 tf = _engine.transport_frame();
1356 tf = _transport_frame;
1359 if (_transport_speed == 0) {
1369 if (!non_realtime_work_pending()) {
1373 /* take latency into account */
1382 Session::set_frame_rate (nframes_t frames_per_second)
1384 /** \fn void Session::set_frame_size(nframes_t)
1385 the AudioEngine object that calls this guarantees
1386 that it will not be called while we are also in
1387 ::process(). Its fine to do things that block
1391 _base_frame_rate = frames_per_second;
1395 Route::set_automation_interval ((jack_nframes_t) ceil ((double) frames_per_second * 0.25));
1397 // XXX we need some equivalent to this, somehow
1398 // SndFileSource::setup_standard_crossfades (frames_per_second);
1402 /* XXX need to reset/reinstantiate all LADSPA plugins */
1406 Session::set_block_size (nframes_t nframes)
1408 /* the AudioEngine guarantees
1409 that it will not be called while we are also in
1410 ::process(). It is therefore fine to do things that block
1415 vector<Sample*>::iterator i;
1418 current_block_size = nframes;
1420 for (np = 0, i = _passthru_buffers.begin(); i != _passthru_buffers.end(); ++i, ++np) {
1424 for (vector<Sample*>::iterator i = _silent_buffers.begin(); i != _silent_buffers.end(); ++i) {
1428 _passthru_buffers.clear ();
1429 _silent_buffers.clear ();
1431 ensure_passthru_buffers (np);
1433 for (vector<Sample*>::iterator i = _send_buffers.begin(); i != _send_buffers.end(); ++i) {
1437 #ifdef NO_POSIX_MEMALIGN
1438 buf = (Sample *) malloc(current_block_size * sizeof(Sample));
1440 posix_memalign((void **)&buf,CPU_CACHE_ALIGN,current_block_size * sizeof(Sample));
1444 memset (*i, 0, sizeof (Sample) * current_block_size);
1448 if (_gain_automation_buffer) {
1449 delete [] _gain_automation_buffer;
1451 _gain_automation_buffer = new gain_t[nframes];
1453 allocate_pan_automation_buffers (nframes, _npan_buffers, true);
1455 boost::shared_ptr<RouteList> r = routes.reader ();
1457 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1458 (*i)->set_block_size (nframes);
1461 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
1462 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
1463 (*i)->set_block_size (nframes);
1466 set_worst_io_latencies ();
1471 Session::set_default_fade (float steepness, float fade_msecs)
1474 nframes_t fade_frames;
1476 /* Don't allow fade of less 1 frame */
1478 if (fade_msecs < (1000.0 * (1.0/_current_frame_rate))) {
1485 fade_frames = (nframes_t) floor (fade_msecs * _current_frame_rate * 0.001);
1489 default_fade_msecs = fade_msecs;
1490 default_fade_steepness = steepness;
1493 // jlc, WTF is this!
1494 Glib::RWLock::ReaderLock lm (route_lock);
1495 AudioRegion::set_default_fade (steepness, fade_frames);
1500 /* XXX have to do this at some point */
1501 /* foreach region using default fade, reset, then
1502 refill_all_diskstream_buffers ();
1507 struct RouteSorter {
1508 bool operator() (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> r2) {
1509 if (r1->fed_by.find (r2) != r1->fed_by.end()) {
1511 } else if (r2->fed_by.find (r1) != r2->fed_by.end()) {
1514 if (r1->fed_by.empty()) {
1515 if (r2->fed_by.empty()) {
1516 /* no ardour-based connections inbound to either route. just use signal order */
1517 return r1->order_key(N_("signal")) < r2->order_key(N_("signal"));
1519 /* r2 has connections, r1 does not; run r1 early */
1523 return r1->order_key(N_("signal")) < r2->order_key(N_("signal"));
1530 trace_terminal (shared_ptr<Route> r1, shared_ptr<Route> rbase)
1532 shared_ptr<Route> r2;
1534 if ((r1->fed_by.find (rbase) != r1->fed_by.end()) && (rbase->fed_by.find (r1) != rbase->fed_by.end())) {
1535 info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
1539 /* make a copy of the existing list of routes that feed r1 */
1541 set<shared_ptr<Route> > existing = r1->fed_by;
1543 /* for each route that feeds r1, recurse, marking it as feeding
1547 for (set<shared_ptr<Route> >::iterator i = existing.begin(); i != existing.end(); ++i) {
1550 /* r2 is a route that feeds r1 which somehow feeds base. mark
1551 base as being fed by r2
1554 rbase->fed_by.insert (r2);
1558 /* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
1562 if ((r1->fed_by.find (r2) != r1->fed_by.end()) && (r2->fed_by.find (r1) != r2->fed_by.end())) {
1566 /* now recurse, so that we can mark base as being fed by
1567 all routes that feed r2
1570 trace_terminal (r2, rbase);
1577 Session::resort_routes ()
1579 /* don't do anything here with signals emitted
1580 by Routes while we are being destroyed.
1583 if (_state_of_the_state & Deletion) {
1590 RCUWriter<RouteList> writer (routes);
1591 shared_ptr<RouteList> r = writer.get_copy ();
1592 resort_routes_using (r);
1593 /* writer goes out of scope and forces update */
1598 Session::resort_routes_using (shared_ptr<RouteList> r)
1600 RouteList::iterator i, j;
1602 for (i = r->begin(); i != r->end(); ++i) {
1604 (*i)->fed_by.clear ();
1606 for (j = r->begin(); j != r->end(); ++j) {
1608 /* although routes can feed themselves, it will
1609 cause an endless recursive descent if we
1610 detect it. so don't bother checking for
1618 if ((*j)->feeds (*i)) {
1619 (*i)->fed_by.insert (*j);
1624 for (i = r->begin(); i != r->end(); ++i) {
1625 trace_terminal (*i, *i);
1631 /* don't leave dangling references to routes in Route::fed_by */
1633 for (i = r->begin(); i != r->end(); ++i) {
1634 (*i)->fed_by.clear ();
1638 cerr << "finished route resort\n";
1640 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1641 cerr << " " << (*i)->name() << " signal order = " << (*i)->order_key ("signal") << endl;
1648 list<boost::shared_ptr<AudioTrack> >
1649 Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, uint32_t how_many)
1651 char track_name[32];
1652 uint32_t track_id = 0;
1654 uint32_t channels_used = 0;
1656 RouteList new_routes;
1657 list<boost::shared_ptr<AudioTrack> > ret;
1658 uint32_t control_id;
1660 /* count existing audio tracks */
1663 shared_ptr<RouteList> r = routes.reader ();
1665 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1666 if (dynamic_cast<AudioTrack*>((*i).get()) != 0) {
1667 if (!(*i)->hidden()) {
1669 channels_used += (*i)->n_inputs();
1675 vector<string> physinputs;
1676 vector<string> physoutputs;
1677 uint32_t nphysical_in;
1678 uint32_t nphysical_out;
1680 _engine.get_physical_outputs (physoutputs);
1681 _engine.get_physical_inputs (physinputs);
1682 control_id = ntracks() + nbusses() + 1;
1686 /* check for duplicate route names, since we might have pre-existing
1687 routes with this name (e.g. create Audio1, Audio2, delete Audio1,
1688 save, close,restart,add new route - first named route is now
1696 snprintf (track_name, sizeof(track_name), "Audio %" PRIu32, track_id);
1698 if (route_by_name (track_name) == 0) {
1702 } while (track_id < (UINT_MAX-1));
1704 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
1705 nphysical_in = min (n_physical_inputs, (uint32_t) physinputs.size());
1710 if (Config->get_output_auto_connect() & AutoConnectPhysical) {
1711 nphysical_out = min (n_physical_outputs, (uint32_t) physinputs.size());
1716 shared_ptr<AudioTrack> track;
1719 track = boost::shared_ptr<AudioTrack>((new AudioTrack (*this, track_name, Route::Flag (0), mode)));
1721 if (track->ensure_io (input_channels, output_channels, false, this)) {
1722 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
1723 input_channels, output_channels)
1729 for (uint32_t x = 0; x < track->n_inputs() && x < nphysical_in; ++x) {
1733 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
1734 port = physinputs[(channels_used+x)%nphysical_in];
1737 if (port.length() && track->connect_input (track->input (x), port, this)) {
1743 for (uint32_t x = 0; x < track->n_outputs(); ++x) {
1747 if (nphysical_out && (Config->get_output_auto_connect() & AutoConnectPhysical)) {
1748 port = physoutputs[(channels_used+x)%nphysical_out];
1749 } else if (Config->get_output_auto_connect() & AutoConnectMaster) {
1751 port = _master_out->input (x%_master_out->n_inputs())->name();
1755 if (port.length() && track->connect_output (track->output (x), port, this)) {
1760 channels_used += track->n_inputs ();
1762 track->audio_diskstream()->non_realtime_input_change();
1764 track->DiskstreamChanged.connect (mem_fun (this, &Session::resort_routes));
1765 track->set_remote_control_id (control_id);
1768 new_routes.push_back (track);
1769 ret.push_back (track);
1772 catch (failed_constructor &err) {
1773 error << _("Session: could not create new audio track.") << endmsg;
1776 /* we need to get rid of this, since the track failed to be created */
1777 /* XXX arguably, AudioTrack::AudioTrack should not do the Session::add_diskstream() */
1780 RCUWriter<DiskstreamList> writer (diskstreams);
1781 boost::shared_ptr<DiskstreamList> ds = writer.get_copy();
1782 ds->remove (track->audio_diskstream());
1789 catch (AudioEngine::PortRegistrationFailure& pfe) {
1791 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;
1794 /* we need to get rid of this, since the track failed to be created */
1795 /* XXX arguably, AudioTrack::AudioTrack should not do the Session::add_diskstream() */
1798 RCUWriter<DiskstreamList> writer (diskstreams);
1799 boost::shared_ptr<DiskstreamList> ds = writer.get_copy();
1800 ds->remove (track->audio_diskstream());
1811 if (!new_routes.empty()) {
1812 add_routes (new_routes, false);
1813 save_state (_current_snapshot_name);
1820 Session::set_remote_control_ids ()
1822 RemoteModel m = Config->get_remote_model();
1824 shared_ptr<RouteList> r = routes.reader ();
1826 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1827 if ( MixerOrdered == m) {
1828 long order = (*i)->order_key(N_("signal"));
1829 (*i)->set_remote_control_id( order+1 );
1830 } else if ( EditorOrdered == m) {
1831 long order = (*i)->order_key(N_("editor"));
1832 (*i)->set_remote_control_id( order+1 );
1833 } else if ( UserOrdered == m) {
1834 //do nothing ... only changes to remote id's are initiated by user
1841 Session::new_audio_route (int input_channels, int output_channels, uint32_t how_many)
1844 uint32_t bus_id = 1;
1848 uint32_t control_id;
1850 /* count existing audio busses */
1853 shared_ptr<RouteList> r = routes.reader ();
1855 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1856 if (dynamic_cast<AudioTrack*>((*i).get()) == 0) {
1857 if (!(*i)->hidden() && (*i)->name() != _("master")) {
1864 vector<string> physinputs;
1865 vector<string> physoutputs;
1867 _engine.get_physical_outputs (physoutputs);
1868 _engine.get_physical_inputs (physinputs);
1869 control_id = ntracks() + nbusses() + 1;
1874 snprintf (bus_name, sizeof(bus_name), "Bus %" PRIu32, bus_id);
1878 if (route_by_name (bus_name) == 0) {
1882 } while (bus_id < (UINT_MAX-1));
1885 shared_ptr<Route> bus (new Route (*this, bus_name, -1, -1, -1, -1, Route::Flag(0), DataType::AUDIO));
1887 if (bus->ensure_io (input_channels, output_channels, false, this)) {
1888 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
1889 input_channels, output_channels)
1894 for (uint32_t x = 0; n_physical_inputs && x < bus->n_inputs(); ++x) {
1898 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
1899 port = physinputs[((n+x)%n_physical_inputs)];
1902 if (port.length() && bus->connect_input (bus->input (x), port, this)) {
1907 for (uint32_t x = 0; n_physical_outputs && x < bus->n_outputs(); ++x) {
1911 if (Config->get_output_auto_connect() & AutoConnectPhysical) {
1912 port = physoutputs[((n+x)%n_physical_outputs)];
1913 } else if (Config->get_output_auto_connect() & AutoConnectMaster) {
1915 port = _master_out->input (x%_master_out->n_inputs())->name();
1919 if (port.length() && bus->connect_output (bus->output (x), port, this)) {
1924 bus->set_remote_control_id (control_id);
1927 ret.push_back (bus);
1931 catch (failed_constructor &err) {
1932 error << _("Session: could not create new audio route.") << endmsg;
1936 catch (AudioEngine::PortRegistrationFailure& pfe) {
1937 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;
1947 add_routes (ret, false);
1948 save_state (_current_snapshot_name);
1956 Session::add_routes (RouteList& new_routes, bool save)
1959 RCUWriter<RouteList> writer (routes);
1960 shared_ptr<RouteList> r = writer.get_copy ();
1961 r->insert (r->end(), new_routes.begin(), new_routes.end());
1962 resort_routes_using (r);
1965 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
1967 boost::weak_ptr<Route> wpr (*x);
1969 (*x)->solo_changed.connect (sigc::bind (mem_fun (*this, &Session::route_solo_changed), wpr));
1970 (*x)->mute_changed.connect (mem_fun (*this, &Session::route_mute_changed));
1971 (*x)->output_changed.connect (mem_fun (*this, &Session::set_worst_io_latencies_x));
1972 (*x)->redirects_changed.connect (mem_fun (*this, &Session::update_latency_compensation_proxy));
1974 if ((*x)->master()) {
1978 if ((*x)->control()) {
1979 _control_out = (*x);
1983 if (_control_out && IO::connecting_legal) {
1985 vector<string> cports;
1986 uint32_t ni = _control_out->n_inputs();
1989 for (n = 0; n < ni; ++n) {
1990 cports.push_back (_control_out->input(n)->name());
1993 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
1994 (*x)->set_control_outs (cports);
2001 save_state (_current_snapshot_name);
2004 RouteAdded (new_routes); /* EMIT SIGNAL */
2008 Session::add_diskstream (boost::shared_ptr<Diskstream> dstream)
2010 /* need to do this in case we're rolling at the time, to prevent false underruns */
2011 dstream->do_refill_with_alloc ();
2013 dstream->set_block_size (current_block_size);
2016 RCUWriter<DiskstreamList> writer (diskstreams);
2017 boost::shared_ptr<DiskstreamList> ds = writer.get_copy();
2018 ds->push_back (dstream);
2019 /* writer goes out of scope, copies ds back to main */
2022 dstream->PlaylistChanged.connect (sigc::bind (mem_fun (*this, &Session::diskstream_playlist_changed), dstream));
2023 /* this will connect to future changes, and check the current length */
2024 diskstream_playlist_changed (dstream);
2026 dstream->prepare ();
2031 Session::remove_route (shared_ptr<Route> route)
2034 RCUWriter<RouteList> writer (routes);
2035 shared_ptr<RouteList> rs = writer.get_copy ();
2039 /* deleting the master out seems like a dumb
2040 idea, but its more of a UI policy issue
2044 if (route == _master_out) {
2045 _master_out = shared_ptr<Route> ();
2048 if (route == _control_out) {
2049 _control_out = shared_ptr<Route> ();
2051 /* cancel control outs for all routes */
2053 vector<string> empty;
2055 for (RouteList::iterator r = rs->begin(); r != rs->end(); ++r) {
2056 (*r)->set_control_outs (empty);
2060 update_route_solo_state ();
2062 /* writer goes out of scope, forces route list update */
2065 // FIXME: audio specific
2067 boost::shared_ptr<AudioDiskstream> ds;
2069 if ((at = dynamic_cast<AudioTrack*>(route.get())) != 0) {
2070 ds = at->audio_diskstream();
2076 RCUWriter<DiskstreamList> dsl (diskstreams);
2077 boost::shared_ptr<DiskstreamList> d = dsl.get_copy();
2082 find_current_end ();
2084 update_latency_compensation (false, false);
2087 // We need to disconnect the routes inputs and outputs
2088 route->disconnect_inputs(NULL);
2089 route->disconnect_outputs(NULL);
2091 /* get rid of it from the dead wood collection in the route list manager */
2093 /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
2097 /* try to cause everyone to drop their references */
2099 route->drop_references ();
2101 /* save the new state of the world */
2103 if (save_state (_current_snapshot_name)) {
2104 save_history (_current_snapshot_name);
2109 Session::route_mute_changed (void* src)
2115 Session::route_solo_changed (void* src, boost::weak_ptr<Route> wpr)
2117 if (solo_update_disabled) {
2123 boost::shared_ptr<Route> route = wpr.lock ();
2126 /* should not happen */
2127 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2131 is_track = (boost::dynamic_pointer_cast<AudioTrack>(route) != 0);
2133 shared_ptr<RouteList> r = routes.reader ();
2135 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2137 /* soloing a track mutes all other tracks, soloing a bus mutes all other busses */
2141 /* don't mess with busses */
2143 if (dynamic_cast<AudioTrack*>((*i).get()) == 0) {
2149 /* don't mess with tracks */
2151 if (dynamic_cast<AudioTrack*>((*i).get()) != 0) {
2156 if ((*i) != route &&
2157 ((*i)->mix_group () == 0 ||
2158 (*i)->mix_group () != route->mix_group () ||
2159 !route->mix_group ()->is_active())) {
2161 if ((*i)->soloed()) {
2163 /* if its already soloed, and solo latching is enabled,
2164 then leave it as it is.
2167 if (Config->get_solo_latched()) {
2174 solo_update_disabled = true;
2175 (*i)->set_solo (false, src);
2176 solo_update_disabled = false;
2180 bool something_soloed = false;
2181 bool same_thing_soloed = false;
2182 bool signal = false;
2184 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2185 if ((*i)->soloed()) {
2186 something_soloed = true;
2187 if (dynamic_cast<AudioTrack*>((*i).get())) {
2189 same_thing_soloed = true;
2194 same_thing_soloed = true;
2202 if (something_soloed != currently_soloing) {
2204 currently_soloing = something_soloed;
2207 modify_solo_mute (is_track, same_thing_soloed);
2210 SoloActive (currently_soloing); /* EMIT SIGNAL */
2213 SoloChanged (); /* EMIT SIGNAL */
2219 Session::update_route_solo_state ()
2222 bool is_track = false;
2223 bool signal = false;
2225 /* caller must hold RouteLock */
2227 /* this is where we actually implement solo by changing
2228 the solo mute setting of each track.
2231 shared_ptr<RouteList> r = routes.reader ();
2233 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2234 if ((*i)->soloed()) {
2236 if (dynamic_cast<AudioTrack*>((*i).get())) {
2243 if (mute != currently_soloing) {
2245 currently_soloing = mute;
2248 if (!is_track && !mute) {
2250 /* nothing is soloed */
2252 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2253 (*i)->set_solo_mute (false);
2263 modify_solo_mute (is_track, mute);
2266 SoloActive (currently_soloing);
2271 Session::modify_solo_mute (bool is_track, bool mute)
2273 shared_ptr<RouteList> r = routes.reader ();
2275 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2279 /* only alter track solo mute */
2281 if (dynamic_cast<AudioTrack*>((*i).get())) {
2282 if ((*i)->soloed()) {
2283 (*i)->set_solo_mute (!mute);
2285 (*i)->set_solo_mute (mute);
2291 /* only alter bus solo mute */
2293 if (!dynamic_cast<AudioTrack*>((*i).get())) {
2295 if ((*i)->soloed()) {
2297 (*i)->set_solo_mute (false);
2301 /* don't mute master or control outs
2302 in response to another bus solo
2305 if ((*i) != _master_out &&
2306 (*i) != _control_out) {
2307 (*i)->set_solo_mute (mute);
2318 Session::catch_up_on_solo ()
2320 /* this is called after set_state() to catch the full solo
2321 state, which can't be correctly determined on a per-route
2322 basis, but needs the global overview that only the session
2325 update_route_solo_state();
2329 Session::route_by_name (string name)
2331 shared_ptr<RouteList> r = routes.reader ();
2333 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2334 if ((*i)->name() == name) {
2339 return shared_ptr<Route> ((Route*) 0);
2343 Session::route_by_id (PBD::ID id)
2345 shared_ptr<RouteList> r = routes.reader ();
2347 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2348 if ((*i)->id() == id) {
2353 return shared_ptr<Route> ((Route*) 0);
2357 Session::route_by_remote_id (uint32_t id)
2359 shared_ptr<RouteList> r = routes.reader ();
2361 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2362 if ((*i)->remote_control_id() == id) {
2367 return shared_ptr<Route> ((Route*) 0);
2371 Session::find_current_end ()
2373 if (_state_of_the_state & Loading) {
2377 nframes_t max = get_maximum_extent ();
2379 if (max > end_location->end()) {
2380 end_location->set_end (max);
2382 DurationChanged(); /* EMIT SIGNAL */
2387 Session::get_maximum_extent () const
2392 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
2394 for (DiskstreamList::const_iterator i = dsl->begin(); i != dsl->end(); ++i) {
2395 boost::shared_ptr<Playlist> pl = (*i)->playlist();
2396 if ((me = pl->get_maximum_extent()) > max) {
2404 boost::shared_ptr<Diskstream>
2405 Session::diskstream_by_name (string name)
2407 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
2409 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
2410 if ((*i)->name() == name) {
2415 return boost::shared_ptr<Diskstream>((Diskstream*) 0);
2418 boost::shared_ptr<Diskstream>
2419 Session::diskstream_by_id (const PBD::ID& id)
2421 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
2423 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
2424 if ((*i)->id() == id) {
2429 return boost::shared_ptr<Diskstream>((Diskstream*) 0);
2432 /* AudioRegion management */
2435 Session::new_region_name (string old)
2437 string::size_type last_period;
2439 string::size_type len = old.length() + 64;
2442 if ((last_period = old.find_last_of ('.')) == string::npos) {
2444 /* no period present - add one explicitly */
2447 last_period = old.length() - 1;
2452 number = atoi (old.substr (last_period+1).c_str());
2456 while (number < (UINT_MAX-1)) {
2458 AudioRegionList::const_iterator i;
2463 snprintf (buf, len, "%s%" PRIu32, old.substr (0, last_period + 1).c_str(), number);
2466 for (i = audio_regions.begin(); i != audio_regions.end(); ++i) {
2467 if (i->second->name() == sbuf) {
2472 if (i == audio_regions.end()) {
2477 if (number != (UINT_MAX-1)) {
2481 error << string_compose (_("cannot create new name for region \"%1\""), old) << endmsg;
2486 Session::region_name (string& result, string base, bool newlevel) const
2493 Glib::Mutex::Lock lm (region_lock);
2495 snprintf (buf, sizeof (buf), "%d", (int)audio_regions.size() + 1);
2503 /* XXX this is going to be slow. optimize me later */
2508 string::size_type pos;
2510 pos = base.find_last_of ('.');
2512 /* pos may be npos, but then we just use entire base */
2514 subbase = base.substr (0, pos);
2518 bool name_taken = true;
2521 Glib::Mutex::Lock lm (region_lock);
2523 for (int n = 1; n < 5000; ++n) {
2526 snprintf (buf, sizeof (buf), ".%d", n);
2531 for (AudioRegionList::const_iterator i = audio_regions.begin(); i != audio_regions.end(); ++i) {
2532 if (i->second->name() == result) {
2545 fatal << string_compose(_("too many regions with names like %1"), base) << endmsg;
2553 Session::add_region (boost::shared_ptr<Region> region)
2555 boost::shared_ptr<AudioRegion> ar;
2556 boost::shared_ptr<AudioRegion> oar;
2560 Glib::Mutex::Lock lm (region_lock);
2562 if ((ar = boost::dynamic_pointer_cast<AudioRegion> (region)) != 0) {
2564 AudioRegionList::iterator x;
2566 for (x = audio_regions.begin(); x != audio_regions.end(); ++x) {
2568 oar = boost::dynamic_pointer_cast<AudioRegion> (x->second);
2570 if (ar->region_list_equivalent (oar)) {
2575 if (x == audio_regions.end()) {
2577 pair<AudioRegionList::key_type,AudioRegionList::mapped_type> entry;
2579 entry.first = region->id();
2582 pair<AudioRegionList::iterator,bool> x = audio_regions.insert (entry);
2594 fatal << _("programming error: ")
2595 << X_("unknown region type passed to Session::add_region()")
2602 /* mark dirty because something has changed even if we didn't
2603 add the region to the region list.
2609 region->GoingAway.connect (sigc::bind (mem_fun (*this, &Session::remove_region), boost::weak_ptr<Region>(region)));
2610 region->StateChanged.connect (sigc::bind (mem_fun (*this, &Session::region_changed), boost::weak_ptr<Region>(region)));
2611 AudioRegionAdded (ar); /* EMIT SIGNAL */
2616 Session::region_changed (Change what_changed, boost::weak_ptr<Region> weak_region)
2618 boost::shared_ptr<Region> region (weak_region.lock ());
2624 if (what_changed & Region::HiddenChanged) {
2625 /* relay hidden changes */
2626 RegionHiddenChange (region);
2631 Session::remove_region (boost::weak_ptr<Region> weak_region)
2633 AudioRegionList::iterator i;
2634 boost::shared_ptr<Region> region (weak_region.lock ());
2640 boost::shared_ptr<AudioRegion> ar;
2641 bool removed = false;
2644 Glib::Mutex::Lock lm (region_lock);
2646 if ((ar = boost::dynamic_pointer_cast<AudioRegion> (region)) != 0) {
2647 if ((i = audio_regions.find (region->id())) != audio_regions.end()) {
2648 audio_regions.erase (i);
2654 fatal << _("programming error: ")
2655 << X_("unknown region type passed to Session::remove_region()")
2661 /* mark dirty because something has changed even if we didn't
2662 remove the region from the region list.
2668 AudioRegionRemoved (ar); /* EMIT SIGNAL */
2672 boost::shared_ptr<AudioRegion>
2673 Session::find_whole_file_parent (boost::shared_ptr<AudioRegion const> child)
2675 AudioRegionList::iterator i;
2676 boost::shared_ptr<AudioRegion> region;
2677 Glib::Mutex::Lock lm (region_lock);
2679 for (i = audio_regions.begin(); i != audio_regions.end(); ++i) {
2683 if (region->whole_file()) {
2685 if (child->source_equivalent (region)) {
2691 return boost::shared_ptr<AudioRegion> ();
2695 Session::find_equivalent_playlist_regions (boost::shared_ptr<Region> region, vector<boost::shared_ptr<Region> >& result)
2697 for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i)
2698 (*i)->get_region_list_equivalent_regions (region, result);
2702 Session::destroy_region (boost::shared_ptr<Region> region)
2704 vector<boost::shared_ptr<Source> > srcs;
2707 boost::shared_ptr<AudioRegion> aregion;
2709 if ((aregion = boost::dynamic_pointer_cast<AudioRegion> (region)) == 0) {
2713 if (aregion->playlist()) {
2714 aregion->playlist()->destroy_region (region);
2717 for (uint32_t n = 0; n < aregion->n_channels(); ++n) {
2718 srcs.push_back (aregion->source (n));
2722 region->drop_references ();
2724 for (vector<boost::shared_ptr<Source> >::iterator i = srcs.begin(); i != srcs.end(); ++i) {
2726 if (!(*i)->used()) {
2727 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*i);
2730 (afs)->mark_for_remove ();
2733 (*i)->drop_references ();
2735 cerr << "source was not used by any playlist\n";
2743 Session::destroy_regions (list<boost::shared_ptr<Region> > regions)
2745 for (list<boost::shared_ptr<Region> >::iterator i = regions.begin(); i != regions.end(); ++i) {
2746 destroy_region (*i);
2752 Session::remove_last_capture ()
2754 list<boost::shared_ptr<Region> > r;
2756 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
2758 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
2759 list<boost::shared_ptr<Region> >& l = (*i)->last_capture_regions();
2762 r.insert (r.end(), l.begin(), l.end());
2767 destroy_regions (r);
2769 save_state (_current_snapshot_name);
2775 Session::remove_region_from_region_list (boost::shared_ptr<Region> r)
2781 /* Source Management */
2784 Session::add_source (boost::shared_ptr<Source> source)
2786 boost::shared_ptr<AudioFileSource> afs;
2788 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
2790 pair<AudioSourceList::key_type, AudioSourceList::mapped_type> entry;
2791 pair<AudioSourceList::iterator,bool> result;
2793 entry.first = source->id();
2797 Glib::Mutex::Lock lm (audio_source_lock);
2798 result = audio_sources.insert (entry);
2801 if (result.second) {
2802 source->GoingAway.connect (sigc::bind (mem_fun (this, &Session::remove_source), boost::weak_ptr<Source> (source)));
2810 Session::remove_source (boost::weak_ptr<Source> src)
2812 AudioSourceList::iterator i;
2813 boost::shared_ptr<Source> source = src.lock();
2820 Glib::Mutex::Lock lm (audio_source_lock);
2822 if ((i = audio_sources.find (source->id())) != audio_sources.end()) {
2823 audio_sources.erase (i);
2827 if (!_state_of_the_state & InCleanup) {
2829 /* save state so we don't end up with a session file
2830 referring to non-existent sources.
2833 save_state (_current_snapshot_name);
2837 boost::shared_ptr<Source>
2838 Session::source_by_id (const PBD::ID& id)
2840 Glib::Mutex::Lock lm (audio_source_lock);
2841 AudioSourceList::iterator i;
2842 boost::shared_ptr<Source> source;
2844 if ((i = audio_sources.find (id)) != audio_sources.end()) {
2848 /* XXX search MIDI or other searches here */
2854 boost::shared_ptr<Source>
2855 Session::source_by_path_and_channel (const Glib::ustring& path, uint16_t chn)
2857 Glib::Mutex::Lock lm (audio_source_lock);
2859 for (AudioSourceList::iterator i = audio_sources.begin(); i != audio_sources.end(); ++i) {
2860 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
2862 if (afs && afs->path() == path && chn == afs->channel()) {
2867 return boost::shared_ptr<Source>();
2871 Session::peak_path_from_audio_path (string audio_path) const
2876 res += PBD::basename_nosuffix (audio_path);
2883 Session::change_audio_path_by_name (string path, string oldname, string newname, bool destructive)
2886 string old_basename = PBD::basename_nosuffix (oldname);
2887 string new_legalized = legalize_for_path (newname);
2889 /* note: we know (or assume) the old path is already valid */
2893 /* destructive file sources have a name of the form:
2895 /path/to/Tnnnn-NAME(%[LR])?.wav
2897 the task here is to replace NAME with the new name.
2900 /* find last slash */
2904 string::size_type slash;
2905 string::size_type dash;
2907 if ((slash = path.find_last_of ('/')) == string::npos) {
2911 dir = path.substr (0, slash+1);
2913 /* '-' is not a legal character for the NAME part of the path */
2915 if ((dash = path.find_last_of ('-')) == string::npos) {
2919 prefix = path.substr (slash+1, dash-(slash+1));
2924 path += new_legalized;
2925 path += ".wav"; /* XXX gag me with a spoon */
2929 /* non-destructive file sources have a name of the form:
2931 /path/to/NAME-nnnnn(%[LR])?.wav
2933 the task here is to replace NAME with the new name.
2938 string::size_type slash;
2939 string::size_type dash;
2940 string::size_type postfix;
2942 /* find last slash */
2944 if ((slash = path.find_last_of ('/')) == string::npos) {
2948 dir = path.substr (0, slash+1);
2950 /* '-' is not a legal character for the NAME part of the path */
2952 if ((dash = path.find_last_of ('-')) == string::npos) {
2956 suffix = path.substr (dash+1);
2958 // Suffix is now everything after the dash. Now we need to eliminate
2959 // the nnnnn part, which is done by either finding a '%' or a '.'
2961 postfix = suffix.find_last_of ("%");
2962 if (postfix == string::npos) {
2963 postfix = suffix.find_last_of ('.');
2966 if (postfix != string::npos) {
2967 suffix = suffix.substr (postfix);
2969 error << "Logic error in Session::change_audio_path_by_name(), please report to the developers" << endl;
2973 const uint32_t limit = 10000;
2974 char buf[PATH_MAX+1];
2976 for (uint32_t cnt = 1; cnt <= limit; ++cnt) {
2978 snprintf (buf, sizeof(buf), "%s%s-%u%s", dir.c_str(), newname.c_str(), cnt, suffix.c_str());
2980 if (access (buf, F_OK) != 0) {
2988 error << "FATAL ERROR! Could not find a " << endl;
2997 Session::audio_path_from_name (string name, uint32_t nchan, uint32_t chan, bool destructive)
3001 char buf[PATH_MAX+1];
3002 const uint32_t limit = 10000;
3006 legalized = legalize_for_path (name);
3008 /* find a "version" of the file name that doesn't exist in
3009 any of the possible directories.
3012 for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
3014 vector<space_and_path>::iterator i;
3015 uint32_t existing = 0;
3017 for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
3021 spath += sound_dir (false);
3025 snprintf (buf, sizeof(buf), "%s/T%04d-%s.wav", spath.c_str(), cnt, legalized.c_str());
3026 } else if (nchan == 2) {
3028 snprintf (buf, sizeof(buf), "%s/T%04d-%s%%L.wav", spath.c_str(), cnt, legalized.c_str());
3030 snprintf (buf, sizeof(buf), "%s/T%04d-%s%%R.wav", spath.c_str(), cnt, legalized.c_str());
3032 } else if (nchan < 26) {
3033 snprintf (buf, sizeof(buf), "%s/T%04d-%s%%%c.wav", spath.c_str(), cnt, legalized.c_str(), 'a' + chan);
3035 snprintf (buf, sizeof(buf), "%s/T%04d-%s.wav", spath.c_str(), cnt, legalized.c_str());
3044 snprintf (buf, sizeof(buf), "%s-%u.wav", spath.c_str(), cnt);
3045 } else if (nchan == 2) {
3047 snprintf (buf, sizeof(buf), "%s-%u%%L.wav", spath.c_str(), cnt);
3049 snprintf (buf, sizeof(buf), "%s-%u%%R.wav", spath.c_str(), cnt);
3051 } else if (nchan < 26) {
3052 snprintf (buf, sizeof(buf), "%s-%u%%%c.wav", spath.c_str(), cnt, 'a' + chan);
3054 snprintf (buf, sizeof(buf), "%s-%u.wav", spath.c_str(), cnt);
3058 if (g_file_test (buf, G_FILE_TEST_EXISTS)) {
3064 if (existing == 0) {
3069 error << string_compose(_("There are already %1 recordings for %2, which I consider too many."), limit, name) << endmsg;
3071 throw failed_constructor();
3075 /* we now have a unique name for the file, but figure out where to
3081 spath = discover_best_sound_dir ();
3084 string::size_type pos = foo.find_last_of ('/');
3086 if (pos == string::npos) {
3089 spath += foo.substr (pos + 1);
3095 boost::shared_ptr<AudioFileSource>
3096 Session::create_audio_source_for_session (AudioDiskstream& ds, uint32_t chan, bool destructive)
3098 string spath = audio_path_from_name (ds.name(), ds.n_channels(), chan, destructive);
3099 return boost::dynamic_pointer_cast<AudioFileSource> (SourceFactory::createWritable (*this, spath, destructive, frame_rate()));
3102 /* Playlist management */
3104 boost::shared_ptr<Playlist>
3105 Session::playlist_by_name (string name)
3107 Glib::Mutex::Lock lm (playlist_lock);
3108 for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i) {
3109 if ((*i)->name() == name) {
3113 for (PlaylistList::iterator i = unused_playlists.begin(); i != unused_playlists.end(); ++i) {
3114 if ((*i)->name() == name) {
3119 return boost::shared_ptr<Playlist>();
3123 Session::add_playlist (boost::shared_ptr<Playlist> playlist)
3125 if (playlist->hidden()) {
3130 Glib::Mutex::Lock lm (playlist_lock);
3131 if (find (playlists.begin(), playlists.end(), playlist) == playlists.end()) {
3132 playlists.insert (playlists.begin(), playlist);
3133 playlist->InUse.connect (sigc::bind (mem_fun (*this, &Session::track_playlist), boost::weak_ptr<Playlist>(playlist)));
3134 playlist->GoingAway.connect (sigc::bind (mem_fun (*this, &Session::remove_playlist), boost::weak_ptr<Playlist>(playlist)));
3140 PlaylistAdded (playlist); /* EMIT SIGNAL */
3144 Session::get_playlists (vector<boost::shared_ptr<Playlist> >& s)
3147 Glib::Mutex::Lock lm (playlist_lock);
3148 for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i) {
3151 for (PlaylistList::iterator i = unused_playlists.begin(); i != unused_playlists.end(); ++i) {
3158 Session::track_playlist (bool inuse, boost::weak_ptr<Playlist> wpl)
3160 boost::shared_ptr<Playlist> pl(wpl.lock());
3166 PlaylistList::iterator x;
3169 /* its not supposed to be visible */
3174 Glib::Mutex::Lock lm (playlist_lock);
3178 unused_playlists.insert (pl);
3180 if ((x = playlists.find (pl)) != playlists.end()) {
3181 playlists.erase (x);
3187 playlists.insert (pl);
3189 if ((x = unused_playlists.find (pl)) != unused_playlists.end()) {
3190 unused_playlists.erase (x);
3197 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
3199 if (_state_of_the_state & Deletion) {
3203 boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
3210 Glib::Mutex::Lock lm (playlist_lock);
3212 PlaylistList::iterator i;
3214 i = find (playlists.begin(), playlists.end(), playlist);
3215 if (i != playlists.end()) {
3216 playlists.erase (i);
3219 i = find (unused_playlists.begin(), unused_playlists.end(), playlist);
3220 if (i != unused_playlists.end()) {
3221 unused_playlists.erase (i);
3228 PlaylistRemoved (playlist); /* EMIT SIGNAL */
3232 Session::set_audition (boost::shared_ptr<Region> r)
3234 pending_audition_region = r;
3235 post_transport_work = PostTransportWork (post_transport_work | PostTransportAudition);
3236 schedule_butler_transport_work ();
3240 Session::audition_playlist ()
3242 Event* ev = new Event (Event::Audition, Event::Add, Event::Immediate, 0, 0.0);
3243 ev->region.reset ();
3248 Session::non_realtime_set_audition ()
3250 if (!pending_audition_region) {
3251 auditioner->audition_current_playlist ();
3253 auditioner->audition_region (pending_audition_region);
3254 pending_audition_region.reset ();
3256 AuditionActive (true); /* EMIT SIGNAL */
3260 Session::audition_region (boost::shared_ptr<Region> r)
3262 Event* ev = new Event (Event::Audition, Event::Add, Event::Immediate, 0, 0.0);
3268 Session::cancel_audition ()
3270 if (auditioner->active()) {
3271 auditioner->cancel_audition ();
3272 AuditionActive (false); /* EMIT SIGNAL */
3277 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
3279 return a->order_key(N_("signal")) < b->order_key(N_("signal"));
3283 Session::remove_empty_sounds ()
3285 PathScanner scanner;
3287 vector<string *>* possible_audiofiles = scanner (sound_dir(), "\\.(wav|aiff|caf|w64|L|R)$", false, true);
3289 Glib::Mutex::Lock lm (audio_source_lock);
3291 regex_t compiled_tape_track_pattern;
3294 if ((err = regcomp (&compiled_tape_track_pattern, "/T[0-9][0-9][0-9][0-9]-", REG_EXTENDED|REG_NOSUB))) {
3298 regerror (err, &compiled_tape_track_pattern, msg, sizeof (msg));
3300 error << string_compose (_("Cannot compile tape track regexp for use (%1)"), msg) << endmsg;
3304 for (vector<string *>::iterator i = possible_audiofiles->begin(); i != possible_audiofiles->end(); ++i) {
3306 /* never remove files that appear to be a tape track */
3308 if (regexec (&compiled_tape_track_pattern, (*i)->c_str(), 0, 0, 0) == 0) {
3313 if (AudioFileSource::is_empty (*this, *(*i))) {
3315 unlink ((*i)->c_str());
3317 string peak_path = peak_path_from_audio_path (**i);
3318 unlink (peak_path.c_str());
3324 delete possible_audiofiles;
3328 Session::is_auditioning () const
3330 /* can be called before we have an auditioner object */
3332 return auditioner->active();
3339 Session::set_all_solo (bool yn)
3341 shared_ptr<RouteList> r = routes.reader ();
3343 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3344 if (!(*i)->hidden()) {
3345 (*i)->set_solo (yn, this);
3353 Session::set_all_mute (bool yn)
3355 shared_ptr<RouteList> r = routes.reader ();
3357 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3358 if (!(*i)->hidden()) {
3359 (*i)->set_mute (yn, this);
3367 Session::n_diskstreams () const
3371 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
3373 for (DiskstreamList::const_iterator i = dsl->begin(); i != dsl->end(); ++i) {
3374 if (!(*i)->hidden()) {
3382 Session::graph_reordered ()
3384 /* don't do this stuff if we are setting up connections
3385 from a set_state() call or creating new tracks.
3388 if (_state_of_the_state & InitialConnecting) {
3392 /* every track/bus asked for this to be handled but it was deferred because
3393 we were connecting. do it now.
3396 request_input_change_handling ();
3400 /* force all diskstreams to update their capture offset values to
3401 reflect any changes in latencies within the graph.
3404 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
3406 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
3407 (*i)->set_capture_offset ();
3412 Session::record_disenable_all ()
3414 record_enable_change_all (false);
3418 Session::record_enable_all ()
3420 record_enable_change_all (true);
3424 Session::record_enable_change_all (bool yn)
3426 shared_ptr<RouteList> r = routes.reader ();
3428 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3431 if ((at = dynamic_cast<AudioTrack*>((*i).get())) != 0) {
3432 at->set_record_enable (yn, this);
3436 /* since we don't keep rec-enable state, don't mark session dirty */
3440 Session::add_redirect (Redirect* redirect)
3444 PortInsert* port_insert;
3445 PluginInsert* plugin_insert;
3447 if ((insert = dynamic_cast<Insert *> (redirect)) != 0) {
3448 if ((port_insert = dynamic_cast<PortInsert *> (insert)) != 0) {
3449 _port_inserts.insert (_port_inserts.begin(), port_insert);
3450 } else if ((plugin_insert = dynamic_cast<PluginInsert *> (insert)) != 0) {
3451 _plugin_inserts.insert (_plugin_inserts.begin(), plugin_insert);
3453 fatal << _("programming error: unknown type of Insert created!") << endmsg;
3456 } else if ((send = dynamic_cast<Send *> (redirect)) != 0) {
3457 _sends.insert (_sends.begin(), send);
3459 fatal << _("programming error: unknown type of Redirect created!") << endmsg;
3463 redirect->GoingAway.connect (sigc::bind (mem_fun (*this, &Session::remove_redirect), redirect));
3469 Session::remove_redirect (Redirect* redirect)
3473 PortInsert* port_insert;
3474 PluginInsert* plugin_insert;
3476 if ((insert = dynamic_cast<Insert *> (redirect)) != 0) {
3477 if ((port_insert = dynamic_cast<PortInsert *> (insert)) != 0) {
3478 list<PortInsert*>::iterator x = find (_port_inserts.begin(), _port_inserts.end(), port_insert);
3479 if (x != _port_inserts.end()) {
3480 insert_bitset[port_insert->bit_slot()] = false;
3481 _port_inserts.erase (x);
3483 } else if ((plugin_insert = dynamic_cast<PluginInsert *> (insert)) != 0) {
3484 _plugin_inserts.remove (plugin_insert);
3486 fatal << string_compose (_("programming error: %1"),
3487 X_("unknown type of Insert deleted!"))
3491 } else if ((send = dynamic_cast<Send *> (redirect)) != 0) {
3492 list<Send*>::iterator x = find (_sends.begin(), _sends.end(), send);
3493 if (x != _sends.end()) {
3494 send_bitset[send->bit_slot()] = false;
3498 fatal << _("programming error: unknown type of Redirect deleted!") << endmsg;
3506 Session::available_capture_duration ()
3508 float sample_bytes_on_disk = 4.0; // keep gcc happy
3510 switch (Config->get_native_file_data_format()) {
3512 sample_bytes_on_disk = 4.0;
3516 sample_bytes_on_disk = 3.0;
3520 /* impossible, but keep some gcc versions happy */
3521 fatal << string_compose (_("programming error: %1"),
3522 X_("illegal native file data format"))
3527 double scale = 4096.0 / sample_bytes_on_disk;
3529 if (_total_free_4k_blocks * scale > (double) max_frames) {
3533 return (nframes_t) floor (_total_free_4k_blocks * scale);
3537 Session::add_connection (ARDOUR::Connection* connection)
3540 Glib::Mutex::Lock guard (connection_lock);
3541 _connections.push_back (connection);
3544 ConnectionAdded (connection); /* EMIT SIGNAL */
3550 Session::remove_connection (ARDOUR::Connection* connection)
3552 bool removed = false;
3555 Glib::Mutex::Lock guard (connection_lock);
3556 ConnectionList::iterator i = find (_connections.begin(), _connections.end(), connection);
3558 if (i != _connections.end()) {
3559 _connections.erase (i);
3565 ConnectionRemoved (connection); /* EMIT SIGNAL */
3571 ARDOUR::Connection *
3572 Session::connection_by_name (string name) const
3574 Glib::Mutex::Lock lm (connection_lock);
3576 for (ConnectionList::const_iterator i = _connections.begin(); i != _connections.end(); ++i) {
3577 if ((*i)->name() == name) {
3586 Session::tempo_map_changed (Change ignored)
3593 Session::ensure_passthru_buffers (uint32_t howmany)
3595 while (howmany > _passthru_buffers.size()) {
3597 #ifdef NO_POSIX_MEMALIGN
3598 p = (Sample *) malloc(current_block_size * sizeof(Sample));
3600 posix_memalign((void **)&p,CPU_CACHE_ALIGN,current_block_size * sizeof(Sample));
3602 _passthru_buffers.push_back (p);
3606 #ifdef NO_POSIX_MEMALIGN
3607 p = (Sample *) malloc(current_block_size * sizeof(Sample));
3609 posix_memalign((void **)&p,CPU_CACHE_ALIGN,current_block_size * 4);
3611 memset (p, 0, sizeof (Sample) * current_block_size);
3612 _silent_buffers.push_back (p);
3616 #ifdef NO_POSIX_MEMALIGN
3617 p = (Sample *) malloc(current_block_size * sizeof(Sample));
3619 posix_memalign((void **)&p,CPU_CACHE_ALIGN,current_block_size * sizeof(Sample));
3621 memset (p, 0, sizeof (Sample) * current_block_size);
3622 _send_buffers.push_back (p);
3625 allocate_pan_automation_buffers (current_block_size, howmany, false);
3629 Session::next_insert_id ()
3631 /* this doesn't really loop forever. just think about it */
3634 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
3635 if (!insert_bitset[n]) {
3636 insert_bitset[n] = true;
3642 /* none available, so resize and try again */
3644 insert_bitset.resize (insert_bitset.size() + 16, false);
3649 Session::next_send_id ()
3651 /* this doesn't really loop forever. just think about it */
3654 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
3655 if (!send_bitset[n]) {
3656 send_bitset[n] = true;
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;