2 Copyright (C) 1999-2010 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.
27 #include <cstdio> /* sprintf(3) ... grrr */
33 #include <glibmm/threads.h>
34 #include <glibmm/miscutils.h>
35 #include <glibmm/fileutils.h>
37 #include <boost/algorithm/string/erase.hpp>
39 #include "pbd/basename.h"
40 #include "pbd/boost_debug.h"
41 #include "pbd/convert.h"
42 #include "pbd/convert.h"
43 #include "pbd/error.h"
44 #include "pbd/file_utils.h"
46 #include "pbd/search_path.h"
47 #include "pbd/stacktrace.h"
48 #include "pbd/stl_delete.h"
49 #include "pbd/unwind.h"
51 #include "ardour/amp.h"
52 #include "ardour/analyser.h"
53 #include "ardour/async_midi_port.h"
54 #include "ardour/audio_buffer.h"
55 #include "ardour/audio_diskstream.h"
56 #include "ardour/audio_port.h"
57 #include "ardour/audio_track.h"
58 #include "ardour/audioengine.h"
59 #include "ardour/audiofilesource.h"
60 #include "ardour/auditioner.h"
61 #include "ardour/buffer_manager.h"
62 #include "ardour/buffer_set.h"
63 #include "ardour/bundle.h"
64 #include "ardour/butler.h"
65 #include "ardour/click.h"
66 #include "ardour/control_protocol_manager.h"
67 #include "ardour/data_type.h"
68 #include "ardour/debug.h"
69 #include "ardour/directory_names.h"
70 #ifdef USE_TRACKS_CODE_FEATURES
71 #include "ardour/engine_state_controller.h"
73 #include "ardour/filename_extensions.h"
74 #include "ardour/graph.h"
75 #include "ardour/midiport_manager.h"
76 #include "ardour/scene_changer.h"
77 #include "ardour/midi_track.h"
78 #include "ardour/midi_ui.h"
79 #include "ardour/operations.h"
80 #include "ardour/playlist.h"
81 #include "ardour/plugin.h"
82 #include "ardour/plugin_insert.h"
83 #include "ardour/process_thread.h"
84 #include "ardour/profile.h"
85 #include "ardour/rc_configuration.h"
86 #include "ardour/recent_sessions.h"
87 #include "ardour/region.h"
88 #include "ardour/region_factory.h"
89 #include "ardour/route_graph.h"
90 #include "ardour/route_group.h"
91 #include "ardour/route_sorters.h"
92 #include "ardour/send.h"
93 #include "ardour/session.h"
94 #include "ardour/session_directory.h"
95 #include "ardour/session_playlists.h"
96 #include "ardour/smf_source.h"
97 #include "ardour/source_factory.h"
98 #include "ardour/speakers.h"
99 #include "ardour/tempo.h"
100 #include "ardour/track.h"
101 #include "ardour/user_bundle.h"
102 #include "ardour/utils.h"
104 #include "midi++/port.h"
105 #include "midi++/mmc.h"
116 using namespace ARDOUR;
119 bool Session::_disable_all_loaded_plugins = false;
121 PBD::Signal1<int,uint32_t> Session::AudioEngineSetupRequired;
122 PBD::Signal1<void,std::string> Session::Dialog;
123 PBD::Signal0<int> Session::AskAboutPendingState;
124 PBD::Signal2<int, framecnt_t, framecnt_t> Session::AskAboutSampleRateMismatch;
125 PBD::Signal0<void> Session::SendFeedback;
126 PBD::Signal3<int,Session*,std::string,DataType> Session::MissingFile;
128 PBD::Signal1<void, framepos_t> Session::StartTimeChanged;
129 PBD::Signal1<void, framepos_t> Session::EndTimeChanged;
130 PBD::Signal2<void,std::string, std::string> Session::Exported;
131 PBD::Signal1<int,boost::shared_ptr<Playlist> > Session::AskAboutPlaylistDeletion;
132 PBD::Signal0<void> Session::Quit;
133 PBD::Signal0<void> Session::FeedbackDetected;
134 PBD::Signal0<void> Session::SuccessfulGraphSort;
135 PBD::Signal2<void,std::string,std::string> Session::VersionMismatch;
137 const framecnt_t Session::bounce_chunk_size = 65536;
138 static void clean_up_session_event (SessionEvent* ev) { delete ev; }
139 const SessionEvent::RTeventCallback Session::rt_cleanup (clean_up_session_event);
141 /** @param snapshot_name Snapshot name, without .ardour suffix */
142 Session::Session (AudioEngine &eng,
143 const string& fullpath,
144 const string& snapshot_name,
145 BusProfile* bus_profile,
147 : playlists (new SessionPlaylists)
149 , process_function (&Session::process_with_events)
150 , _bounce_processing_active (false)
151 , waiting_for_sync_offset (false)
152 , _base_frame_rate (0)
153 , _current_frame_rate (0)
154 , _nominal_frame_rate (0)
155 , transport_sub_state (0)
156 , _record_status (Disabled)
157 , _transport_frame (0)
158 , _session_range_location (0)
161 , _transport_speed (0)
162 , _default_transport_speed (1.0)
163 , _last_transport_speed (0)
164 , _target_transport_speed (0.0)
165 , auto_play_legal (false)
166 , _last_slave_transport_frame (0)
167 , maximum_output_latency (0)
168 , _requested_return_frame (-1)
169 , current_block_size (0)
170 , _worst_output_latency (0)
171 , _worst_input_latency (0)
172 , _worst_track_latency (0)
173 , _have_captured (false)
174 , _non_soloed_outs_muted (false)
176 , _solo_isolated_cnt (0)
178 , _was_seamless (Config->get_seamless_loop ())
179 , _under_nsm_control (false)
181 , delta_accumulator_cnt (0)
182 , average_slave_delta (1800) // !!! why 1800 ???
184 , have_first_delta_accumulator (false)
185 , _slave_state (Stopped)
186 , post_export_sync (false)
187 , post_export_position (0)
189 , _export_started (false)
190 , _export_rolling (false)
191 , _pre_export_mmc_enabled (false)
192 , _name (snapshot_name)
194 , _send_qf_mtc (false)
195 , _pframes_since_last_mtc (0)
196 , session_midi_feedback (0)
198 , loop_changing (false)
200 , _session_dir (new SessionDirectory (fullpath))
201 , _current_snapshot_name (snapshot_name)
203 , state_was_pending (false)
204 , _state_of_the_state (StateOfTheState(CannotSave|InitialConnecting|Loading))
206 , _save_queued (false)
207 , _last_roll_location (0)
208 , _last_roll_or_reversal_location (0)
209 , _last_record_location (0)
210 , pending_locate_roll (false)
211 , pending_locate_frame (0)
212 , pending_locate_flush (false)
213 , pending_abort (false)
214 , pending_auto_loop (false)
215 , _butler (new Butler (*this))
216 , _post_transport_work (0)
217 , cumulative_rf_motion (0)
219 , _locations (new Locations (*this))
220 , _ignore_skips_updates (false)
221 , _rt_thread_active (false)
222 , _rt_emit_pending (false)
224 , outbound_mtc_timecode_frame (0)
225 , next_quarter_frame_to_send (-1)
226 , _frames_per_timecode_frame (0)
227 , _frames_per_hour (0)
228 , _timecode_frames_per_hour (0)
229 , last_timecode_valid (false)
230 , last_timecode_when (0)
231 , _send_timecode_update (false)
243 , ltc_timecode_offset (0)
244 , ltc_timecode_negative_offset (false)
245 , midi_control_ui (0)
247 , _all_route_group (new RouteGroup (*this, "all"))
248 , routes (new RouteList)
249 , _adding_routes_in_progress (false)
250 , _reconnecting_routes_in_progress (false)
251 , _route_deletion_in_progress (false)
252 , destructive_index (0)
253 , _track_number_decimals(1)
254 , solo_update_disabled (false)
255 , default_fade_steepness (0)
256 , default_fade_msecs (0)
257 , _total_free_4k_blocks (0)
258 , _total_free_4k_blocks_uncertain (false)
259 , no_questions_about_missing_files (false)
262 , _bundles (new BundleList)
263 , _bundle_xml_node (0)
267 , click_emphasis_data (0)
269 , click_emphasis_length (0)
270 , _clicks_cleared (0)
271 , _play_range (false)
273 , first_file_data_format_reset (true)
274 , first_file_header_format_reset (true)
275 , have_looped (false)
276 , _have_rec_enabled_track (false)
277 , _have_rec_disabled_track (true)
279 , _suspend_timecode_transmission (0)
280 , _speakers (new Speakers)
282 , ignore_route_processor_changes (false)
289 pthread_mutex_init (&_rt_emit_mutex, 0);
290 pthread_cond_init (&_rt_emit_cond, 0);
292 pre_engine_init (fullpath);
295 if (ensure_engine (sr)) {
297 throw failed_constructor ();
300 if (create (mix_template, bus_profile)) {
302 throw failed_constructor ();
305 /* if a mix template was provided, then ::create() will
306 * have copied it into the session and we need to load it
307 * so that we have the state ready for ::set_state()
308 * after the engine is started.
310 * Note that we do NOT try to get the sample rate from
311 * the template at this time, though doing so would
312 * be easy if we decided this was an appropriate part
316 if (!mix_template.empty()) {
317 if (load_state (_current_snapshot_name)) {
318 throw failed_constructor ();
320 store_recent_templates (mix_template);
323 /* load default session properties - if any */
328 if (load_state (_current_snapshot_name)) {
329 throw failed_constructor ();
332 /* try to get sample rate from XML state so that we
333 * can influence the SR if we set up the audio
338 const XMLProperty* prop;
339 if ((prop = state_tree->root()->property (X_("sample-rate"))) != 0) {
340 sr = atoi (prop->value());
344 if (ensure_engine (sr)) {
346 throw failed_constructor ();
350 if (post_engine_init ()) {
352 throw failed_constructor ();
355 store_recent_sessions (_name, _path);
357 bool was_dirty = dirty();
359 _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
361 Config->ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, false));
362 config.ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, true));
365 DirtyChanged (); /* EMIT SIGNAL */
368 StartTimeChanged.connect_same_thread (*this, boost::bind (&Session::start_time_changed, this, _1));
369 EndTimeChanged.connect_same_thread (*this, boost::bind (&Session::end_time_changed, this, _1));
373 emit_thread_start ();
375 /* hook us up to the engine since we are now completely constructed */
377 BootMessage (_("Connect to engine"));
379 _engine.set_session (this);
380 _engine.reset_timebase ();
382 #ifdef USE_TRACKS_CODE_FEATURES
384 EngineStateController::instance()->set_session(this);
387 if ( ARDOUR::Profile->get_trx () ) {
389 /* Waves Tracks: fill session with tracks basing on the amount of inputs.
390 * each available input must have corresponding track when session starts.
393 uint32_t how_many (0);
395 std::vector<std::string> inputs;
396 EngineStateController::instance()->get_physical_audio_inputs(inputs);
398 how_many = inputs.size();
400 list<boost::shared_ptr<AudioTrack> > tracks;
402 // Track names after driver
403 if (Config->get_tracks_auto_naming() == NameAfterDriver) {
404 string track_name = "";
405 for (std::vector<string>::size_type i = 0; i < inputs.size(); ++i) {
407 remove_pattern_from_string(inputs[i], "system:capture:", track_name);
409 list<boost::shared_ptr<AudioTrack> > single_track = new_audio_track (1, 1, Normal, 0, 1, track_name);
410 tracks.insert(tracks.begin(), single_track.front());
412 } else { // Default track names
413 tracks = new_audio_track (1, 1, Normal, 0, how_many, string());
416 if (tracks.size() != how_many) {
418 throw failed_constructor ();
426 BootMessage (_("Session loading complete"));
438 Session::ensure_engine (uint32_t desired_sample_rate)
440 if (_engine.current_backend() == 0) {
441 /* backend is unknown ... */
442 boost::optional<int> r = AudioEngineSetupRequired (desired_sample_rate);
443 if (r.get_value_or (-1) != 0) {
446 } else if (_engine.setup_required()) {
447 /* backend is known, but setup is needed */
448 boost::optional<int> r = AudioEngineSetupRequired (desired_sample_rate);
449 if (r.get_value_or (-1) != 0) {
452 } else if (!_engine.running()) {
453 if (_engine.start()) {
458 /* at this point the engine should be running
461 if (!_engine.running()) {
465 return immediately_post_engine ();
470 Session::immediately_post_engine ()
472 /* Do various initializations that should take place directly after we
473 * know that the engine is running, but before we either create a
474 * session or set state for an existing one.
477 if (how_many_dsp_threads () > 1) {
478 /* For now, only create the graph if we are using >1 DSP threads, as
479 it is a bit slower than the old code with 1 thread.
481 _process_graph.reset (new Graph (*this));
484 /* every time we reconnect, recompute worst case output latencies */
486 _engine.Running.connect_same_thread (*this, boost::bind (&Session::initialize_latencies, this));
488 if (synced_to_engine()) {
489 _engine.transport_stop ();
492 if (config.get_jack_time_master()) {
493 _engine.transport_locate (_transport_frame);
497 BootMessage (_("Set up LTC"));
499 BootMessage (_("Set up Click"));
501 BootMessage (_("Set up standard connections"));
505 catch (failed_constructor& err) {
509 /* TODO, connect in different thread. (PortRegisteredOrUnregistered may be in RT context)
511 _engine.PortRegisteredOrUnregistered.connect_same_thread (*this, boost::bind (&Session::setup_bundles, this));
519 vector<void*> debug_pointers;
521 /* if we got to here, leaving pending capture state around
525 remove_pending_capture_state ();
527 _state_of_the_state = StateOfTheState (CannotSave|Deletion);
529 /* disconnect from any and all signals that we are connected to */
533 _engine.remove_session ();
535 #ifdef USE_TRACKS_CODE_FEATURES
536 EngineStateController::instance()->remove_session();
539 /* deregister all ports - there will be no process or any other
540 * callbacks from the engine any more.
543 Port::PortDrop (); /* EMIT SIGNAL */
547 /* clear history so that no references to objects are held any more */
551 /* clear state tree so that no references to objects are held any more */
556 /* reset dynamic state version back to default */
558 Stateful::loading_state_version = 0;
560 _butler->drop_references ();
564 delete _all_route_group;
566 DEBUG_TRACE (DEBUG::Destruction, "delete route groups\n");
567 for (list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
571 if (click_data != default_click) {
572 delete [] click_data;
575 if (click_emphasis_data != default_click_emphasis) {
576 delete [] click_emphasis_data;
581 /* need to remove auditioner before monitoring section
582 * otherwise it is re-connected */
585 /* drop references to routes held by the monitoring section
586 * specifically _monitor_out aux/listen references */
587 remove_monitor_section();
589 /* clear out any pending dead wood from RCU managed objects */
594 AudioDiskstream::free_working_buffers();
596 /* tell everyone who is still standing that we're about to die */
599 /* tell everyone to drop references and delete objects as we go */
601 DEBUG_TRACE (DEBUG::Destruction, "delete regions\n");
602 RegionFactory::delete_all_regions ();
604 DEBUG_TRACE (DEBUG::Destruction, "delete routes\n");
606 /* reset these three references to special routes before we do the usual route delete thing */
608 _master_out.reset ();
609 _monitor_out.reset ();
612 RCUWriter<RouteList> writer (routes);
613 boost::shared_ptr<RouteList> r = writer.get_copy ();
615 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
616 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for route %1 ; pre-ref = %2\n", (*i)->name(), (*i).use_count()));
617 (*i)->drop_references ();
621 /* writer goes out of scope and updates master */
626 DEBUG_TRACE (DEBUG::Destruction, "delete sources\n");
627 Glib::Threads::Mutex::Lock lm (source_lock);
628 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
629 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for source %1 ; pre-ref = %2\n", i->second->name(), i->second.use_count()));
630 i->second->drop_references ();
636 /* not strictly necessary, but doing it here allows the shared_ptr debugging to work */
639 emit_thread_terminate ();
641 pthread_cond_destroy (&_rt_emit_cond);
642 pthread_mutex_destroy (&_rt_emit_mutex);
644 delete _scene_changer; _scene_changer = 0;
645 delete midi_control_ui; midi_control_ui = 0;
647 delete _mmc; _mmc = 0;
648 delete _midi_ports; _midi_ports = 0;
649 delete _locations; _locations = 0;
653 DEBUG_TRACE (DEBUG::Destruction, "Session::destroy() done\n");
655 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
656 boost_debug_list_ptrs ();
661 Session::setup_ltc ()
665 _ltc_input.reset (new IO (*this, X_("LTC In"), IO::Input));
666 _ltc_output.reset (new IO (*this, X_("LTC Out"), IO::Output));
668 if (state_tree && (child = find_named_node (*state_tree->root(), X_("LTC In"))) != 0) {
669 _ltc_input->set_state (*(child->children().front()), Stateful::loading_state_version);
672 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
673 _ltc_input->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
675 reconnect_ltc_input ();
678 if (state_tree && (child = find_named_node (*state_tree->root(), X_("LTC Out"))) != 0) {
679 _ltc_output->set_state (*(child->children().front()), Stateful::loading_state_version);
682 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
683 _ltc_output->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
685 reconnect_ltc_output ();
688 /* fix up names of LTC ports because we don't want the normal
689 * IO style of NAME/TYPE-{in,out}N
692 _ltc_input->nth (0)->set_name (X_("LTC-in"));
693 _ltc_output->nth (0)->set_name (X_("LTC-out"));
697 Session::setup_click ()
700 _click_io.reset (new ClickIO (*this, X_("Click")));
701 _click_gain.reset (new Amp (*this));
702 _click_gain->activate ();
704 setup_click_state (state_tree->root());
706 setup_click_state (0);
711 Session::setup_click_state (const XMLNode* node)
713 const XMLNode* child = 0;
715 if (node && (child = find_named_node (*node, "Click")) != 0) {
717 /* existing state for Click */
720 if (Stateful::loading_state_version < 3000) {
721 c = _click_io->set_state_2X (*child->children().front(), Stateful::loading_state_version, false);
723 const XMLNodeList& children (child->children());
724 XMLNodeList::const_iterator i = children.begin();
725 if ((c = _click_io->set_state (**i, Stateful::loading_state_version)) == 0) {
727 if (i != children.end()) {
728 c = _click_gain->set_state (**i, Stateful::loading_state_version);
734 _clicking = Config->get_clicking ();
738 error << _("could not setup Click I/O") << endmsg;
745 /* default state for Click: dual-mono to first 2 physical outputs */
748 _engine.get_physical_outputs (DataType::AUDIO, outs);
750 for (uint32_t physport = 0; physport < 2; ++physport) {
751 if (outs.size() > physport) {
752 if (_click_io->add_port (outs[physport], this)) {
753 // relax, even though its an error
758 if (_click_io->n_ports () > ChanCount::ZERO) {
759 _clicking = Config->get_clicking ();
765 Session::setup_bundles ()
769 RCUWriter<BundleList> writer (_bundles);
770 boost::shared_ptr<BundleList> b = writer.get_copy ();
771 for (BundleList::iterator i = b->begin(); i != b->end();) {
772 if (boost::dynamic_pointer_cast<UserBundle>(*i)) {
780 vector<string> inputs[DataType::num_types];
781 vector<string> outputs[DataType::num_types];
782 for (uint32_t i = 0; i < DataType::num_types; ++i) {
783 _engine.get_physical_inputs (DataType (DataType::Symbol (i)), inputs[i]);
784 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
787 /* Create a set of Bundle objects that map
788 to the physical I/O currently available. We create both
789 mono and stereo bundles, so that the common cases of mono
790 and stereo tracks get bundles to put in their mixer strip
791 in / out menus. There may be a nicer way of achieving that;
792 it doesn't really scale that well to higher channel counts
795 /* mono output bundles */
797 for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); ++np) {
799 std::string pn = _engine.get_pretty_name_by_name (outputs[DataType::AUDIO][np]);
801 snprintf (buf, sizeof (buf), _("out %s"), pn.substr(0,12).c_str());
803 snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
806 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
807 c->add_channel (_("mono"), DataType::AUDIO);
808 c->set_port (0, outputs[DataType::AUDIO][np]);
810 add_bundle (c, false);
813 /* stereo output bundles */
815 for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); np += 2) {
816 if (np + 1 < outputs[DataType::AUDIO].size()) {
818 snprintf (buf, sizeof(buf), _("out %" PRIu32 "+%" PRIu32), np + 1, np + 2);
819 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
820 c->add_channel (_("L"), DataType::AUDIO);
821 c->set_port (0, outputs[DataType::AUDIO][np]);
822 c->add_channel (_("R"), DataType::AUDIO);
823 c->set_port (1, outputs[DataType::AUDIO][np + 1]);
825 add_bundle (c, false);
829 /* mono input bundles */
831 for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); ++np) {
833 std::string pn = _engine.get_pretty_name_by_name (inputs[DataType::AUDIO][np]);
835 snprintf (buf, sizeof (buf), _("in %s"), pn.substr(0,12).c_str());
837 snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
840 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
841 c->add_channel (_("mono"), DataType::AUDIO);
842 c->set_port (0, inputs[DataType::AUDIO][np]);
844 add_bundle (c, false);
847 /* stereo input bundles */
849 for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); np += 2) {
850 if (np + 1 < inputs[DataType::AUDIO].size()) {
852 snprintf (buf, sizeof(buf), _("in %" PRIu32 "+%" PRIu32), np + 1, np + 2);
854 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
855 c->add_channel (_("L"), DataType::AUDIO);
856 c->set_port (0, inputs[DataType::AUDIO][np]);
857 c->add_channel (_("R"), DataType::AUDIO);
858 c->set_port (1, inputs[DataType::AUDIO][np + 1]);
860 add_bundle (c, false);
864 /* MIDI input bundles */
866 for (uint32_t np = 0; np < inputs[DataType::MIDI].size(); ++np) {
867 string n = inputs[DataType::MIDI][np];
868 std::string pn = _engine.get_pretty_name_by_name (n);
872 boost::erase_first (n, X_("alsa_pcm:"));
874 boost::shared_ptr<Bundle> c (new Bundle (n, false));
875 c->add_channel ("", DataType::MIDI);
876 c->set_port (0, inputs[DataType::MIDI][np]);
877 add_bundle (c, false);
880 /* MIDI output bundles */
882 for (uint32_t np = 0; np < outputs[DataType::MIDI].size(); ++np) {
883 string n = outputs[DataType::MIDI][np];
884 std::string pn = _engine.get_pretty_name_by_name (n);
888 boost::erase_first (n, X_("alsa_pcm:"));
890 boost::shared_ptr<Bundle> c (new Bundle (n, true));
891 c->add_channel ("", DataType::MIDI);
892 c->set_port (0, outputs[DataType::MIDI][np]);
893 add_bundle (c, false);
896 // we trust the backend to only calls us if there's a change
897 BundleAddedOrRemoved (); /* EMIT SIGNAL */
901 Session::auto_connect_master_bus ()
903 if (!_master_out || !Config->get_auto_connect_standard_busses() || _monitor_out) {
907 // Waves Tracks: Do not connect master bas for Tracks if AutoConnectMaster option is not set
908 // In this case it means "Multi Out" output mode
909 if (ARDOUR::Profile->get_trx() && !(Config->get_output_auto_connect() & AutoConnectMaster) ) {
913 /* if requested auto-connect the outputs to the first N physical ports.
916 uint32_t limit = _master_out->n_outputs().n_total();
917 vector<string> outputs[DataType::num_types];
919 for (uint32_t i = 0; i < DataType::num_types; ++i) {
920 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
923 for (uint32_t n = 0; n < limit; ++n) {
924 boost::shared_ptr<Port> p = _master_out->output()->nth (n);
926 if (outputs[p->type()].size() > n) {
927 connect_to = outputs[p->type()][n];
930 if (!connect_to.empty() && p->connected_to (connect_to) == false) {
931 if (_master_out->output()->connect (p, connect_to, this)) {
932 error << string_compose (_("cannot connect master output %1 to %2"), n, connect_to)
941 Session::remove_monitor_section ()
943 if (!_monitor_out || Profile->get_trx()) {
947 /* force reversion to Solo-In-Place */
948 Config->set_solo_control_is_listen_control (false);
950 /* if we are auditioning, cancel it ... this is a workaround
951 to a problem (auditioning does not execute the process graph,
952 which is needed to remove routes when using >1 core for processing)
957 /* Hold process lock while doing this so that we don't hear bits and
958 * pieces of audio as we work on each route.
961 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
963 /* Connect tracks to monitor section. Note that in an
964 existing session, the internal sends will already exist, but we want the
965 routes to notice that they connect to the control out specifically.
969 boost::shared_ptr<RouteList> r = routes.reader ();
970 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
972 for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
974 if ((*x)->is_monitor()) {
976 } else if ((*x)->is_master()) {
979 (*x)->remove_aux_or_listen (_monitor_out);
984 remove_route (_monitor_out);
985 auto_connect_master_bus ();
988 auditioner->connect ();
993 Session::add_monitor_section ()
997 if (_monitor_out || !_master_out || Profile->get_trx()) {
1001 boost::shared_ptr<Route> r (new Route (*this, _("Monitor"), Route::MonitorOut, DataType::AUDIO));
1007 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1008 // boost_debug_shared_ptr_mark_interesting (r.get(), "Route");
1011 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1012 r->input()->ensure_io (_master_out->output()->n_ports(), false, this);
1013 r->output()->ensure_io (_master_out->output()->n_ports(), false, this);
1017 add_routes (rl, false, false, false);
1019 assert (_monitor_out);
1021 /* AUDIO ONLY as of june 29th 2009, because listen semantics for anything else
1022 are undefined, at best.
1025 uint32_t limit = _monitor_out->n_inputs().n_audio();
1029 /* connect the inputs to the master bus outputs. this
1030 * represents a separate data feed from the internal sends from
1031 * each route. as of jan 2011, it allows the monitor section to
1032 * conditionally ignore either the internal sends or the normal
1033 * input feed, but we should really find a better way to do
1037 _master_out->output()->disconnect (this);
1039 for (uint32_t n = 0; n < limit; ++n) {
1040 boost::shared_ptr<AudioPort> p = _monitor_out->input()->ports().nth_audio_port (n);
1041 boost::shared_ptr<AudioPort> o = _master_out->output()->ports().nth_audio_port (n);
1044 string connect_to = o->name();
1045 if (_monitor_out->input()->connect (p, connect_to, this)) {
1046 error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
1054 /* if monitor section is not connected, connect it to physical outs
1057 if (Config->get_auto_connect_standard_busses() && !_monitor_out->output()->connected ()) {
1059 if (!Config->get_monitor_bus_preferred_bundle().empty()) {
1061 boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
1064 _monitor_out->output()->connect_ports_to_bundle (b, true, this);
1066 warning << string_compose (_("The preferred I/O for the monitor bus (%1) cannot be found"),
1067 Config->get_monitor_bus_preferred_bundle())
1073 /* Monitor bus is audio only */
1075 vector<string> outputs[DataType::num_types];
1077 for (uint32_t i = 0; i < DataType::num_types; ++i) {
1078 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
1081 uint32_t mod = outputs[DataType::AUDIO].size();
1082 uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
1086 for (uint32_t n = 0; n < limit; ++n) {
1088 boost::shared_ptr<Port> p = _monitor_out->output()->ports().port(DataType::AUDIO, n);
1090 if (outputs[DataType::AUDIO].size() > (n % mod)) {
1091 connect_to = outputs[DataType::AUDIO][n % mod];
1094 if (!connect_to.empty()) {
1095 if (_monitor_out->output()->connect (p, connect_to, this)) {
1096 error << string_compose (
1097 _("cannot connect control output %1 to %2"),
1108 /* Hold process lock while doing this so that we don't hear bits and
1109 * pieces of audio as we work on each route.
1112 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1114 /* Connect tracks to monitor section. Note that in an
1115 existing session, the internal sends will already exist, but we want the
1116 routes to notice that they connect to the control out specifically.
1120 boost::shared_ptr<RouteList> rls = routes.reader ();
1122 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
1124 for (RouteList::iterator x = rls->begin(); x != rls->end(); ++x) {
1126 if ((*x)->is_monitor()) {
1128 } else if ((*x)->is_master()) {
1131 (*x)->enable_monitor_send ();
1136 auditioner->connect ();
1141 Session::reset_monitor_section ()
1143 /* Process lock should be held by the caller.*/
1145 if (!_monitor_out || Profile->get_trx()) {
1149 uint32_t limit = _master_out->n_outputs().n_audio();
1151 /* connect the inputs to the master bus outputs. this
1152 * represents a separate data feed from the internal sends from
1153 * each route. as of jan 2011, it allows the monitor section to
1154 * conditionally ignore either the internal sends or the normal
1155 * input feed, but we should really find a better way to do
1159 _master_out->output()->disconnect (this);
1160 _monitor_out->output()->disconnect (this);
1162 _monitor_out->input()->ensure_io (_master_out->output()->n_ports(), false, this);
1163 _monitor_out->output()->ensure_io (_master_out->output()->n_ports(), false, this);
1165 for (uint32_t n = 0; n < limit; ++n) {
1166 boost::shared_ptr<AudioPort> p = _monitor_out->input()->ports().nth_audio_port (n);
1167 boost::shared_ptr<AudioPort> o = _master_out->output()->ports().nth_audio_port (n);
1170 string connect_to = o->name();
1171 if (_monitor_out->input()->connect (p, connect_to, this)) {
1172 error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
1179 /* connect monitor section to physical outs
1182 if (Config->get_auto_connect_standard_busses()) {
1184 if (!Config->get_monitor_bus_preferred_bundle().empty()) {
1186 boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
1189 _monitor_out->output()->connect_ports_to_bundle (b, true, this);
1191 warning << string_compose (_("The preferred I/O for the monitor bus (%1) cannot be found"),
1192 Config->get_monitor_bus_preferred_bundle())
1198 /* Monitor bus is audio only */
1200 vector<string> outputs[DataType::num_types];
1202 for (uint32_t i = 0; i < DataType::num_types; ++i) {
1203 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
1206 uint32_t mod = outputs[DataType::AUDIO].size();
1207 uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
1211 for (uint32_t n = 0; n < limit; ++n) {
1213 boost::shared_ptr<Port> p = _monitor_out->output()->ports().port(DataType::AUDIO, n);
1215 if (outputs[DataType::AUDIO].size() > (n % mod)) {
1216 connect_to = outputs[DataType::AUDIO][n % mod];
1219 if (!connect_to.empty()) {
1220 if (_monitor_out->output()->connect (p, connect_to, this)) {
1221 error << string_compose (
1222 _("cannot connect control output %1 to %2"),
1233 /* Connect tracks to monitor section. Note that in an
1234 existing session, the internal sends will already exist, but we want the
1235 routes to notice that they connect to the control out specifically.
1239 boost::shared_ptr<RouteList> rls = routes.reader ();
1241 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
1243 for (RouteList::iterator x = rls->begin(); x != rls->end(); ++x) {
1245 if ((*x)->is_monitor()) {
1247 } else if ((*x)->is_master()) {
1250 (*x)->enable_monitor_send ();
1256 Session::hookup_io ()
1258 /* stop graph reordering notifications from
1259 causing resorts, etc.
1262 _state_of_the_state = StateOfTheState (_state_of_the_state | InitialConnecting);
1266 /* we delay creating the auditioner till now because
1267 it makes its own connections to ports.
1271 boost::shared_ptr<Auditioner> a (new Auditioner (*this));
1273 throw failed_constructor ();
1275 a->use_new_diskstream ();
1279 catch (failed_constructor& err) {
1280 warning << _("cannot create Auditioner: no auditioning of regions possible") << endmsg;
1284 /* load bundles, which we may have postponed earlier on */
1285 if (_bundle_xml_node) {
1286 load_bundles (*_bundle_xml_node);
1287 delete _bundle_xml_node;
1290 /* Tell all IO objects to connect themselves together */
1292 IO::enable_connecting ();
1294 /* Now tell all "floating" ports to connect to whatever
1295 they should be connected to.
1298 AudioEngine::instance()->reconnect_ports ();
1300 /* Anyone who cares about input state, wake up and do something */
1302 IOConnectionsComplete (); /* EMIT SIGNAL */
1304 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InitialConnecting);
1306 /* now handle the whole enchilada as if it was one
1307 graph reorder event.
1312 /* update the full solo state, which can't be
1313 correctly determined on a per-route basis, but
1314 needs the global overview that only the session
1318 update_route_solo_state ();
1322 Session::track_playlist_changed (boost::weak_ptr<Track> wp)
1324 boost::shared_ptr<Track> track = wp.lock ();
1329 boost::shared_ptr<Playlist> playlist;
1331 if ((playlist = track->playlist()) != 0) {
1332 playlist->RegionAdded.connect_same_thread (*this, boost::bind (&Session::playlist_region_added, this, _1));
1333 playlist->RangesMoved.connect_same_thread (*this, boost::bind (&Session::playlist_ranges_moved, this, _1));
1334 playlist->RegionsExtended.connect_same_thread (*this, boost::bind (&Session::playlist_regions_extended, this, _1));
1339 Session::record_enabling_legal () const
1341 /* this used to be in here, but survey says.... we don't need to restrict it */
1342 // if (record_status() == Recording) {
1346 if (Config->get_all_safe()) {
1353 Session::set_track_monitor_input_status (bool yn)
1355 boost::shared_ptr<RouteList> rl = routes.reader ();
1356 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1357 boost::shared_ptr<AudioTrack> tr = boost::dynamic_pointer_cast<AudioTrack> (*i);
1358 if (tr && tr->record_enabled ()) {
1359 //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
1360 tr->request_input_monitoring (yn);
1366 Session::auto_punch_start_changed (Location* location)
1368 replace_event (SessionEvent::PunchIn, location->start());
1370 if (get_record_enabled() && config.get_punch_in()) {
1371 /* capture start has been changed, so save new pending state */
1372 save_state ("", true);
1377 Session::auto_punch_end_changed (Location* location)
1379 framepos_t when_to_stop = location->end();
1380 // when_to_stop += _worst_output_latency + _worst_input_latency;
1381 replace_event (SessionEvent::PunchOut, when_to_stop);
1385 Session::auto_punch_changed (Location* location)
1387 framepos_t when_to_stop = location->end();
1389 replace_event (SessionEvent::PunchIn, location->start());
1390 //when_to_stop += _worst_output_latency + _worst_input_latency;
1391 replace_event (SessionEvent::PunchOut, when_to_stop);
1394 /** @param loc A loop location.
1395 * @param pos Filled in with the start time of the required fade-out (in session frames).
1396 * @param length Filled in with the length of the required fade-out.
1399 Session::auto_loop_declick_range (Location* loc, framepos_t & pos, framepos_t & length)
1401 pos = max (loc->start(), loc->end() - 64);
1402 length = loc->end() - pos;
1406 Session::auto_loop_changed (Location* location)
1408 replace_event (SessionEvent::AutoLoop, location->end(), location->start());
1411 auto_loop_declick_range (location, dcp, dcl);
1413 if (transport_rolling() && play_loop) {
1415 replace_event (SessionEvent::AutoLoopDeclick, dcp, dcl);
1417 // if (_transport_frame > location->end()) {
1419 if (_transport_frame < location->start() || _transport_frame > location->end()) {
1420 // relocate to beginning of loop
1421 clear_events (SessionEvent::LocateRoll);
1423 request_locate (location->start(), true);
1426 else if (Config->get_seamless_loop() && !loop_changing) {
1428 // schedule a locate-roll to refill the diskstreams at the
1429 // previous loop end
1430 loop_changing = true;
1432 if (location->end() > last_loopend) {
1433 clear_events (SessionEvent::LocateRoll);
1434 SessionEvent *ev = new SessionEvent (SessionEvent::LocateRoll, SessionEvent::Add, last_loopend, last_loopend, 0, true);
1440 clear_events (SessionEvent::AutoLoopDeclick);
1441 clear_events (SessionEvent::AutoLoop);
1444 last_loopend = location->end();
1449 Session::set_auto_punch_location (Location* location)
1453 if ((existing = _locations->auto_punch_location()) != 0 && existing != location) {
1454 punch_connections.drop_connections();
1455 existing->set_auto_punch (false, this);
1456 remove_event (existing->start(), SessionEvent::PunchIn);
1457 clear_events (SessionEvent::PunchOut);
1458 auto_punch_location_changed (0);
1463 if (location == 0) {
1467 if (location->end() <= location->start()) {
1468 error << _("Session: you can't use that location for auto punch (start <= end)") << endmsg;
1472 punch_connections.drop_connections ();
1474 location->StartChanged.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_start_changed, this, location));
1475 location->EndChanged.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_end_changed, this, location));
1476 location->Changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_changed, this, location));
1478 location->set_auto_punch (true, this);
1480 auto_punch_changed (location);
1482 auto_punch_location_changed (location);
1486 Session::set_session_extents (framepos_t start, framepos_t end)
1489 if ((existing = _locations->session_range_location()) == 0) {
1490 //if there is no existing session, we need to make a new session location (should never happen)
1491 existing = new Location (*this, 0, 0, _("session"), Location::IsSessionRange);
1495 error << _("Session: you can't use that location for session start/end)") << endmsg;
1499 existing->set( start, end );
1505 Session::set_auto_loop_location (Location* location)
1509 if ((existing = _locations->auto_loop_location()) != 0 && existing != location) {
1510 loop_connections.drop_connections ();
1511 existing->set_auto_loop (false, this);
1512 remove_event (existing->end(), SessionEvent::AutoLoop);
1515 auto_loop_declick_range (existing, dcp, dcl);
1516 remove_event (dcp, SessionEvent::AutoLoopDeclick);
1517 auto_loop_location_changed (0);
1522 if (location == 0) {
1526 if (location->end() <= location->start()) {
1527 error << _("You cannot use this location for auto-loop because it has zero or negative length") << endmsg;
1531 last_loopend = location->end();
1533 loop_connections.drop_connections ();
1535 location->StartChanged.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1536 location->EndChanged.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1537 location->Changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1539 location->set_auto_loop (true, this);
1541 /* take care of our stuff first */
1543 auto_loop_changed (location);
1545 /* now tell everyone else */
1547 auto_loop_location_changed (location);
1551 Session::update_loop (Location*)
1557 Session::update_marks (Location*)
1563 Session::update_skips (Location* loc, bool consolidate)
1565 if (_ignore_skips_updates) {
1569 Locations::LocationList skips;
1572 PBD::Unwinder<bool> uw (_ignore_skips_updates, true);
1573 consolidate_skips (loc);
1576 sync_locations_to_skips ();
1582 Session::consolidate_skips (Location* loc)
1584 Locations::LocationList all_locations = _locations->list ();
1586 for (Locations::LocationList::iterator l = all_locations.begin(); l != all_locations.end(); ) {
1588 if (!(*l)->is_skip ()) {
1593 /* don't test against self */
1600 switch (Evoral::coverage ((*l)->start(), (*l)->end(), loc->start(), loc->end())) {
1601 case Evoral::OverlapInternal:
1602 case Evoral::OverlapExternal:
1603 case Evoral::OverlapStart:
1604 case Evoral::OverlapEnd:
1605 /* adjust new location to cover existing one */
1606 loc->set_start (min (loc->start(), (*l)->start()));
1607 loc->set_end (max (loc->end(), (*l)->end()));
1608 /* we don't need this one any more */
1609 _locations->remove (*l);
1610 /* the location has been deleted, so remove reference to it in our local list */
1611 l = all_locations.erase (l);
1614 case Evoral::OverlapNone:
1622 Session::sync_locations_to_skips ()
1624 /* This happens asynchronously (in the audioengine thread). After the clear is done, we will call
1625 * Session::_sync_locations_to_skips() from the audioengine thread.
1627 clear_events (SessionEvent::Skip, boost::bind (&Session::_sync_locations_to_skips, this));
1631 Session::_sync_locations_to_skips ()
1633 /* called as a callback after existing Skip events have been cleared from a realtime audioengine thread */
1635 Locations::LocationList const & locs (_locations->list());
1637 for (Locations::LocationList::const_iterator i = locs.begin(); i != locs.end(); ++i) {
1639 Location* location = *i;
1641 if (location->is_skip() && location->is_skipping()) {
1642 SessionEvent* ev = new SessionEvent (SessionEvent::Skip, SessionEvent::Add, location->start(), location->end(), 1.0);
1650 Session::location_added (Location *location)
1652 if (location->is_auto_punch()) {
1653 set_auto_punch_location (location);
1656 if (location->is_auto_loop()) {
1657 set_auto_loop_location (location);
1660 if (location->is_session_range()) {
1661 /* no need for any signal handling or event setting with the session range,
1662 because we keep a direct reference to it and use its start/end directly.
1664 _session_range_location = location;
1667 if (location->is_mark()) {
1668 /* listen for per-location signals that require us to do any * global updates for marks */
1670 location->StartChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1671 location->EndChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1672 location->Changed.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1673 location->FlagsChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1676 if (location->is_skip()) {
1677 /* listen for per-location signals that require us to update skip-locate events */
1679 location->StartChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, true));
1680 location->EndChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, true));
1681 location->Changed.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, true));
1682 location->FlagsChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, false));
1684 update_skips (location, true);
1691 Session::location_removed (Location *location)
1693 if (location->is_auto_loop()) {
1694 set_auto_loop_location (0);
1695 set_track_loop (false);
1698 if (location->is_auto_punch()) {
1699 set_auto_punch_location (0);
1702 if (location->is_session_range()) {
1703 /* this is never supposed to happen */
1704 error << _("programming error: session range removed!") << endl;
1707 if (location->is_skip()) {
1709 update_skips (location, false);
1716 Session::locations_changed ()
1718 _locations->apply (*this, &Session::_locations_changed);
1722 Session::_locations_changed (const Locations::LocationList& locations)
1724 /* There was some mass-change in the Locations object.
1726 We might be re-adding a location here but it doesn't actually matter
1727 for all the locations that the Session takes an interest in.
1730 for (Locations::LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
1731 location_added (*i);
1736 Session::enable_record ()
1738 if (_transport_speed != 0.0 && _transport_speed != 1.0) {
1739 /* no recording at anything except normal speed */
1744 RecordState rs = (RecordState) g_atomic_int_get (&_record_status);
1746 if (rs == Recording) {
1750 if (g_atomic_int_compare_and_exchange (&_record_status, rs, Recording)) {
1752 _last_record_location = _transport_frame;
1753 send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordStrobe));
1755 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1756 set_track_monitor_input_status (true);
1759 RecordStateChanged ();
1766 Session::disable_record (bool rt_context, bool force)
1770 if ((rs = (RecordState) g_atomic_int_get (&_record_status)) != Disabled) {
1772 if ((!Config->get_latched_record_enable () && !play_loop) || force) {
1773 g_atomic_int_set (&_record_status, Disabled);
1774 send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordExit));
1776 if (rs == Recording) {
1777 g_atomic_int_set (&_record_status, Enabled);
1781 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1782 set_track_monitor_input_status (false);
1785 RecordStateChanged (); /* emit signal */
1788 remove_pending_capture_state ();
1794 Session::step_back_from_record ()
1796 if (g_atomic_int_compare_and_exchange (&_record_status, Recording, Enabled)) {
1798 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1799 set_track_monitor_input_status (false);
1802 RecordStateChanged (); /* emit signal */
1807 Session::maybe_enable_record ()
1809 if (_step_editors > 0) {
1813 g_atomic_int_set (&_record_status, Enabled);
1815 /* This function is currently called from somewhere other than an RT thread.
1816 This save_state() call therefore doesn't impact anything. Doing it here
1817 means that we save pending state of which sources the next record will use,
1818 which gives us some chance of recovering from a crash during the record.
1821 save_state ("", true);
1823 if (_transport_speed) {
1824 if (!config.get_punch_in()) {
1828 send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordPause));
1829 RecordStateChanged (); /* EMIT SIGNAL */
1836 Session::audible_frame () const
1842 offset = worst_playback_latency ();
1844 if (synced_to_engine()) {
1845 /* Note: this is basically just sync-to-JACK */
1846 tf = _engine.transport_frame();
1848 tf = _transport_frame;
1853 if (!non_realtime_work_pending()) {
1857 /* Check to see if we have passed the first guaranteed
1858 audible frame past our last start position. if not,
1859 return that last start point because in terms
1860 of audible frames, we have not moved yet.
1862 `Start position' in this context means the time we last
1863 either started, located, or changed transport direction.
1866 if (_transport_speed > 0.0f) {
1868 if (!play_loop || !have_looped) {
1869 if (tf < _last_roll_or_reversal_location + offset) {
1870 return _last_roll_or_reversal_location;
1878 } else if (_transport_speed < 0.0f) {
1880 /* XXX wot? no backward looping? */
1882 if (tf > _last_roll_or_reversal_location - offset) {
1883 return _last_roll_or_reversal_location;
1895 Session::set_frame_rate (framecnt_t frames_per_second)
1897 /** \fn void Session::set_frame_size(framecnt_t)
1898 the AudioEngine object that calls this guarantees
1899 that it will not be called while we are also in
1900 ::process(). Its fine to do things that block
1904 _base_frame_rate = frames_per_second;
1905 _nominal_frame_rate = frames_per_second;
1911 // XXX we need some equivalent to this, somehow
1912 // SndFileSource::setup_standard_crossfades (frames_per_second);
1916 /* XXX need to reset/reinstantiate all LADSPA plugins */
1920 Session::set_block_size (pframes_t nframes)
1922 /* the AudioEngine guarantees
1923 that it will not be called while we are also in
1924 ::process(). It is therefore fine to do things that block
1929 current_block_size = nframes;
1933 boost::shared_ptr<RouteList> r = routes.reader ();
1935 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1936 (*i)->set_block_size (nframes);
1939 boost::shared_ptr<RouteList> rl = routes.reader ();
1940 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1941 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1943 tr->set_block_size (nframes);
1947 set_worst_io_latencies ();
1953 trace_terminal (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> rbase)
1955 boost::shared_ptr<Route> r2;
1957 if (r1->feeds (rbase) && rbase->feeds (r1)) {
1958 info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
1962 /* make a copy of the existing list of routes that feed r1 */
1964 Route::FedBy existing (r1->fed_by());
1966 /* for each route that feeds r1, recurse, marking it as feeding
1970 for (Route::FedBy::iterator i = existing.begin(); i != existing.end(); ++i) {
1971 if (!(r2 = i->r.lock ())) {
1972 /* (*i) went away, ignore it */
1976 /* r2 is a route that feeds r1 which somehow feeds base. mark
1977 base as being fed by r2
1980 rbase->add_fed_by (r2, i->sends_only);
1984 /* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
1988 if (r1->feeds (r2) && r2->feeds (r1)) {
1992 /* now recurse, so that we can mark base as being fed by
1993 all routes that feed r2
1996 trace_terminal (r2, rbase);
2003 Session::resort_routes ()
2005 /* don't do anything here with signals emitted
2006 by Routes during initial setup or while we
2007 are being destroyed.
2010 if (_state_of_the_state & (InitialConnecting | Deletion)) {
2015 RCUWriter<RouteList> writer (routes);
2016 boost::shared_ptr<RouteList> r = writer.get_copy ();
2017 resort_routes_using (r);
2018 /* writer goes out of scope and forces update */
2022 boost::shared_ptr<RouteList> rl = routes.reader ();
2023 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2024 DEBUG_TRACE (DEBUG::Graph, string_compose ("%1 fed by ...\n", (*i)->name()));
2026 const Route::FedBy& fb ((*i)->fed_by());
2028 for (Route::FedBy::const_iterator f = fb.begin(); f != fb.end(); ++f) {
2029 boost::shared_ptr<Route> sf = f->r.lock();
2031 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 (sends only ? %2)\n", sf->name(), f->sends_only));
2039 /** This is called whenever we need to rebuild the graph of how we will process
2041 * @param r List of routes, in any order.
2045 Session::resort_routes_using (boost::shared_ptr<RouteList> r)
2047 /* We are going to build a directed graph of our routes;
2048 this is where the edges of that graph are put.
2053 /* Go through all routes doing two things:
2055 * 1. Collect the edges of the route graph. Each of these edges
2056 * is a pair of routes, one of which directly feeds the other
2057 * either by a JACK connection or by an internal send.
2059 * 2. Begin the process of making routes aware of which other
2060 * routes directly or indirectly feed them. This information
2061 * is used by the solo code.
2064 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2066 /* Clear out the route's list of direct or indirect feeds */
2067 (*i)->clear_fed_by ();
2069 for (RouteList::iterator j = r->begin(); j != r->end(); ++j) {
2071 bool via_sends_only;
2073 /* See if this *j feeds *i according to the current state of the JACK
2074 connections and internal sends.
2076 if ((*j)->direct_feeds_according_to_reality (*i, &via_sends_only)) {
2077 /* add the edge to the graph (part #1) */
2078 edges.add (*j, *i, via_sends_only);
2079 /* tell the route (for part #2) */
2080 (*i)->add_fed_by (*j, via_sends_only);
2085 /* Attempt a topological sort of the route graph */
2086 boost::shared_ptr<RouteList> sorted_routes = topological_sort (r, edges);
2088 if (sorted_routes) {
2089 /* We got a satisfactory topological sort, so there is no feedback;
2092 Note: the process graph rechain does not require a
2093 topologically-sorted list, but hey ho.
2095 if (_process_graph) {
2096 _process_graph->rechain (sorted_routes, edges);
2099 _current_route_graph = edges;
2101 /* Complete the building of the routes' lists of what directly
2102 or indirectly feeds them.
2104 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2105 trace_terminal (*i, *i);
2108 *r = *sorted_routes;
2111 DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
2112 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2113 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 signal order %2\n",
2114 (*i)->name(), (*i)->order_key ()));
2118 SuccessfulGraphSort (); /* EMIT SIGNAL */
2121 /* The topological sort failed, so we have a problem. Tell everyone
2122 and stick to the old graph; this will continue to be processed, so
2123 until the feedback is fixed, what is played back will not quite
2124 reflect what is actually connected. Note also that we do not
2125 do trace_terminal here, as it would fail due to an endless recursion,
2126 so the solo code will think that everything is still connected
2130 FeedbackDetected (); /* EMIT SIGNAL */
2135 /** Find a route name starting with \a base, maybe followed by the
2136 * lowest \a id. \a id will always be added if \a definitely_add_number
2137 * is true on entry; otherwise it will only be added if required
2138 * to make the name unique.
2140 * Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
2141 * The available route name with the lowest ID will be used, and \a id
2142 * will be set to the ID.
2144 * \return false if a route name could not be found, and \a track_name
2145 * and \a id do not reflect a free route name.
2148 Session::find_route_name (string const & base, uint32_t& id, char* name, size_t name_len, bool definitely_add_number)
2150 if (!definitely_add_number && route_by_name (base) == 0) {
2151 /* juse use the base */
2152 snprintf (name, name_len, "%s", base.c_str());
2157 snprintf (name, name_len, "%s %" PRIu32, base.c_str(), id);
2159 if (route_by_name (name) == 0) {
2165 } while (id < (UINT_MAX-1));
2170 /** Count the total ins and outs of all non-hidden tracks in the session and return them in in and out */
2172 Session::count_existing_track_channels (ChanCount& in, ChanCount& out)
2174 in = ChanCount::ZERO;
2175 out = ChanCount::ZERO;
2177 boost::shared_ptr<RouteList> r = routes.reader ();
2179 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2180 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2181 if (tr && !tr->is_auditioner()) {
2182 in += tr->n_inputs();
2183 out += tr->n_outputs();
2188 /** Caller must not hold process lock
2189 * @param name_template string to use for the start of the name, or "" to use "MIDI".
2190 * @param instrument plugin info for the instrument to insert pre-fader, if any
2192 list<boost::shared_ptr<MidiTrack> >
2193 Session::new_midi_track (const ChanCount& input, const ChanCount& output, boost::shared_ptr<PluginInfo> instrument,
2194 TrackMode mode, RouteGroup* route_group, uint32_t how_many, string name_template)
2196 char track_name[32];
2197 uint32_t track_id = 0;
2199 RouteList new_routes;
2200 list<boost::shared_ptr<MidiTrack> > ret;
2202 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("MIDI");
2205 if (!find_route_name (name_template.empty() ? _("MIDI") : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
2206 error << "cannot find name for new midi track" << endmsg;
2210 boost::shared_ptr<MidiTrack> track;
2213 track.reset (new MidiTrack (*this, track_name, Route::Flag (0), mode));
2215 if (track->init ()) {
2219 track->use_new_diskstream();
2221 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2222 // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
2225 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2226 if (track->input()->ensure_io (input, false, this)) {
2227 error << "cannot configure " << input << " out configuration for new midi track" << endmsg;
2231 if (track->output()->ensure_io (output, false, this)) {
2232 error << "cannot configure " << output << " out configuration for new midi track" << endmsg;
2237 track->non_realtime_input_change();
2240 route_group->add (track);
2243 track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
2245 if (Config->get_remote_model() == UserOrdered) {
2246 track->set_remote_control_id (next_control_id());
2249 new_routes.push_back (track);
2250 ret.push_back (track);
2252 RouteAddedOrRemoved (true); /* EMIT SIGNAL */
2255 catch (failed_constructor &err) {
2256 error << _("Session: could not create new midi track.") << endmsg;
2260 catch (AudioEngine::PortRegistrationFailure& pfe) {
2262 error << string_compose (_("No more JACK ports are available. You will need to stop %1 and restart JACK with more ports if you need this many tracks."), PROGRAM_NAME) << endmsg;
2270 if (!new_routes.empty()) {
2271 StateProtector sp (this);
2272 if (Profile->get_trx()) {
2273 add_routes (new_routes, false, false, false);
2275 add_routes (new_routes, true, true, false);
2279 for (RouteList::iterator r = new_routes.begin(); r != new_routes.end(); ++r) {
2280 PluginPtr plugin = instrument->load (*this);
2281 boost::shared_ptr<Processor> p (new PluginInsert (*this, plugin));
2282 (*r)->add_processor (p, PreFader);
2292 Session::midi_output_change_handler (IOChange change, void * /*src*/, boost::weak_ptr<Route> wmt)
2294 boost::shared_ptr<Route> midi_track (wmt.lock());
2300 if ((change.type & IOChange::ConfigurationChanged) && Config->get_output_auto_connect() != ManualConnect) {
2302 if (change.after.n_audio() <= change.before.n_audio()) {
2306 /* new audio ports: make sure the audio goes somewhere useful,
2307 unless the user has no-auto-connect selected.
2309 The existing ChanCounts don't matter for this call as they are only
2310 to do with matching input and output indices, and we are only changing
2316 auto_connect_route (midi_track, dummy, dummy, false, false, ChanCount(), change.before);
2320 /** @param connect_inputs true to connect inputs as well as outputs, false to connect just outputs.
2321 * @param input_start Where to start from when auto-connecting inputs; e.g. if this is 0, auto-connect starting from input 0.
2322 * @param output_start As \a input_start, but for outputs.
2325 Session::auto_connect_route (boost::shared_ptr<Route> route, ChanCount& existing_inputs, ChanCount& existing_outputs,
2326 bool with_lock, bool connect_inputs, ChanCount input_start, ChanCount output_start)
2328 if (!IO::connecting_legal) {
2332 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
2338 /* If both inputs and outputs are auto-connected to physical ports,
2339 use the max of input and output offsets to ensure auto-connected
2340 port numbers always match up (e.g. the first audio input and the
2341 first audio output of the route will have the same physical
2342 port number). Otherwise just use the lowest input or output
2346 DEBUG_TRACE (DEBUG::Graph,
2347 string_compose("Auto-connect: existing in = %1 out = %2\n",
2348 existing_inputs, existing_outputs));
2350 const bool in_out_physical =
2351 (Config->get_input_auto_connect() & AutoConnectPhysical)
2352 && (Config->get_output_auto_connect() & AutoConnectPhysical)
2355 const ChanCount in_offset = in_out_physical
2356 ? ChanCount::max(existing_inputs, existing_outputs)
2359 const ChanCount out_offset = in_out_physical
2360 ? ChanCount::max(existing_inputs, existing_outputs)
2363 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
2364 vector<string> physinputs;
2365 vector<string> physoutputs;
2367 _engine.get_physical_outputs (*t, physoutputs);
2368 _engine.get_physical_inputs (*t, physinputs);
2370 if (!physinputs.empty() && connect_inputs) {
2371 uint32_t nphysical_in = physinputs.size();
2373 DEBUG_TRACE (DEBUG::Graph,
2374 string_compose("There are %1 physical inputs of type %2\n",
2377 for (uint32_t i = input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
2380 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
2381 DEBUG_TRACE (DEBUG::Graph,
2382 string_compose("Get index %1 + %2 % %3 = %4\n",
2383 in_offset.get(*t), i, nphysical_in,
2384 (in_offset.get(*t) + i) % nphysical_in));
2385 port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
2388 DEBUG_TRACE (DEBUG::Graph,
2389 string_compose("Connect route %1 IN to %2\n",
2390 route->name(), port));
2392 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
2396 ChanCount one_added (*t, 1);
2397 existing_inputs += one_added;
2401 if (!physoutputs.empty()) {
2402 uint32_t nphysical_out = physoutputs.size();
2403 for (uint32_t i = output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
2407 * do not create new connections if we reached the limit of physical outputs
2411 if (!(Config->get_output_auto_connect() & AutoConnectMaster) &&
2412 ARDOUR::Profile->get_trx () &&
2413 existing_outputs.get(*t) == nphysical_out ) {
2417 if ((*t) == DataType::MIDI && (Config->get_output_auto_connect() & AutoConnectPhysical)) {
2418 port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
2419 } else if ((*t) == DataType::AUDIO && (Config->get_output_auto_connect() & AutoConnectMaster)) {
2420 /* master bus is audio only */
2421 if (_master_out && _master_out->n_inputs().get(*t) > 0) {
2422 port = _master_out->input()->ports().port(*t,
2423 i % _master_out->input()->n_ports().get(*t))->name();
2427 DEBUG_TRACE (DEBUG::Graph,
2428 string_compose("Connect route %1 OUT to %2\n",
2429 route->name(), port));
2431 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
2435 ChanCount one_added (*t, 1);
2436 existing_outputs += one_added;
2442 #ifdef USE_TRACKS_CODE_FEATURES
2445 compare_routes_by_remote_id (const boost::shared_ptr<Route>& route1, const boost::shared_ptr<Route>& route2)
2447 return route1->remote_control_id() < route2->remote_control_id();
2451 Session::reconnect_existing_routes (bool withLock, bool reconnect_master, bool reconnect_inputs, bool reconnect_outputs)
2453 // it is not allowed to perform connection
2454 if (!IO::connecting_legal) {
2458 // if we are deleting routes we will call this once at the end
2459 if (_route_deletion_in_progress) {
2463 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
2469 // We need to disconnect the route's inputs and outputs first
2470 // basing on autoconnect configuration
2471 bool reconnectIputs = !(Config->get_input_auto_connect() & ManualConnect) && reconnect_inputs;
2472 bool reconnectOutputs = !(Config->get_output_auto_connect() & ManualConnect) && reconnect_outputs;
2474 ChanCount existing_inputs;
2475 ChanCount existing_outputs;
2476 count_existing_track_channels (existing_inputs, existing_outputs);
2478 //ChanCount inputs = ChanCount::ZERO;
2479 //ChanCount outputs = ChanCount::ZERO;
2481 RouteList existing_routes = *routes.reader ();
2482 existing_routes.sort (compare_routes_by_remote_id);
2485 PBD::Unwinder<bool> protect_ignore_changes (_reconnecting_routes_in_progress, true);
2487 vector<string> physinputs;
2488 vector<string> physoutputs;
2490 EngineStateController::instance()->get_physical_audio_outputs(physoutputs);
2491 EngineStateController::instance()->get_physical_audio_inputs(physinputs);
2493 uint32_t input_n = 0;
2494 uint32_t output_n = 0;
2495 RouteList::iterator rIter = existing_routes.begin();
2496 const AutoConnectOption current_input_auto_connection (Config->get_input_auto_connect());
2497 const AutoConnectOption current_output_auto_connection (Config->get_output_auto_connect());
2498 for (; rIter != existing_routes.end(); ++rIter) {
2499 if (*rIter == _master_out || *rIter == _monitor_out ) {
2503 if (current_output_auto_connection == AutoConnectPhysical) {
2504 (*rIter)->amp()->deactivate();
2505 } else if (current_output_auto_connection == AutoConnectMaster) {
2506 (*rIter)->amp()->activate();
2509 if (reconnectIputs) {
2510 (*rIter)->input()->disconnect (this); //GZ: check this; could be heavy
2512 for (uint32_t route_input_n = 0; route_input_n < (*rIter)->n_inputs().get(DataType::AUDIO); ++route_input_n) {
2514 if (current_input_auto_connection & AutoConnectPhysical) {
2516 if ( input_n == physinputs.size() ) {
2520 string port = physinputs[input_n];
2522 if (port.empty() ) {
2523 error << "Physical Input number "<< input_n << " is unavailable and cannot be connected" << endmsg;
2526 //GZ: check this; could be heavy
2527 (*rIter)->input()->connect ((*rIter)->input()->ports().port(DataType::AUDIO, route_input_n), port, this);
2533 if (reconnectOutputs) {
2535 //normalize route ouptuts: reduce the amount outputs to be equal to the amount of inputs
2536 if (current_output_auto_connection & AutoConnectPhysical) {
2538 //GZ: check this; could be heavy
2539 (*rIter)->output()->disconnect (this);
2540 size_t route_inputs_count = (*rIter)->n_inputs().get(DataType::AUDIO);
2542 //GZ: check this; could be heavy
2543 (*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, route_inputs_count), false, this );
2545 } else if (current_output_auto_connection & AutoConnectMaster){
2547 if (!reconnect_master) {
2551 //GZ: check this; could be heavy
2552 (*rIter)->output()->disconnect (this);
2555 uint32_t master_inputs_count = _master_out->n_inputs().get(DataType::AUDIO);
2556 (*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, master_inputs_count), false, this );
2558 error << error << "Master bus is not available" << endmsg;
2563 for (uint32_t route_output_n = 0; route_output_n < (*rIter)->n_outputs().get(DataType::AUDIO); ++route_output_n) {
2564 if (current_output_auto_connection & AutoConnectPhysical) {
2566 if ( output_n == physoutputs.size() ) {
2570 string port = physoutputs[output_n];
2572 if (port.empty() ) {
2573 error << "Physical Output number "<< output_n << " is unavailable and cannot be connected" << endmsg;
2576 //GZ: check this; could be heavy
2577 (*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
2580 } else if (current_output_auto_connection & AutoConnectMaster) {
2582 if ( route_output_n == _master_out->n_inputs().get(DataType::AUDIO) ) {
2586 // connect to master bus
2587 string port = _master_out->input()->ports().port(DataType::AUDIO, route_output_n)->name();
2589 if (port.empty() ) {
2590 error << "MasterBus Input number "<< route_output_n << " is unavailable and cannot be connected" << endmsg;
2594 //GZ: check this; could be heavy
2595 (*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
2601 //auto_connect_route (*rIter, inputs, outputs, false, reconnectIputs);
2604 _master_out->output()->disconnect (this);
2605 auto_connect_master_bus ();
2610 session_routes_reconnected (); /* EMIT SIGNAL */
2614 Session::reconnect_midi_scene_ports(bool inputs)
2618 boost::shared_ptr<MidiPort> scene_in_ptr = scene_in();
2620 scene_in_ptr->disconnect_all ();
2622 std::vector<EngineStateController::MidiPortState> midi_port_states;
2623 EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
2625 std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2627 for (; state_iter != midi_port_states.end(); ++state_iter) {
2628 if (state_iter->active && state_iter->available && state_iter->scene_connected) {
2629 scene_in_ptr->connect (state_iter->name);
2636 boost::shared_ptr<MidiPort> scene_out_ptr = scene_out();
2638 if (scene_out_ptr ) {
2639 scene_out_ptr->disconnect_all ();
2641 std::vector<EngineStateController::MidiPortState> midi_port_states;
2642 EngineStateController::instance()->get_physical_midi_output_states (midi_port_states);
2644 std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2646 for (; state_iter != midi_port_states.end(); ++state_iter) {
2647 if (state_iter->active && state_iter->available && state_iter->scene_connected) {
2648 scene_out_ptr->connect (state_iter->name);
2657 /** Caller must not hold process lock
2658 * @param name_template string to use for the start of the name, or "" to use "Audio".
2660 list< boost::shared_ptr<AudioTrack> >
2661 Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group,
2662 uint32_t how_many, string name_template)
2664 char track_name[32];
2665 uint32_t track_id = 0;
2667 RouteList new_routes;
2668 list<boost::shared_ptr<AudioTrack> > ret;
2670 string name_pattern;
2672 if (Profile->get_trx() ) {
2673 name_pattern = "Track ";
2675 name_pattern = "Audio ";
2678 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _(name_pattern.c_str() );
2682 if (!find_route_name (name_template.empty() ? _(name_pattern.c_str()) : name_template, ++track_id, track_name, sizeof(track_name), use_number)) {
2683 error << "cannot find name for new audio track" << endmsg;
2687 boost::shared_ptr<AudioTrack> track;
2690 track.reset (new AudioTrack (*this, track_name, Route::Flag (0), mode));
2692 if (track->init ()) {
2696 track->use_new_diskstream();
2698 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2699 // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
2702 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2704 if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
2705 error << string_compose (
2706 _("cannot configure %1 in/%2 out configuration for new audio track"),
2707 input_channels, output_channels)
2712 if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
2713 error << string_compose (
2714 _("cannot configure %1 in/%2 out configuration for new audio track"),
2715 input_channels, output_channels)
2722 route_group->add (track);
2725 track->non_realtime_input_change();
2727 track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
2728 if (Config->get_remote_model() == UserOrdered) {
2729 track->set_remote_control_id (next_control_id());
2732 new_routes.push_back (track);
2733 ret.push_back (track);
2735 RouteAddedOrRemoved (true); /* EMIT SIGNAL */
2738 catch (failed_constructor &err) {
2739 error << _("Session: could not create new audio track.") << endmsg;
2743 catch (AudioEngine::PortRegistrationFailure& pfe) {
2745 error << pfe.what() << endmsg;
2753 if (!new_routes.empty()) {
2754 StateProtector sp (this);
2755 if (Profile->get_trx()) {
2756 add_routes (new_routes, false, false, false);
2758 add_routes (new_routes, true, true, false);
2765 /** Caller must not hold process lock.
2766 * @param name_template string to use for the start of the name, or "" to use "Bus".
2769 Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template)
2772 uint32_t bus_id = 0;
2776 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
2779 if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, sizeof(bus_name), use_number)) {
2780 error << "cannot find name for new audio bus" << endmsg;
2785 boost::shared_ptr<Route> bus (new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO));
2791 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2792 // boost_debug_shared_ptr_mark_interesting (bus.get(), "Route");
2795 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2797 if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
2798 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
2799 input_channels, output_channels)
2805 if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
2806 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
2807 input_channels, output_channels)
2814 route_group->add (bus);
2816 if (Config->get_remote_model() == UserOrdered) {
2817 bus->set_remote_control_id (next_control_id());
2820 bus->add_internal_return ();
2822 ret.push_back (bus);
2824 RouteAddedOrRemoved (true); /* EMIT SIGNAL */
2830 catch (failed_constructor &err) {
2831 error << _("Session: could not create new audio route.") << endmsg;
2835 catch (AudioEngine::PortRegistrationFailure& pfe) {
2836 error << pfe.what() << endmsg;
2846 StateProtector sp (this);
2847 if (Profile->get_trx()) {
2848 add_routes (ret, false, false, false);
2850 add_routes (ret, false, true, true); // autoconnect // outputs only
2859 Session::new_route_from_template (uint32_t how_many, const std::string& template_path, const std::string& name_base)
2862 uint32_t control_id;
2864 uint32_t number = 0;
2865 const uint32_t being_added = how_many;
2867 if (!tree.read (template_path.c_str())) {
2871 XMLNode* node = tree.root();
2873 IO::disable_connecting ();
2875 control_id = next_control_id ();
2879 XMLNode node_copy (*node);
2881 /* Remove IDs of everything so that new ones are used */
2882 node_copy.remove_property_recursively (X_("id"));
2887 if (!name_base.empty()) {
2889 /* if we're adding more than one routes, force
2890 * all the names of the new routes to be
2891 * numbered, via the final parameter.
2894 if (!find_route_name (name_base.c_str(), ++number, name, sizeof(name), (being_added > 1))) {
2895 fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
2901 string const route_name = node_copy.property(X_("name"))->value ();
2903 /* generate a new name by adding a number to the end of the template name */
2904 if (!find_route_name (route_name.c_str(), ++number, name, sizeof(name), true)) {
2905 fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
2906 abort(); /*NOTREACHED*/
2910 /* set this name in the XML description that we are about to use */
2911 Route::set_name_in_state (node_copy, name);
2913 /* trim bitslots from listen sends so that new ones are used */
2914 XMLNodeList children = node_copy.children ();
2915 for (XMLNodeList::iterator i = children.begin(); i != children.end(); ++i) {
2916 if ((*i)->name() == X_("Processor")) {
2917 XMLProperty* role = (*i)->property (X_("role"));
2918 if (role && role->value() == X_("Listen")) {
2919 (*i)->remove_property (X_("bitslot"));
2924 boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
2927 error << _("Session: cannot create track/bus from template description") << endmsg;
2931 if (boost::dynamic_pointer_cast<Track>(route)) {
2932 /* force input/output change signals so that the new diskstream
2933 picks up the configuration of the route. During session
2934 loading this normally happens in a different way.
2937 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2939 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
2940 change.after = route->input()->n_ports();
2941 route->input()->changed (change, this);
2942 change.after = route->output()->n_ports();
2943 route->output()->changed (change, this);
2946 route->set_remote_control_id (control_id);
2949 ret.push_back (route);
2951 RouteAddedOrRemoved (true); /* EMIT SIGNAL */
2954 catch (failed_constructor &err) {
2955 error << _("Session: could not create new route from template") << endmsg;
2959 catch (AudioEngine::PortRegistrationFailure& pfe) {
2960 error << pfe.what() << endmsg;
2969 StateProtector sp (this);
2970 if (Profile->get_trx()) {
2971 add_routes (ret, false, false, false);
2973 add_routes (ret, true, true, false);
2975 IO::enable_connecting ();
2982 Session::add_routes (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, bool save)
2985 PBD::Unwinder<bool> aip (_adding_routes_in_progress, true);
2986 add_routes_inner (new_routes, input_auto_connect, output_auto_connect);
2989 error << _("Adding new tracks/busses failed") << endmsg;
2994 update_latency (true);
2995 update_latency (false);
3000 save_state (_current_snapshot_name);
3003 reassign_track_numbers();
3005 update_route_record_state ();
3007 RouteAdded (new_routes); /* EMIT SIGNAL */
3011 Session::add_routes_inner (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect)
3013 ChanCount existing_inputs;
3014 ChanCount existing_outputs;
3015 uint32_t order = next_control_id();
3017 if (_order_hint > -1) {
3018 order = _order_hint;
3022 count_existing_track_channels (existing_inputs, existing_outputs);
3025 RCUWriter<RouteList> writer (routes);
3026 boost::shared_ptr<RouteList> r = writer.get_copy ();
3027 r->insert (r->end(), new_routes.begin(), new_routes.end());
3029 /* if there is no control out and we're not in the middle of loading,
3030 resort the graph here. if there is a control out, we will resort
3031 toward the end of this method. if we are in the middle of loading,
3032 we will resort when done.
3035 if (!_monitor_out && IO::connecting_legal) {
3036 resort_routes_using (r);
3040 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
3042 boost::weak_ptr<Route> wpr (*x);
3043 boost::shared_ptr<Route> r (*x);
3045 r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
3046 r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2, wpr));
3047 r->solo_isolated_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, _1, wpr));
3048 r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this, _1));
3049 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
3050 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
3052 if (r->is_master()) {
3056 if (r->is_monitor()) {
3060 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
3062 tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
3063 track_playlist_changed (boost::weak_ptr<Track> (tr));
3064 tr->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Session::update_route_record_state, this));
3066 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
3068 mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
3069 mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
3074 if (input_auto_connect || output_auto_connect) {
3075 auto_connect_route (r, existing_inputs, existing_outputs, true, input_auto_connect);
3078 /* order keys are a GUI responsibility but we need to set up
3079 reasonable defaults because they also affect the remote control
3080 ID in most situations.
3083 if (!r->has_order_key ()) {
3084 if (r->is_auditioner()) {
3085 /* use an arbitrarily high value */
3086 r->set_order_key (UINT_MAX);
3088 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("while adding, set %1 to order key %2\n", r->name(), order));
3089 r->set_order_key (order);
3097 if (_monitor_out && IO::connecting_legal) {
3098 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
3100 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
3101 if ((*x)->is_monitor()) {
3103 } else if ((*x)->is_master()) {
3106 (*x)->enable_monitor_send ();
3113 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
3115 boost::shared_ptr<RouteList> r = routes.reader ();
3116 boost::shared_ptr<Send> s;
3118 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3119 if ((s = (*i)->internal_send_for (dest)) != 0) {
3120 s->amp()->gain_control()->set_value (GAIN_COEFF_ZERO);
3126 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
3128 boost::shared_ptr<RouteList> r = routes.reader ();
3129 boost::shared_ptr<Send> s;
3131 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3132 if ((s = (*i)->internal_send_for (dest)) != 0) {
3133 s->amp()->gain_control()->set_value (GAIN_COEFF_UNITY);
3139 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
3141 boost::shared_ptr<RouteList> r = routes.reader ();
3142 boost::shared_ptr<Send> s;
3144 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3145 if ((s = (*i)->internal_send_for (dest)) != 0) {
3146 s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value());
3151 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
3153 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
3155 boost::shared_ptr<RouteList> r = routes.reader ();
3156 boost::shared_ptr<RouteList> t (new RouteList);
3158 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3159 /* no MIDI sends because there are no MIDI busses yet */
3160 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
3165 add_internal_sends (dest, p, t);
3169 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
3171 for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
3172 add_internal_send (dest, (*i)->before_processor_for_placement (p), *i);
3177 Session::add_internal_send (boost::shared_ptr<Route> dest, int index, boost::shared_ptr<Route> sender)
3179 add_internal_send (dest, sender->before_processor_for_index (index), sender);
3183 Session::add_internal_send (boost::shared_ptr<Route> dest, boost::shared_ptr<Processor> before, boost::shared_ptr<Route> sender)
3185 if (sender->is_monitor() || sender->is_master() || sender == dest || dest->is_monitor() || dest->is_master()) {
3189 if (!dest->internal_return()) {
3190 dest->add_internal_return ();
3193 sender->add_aux_send (dest, before);
3200 Session::remove_routes (boost::shared_ptr<RouteList> routes_to_remove)
3202 { // RCU Writer scope
3203 RCUWriter<RouteList> writer (routes);
3204 boost::shared_ptr<RouteList> rs = writer.get_copy ();
3207 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3209 if (*iter == _master_out) {
3213 (*iter)->set_solo (false, this);
3217 /* deleting the master out seems like a dumb
3218 idea, but its more of a UI policy issue
3222 if (*iter == _master_out) {
3223 _master_out = boost::shared_ptr<Route> ();
3226 if (*iter == _monitor_out) {
3227 _monitor_out.reset ();
3230 update_route_solo_state ();
3232 // We need to disconnect the route's inputs and outputs
3234 (*iter)->input()->disconnect (0);
3235 (*iter)->output()->disconnect (0);
3237 /* if the route had internal sends sending to it, remove them */
3238 if ((*iter)->internal_return()) {
3240 boost::shared_ptr<RouteList> r = routes.reader ();
3241 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3242 boost::shared_ptr<Send> s = (*i)->internal_send_for (*iter);
3244 (*i)->remove_processor (s);
3249 /* if the monitoring section had a pointer to this route, remove it */
3250 if (_monitor_out && !(*iter)->is_master() && !(*iter)->is_monitor()) {
3251 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3252 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
3253 (*iter)->remove_aux_or_listen (_monitor_out);
3256 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*iter);
3257 if (mt && mt->step_editing()) {
3258 if (_step_editors > 0) {
3263 RouteAddedOrRemoved (false); /* EMIT SIGNAL */
3266 /* writer goes out of scope, forces route list update */
3268 } // end of RCU Writer scope
3270 update_latency_compensation ();
3273 /* Re-sort routes to remove the graph's current references to the one that is
3274 * going away, then flush old references out of the graph.
3275 * Wave Tracks: reconnect routes
3278 #ifdef USE_TRACKS_CODE_FEATURES
3279 reconnect_existing_routes(true, false);
3284 if (_process_graph) {
3285 _process_graph->clear_other_chain ();
3288 /* get rid of it from the dead wood collection in the route list manager */
3289 /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
3293 /* try to cause everyone to drop their references
3294 * and unregister ports from the backend
3296 PBD::Unwinder<bool> uw_flag (_route_deletion_in_progress, true);
3298 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3299 (*iter)->drop_references ();
3302 Route::RemoteControlIDChange(); /* EMIT SIGNAL */
3304 /* save the new state of the world */
3306 if (save_state (_current_snapshot_name)) {
3307 save_history (_current_snapshot_name);
3310 reassign_track_numbers();
3311 update_route_record_state ();
3315 Session::remove_route (boost::shared_ptr<Route> route)
3317 boost::shared_ptr<RouteList> rl (new RouteList);
3318 rl->push_back (route);
3323 Session::route_mute_changed (void* /*src*/)
3329 Session::route_listen_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
3331 boost::shared_ptr<Route> route = wpr.lock();
3333 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
3337 if (route->listening_via_monitor ()) {
3339 if (Config->get_exclusive_solo()) {
3340 /* new listen: disable all other listen */
3341 boost::shared_ptr<RouteList> r = routes.reader ();
3342 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3343 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3346 (*i)->set_listen (false, this);
3352 } else if (_listen_cnt > 0) {
3357 update_route_solo_state ();
3360 Session::route_solo_isolated_changed (void* /*src*/, boost::weak_ptr<Route> wpr)
3362 boost::shared_ptr<Route> route = wpr.lock ();
3365 /* should not happen */
3366 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
3370 bool send_changed = false;
3372 if (route->solo_isolated()) {
3373 if (_solo_isolated_cnt == 0) {
3374 send_changed = true;
3376 _solo_isolated_cnt++;
3377 } else if (_solo_isolated_cnt > 0) {
3378 _solo_isolated_cnt--;
3379 if (_solo_isolated_cnt == 0) {
3380 send_changed = true;
3385 IsolatedChanged (); /* EMIT SIGNAL */
3390 Session::route_solo_changed (bool self_solo_change, void* /*src*/, boost::weak_ptr<Route> wpr)
3392 DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1\n", self_solo_change));
3394 if (!self_solo_change) {
3395 // session doesn't care about changes to soloed-by-others
3399 if (solo_update_disabled) {
3401 DEBUG_TRACE (DEBUG::Solo, "solo update disabled - changed ignored\n");
3405 boost::shared_ptr<Route> route = wpr.lock ();
3408 boost::shared_ptr<RouteList> r = routes.reader ();
3411 if (route->self_soloed()) {
3417 RouteGroup* rg = route->route_group ();
3418 bool leave_group_alone = (rg && rg->is_active() && rg->is_solo());
3420 if (delta == 1 && Config->get_exclusive_solo()) {
3422 /* new solo: disable all other solos, but not the group if its solo-enabled */
3424 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3425 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
3426 (leave_group_alone && ((*i)->route_group() == rg))) {
3429 (*i)->set_solo (false, this);
3433 DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
3435 solo_update_disabled = true;
3437 RouteList uninvolved;
3439 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
3441 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3442 bool via_sends_only;
3443 bool in_signal_flow;
3445 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner() ||
3446 (leave_group_alone && ((*i)->route_group() == rg))) {
3450 in_signal_flow = false;
3452 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
3454 if ((*i)->feeds (route, &via_sends_only)) {
3455 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
3456 if (!via_sends_only) {
3457 if (!route->soloed_by_others_upstream()) {
3458 (*i)->mod_solo_by_others_downstream (delta);
3461 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
3463 in_signal_flow = true;
3465 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
3468 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
3470 if (route->feeds (*i, &via_sends_only)) {
3471 /* propagate solo upstream only if routing other than
3472 sends is involved, but do consider the other route
3473 (*i) to be part of the signal flow even if only
3476 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
3480 route->soloed_by_others_downstream(),
3481 route->soloed_by_others_upstream()));
3482 if (!via_sends_only) {
3483 if (!route->soloed_by_others_downstream()) {
3484 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
3485 (*i)->mod_solo_by_others_upstream (delta);
3487 DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others downstream\n");
3490 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
3492 in_signal_flow = true;
3494 DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
3497 if (!in_signal_flow) {
3498 uninvolved.push_back (*i);
3502 solo_update_disabled = false;
3503 DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
3505 update_route_solo_state (r);
3507 /* now notify that the mute state of the routes not involved in the signal
3508 pathway of the just-solo-changed route may have altered.
3511 for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
3512 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
3513 (*i)->act_on_mute ();
3514 (*i)->mute_changed (this);
3517 SoloChanged (); /* EMIT SIGNAL */
3522 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
3524 /* now figure out if anything that matters is soloed (or is "listening")*/
3526 bool something_soloed = false;
3527 uint32_t listeners = 0;
3528 uint32_t isolated = 0;
3531 r = routes.reader();
3534 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3535 if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner() && (*i)->self_soloed()) {
3536 something_soloed = true;
3539 if (!(*i)->is_auditioner() && (*i)->listening_via_monitor()) {
3540 if (Config->get_solo_control_is_listen_control()) {
3543 (*i)->set_listen (false, this);
3547 if ((*i)->solo_isolated()) {
3552 if (something_soloed != _non_soloed_outs_muted) {
3553 _non_soloed_outs_muted = something_soloed;
3554 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
3557 _listen_cnt = listeners;
3559 if (isolated != _solo_isolated_cnt) {
3560 _solo_isolated_cnt = isolated;
3561 IsolatedChanged (); /* EMIT SIGNAL */
3564 DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
3565 something_soloed, listeners, isolated));
3568 boost::shared_ptr<RouteList>
3569 Session::get_routes_with_internal_returns() const
3571 boost::shared_ptr<RouteList> r = routes.reader ();
3572 boost::shared_ptr<RouteList> rl (new RouteList);
3574 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3575 if ((*i)->internal_return ()) {
3583 Session::io_name_is_legal (const std::string& name)
3585 boost::shared_ptr<RouteList> r = routes.reader ();
3587 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3588 if ((*i)->name() == name) {
3592 if ((*i)->has_io_processor_named (name)) {
3601 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
3604 vector<string> connections;
3606 /* if we are passed only a single route and we're not told to turn
3607 * others off, then just do the simple thing.
3610 if (flip_others == false && rl->size() == 1) {
3611 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
3613 mt->set_input_active (onoff);
3618 for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
3620 PortSet& ps ((*rt)->input()->ports());
3622 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
3623 p->get_connections (connections);
3626 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
3627 routes_using_input_from (*s, rl2);
3630 /* scan all relevant routes to see if others are on or off */
3632 bool others_are_already_on = false;
3634 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
3636 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
3642 if ((*r) != (*rt)) {
3643 if (mt->input_active()) {
3644 others_are_already_on = true;
3647 /* this one needs changing */
3648 mt->set_input_active (onoff);
3654 /* globally reverse other routes */
3656 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
3657 if ((*r) != (*rt)) {
3658 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
3660 mt->set_input_active (!others_are_already_on);
3669 Session::routes_using_input_from (const string& str, RouteList& rl)
3671 boost::shared_ptr<RouteList> r = routes.reader();
3673 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3674 if ((*i)->input()->connected_to (str)) {
3680 boost::shared_ptr<Route>
3681 Session::route_by_name (string name)
3683 boost::shared_ptr<RouteList> r = routes.reader ();
3685 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3686 if ((*i)->name() == name) {
3691 return boost::shared_ptr<Route> ((Route*) 0);
3694 boost::shared_ptr<Route>
3695 Session::route_by_id (PBD::ID id)
3697 boost::shared_ptr<RouteList> r = routes.reader ();
3699 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3700 if ((*i)->id() == id) {
3705 return boost::shared_ptr<Route> ((Route*) 0);
3708 boost::shared_ptr<Track>
3709 Session::track_by_diskstream_id (PBD::ID id)
3711 boost::shared_ptr<RouteList> r = routes.reader ();
3713 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3714 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
3715 if (t && t->using_diskstream_id (id)) {
3720 return boost::shared_ptr<Track> ();
3723 boost::shared_ptr<Route>
3724 Session::route_by_remote_id (uint32_t id)
3726 boost::shared_ptr<RouteList> r = routes.reader ();
3728 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3729 if ((*i)->remote_control_id() == id) {
3734 return boost::shared_ptr<Route> ((Route*) 0);
3739 Session::reassign_track_numbers ()
3743 RouteList r (*(routes.reader ()));
3744 SignalOrderRouteSorter sorter;
3747 StateProtector sp (this);
3749 for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
3750 if (boost::dynamic_pointer_cast<Track> (*i)) {
3751 (*i)->set_track_number(++tn);
3753 else if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner()) {
3754 (*i)->set_track_number(--bn);
3757 const uint32_t decimals = ceilf (log10f (tn + 1));
3758 const bool decimals_changed = _track_number_decimals != decimals;
3759 _track_number_decimals = decimals;
3761 if (decimals_changed && config.get_track_name_number ()) {
3762 for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
3763 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
3765 t->resync_track_name();
3768 // trigger GUI re-layout
3769 config.ParameterChanged("track-name-number");
3774 Session::playlist_region_added (boost::weak_ptr<Region> w)
3776 boost::shared_ptr<Region> r = w.lock ();
3781 /* These are the operations that are currently in progress... */
3782 list<GQuark> curr = _current_trans_quarks;
3785 /* ...and these are the operations during which we want to update
3786 the session range location markers.
3789 ops.push_back (Operations::capture);
3790 ops.push_back (Operations::paste);
3791 ops.push_back (Operations::duplicate_region);
3792 ops.push_back (Operations::insert_file);
3793 ops.push_back (Operations::insert_region);
3794 ops.push_back (Operations::drag_region_brush);
3795 ops.push_back (Operations::region_drag);
3796 ops.push_back (Operations::selection_grab);
3797 ops.push_back (Operations::region_fill);
3798 ops.push_back (Operations::fill_selection);
3799 ops.push_back (Operations::create_region);
3800 ops.push_back (Operations::region_copy);
3801 ops.push_back (Operations::fixed_time_region_copy);
3804 /* See if any of the current operations match the ones that we want */
3806 set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
3808 /* If so, update the session range markers */
3810 maybe_update_session_range (r->position (), r->last_frame ());
3814 /** Update the session range markers if a is before the current start or
3815 * b is after the current end.
3818 Session::maybe_update_session_range (framepos_t a, framepos_t b)
3820 if (_state_of_the_state & Loading) {
3824 if (_session_range_location == 0) {
3826 add_session_range_location (a, b);
3830 if (a < _session_range_location->start()) {
3831 _session_range_location->set_start (a);
3834 if (b > _session_range_location->end()) {
3835 _session_range_location->set_end (b);
3841 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
3843 for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
3844 maybe_update_session_range (i->to, i->to + i->length);
3849 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
3851 for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
3852 maybe_update_session_range (i->from, i->to);
3856 /* Region management */
3858 boost::shared_ptr<Region>
3859 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
3861 const RegionFactory::RegionMap& regions (RegionFactory::regions());
3862 RegionFactory::RegionMap::const_iterator i;
3863 boost::shared_ptr<Region> region;
3865 Glib::Threads::Mutex::Lock lm (region_lock);
3867 for (i = regions.begin(); i != regions.end(); ++i) {
3871 if (region->whole_file()) {
3873 if (child->source_equivalent (region)) {
3879 return boost::shared_ptr<Region> ();
3883 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
3885 set<boost::shared_ptr<Region> > relevant_regions;
3887 for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
3888 RegionFactory::get_regions_using_source (*s, relevant_regions);
3891 for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
3892 set<boost::shared_ptr<Region> >::iterator tmp;
3897 playlists->destroy_region (*r);
3898 RegionFactory::map_remove (*r);
3900 (*r)->drop_sources ();
3901 (*r)->drop_references ();
3903 relevant_regions.erase (r);
3908 for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
3911 Glib::Threads::Mutex::Lock ls (source_lock);
3912 /* remove from the main source list */
3913 sources.erase ((*s)->id());
3916 (*s)->mark_for_remove ();
3917 (*s)->drop_references ();
3926 Session::remove_last_capture ()
3928 list<boost::shared_ptr<Source> > srcs;
3930 boost::shared_ptr<RouteList> rl = routes.reader ();
3931 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
3932 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
3937 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
3940 srcs.insert (srcs.end(), l.begin(), l.end());
3945 destroy_sources (srcs);
3947 save_state (_current_snapshot_name);
3952 /* Source Management */
3955 Session::add_source (boost::shared_ptr<Source> source)
3957 pair<SourceMap::key_type, SourceMap::mapped_type> entry;
3958 pair<SourceMap::iterator,bool> result;
3960 entry.first = source->id();
3961 entry.second = source;
3964 Glib::Threads::Mutex::Lock lm (source_lock);
3965 result = sources.insert (entry);
3968 if (result.second) {
3970 /* yay, new source */
3972 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
3975 if (!fs->within_session()) {
3976 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
3982 boost::shared_ptr<AudioFileSource> afs;
3984 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
3985 if (Config->get_auto_analyse_audio()) {
3986 Analyser::queue_source_for_analysis (source, false);
3990 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
3995 Session::remove_source (boost::weak_ptr<Source> src)
3997 if (_state_of_the_state & Deletion) {
4001 SourceMap::iterator i;
4002 boost::shared_ptr<Source> source = src.lock();
4009 Glib::Threads::Mutex::Lock lm (source_lock);
4011 if ((i = sources.find (source->id())) != sources.end()) {
4016 if (!(_state_of_the_state & StateOfTheState (InCleanup|Loading))) {
4018 /* save state so we don't end up with a session file
4019 referring to non-existent sources.
4022 save_state (_current_snapshot_name);
4026 boost::shared_ptr<Source>
4027 Session::source_by_id (const PBD::ID& id)
4029 Glib::Threads::Mutex::Lock lm (source_lock);
4030 SourceMap::iterator i;
4031 boost::shared_ptr<Source> source;
4033 if ((i = sources.find (id)) != sources.end()) {
4040 boost::shared_ptr<AudioFileSource>
4041 Session::audio_source_by_path_and_channel (const string& path, uint16_t chn) const
4043 /* Restricted to audio files because only audio sources have channel
4047 Glib::Threads::Mutex::Lock lm (source_lock);
4049 for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
4050 boost::shared_ptr<AudioFileSource> afs
4051 = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
4053 if (afs && afs->path() == path && chn == afs->channel()) {
4058 return boost::shared_ptr<AudioFileSource>();
4061 boost::shared_ptr<MidiSource>
4062 Session::midi_source_by_path (const std::string& path) const
4064 /* Restricted to MIDI files because audio sources require a channel
4065 for unique identification, in addition to a path.
4068 Glib::Threads::Mutex::Lock lm (source_lock);
4070 for (SourceMap::const_iterator s = sources.begin(); s != sources.end(); ++s) {
4071 boost::shared_ptr<MidiSource> ms
4072 = boost::dynamic_pointer_cast<MidiSource>(s->second);
4073 boost::shared_ptr<FileSource> fs
4074 = boost::dynamic_pointer_cast<FileSource>(s->second);
4076 if (ms && fs && fs->path() == path) {
4081 return boost::shared_ptr<MidiSource>();
4085 Session::count_sources_by_origin (const string& path)
4088 Glib::Threads::Mutex::Lock lm (source_lock);
4090 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
4091 boost::shared_ptr<FileSource> fs
4092 = boost::dynamic_pointer_cast<FileSource>(i->second);
4094 if (fs && fs->origin() == path) {
4103 Session::peak_path (string base) const
4105 if (Glib::path_is_absolute (base)) {
4107 /* rip the session dir from the audiofile source */
4109 string session_path;
4110 string interchange_dir_string = string (interchange_dir_name) + G_DIR_SEPARATOR;
4111 bool in_another_session = true;
4113 if (base.find (interchange_dir_string) != string::npos) {
4115 session_path = Glib::path_get_dirname (base); /* now ends in audiofiles */
4116 session_path = Glib::path_get_dirname (session_path); /* now ends in session name */
4117 session_path = Glib::path_get_dirname (session_path); /* now ends in interchange */
4118 session_path = Glib::path_get_dirname (session_path); /* now has session path */
4120 /* see if it is within our session */
4122 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4123 if (i->path == session_path) {
4124 in_another_session = false;
4129 in_another_session = false;
4133 if (in_another_session) {
4134 SessionDirectory sd (session_path);
4135 return Glib::build_filename (sd.peak_path(), Glib::path_get_basename (base) + peakfile_suffix);
4139 base = Glib::path_get_basename (base);
4140 return Glib::build_filename (_session_dir->peak_path(), base + peakfile_suffix);
4144 Session::new_audio_source_path_for_embedded (const std::string& path)
4148 * we know that the filename is already unique because it exists
4149 * out in the filesystem.
4151 * However, when we bring it into the session, we could get a
4154 * Eg. two embedded files:
4159 * When merged into session, these collide.
4161 * There will not be a conflict with in-memory sources
4162 * because when the source was created we already picked
4163 * a unique name for it.
4165 * This collision is not likely to be common, but we have to guard
4166 * against it. So, if there is a collision, take the md5 hash of the
4167 * the path, and use that as the filename instead.
4170 SessionDirectory sdir (get_best_session_directory_for_new_audio());
4171 string base = Glib::path_get_basename (path);
4172 string newpath = Glib::build_filename (sdir.sound_path(), base);
4174 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
4178 md5.digestString (path.c_str());
4179 md5.writeToString ();
4180 base = md5.digestChars;
4182 string ext = get_suffix (path);
4189 newpath = Glib::build_filename (sdir.sound_path(), base);
4191 /* if this collides, we're screwed */
4193 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
4194 error << string_compose (_("Merging embedded file %1: name collision AND md5 hash collision!"), path) << endmsg;
4203 /** Return true if there are no audio file sources that use @param name as
4204 * the filename component of their path.
4206 * Return false otherwise.
4208 * This method MUST ONLY be used to check in-session, mono files since it
4209 * hard-codes the channel of the audio file source we are looking for as zero.
4211 * If/when Ardour supports native files in non-mono formats, the logic here
4212 * will need to be revisited.
4215 Session::audio_source_name_is_unique (const string& name)
4217 std::vector<string> sdirs = source_search_path (DataType::AUDIO);
4218 vector<space_and_path>::iterator i;
4219 uint32_t existing = 0;
4221 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
4223 /* note that we search *without* the extension so that
4224 we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
4225 in the event that this new name is required for
4226 a file format change.
4229 const string spath = *i;
4231 if (matching_unsuffixed_filename_exists_in (spath, name)) {
4236 /* it is possible that we have the path already
4237 * assigned to a source that has not yet been written
4238 * (ie. the write source for a diskstream). we have to
4239 * check this in order to make sure that our candidate
4240 * path isn't used again, because that can lead to
4241 * two Sources point to the same file with different
4242 * notions of their removability.
4246 string possible_path = Glib::build_filename (spath, name);
4248 if (audio_source_by_path_and_channel (possible_path, 0)) {
4254 return (existing == 0);
4258 Session::format_audio_source_name (const string& legalized_base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required, uint32_t cnt, bool related_exists)
4261 const string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
4265 sstr << setfill ('0') << setw (4) << cnt;
4266 sstr << legalized_base;
4268 sstr << legalized_base;
4270 if (take_required || related_exists) {
4282 } else if (nchan > 2) {
4287 /* XXX what? more than 26 channels! */
4298 /** Return a unique name based on \a base for a new internal audio source */
4300 Session::new_audio_source_path (const string& base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required)
4303 string possible_name;
4304 const uint32_t limit = 9999; // arbitrary limit on number of files with the same basic name
4306 bool some_related_source_name_exists = false;
4308 legalized = legalize_for_path (base);
4310 // Find a "version" of the base name that doesn't exist in any of the possible directories.
4312 for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
4314 possible_name = format_audio_source_name (legalized, nchan, chan, destructive, take_required, cnt, some_related_source_name_exists);
4316 if (audio_source_name_is_unique (possible_name)) {
4320 some_related_source_name_exists = true;
4323 error << string_compose(
4324 _("There are already %1 recordings for %2, which I consider too many."),
4325 limit, base) << endmsg;
4327 throw failed_constructor();
4331 /* We've established that the new name does not exist in any session
4332 * directory, so now find out which one we should use for this new
4336 SessionDirectory sdir (get_best_session_directory_for_new_audio());
4338 std::string s = Glib::build_filename (sdir.sound_path(), possible_name);
4343 /** Return a unique name based on `base` for a new internal MIDI source */
4345 Session::new_midi_source_path (const string& base)
4348 char buf[PATH_MAX+1];
4349 const uint32_t limit = 10000;
4351 string possible_path;
4352 string possible_name;
4355 legalized = legalize_for_path (base);
4357 // Find a "version" of the file name that doesn't exist in any of the possible directories.
4358 std::vector<string> sdirs = source_search_path(DataType::MIDI);
4360 /* - the main session folder is the first in the vector.
4361 * - after checking all locations for file-name uniqueness,
4362 * we keep the one from the last iteration as new file name
4363 * - midi files are small and should just be kept in the main session-folder
4365 * -> reverse the array, check main session folder last and use that as location
4368 std::reverse(sdirs.begin(), sdirs.end());
4370 for (cnt = 1; cnt <= limit; ++cnt) {
4372 vector<space_and_path>::iterator i;
4373 uint32_t existing = 0;
4375 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
4377 snprintf (buf, sizeof(buf), "%s-%u.mid", legalized.c_str(), cnt);
4378 possible_name = buf;
4380 possible_path = Glib::build_filename (*i, possible_name);
4382 if (Glib::file_test (possible_path, Glib::FILE_TEST_EXISTS)) {
4386 if (midi_source_by_path (possible_path)) {
4391 if (existing == 0) {
4396 error << string_compose(
4397 _("There are already %1 recordings for %2, which I consider too many."),
4398 limit, base) << endmsg;
4404 /* No need to "find best location" for software/app-based RAID, because
4405 MIDI is so small that we always put it in the same place.
4408 return possible_path;
4412 /** Create a new within-session audio source */
4413 boost::shared_ptr<AudioFileSource>
4414 Session::create_audio_source_for_session (size_t n_chans, string const & base, uint32_t chan, bool destructive)
4416 const string path = new_audio_source_path (base, n_chans, chan, destructive, true);
4418 if (!path.empty()) {
4419 return boost::dynamic_pointer_cast<AudioFileSource> (
4420 SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate()));
4422 throw failed_constructor ();
4426 /** Create a new within-session MIDI source */
4427 boost::shared_ptr<MidiSource>
4428 Session::create_midi_source_for_session (string const & basic_name)
4430 const string path = new_midi_source_path (basic_name);
4432 if (!path.empty()) {
4433 return boost::dynamic_pointer_cast<SMFSource> (
4434 SourceFactory::createWritable (
4435 DataType::MIDI, *this, path, false, frame_rate()));
4437 throw failed_constructor ();
4441 /** Create a new within-session MIDI source */
4442 boost::shared_ptr<MidiSource>
4443 Session::create_midi_source_by_stealing_name (boost::shared_ptr<Track> track)
4445 /* the caller passes in the track the source will be used in,
4446 so that we can keep the numbering sane.
4448 Rationale: a track with the name "Foo" that has had N
4449 captures carried out so far will ALREADY have a write source
4450 named "Foo-N+1.mid" waiting to be used for the next capture.
4452 If we call new_midi_source_name() we will get "Foo-N+2". But
4453 there is no region corresponding to "Foo-N+1", so when
4454 "Foo-N+2" appears in the track, the gap presents the user
4455 with odd behaviour - why did it skip past Foo-N+1?
4457 We could explain this to the user in some odd way, but
4458 instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
4461 If that attempted rename fails, we get "Foo-N+2.mid" anyway.
4464 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (track);
4466 std::string name = track->steal_write_source_name ();
4469 return boost::shared_ptr<MidiSource>();
4472 /* MIDI files are small, just put them in the first location of the
4473 session source search path.
4476 const string path = Glib::build_filename (source_search_path (DataType::MIDI).front(), name);
4478 return boost::dynamic_pointer_cast<SMFSource> (
4479 SourceFactory::createWritable (
4480 DataType::MIDI, *this, path, false, frame_rate()));
4485 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
4487 if (playlist->hidden()) {
4491 playlists->add (playlist);
4494 playlist->release();
4501 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
4503 if (_state_of_the_state & Deletion) {
4507 boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
4513 playlists->remove (playlist);
4519 Session::set_audition (boost::shared_ptr<Region> r)
4521 pending_audition_region = r;
4522 add_post_transport_work (PostTransportAudition);
4523 _butler->schedule_transport_work ();
4527 Session::audition_playlist ()
4529 SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
4530 ev->region.reset ();
4535 Session::non_realtime_set_audition ()
4537 assert (pending_audition_region);
4538 auditioner->audition_region (pending_audition_region);
4539 pending_audition_region.reset ();
4540 AuditionActive (true); /* EMIT SIGNAL */
4544 Session::audition_region (boost::shared_ptr<Region> r)
4546 SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
4552 Session::cancel_audition ()
4557 if (auditioner->auditioning()) {
4558 auditioner->cancel_audition ();
4559 AuditionActive (false); /* EMIT SIGNAL */
4564 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
4566 if (a->is_monitor()) {
4569 if (b->is_monitor()) {
4572 return a->order_key () < b->order_key ();
4576 Session::is_auditioning () const
4578 /* can be called before we have an auditioner object */
4580 return auditioner->auditioning();
4587 Session::graph_reordered ()
4589 /* don't do this stuff if we are setting up connections
4590 from a set_state() call or creating new tracks. Ditto for deletion.
4593 if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _reconnecting_routes_in_progress) {
4597 /* every track/bus asked for this to be handled but it was deferred because
4598 we were connecting. do it now.
4601 request_input_change_handling ();
4605 /* force all diskstreams to update their capture offset values to
4606 reflect any changes in latencies within the graph.
4609 boost::shared_ptr<RouteList> rl = routes.reader ();
4610 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4611 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4613 tr->set_capture_offset ();
4618 /** @return Number of frames that there is disk space available to write,
4621 boost::optional<framecnt_t>
4622 Session::available_capture_duration ()
4624 Glib::Threads::Mutex::Lock lm (space_lock);
4626 if (_total_free_4k_blocks_uncertain) {
4627 return boost::optional<framecnt_t> ();
4630 float sample_bytes_on_disk = 4.0; // keep gcc happy
4632 switch (config.get_native_file_data_format()) {
4634 sample_bytes_on_disk = 4.0;
4638 sample_bytes_on_disk = 3.0;
4642 sample_bytes_on_disk = 2.0;
4646 /* impossible, but keep some gcc versions happy */
4647 fatal << string_compose (_("programming error: %1"),
4648 X_("illegal native file data format"))
4650 abort(); /*NOTREACHED*/
4653 double scale = 4096.0 / sample_bytes_on_disk;
4655 if (_total_free_4k_blocks * scale > (double) max_framecnt) {
4656 return max_framecnt;
4659 return (framecnt_t) floor (_total_free_4k_blocks * scale);
4663 Session::add_bundle (boost::shared_ptr<Bundle> bundle, bool emit_signal)
4666 RCUWriter<BundleList> writer (_bundles);
4667 boost::shared_ptr<BundleList> b = writer.get_copy ();
4668 b->push_back (bundle);
4672 BundleAddedOrRemoved (); /* EMIT SIGNAL */
4679 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
4681 bool removed = false;
4684 RCUWriter<BundleList> writer (_bundles);
4685 boost::shared_ptr<BundleList> b = writer.get_copy ();
4686 BundleList::iterator i = find (b->begin(), b->end(), bundle);
4688 if (i != b->end()) {
4695 BundleAddedOrRemoved (); /* EMIT SIGNAL */
4701 boost::shared_ptr<Bundle>
4702 Session::bundle_by_name (string name) const
4704 boost::shared_ptr<BundleList> b = _bundles.reader ();
4706 for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
4707 if ((*i)->name() == name) {
4712 return boost::shared_ptr<Bundle> ();
4716 Session::tempo_map_changed (const PropertyChange&)
4720 playlists->update_after_tempo_map_change ();
4722 _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
4728 Session::update_locations_after_tempo_map_change (const Locations::LocationList& loc)
4730 for (Locations::LocationList::const_iterator i = loc.begin(); i != loc.end(); ++i) {
4731 (*i)->recompute_frames_from_bbt ();
4735 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
4736 * the given count with the current block size.
4739 Session::ensure_buffers (ChanCount howmany)
4741 BufferManager::ensure_buffers (howmany, bounce_processing() ? bounce_chunk_size : 0);
4745 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
4747 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
4748 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
4753 Session::next_insert_id ()
4755 /* this doesn't really loop forever. just think about it */
4758 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < insert_bitset.size(); ++n) {
4759 if (!insert_bitset[n]) {
4760 insert_bitset[n] = true;
4766 /* none available, so resize and try again */
4768 insert_bitset.resize (insert_bitset.size() + 16, false);
4773 Session::next_send_id ()
4775 /* this doesn't really loop forever. just think about it */
4778 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < send_bitset.size(); ++n) {
4779 if (!send_bitset[n]) {
4780 send_bitset[n] = true;
4786 /* none available, so resize and try again */
4788 send_bitset.resize (send_bitset.size() + 16, false);
4793 Session::next_aux_send_id ()
4795 /* this doesn't really loop forever. just think about it */
4798 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < aux_send_bitset.size(); ++n) {
4799 if (!aux_send_bitset[n]) {
4800 aux_send_bitset[n] = true;
4806 /* none available, so resize and try again */
4808 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
4813 Session::next_return_id ()
4815 /* this doesn't really loop forever. just think about it */
4818 for (boost::dynamic_bitset<uint32_t>::size_type n = 0; n < return_bitset.size(); ++n) {
4819 if (!return_bitset[n]) {
4820 return_bitset[n] = true;
4826 /* none available, so resize and try again */
4828 return_bitset.resize (return_bitset.size() + 16, false);
4833 Session::mark_send_id (uint32_t id)
4835 if (id >= send_bitset.size()) {
4836 send_bitset.resize (id+16, false);
4838 if (send_bitset[id]) {
4839 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
4841 send_bitset[id] = true;
4845 Session::mark_aux_send_id (uint32_t id)
4847 if (id >= aux_send_bitset.size()) {
4848 aux_send_bitset.resize (id+16, false);
4850 if (aux_send_bitset[id]) {
4851 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
4853 aux_send_bitset[id] = true;
4857 Session::mark_return_id (uint32_t id)
4859 if (id >= return_bitset.size()) {
4860 return_bitset.resize (id+16, false);
4862 if (return_bitset[id]) {
4863 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
4865 return_bitset[id] = true;
4869 Session::mark_insert_id (uint32_t id)
4871 if (id >= insert_bitset.size()) {
4872 insert_bitset.resize (id+16, false);
4874 if (insert_bitset[id]) {
4875 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
4877 insert_bitset[id] = true;
4881 Session::unmark_send_id (uint32_t id)
4883 if (id < send_bitset.size()) {
4884 send_bitset[id] = false;
4889 Session::unmark_aux_send_id (uint32_t id)
4891 if (id < aux_send_bitset.size()) {
4892 aux_send_bitset[id] = false;
4897 Session::unmark_return_id (uint32_t id)
4899 if (id < return_bitset.size()) {
4900 return_bitset[id] = false;
4905 Session::unmark_insert_id (uint32_t id)
4907 if (id < insert_bitset.size()) {
4908 insert_bitset[id] = false;
4913 Session::reset_native_file_format ()
4915 boost::shared_ptr<RouteList> rl = routes.reader ();
4916 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4917 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4919 /* don't save state as we do this, there's no point
4922 _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
4923 tr->reset_write_sources (false);
4924 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
4930 Session::route_name_unique (string n) const
4932 boost::shared_ptr<RouteList> r = routes.reader ();
4934 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
4935 if ((*i)->name() == n) {
4944 Session::route_name_internal (string n) const
4946 if (auditioner && auditioner->name() == n) {
4950 if (_click_io && _click_io->name() == n) {
4958 Session::freeze_all (InterThreadInfo& itt)
4960 boost::shared_ptr<RouteList> r = routes.reader ();
4962 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4964 boost::shared_ptr<Track> t;
4966 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
4967 /* XXX this is wrong because itt.progress will keep returning to zero at the start
4977 boost::shared_ptr<Region>
4978 Session::write_one_track (Track& track, framepos_t start, framepos_t end,
4979 bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
4980 InterThreadInfo& itt,
4981 boost::shared_ptr<Processor> endpoint, bool include_endpoint,
4982 bool for_export, bool for_freeze)
4984 boost::shared_ptr<Region> result;
4985 boost::shared_ptr<Playlist> playlist;
4986 boost::shared_ptr<Source> source;
4987 ChanCount diskstream_channels (track.n_channels());
4988 framepos_t position;
4989 framecnt_t this_chunk;
4991 framepos_t latency_skip;
4993 framepos_t len = end - start;
4994 bool need_block_size_reset = false;
4995 ChanCount const max_proc = track.max_processor_streams ();
4996 string legal_playlist_name;
4997 string possible_path;
5000 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
5001 end, start) << endmsg;
5005 diskstream_channels = track.bounce_get_output_streams (diskstream_channels, endpoint,
5006 include_endpoint, for_export, for_freeze);
5008 if (diskstream_channels.n(track.data_type()) < 1) {
5009 error << _("Cannot write a range with no data.") << endmsg;
5013 // block all process callback handling
5015 block_processing ();
5018 // synchronize with AudioEngine::process_callback()
5019 // make sure processing is not currently running
5020 // and processing_blocked() is honored before
5021 // acquiring thread buffers
5022 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
5025 _bounce_processing_active = true;
5027 /* call tree *MUST* hold route_lock */
5029 if ((playlist = track.playlist()) == 0) {
5033 legal_playlist_name = legalize_for_path (playlist->name());
5035 for (uint32_t chan_n = 0; chan_n < diskstream_channels.n(track.data_type()); ++chan_n) {
5037 string base_name = string_compose ("%1-%2-bounce", playlist->name(), chan_n);
5038 string path = ((track.data_type() == DataType::AUDIO)
5039 ? new_audio_source_path (legal_playlist_name, diskstream_channels.n_audio(), chan_n, false, true)
5040 : new_midi_source_path (legal_playlist_name));
5047 source = SourceFactory::createWritable (track.data_type(), *this, path, false, frame_rate());
5050 catch (failed_constructor& err) {
5051 error << string_compose (_("cannot create new file \"%1\" for %2"), path, track.name()) << endmsg;
5055 srcs.push_back (source);
5058 /* tell redirects that care that we are about to use a much larger
5059 * blocksize. this will flush all plugins too, so that they are ready
5060 * to be used for this process.
5063 need_block_size_reset = true;
5064 track.set_block_size (bounce_chunk_size);
5065 _engine.main_thread()->get_buffers ();
5069 latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
5071 /* create a set of reasonably-sized buffers */
5072 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
5073 buffers.ensure_buffers(*t, max_proc.get(*t), bounce_chunk_size);
5075 buffers.set_count (max_proc);
5077 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5078 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5079 boost::shared_ptr<MidiSource> ms;
5081 afs->prepare_for_peakfile_writes ();
5082 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5083 Source::Lock lock(ms->mutex());
5084 ms->mark_streaming_write_started(lock);
5088 while (to_do && !itt.cancel) {
5090 this_chunk = min (to_do, bounce_chunk_size);
5092 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze)) {
5096 start += this_chunk;
5097 to_do -= this_chunk;
5098 itt.progress = (float) (1.0 - ((double) to_do / len));
5100 if (latency_skip >= bounce_chunk_size) {
5101 latency_skip -= bounce_chunk_size;
5105 const framecnt_t current_chunk = this_chunk - latency_skip;
5108 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
5109 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5110 boost::shared_ptr<MidiSource> ms;
5113 if (afs->write (buffers.get_audio(n).data(latency_skip), current_chunk) != current_chunk) {
5116 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5117 Source::Lock lock(ms->mutex());
5119 const MidiBuffer& buf = buffers.get_midi(0);
5120 for (MidiBuffer::const_iterator i = buf.begin(); i != buf.end(); ++i) {
5121 Evoral::Event<framepos_t> ev = *i;
5122 ev.set_time(ev.time() - position);
5123 ms->append_event_frames(lock, ev, ms->timeline_position());
5130 /* post-roll, pick up delayed processor output */
5131 latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
5133 while (latency_skip && !itt.cancel) {
5134 this_chunk = min (latency_skip, bounce_chunk_size);
5135 latency_skip -= this_chunk;
5137 buffers.silence (this_chunk, 0);
5138 track.bounce_process (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze);
5141 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
5142 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5145 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
5157 xnow = localtime (&now);
5159 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
5160 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5161 boost::shared_ptr<MidiSource> ms;
5164 afs->update_header (position, *xnow, now);
5165 afs->flush_header ();
5166 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5167 Source::Lock lock(ms->mutex());
5168 ms->mark_streaming_write_completed(lock);
5172 /* construct a region to represent the bounced material */
5176 plist.add (Properties::start, 0);
5177 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
5178 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
5180 result = RegionFactory::create (srcs, plist);
5186 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5187 (*src)->mark_for_remove ();
5188 (*src)->drop_references ();
5192 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5193 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5196 afs->done_with_peakfile_writes ();
5200 _bounce_processing_active = false;
5202 if (need_block_size_reset) {
5203 _engine.main_thread()->drop_buffers ();
5204 track.set_block_size (get_block_size());
5207 unblock_processing ();
5213 Session::gain_automation_buffer() const
5215 return ProcessThread::gain_automation_buffer ();
5219 Session::trim_automation_buffer() const
5221 return ProcessThread::trim_automation_buffer ();
5225 Session::send_gain_automation_buffer() const
5227 return ProcessThread::send_gain_automation_buffer ();
5231 Session::pan_automation_buffer() const
5233 return ProcessThread::pan_automation_buffer ();
5237 Session::get_silent_buffers (ChanCount count)
5239 return ProcessThread::get_silent_buffers (count);
5243 Session::get_scratch_buffers (ChanCount count, bool silence)
5245 return ProcessThread::get_scratch_buffers (count, silence);
5249 Session::get_route_buffers (ChanCount count, bool silence)
5251 return ProcessThread::get_route_buffers (count, silence);
5256 Session::get_mix_buffers (ChanCount count)
5258 return ProcessThread::get_mix_buffers (count);
5262 Session::ntracks () const
5265 boost::shared_ptr<RouteList> r = routes.reader ();
5267 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5268 if (boost::dynamic_pointer_cast<Track> (*i)) {
5277 Session::nbusses () const
5280 boost::shared_ptr<RouteList> r = routes.reader ();
5282 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5283 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
5292 Session::add_automation_list(AutomationList *al)
5294 automation_lists[al->id()] = al;
5297 /** @return true if there is at least one record-enabled track, otherwise false */
5299 Session::have_rec_enabled_track () const
5301 return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
5305 Session::have_rec_disabled_track () const
5307 return g_atomic_int_get (const_cast<gint*>(&_have_rec_disabled_track)) == 1;
5310 /** Update the state of our rec-enabled tracks flag */
5312 Session::update_route_record_state ()
5314 boost::shared_ptr<RouteList> rl = routes.reader ();
5315 RouteList::iterator i = rl->begin();
5316 while (i != rl->end ()) {
5318 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5319 if (tr && tr->record_enabled ()) {
5326 int const old = g_atomic_int_get (&_have_rec_enabled_track);
5328 g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
5330 if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
5331 RecordStateChanged (); /* EMIT SIGNAL */
5334 for (i = rl->begin(); i != rl->end (); ++i) {
5335 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5336 if (tr && !tr->record_enabled ()) {
5341 g_atomic_int_set (&_have_rec_disabled_track, i != rl->end () ? 1 : 0);
5343 bool record_arm_state_changed = (old != g_atomic_int_get (&_have_rec_enabled_track) );
5345 if (record_status() == Recording && record_arm_state_changed ) {
5346 RecordArmStateChanged ();
5352 Session::listen_position_changed ()
5354 boost::shared_ptr<RouteList> r = routes.reader ();
5356 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5357 (*i)->listen_position_changed ();
5362 Session::solo_control_mode_changed ()
5364 /* cancel all solo or all listen when solo control mode changes */
5367 set_solo (get_routes(), false);
5368 } else if (listening()) {
5369 set_listen (get_routes(), false);
5373 /** Called when a property of one of our route groups changes */
5375 Session::route_group_property_changed (RouteGroup* rg)
5377 RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
5380 /** Called when a route is added to one of our route groups */
5382 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
5384 RouteAddedToRouteGroup (rg, r);
5387 /** Called when a route is removed from one of our route groups */
5389 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
5391 update_route_record_state ();
5392 RouteRemovedFromRouteGroup (rg, r); /* EMIT SIGNAL */
5395 boost::shared_ptr<RouteList>
5396 Session::get_tracks () const
5398 boost::shared_ptr<RouteList> rl = routes.reader ();
5399 boost::shared_ptr<RouteList> tl (new RouteList);
5401 for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
5402 if (boost::dynamic_pointer_cast<Track> (*r)) {
5403 if (!(*r)->is_auditioner()) {
5411 boost::shared_ptr<RouteList>
5412 Session::get_routes_with_regions_at (framepos_t const p) const
5414 boost::shared_ptr<RouteList> r = routes.reader ();
5415 boost::shared_ptr<RouteList> rl (new RouteList);
5417 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5418 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5423 boost::shared_ptr<Playlist> pl = tr->playlist ();
5428 if (pl->has_region_at (p)) {
5437 Session::goto_end ()
5439 if (_session_range_location) {
5440 request_locate (_session_range_location->end(), false);
5442 request_locate (0, false);
5447 Session::goto_start ()
5449 if (_session_range_location) {
5450 request_locate (_session_range_location->start(), false);
5452 request_locate (0, false);
5457 Session::current_start_frame () const
5459 return _session_range_location ? _session_range_location->start() : 0;
5463 Session::current_end_frame () const
5465 return _session_range_location ? _session_range_location->end() : 0;
5469 Session::add_session_range_location (framepos_t start, framepos_t end)
5471 _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
5472 _locations->add (_session_range_location);
5476 Session::step_edit_status_change (bool yn)
5482 send = (_step_editors == 0);
5487 send = (_step_editors == 1);
5490 if (_step_editors > 0) {
5496 StepEditStatusChange (val);
5502 Session::start_time_changed (framepos_t old)
5504 /* Update the auto loop range to match the session range
5505 (unless the auto loop range has been changed by the user)
5508 Location* s = _locations->session_range_location ();
5513 Location* l = _locations->auto_loop_location ();
5515 if (l && l->start() == old) {
5516 l->set_start (s->start(), true);
5521 Session::end_time_changed (framepos_t old)
5523 /* Update the auto loop range to match the session range
5524 (unless the auto loop range has been changed by the user)
5527 Location* s = _locations->session_range_location ();
5532 Location* l = _locations->auto_loop_location ();
5534 if (l && l->end() == old) {
5535 l->set_end (s->end(), true);
5539 std::vector<std::string>
5540 Session::source_search_path (DataType type) const
5544 if (session_dirs.size() == 1) {
5546 case DataType::AUDIO:
5547 sp.push_back (_session_dir->sound_path());
5549 case DataType::MIDI:
5550 sp.push_back (_session_dir->midi_path());
5554 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
5555 SessionDirectory sdir (i->path);
5557 case DataType::AUDIO:
5558 sp.push_back (sdir.sound_path());
5560 case DataType::MIDI:
5561 sp.push_back (sdir.midi_path());
5567 if (type == DataType::AUDIO) {
5568 const string sound_path_2X = _session_dir->sound_path_2X();
5569 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
5570 if (find (sp.begin(), sp.end(), sound_path_2X) == sp.end()) {
5571 sp.push_back (sound_path_2X);
5576 // now check the explicit (possibly user-specified) search path
5579 case DataType::AUDIO:
5580 sp += Searchpath(config.get_audio_search_path ());
5582 case DataType::MIDI:
5583 sp += Searchpath(config.get_midi_search_path ());
5591 Session::ensure_search_path_includes (const string& path, DataType type)
5600 case DataType::AUDIO:
5601 sp += Searchpath(config.get_audio_search_path ());
5603 case DataType::MIDI:
5604 sp += Searchpath (config.get_midi_search_path ());
5608 for (vector<std::string>::iterator i = sp.begin(); i != sp.end(); ++i) {
5609 /* No need to add this new directory if it has the same inode as
5610 an existing one; checking inode rather than name prevents duplicated
5611 directories when we are using symlinks.
5613 On Windows, I think we could just do if (*i == path) here.
5615 if (PBD::equivalent_paths (*i, path)) {
5623 case DataType::AUDIO:
5624 config.set_audio_search_path (sp.to_string());
5626 case DataType::MIDI:
5627 config.set_midi_search_path (sp.to_string());
5633 Session::remove_dir_from_search_path (const string& dir, DataType type)
5638 case DataType::AUDIO:
5639 sp = Searchpath(config.get_audio_search_path ());
5641 case DataType::MIDI:
5642 sp = Searchpath (config.get_midi_search_path ());
5649 case DataType::AUDIO:
5650 config.set_audio_search_path (sp.to_string());
5652 case DataType::MIDI:
5653 config.set_midi_search_path (sp.to_string());
5659 boost::shared_ptr<Speakers>
5660 Session::get_speakers()
5666 Session::unknown_processors () const
5670 boost::shared_ptr<RouteList> r = routes.reader ();
5671 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5672 list<string> t = (*i)->unknown_processors ();
5673 copy (t.begin(), t.end(), back_inserter (p));
5683 Session::update_latency (bool playback)
5685 DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
5687 if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
5691 boost::shared_ptr<RouteList> r = routes.reader ();
5692 framecnt_t max_latency = 0;
5695 /* reverse the list so that we work backwards from the last route to run to the first */
5696 RouteList* rl = routes.reader().get();
5697 r.reset (new RouteList (*rl));
5698 reverse (r->begin(), r->end());
5701 /* compute actual latency values for the given direction and store them all in per-port
5702 structures. this will also publish the same values (to JACK) so that computation of latency
5703 for routes can consistently use public latency values.
5706 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5707 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
5710 /* because we latency compensate playback, our published playback latencies should
5711 be the same for all output ports - all material played back by ardour has
5712 the same latency, whether its caused by plugins or by latency compensation. since
5713 these may differ from the values computed above, reset all playback port latencies
5717 DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
5719 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5720 (*i)->set_public_port_latencies (max_latency, playback);
5725 post_playback_latency ();
5729 post_capture_latency ();
5732 DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
5736 Session::post_playback_latency ()
5738 set_worst_playback_latency ();
5740 boost::shared_ptr<RouteList> r = routes.reader ();
5742 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5743 if (!(*i)->is_auditioner() && ((*i)->active())) {
5744 _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
5748 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5749 (*i)->set_latency_compensation (_worst_track_latency);
5754 Session::post_capture_latency ()
5756 set_worst_capture_latency ();
5758 /* reflect any changes in capture latencies into capture offsets
5761 boost::shared_ptr<RouteList> rl = routes.reader();
5762 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5763 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5765 tr->set_capture_offset ();
5771 Session::initialize_latencies ()
5774 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
5775 update_latency (false);
5776 update_latency (true);
5779 set_worst_io_latencies ();
5783 Session::set_worst_io_latencies ()
5785 set_worst_playback_latency ();
5786 set_worst_capture_latency ();
5790 Session::set_worst_playback_latency ()
5792 if (_state_of_the_state & (InitialConnecting|Deletion)) {
5796 _worst_output_latency = 0;
5798 if (!_engine.connected()) {
5802 boost::shared_ptr<RouteList> r = routes.reader ();
5804 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5805 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
5808 DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
5812 Session::set_worst_capture_latency ()
5814 if (_state_of_the_state & (InitialConnecting|Deletion)) {
5818 _worst_input_latency = 0;
5820 if (!_engine.connected()) {
5824 boost::shared_ptr<RouteList> r = routes.reader ();
5826 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5827 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
5830 DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
5834 Session::update_latency_compensation (bool force_whole_graph)
5836 bool some_track_latency_changed = false;
5838 if (_state_of_the_state & (InitialConnecting|Deletion)) {
5842 DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
5844 _worst_track_latency = 0;
5846 boost::shared_ptr<RouteList> r = routes.reader ();
5848 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5849 if (!(*i)->is_auditioner() && ((*i)->active())) {
5851 if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
5852 some_track_latency_changed = true;
5854 _worst_track_latency = max (tl, _worst_track_latency);
5858 DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
5859 (some_track_latency_changed ? "yes" : "no")));
5861 DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
5863 if (some_track_latency_changed || force_whole_graph) {
5864 _engine.update_latencies ();
5868 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5869 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5873 tr->set_capture_offset ();
5878 Session::session_name_is_legal (const string& path)
5880 char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
5882 for (int i = 0; illegal_chars[i]; ++i) {
5883 if (path.find (illegal_chars[i]) != string::npos) {
5884 return illegal_chars[i];
5892 Session::next_control_id () const
5896 /* the monitor bus remote ID is in a different
5897 * "namespace" than regular routes. its existence doesn't
5898 * affect normal (low) numbered routes.
5905 return nroutes() - subtract;
5909 Session::notify_remote_id_change ()
5911 if (deletion_in_progress()) {
5915 switch (Config->get_remote_model()) {
5917 Route::RemoteControlIDChange (); /* EMIT SIGNAL */
5923 #ifdef USE_TRACKS_CODE_FEATURES
5924 /* Waves Tracks: for Waves Tracks session it's required to reconnect their IOs
5925 * if track order has been changed by user
5927 reconnect_existing_routes(true, true);
5933 Session::sync_order_keys ()
5935 if (deletion_in_progress()) {
5939 /* tell everyone that something has happened to the sort keys
5940 and let them sync up with the change(s)
5941 this will give objects that manage the sort order keys the
5942 opportunity to keep them in sync if they wish to.
5945 DEBUG_TRACE (DEBUG::OrderKeys, "Sync Order Keys.\n");
5947 reassign_track_numbers();
5949 Route::SyncOrderKeys (); /* EMIT SIGNAL */
5951 DEBUG_TRACE (DEBUG::OrderKeys, "\tsync done\n");
5955 Session::operation_in_progress (GQuark op) const
5957 return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
5960 boost::shared_ptr<Port>
5961 Session::ltc_input_port () const
5963 return _ltc_input->nth (0);
5966 boost::shared_ptr<Port>
5967 Session::ltc_output_port () const
5969 return _ltc_output->nth (0);
5973 Session::reconnect_ltc_input ()
5977 string src = Config->get_ltc_source_port();
5979 _ltc_input->disconnect (this);
5981 if (src != _("None") && !src.empty()) {
5982 _ltc_input->nth (0)->connect (src);
5988 Session::reconnect_ltc_output ()
5993 string src = Config->get_ltc_sink_port();
5995 _ltc_output->disconnect (this);
5997 if (src != _("None") && !src.empty()) {
5998 _ltc_output->nth (0)->connect (src);