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.
26 #include <cstdio> /* sprintf(3) ... grrr */
32 #include <glibmm/threads.h>
33 #include <glibmm/miscutils.h>
34 #include <glibmm/fileutils.h>
36 #include <boost/algorithm/string/erase.hpp>
38 #include "pbd/basename.h"
39 #include "pbd/boost_debug.h"
40 #include "pbd/convert.h"
41 #include "pbd/convert.h"
42 #include "pbd/error.h"
43 #include "pbd/file_utils.h"
45 #include "pbd/pthread_utils.h"
46 #include "pbd/search_path.h"
47 #include "pbd/stacktrace.h"
48 #include "pbd/stl_delete.h"
49 #include "pbd/replace_all.h"
50 #include "pbd/unwind.h"
52 #include "ardour/amp.h"
53 #include "ardour/analyser.h"
54 #include "ardour/async_midi_port.h"
55 #include "ardour/audio_buffer.h"
56 #include "ardour/audio_diskstream.h"
57 #include "ardour/audio_port.h"
58 #include "ardour/audio_track.h"
59 #include "ardour/audioengine.h"
60 #include "ardour/audiofilesource.h"
61 #include "ardour/auditioner.h"
62 #include "ardour/buffer_manager.h"
63 #include "ardour/buffer_set.h"
64 #include "ardour/bundle.h"
65 #include "ardour/butler.h"
66 #include "ardour/click.h"
67 #include "ardour/control_protocol_manager.h"
68 #include "ardour/data_type.h"
69 #include "ardour/debug.h"
70 #include "ardour/directory_names.h"
71 #ifdef USE_TRACKS_CODE_FEATURES
72 #include "ardour/engine_state_controller.h"
74 #include "ardour/filename_extensions.h"
75 #include "ardour/gain_control.h"
76 #include "ardour/graph.h"
77 #include "ardour/luabindings.h"
78 #include "ardour/midiport_manager.h"
79 #include "ardour/scene_changer.h"
80 #include "ardour/midi_patch_manager.h"
81 #include "ardour/midi_track.h"
82 #include "ardour/midi_ui.h"
83 #include "ardour/operations.h"
84 #include "ardour/playlist.h"
85 #include "ardour/plugin.h"
86 #include "ardour/plugin_insert.h"
87 #include "ardour/process_thread.h"
88 #include "ardour/profile.h"
89 #include "ardour/rc_configuration.h"
90 #include "ardour/recent_sessions.h"
91 #include "ardour/region.h"
92 #include "ardour/region_factory.h"
93 #include "ardour/route_graph.h"
94 #include "ardour/route_group.h"
95 #include "ardour/route_sorters.h"
96 #include "ardour/send.h"
97 #include "ardour/session.h"
98 #include "ardour/session_directory.h"
99 #include "ardour/session_playlists.h"
100 #include "ardour/smf_source.h"
101 #include "ardour/source_factory.h"
102 #include "ardour/speakers.h"
103 #include "ardour/tempo.h"
104 #include "ardour/ticker.h"
105 #include "ardour/track.h"
106 #include "ardour/user_bundle.h"
107 #include "ardour/utils.h"
109 #include "midi++/port.h"
110 #include "midi++/mmc.h"
112 #include "LuaBridge/LuaBridge.h"
116 #include <glibmm/checksum.h>
125 using namespace ARDOUR;
128 bool Session::_disable_all_loaded_plugins = false;
129 bool Session::_bypass_all_loaded_plugins = false;
130 guint Session::_name_id_counter = 0;
132 PBD::Signal1<int,uint32_t> Session::AudioEngineSetupRequired;
133 PBD::Signal1<void,std::string> Session::Dialog;
134 PBD::Signal0<int> Session::AskAboutPendingState;
135 PBD::Signal2<int, framecnt_t, framecnt_t> Session::AskAboutSampleRateMismatch;
136 PBD::Signal2<void, framecnt_t, framecnt_t> Session::NotifyAboutSampleRateMismatch;
137 PBD::Signal0<void> Session::SendFeedback;
138 PBD::Signal3<int,Session*,std::string,DataType> Session::MissingFile;
140 PBD::Signal1<void, framepos_t> Session::StartTimeChanged;
141 PBD::Signal1<void, framepos_t> Session::EndTimeChanged;
142 PBD::Signal2<void,std::string, std::string> Session::Exported;
143 PBD::Signal1<int,boost::shared_ptr<Playlist> > Session::AskAboutPlaylistDeletion;
144 PBD::Signal0<void> Session::Quit;
145 PBD::Signal0<void> Session::FeedbackDetected;
146 PBD::Signal0<void> Session::SuccessfulGraphSort;
147 PBD::Signal2<void,std::string,std::string> Session::VersionMismatch;
149 const framecnt_t Session::bounce_chunk_size = 8192;
150 static void clean_up_session_event (SessionEvent* ev) { delete ev; }
151 const SessionEvent::RTeventCallback Session::rt_cleanup (clean_up_session_event);
153 // seconds should be added after the region exceeds end marker
154 #ifdef USE_TRACKS_CODE_FEATURES
155 const uint32_t Session::session_end_shift = 5;
157 const uint32_t Session::session_end_shift = 0;
160 /** @param snapshot_name Snapshot name, without .ardour suffix */
161 Session::Session (AudioEngine &eng,
162 const string& fullpath,
163 const string& snapshot_name,
164 BusProfile* bus_profile,
166 : playlists (new SessionPlaylists)
168 , process_function (&Session::process_with_events)
169 , _bounce_processing_active (false)
170 , waiting_for_sync_offset (false)
171 , _base_frame_rate (0)
172 , _nominal_frame_rate (0)
173 , _current_frame_rate (0)
174 , transport_sub_state (0)
175 , _record_status (Disabled)
176 , _transport_frame (0)
177 , _session_range_location (0)
180 , _transport_speed (0)
181 , _default_transport_speed (1.0)
182 , _last_transport_speed (0)
183 , _target_transport_speed (0.0)
184 , auto_play_legal (false)
185 , _last_slave_transport_frame (0)
186 , maximum_output_latency (0)
187 , _requested_return_frame (-1)
188 , current_block_size (0)
189 , _worst_output_latency (0)
190 , _worst_input_latency (0)
191 , _worst_track_latency (0)
192 , _have_captured (false)
193 , _non_soloed_outs_muted (false)
196 , _solo_isolated_cnt (0)
198 , _was_seamless (Config->get_seamless_loop ())
199 , _under_nsm_control (false)
201 , delta_accumulator_cnt (0)
202 , average_slave_delta (1800) // !!! why 1800 ???
204 , have_first_delta_accumulator (false)
205 , _slave_state (Stopped)
206 , _mtc_active (false)
207 , _ltc_active (false)
208 , post_export_sync (false)
209 , post_export_position (0)
211 , _export_rolling (false)
212 , _export_preroll (0)
213 , _pre_export_mmc_enabled (false)
214 , _name (snapshot_name)
216 , _send_qf_mtc (false)
217 , _pframes_since_last_mtc (0)
218 , session_midi_feedback (0)
220 , loop_changing (false)
222 , _session_dir (new SessionDirectory (fullpath))
223 , _current_snapshot_name (snapshot_name)
225 , state_was_pending (false)
226 , _state_of_the_state (StateOfTheState(CannotSave|InitialConnecting|Loading))
228 , _save_queued (false)
229 , _last_roll_location (0)
230 , _last_roll_or_reversal_location (0)
231 , _last_record_location (0)
232 , pending_locate_roll (false)
233 , pending_locate_frame (0)
234 , pending_locate_flush (false)
235 , pending_abort (false)
236 , pending_auto_loop (false)
237 , _mempool ("Session", 1048576)
238 , lua (lua_newstate (&PBD::ReallocPool::lalloc, &_mempool))
240 , _butler (new Butler (*this))
241 , _post_transport_work (0)
242 , cumulative_rf_motion (0)
244 , _locations (new Locations (*this))
245 , _ignore_skips_updates (false)
246 , _rt_thread_active (false)
247 , _rt_emit_pending (false)
248 , _ac_thread_active (false)
250 , outbound_mtc_timecode_frame (0)
251 , next_quarter_frame_to_send (-1)
252 , _frames_per_timecode_frame (0)
253 , _frames_per_hour (0)
254 , _timecode_frames_per_hour (0)
255 , last_timecode_valid (false)
256 , last_timecode_when (0)
257 , _send_timecode_update (false)
269 , ltc_timecode_offset (0)
270 , ltc_timecode_negative_offset (false)
271 , midi_control_ui (0)
273 , _all_route_group (new RouteGroup (*this, "all"))
274 , routes (new RouteList)
275 , _adding_routes_in_progress (false)
276 , _reconnecting_routes_in_progress (false)
277 , _route_deletion_in_progress (false)
278 , destructive_index (0)
279 , _track_number_decimals(1)
280 , default_fade_steepness (0)
281 , default_fade_msecs (0)
282 , _total_free_4k_blocks (0)
283 , _total_free_4k_blocks_uncertain (false)
284 , no_questions_about_missing_files (false)
287 , _bundles (new BundleList)
288 , _bundle_xml_node (0)
292 , click_emphasis_data (0)
294 , click_emphasis_length (0)
295 , _clicks_cleared (0)
296 , _play_range (false)
297 , _range_selection (-1,-1)
298 , _object_selection (-1,-1)
300 , first_file_data_format_reset (true)
301 , first_file_header_format_reset (true)
302 , have_looped (false)
303 , _have_rec_enabled_track (false)
304 , _have_rec_disabled_track (true)
306 , _suspend_timecode_transmission (0)
307 , _speakers (new Speakers)
309 , ignore_route_processor_changes (false)
317 pthread_mutex_init (&_rt_emit_mutex, 0);
318 pthread_cond_init (&_rt_emit_cond, 0);
320 pthread_mutex_init (&_auto_connect_mutex, 0);
321 pthread_cond_init (&_auto_connect_cond, 0);
323 init_name_id_counter (1); // reset for new sessions, start at 1
325 pre_engine_init (fullpath);
331 Stateful::loading_state_version = CURRENT_SESSION_FILE_VERSION;
333 #ifdef USE_TRACKS_CODE_FEATURES
334 sr = EngineStateController::instance()->get_current_sample_rate();
336 if (ensure_engine (sr, true)) {
338 throw SessionException (_("Cannot connect to audio/midi engine"));
341 // set samplerate for plugins added early
342 // e.g from templates or MB channelstrip
343 set_block_size (_engine.samples_per_cycle());
344 set_frame_rate (_engine.sample_rate());
346 if (create (mix_template, bus_profile)) {
348 throw SessionException (_("Session initialization failed"));
351 /* if a mix template was provided, then ::create() will
352 * have copied it into the session and we need to load it
353 * so that we have the state ready for ::set_state()
354 * after the engine is started.
356 * Note that we do NOT try to get the sample rate from
357 * the template at this time, though doing so would
358 * be easy if we decided this was an appropriate part
362 if (!mix_template.empty()) {
363 if (load_state (_current_snapshot_name)) {
364 throw SessionException (_("Failed to load template/snapshot state"));
366 store_recent_templates (mix_template);
369 /* load default session properties - if any */
374 if (load_state (_current_snapshot_name)) {
375 throw SessionException (_("Failed to load state"));
378 /* try to get sample rate from XML state so that we
379 * can influence the SR if we set up the audio
384 const XMLProperty* prop;
385 if ((prop = state_tree->root()->property (X_("sample-rate"))) != 0) {
386 sr = atoi (prop->value());
390 if (ensure_engine (sr, false)) {
392 throw SessionException (_("Cannot connect to audio/midi engine"));
396 if (post_engine_init ()) {
398 throw SessionException (_("Cannot configure audio/midi engine with session parameters"));
401 store_recent_sessions (_name, _path);
403 bool was_dirty = dirty();
405 _state_of_the_state = StateOfTheState (_state_of_the_state & ~Dirty);
407 Config->ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, false));
408 config.ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, true));
411 DirtyChanged (); /* EMIT SIGNAL */
414 StartTimeChanged.connect_same_thread (*this, boost::bind (&Session::start_time_changed, this, _1));
415 EndTimeChanged.connect_same_thread (*this, boost::bind (&Session::end_time_changed, this, _1));
417 emit_thread_start ();
418 auto_connect_thread_start ();
420 /* hook us up to the engine since we are now completely constructed */
422 BootMessage (_("Connect to engine"));
424 _engine.set_session (this);
425 _engine.reset_timebase ();
427 #ifdef USE_TRACKS_CODE_FEATURES
429 EngineStateController::instance()->set_session(this);
432 if ( ARDOUR::Profile->get_trx () ) {
434 /* Waves Tracks: fill session with tracks basing on the amount of inputs.
435 * each available input must have corresponding track when session starts.
438 uint32_t how_many (0);
440 std::vector<std::string> inputs;
441 EngineStateController::instance()->get_physical_audio_inputs(inputs);
443 how_many = inputs.size();
445 list<boost::shared_ptr<AudioTrack> > tracks;
447 // Track names after driver
448 if (Config->get_tracks_auto_naming() == NameAfterDriver) {
449 string track_name = "";
450 for (std::vector<string>::size_type i = 0; i < inputs.size(); ++i) {
452 track_name = inputs[i];
453 replace_all (track_name, "system:capture", "");
455 list<boost::shared_ptr<AudioTrack> > single_track = new_audio_track (1, 1, Normal, 0, 1, track_name);
456 tracks.insert(tracks.begin(), single_track.front());
458 } else { // Default track names
459 tracks = new_audio_track (1, 1, Normal, 0, how_many, string());
462 if (tracks.size() != how_many) {
464 throw failed_constructor ();
473 BootMessage (_("Session loading complete"));
485 Session::next_name_id ()
487 return g_atomic_int_add (&_name_id_counter, 1);
491 Session::name_id_counter ()
493 return g_atomic_int_get (&_name_id_counter);
497 Session::init_name_id_counter (guint n)
499 g_atomic_int_set (&_name_id_counter, n);
503 Session::ensure_engine (uint32_t desired_sample_rate, bool isnew)
505 if (_engine.current_backend() == 0) {
506 /* backend is unknown ... */
507 boost::optional<int> r = AudioEngineSetupRequired (desired_sample_rate);
508 if (r.get_value_or (-1) != 0) {
511 } else if (!isnew && _engine.running() && _engine.sample_rate () == desired_sample_rate) {
513 } else if (_engine.setup_required()) {
514 /* backend is known, but setup is needed */
515 boost::optional<int> r = AudioEngineSetupRequired (desired_sample_rate);
516 if (r.get_value_or (-1) != 0) {
519 } else if (!_engine.running()) {
520 if (_engine.start()) {
525 /* at this point the engine should be running */
527 if (!_engine.running()) {
531 return immediately_post_engine ();
536 Session::immediately_post_engine ()
538 /* Do various initializations that should take place directly after we
539 * know that the engine is running, but before we either create a
540 * session or set state for an existing one.
543 if (how_many_dsp_threads () > 1) {
544 /* For now, only create the graph if we are using >1 DSP threads, as
545 it is a bit slower than the old code with 1 thread.
547 _process_graph.reset (new Graph (*this));
550 /* every time we reconnect, recompute worst case output latencies */
552 _engine.Running.connect_same_thread (*this, boost::bind (&Session::initialize_latencies, this));
554 if (synced_to_engine()) {
555 _engine.transport_stop ();
558 if (config.get_jack_time_master()) {
559 _engine.transport_locate (_transport_frame);
563 BootMessage (_("Set up LTC"));
565 BootMessage (_("Set up Click"));
567 BootMessage (_("Set up standard connections"));
571 catch (failed_constructor& err) {
575 /* TODO, connect in different thread. (PortRegisteredOrUnregistered may be in RT context)
577 _engine.PortRegisteredOrUnregistered.connect_same_thread (*this, boost::bind (&Session::setup_bundles, this));
585 vector<void*> debug_pointers;
587 /* if we got to here, leaving pending capture state around
591 remove_pending_capture_state ();
595 _state_of_the_state = StateOfTheState (CannotSave|Deletion);
597 /* stop autoconnecting */
598 auto_connect_thread_terminate ();
600 /* disconnect from any and all signals that we are connected to */
602 Port::PortSignalDrop (); /* EMIT SIGNAL */
605 /* shutdown control surface protocols while we still have ports
606 and the engine to move data to any devices.
609 ControlProtocolManager::instance().drop_protocols ();
611 MIDI::Name::MidiPatchManager::instance().remove_search_path(session_directory().midi_patch_path());
613 _engine.remove_session ();
615 #ifdef USE_TRACKS_CODE_FEATURES
616 EngineStateController::instance()->remove_session();
619 /* deregister all ports - there will be no process or any other
620 * callbacks from the engine any more.
623 Port::PortDrop (); /* EMIT SIGNAL */
627 /* clear history so that no references to objects are held any more */
631 /* clear state tree so that no references to objects are held any more */
636 // unregister all lua functions, drop held references (if any)
638 lua.do_command ("Session = nil");
646 lua.collect_garbage ();
648 /* reset dynamic state version back to default */
649 Stateful::loading_state_version = 0;
651 _butler->drop_references ();
655 delete _all_route_group;
657 DEBUG_TRACE (DEBUG::Destruction, "delete route groups\n");
658 for (list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
662 if (click_data != default_click) {
663 delete [] click_data;
666 if (click_emphasis_data != default_click_emphasis) {
667 delete [] click_emphasis_data;
672 /* need to remove auditioner before monitoring section
673 * otherwise it is re-connected */
676 /* drop references to routes held by the monitoring section
677 * specifically _monitor_out aux/listen references */
678 remove_monitor_section();
680 /* clear out any pending dead wood from RCU managed objects */
685 AudioDiskstream::free_working_buffers();
687 /* tell everyone who is still standing that we're about to die */
690 /* tell everyone to drop references and delete objects as we go */
692 DEBUG_TRACE (DEBUG::Destruction, "delete regions\n");
693 RegionFactory::delete_all_regions ();
695 DEBUG_TRACE (DEBUG::Destruction, "delete routes\n");
697 /* reset these three references to special routes before we do the usual route delete thing */
699 _master_out.reset ();
700 _monitor_out.reset ();
703 RCUWriter<RouteList> writer (routes);
704 boost::shared_ptr<RouteList> r = writer.get_copy ();
706 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
707 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for route %1 ; pre-ref = %2\n", (*i)->name(), (*i).use_count()));
708 (*i)->drop_references ();
712 /* writer goes out of scope and updates master */
717 DEBUG_TRACE (DEBUG::Destruction, "delete sources\n");
718 Glib::Threads::Mutex::Lock lm (source_lock);
719 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
720 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for source %1 ; pre-ref = %2\n", i->second->name(), i->second.use_count()));
721 i->second->drop_references ();
727 /* not strictly necessary, but doing it here allows the shared_ptr debugging to work */
730 emit_thread_terminate ();
732 pthread_cond_destroy (&_rt_emit_cond);
733 pthread_mutex_destroy (&_rt_emit_mutex);
735 pthread_cond_destroy (&_auto_connect_cond);
736 pthread_mutex_destroy (&_auto_connect_mutex);
738 delete _scene_changer; _scene_changer = 0;
739 delete midi_control_ui; midi_control_ui = 0;
741 delete _mmc; _mmc = 0;
742 delete _midi_ports; _midi_ports = 0;
743 delete _locations; _locations = 0;
748 DEBUG_TRACE (DEBUG::Destruction, "Session::destroy() done\n");
750 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
751 boost_debug_list_ptrs ();
756 Session::setup_ltc ()
760 _ltc_input.reset (new IO (*this, X_("LTC In"), IO::Input));
761 _ltc_output.reset (new IO (*this, X_("LTC Out"), IO::Output));
763 if (state_tree && (child = find_named_node (*state_tree->root(), X_("LTC In"))) != 0) {
764 _ltc_input->set_state (*(child->children().front()), Stateful::loading_state_version);
767 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
768 _ltc_input->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
770 reconnect_ltc_input ();
773 if (state_tree && (child = find_named_node (*state_tree->root(), X_("LTC Out"))) != 0) {
774 _ltc_output->set_state (*(child->children().front()), Stateful::loading_state_version);
777 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
778 _ltc_output->ensure_io (ChanCount (DataType::AUDIO, 1), true, this);
780 reconnect_ltc_output ();
783 /* fix up names of LTC ports because we don't want the normal
784 * IO style of NAME/TYPE-{in,out}N
787 _ltc_input->nth (0)->set_name (X_("LTC-in"));
788 _ltc_output->nth (0)->set_name (X_("LTC-out"));
792 Session::setup_click ()
796 boost::shared_ptr<AutomationList> gl (new AutomationList (Evoral::Parameter (GainAutomation)));
797 boost::shared_ptr<GainControl> gain_control = boost::shared_ptr<GainControl> (new GainControl (*this, Evoral::Parameter(GainAutomation), gl));
799 _click_io.reset (new ClickIO (*this, X_("Click")));
800 _click_gain.reset (new Amp (*this, _("Fader"), gain_control, true));
801 _click_gain->activate ();
803 setup_click_state (state_tree->root());
805 setup_click_state (0);
810 Session::setup_click_state (const XMLNode* node)
812 const XMLNode* child = 0;
814 if (node && (child = find_named_node (*node, "Click")) != 0) {
816 /* existing state for Click */
819 if (Stateful::loading_state_version < 3000) {
820 c = _click_io->set_state_2X (*child->children().front(), Stateful::loading_state_version, false);
822 const XMLNodeList& children (child->children());
823 XMLNodeList::const_iterator i = children.begin();
824 if ((c = _click_io->set_state (**i, Stateful::loading_state_version)) == 0) {
826 if (i != children.end()) {
827 c = _click_gain->set_state (**i, Stateful::loading_state_version);
833 _clicking = Config->get_clicking ();
837 error << _("could not setup Click I/O") << endmsg;
844 /* default state for Click: dual-mono to first 2 physical outputs */
847 _engine.get_physical_outputs (DataType::AUDIO, outs);
849 for (uint32_t physport = 0; physport < 2; ++physport) {
850 if (outs.size() > physport) {
851 if (_click_io->add_port (outs[physport], this)) {
852 // relax, even though its an error
857 if (_click_io->n_ports () > ChanCount::ZERO) {
858 _clicking = Config->get_clicking ();
864 Session::setup_bundles ()
868 RCUWriter<BundleList> writer (_bundles);
869 boost::shared_ptr<BundleList> b = writer.get_copy ();
870 for (BundleList::iterator i = b->begin(); i != b->end();) {
871 if (boost::dynamic_pointer_cast<UserBundle>(*i)) {
879 vector<string> inputs[DataType::num_types];
880 vector<string> outputs[DataType::num_types];
881 for (uint32_t i = 0; i < DataType::num_types; ++i) {
882 _engine.get_physical_inputs (DataType (DataType::Symbol (i)), inputs[i]);
883 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
886 /* Create a set of Bundle objects that map
887 to the physical I/O currently available. We create both
888 mono and stereo bundles, so that the common cases of mono
889 and stereo tracks get bundles to put in their mixer strip
890 in / out menus. There may be a nicer way of achieving that;
891 it doesn't really scale that well to higher channel counts
894 /* mono output bundles */
896 for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); ++np) {
898 std::string pn = _engine.get_pretty_name_by_name (outputs[DataType::AUDIO][np]);
900 snprintf (buf, sizeof (buf), _("out %s"), pn.c_str());
902 snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
905 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
906 c->add_channel (_("mono"), DataType::AUDIO);
907 c->set_port (0, outputs[DataType::AUDIO][np]);
909 add_bundle (c, false);
912 /* stereo output bundles */
914 for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); np += 2) {
915 if (np + 1 < outputs[DataType::AUDIO].size()) {
917 snprintf (buf, sizeof(buf), _("out %" PRIu32 "+%" PRIu32), np + 1, np + 2);
918 boost::shared_ptr<Bundle> c (new Bundle (buf, true));
919 c->add_channel (_("L"), DataType::AUDIO);
920 c->set_port (0, outputs[DataType::AUDIO][np]);
921 c->add_channel (_("R"), DataType::AUDIO);
922 c->set_port (1, outputs[DataType::AUDIO][np + 1]);
924 add_bundle (c, false);
928 /* mono input bundles */
930 for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); ++np) {
932 std::string pn = _engine.get_pretty_name_by_name (inputs[DataType::AUDIO][np]);
934 snprintf (buf, sizeof (buf), _("in %s"), pn.c_str());
936 snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
939 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
940 c->add_channel (_("mono"), DataType::AUDIO);
941 c->set_port (0, inputs[DataType::AUDIO][np]);
943 add_bundle (c, false);
946 /* stereo input bundles */
948 for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); np += 2) {
949 if (np + 1 < inputs[DataType::AUDIO].size()) {
951 snprintf (buf, sizeof(buf), _("in %" PRIu32 "+%" PRIu32), np + 1, np + 2);
953 boost::shared_ptr<Bundle> c (new Bundle (buf, false));
954 c->add_channel (_("L"), DataType::AUDIO);
955 c->set_port (0, inputs[DataType::AUDIO][np]);
956 c->add_channel (_("R"), DataType::AUDIO);
957 c->set_port (1, inputs[DataType::AUDIO][np + 1]);
959 add_bundle (c, false);
963 /* MIDI input bundles */
965 for (uint32_t np = 0; np < inputs[DataType::MIDI].size(); ++np) {
966 string n = inputs[DataType::MIDI][np];
967 std::string pn = _engine.get_pretty_name_by_name (n);
971 boost::erase_first (n, X_("alsa_pcm:"));
973 boost::shared_ptr<Bundle> c (new Bundle (n, false));
974 c->add_channel ("", DataType::MIDI);
975 c->set_port (0, inputs[DataType::MIDI][np]);
976 add_bundle (c, false);
979 /* MIDI output bundles */
981 for (uint32_t np = 0; np < outputs[DataType::MIDI].size(); ++np) {
982 string n = outputs[DataType::MIDI][np];
983 std::string pn = _engine.get_pretty_name_by_name (n);
987 boost::erase_first (n, X_("alsa_pcm:"));
989 boost::shared_ptr<Bundle> c (new Bundle (n, true));
990 c->add_channel ("", DataType::MIDI);
991 c->set_port (0, outputs[DataType::MIDI][np]);
992 add_bundle (c, false);
995 // we trust the backend to only calls us if there's a change
996 BundleAddedOrRemoved (); /* EMIT SIGNAL */
1000 Session::auto_connect_master_bus ()
1002 if (!_master_out || !Config->get_auto_connect_standard_busses() || _monitor_out) {
1006 // Waves Tracks: Do not connect master bas for Tracks if AutoConnectMaster option is not set
1007 // In this case it means "Multi Out" output mode
1008 if (ARDOUR::Profile->get_trx() && !(Config->get_output_auto_connect() & AutoConnectMaster) ) {
1012 /* if requested auto-connect the outputs to the first N physical ports.
1015 uint32_t limit = _master_out->n_outputs().n_total();
1016 vector<string> outputs[DataType::num_types];
1018 for (uint32_t i = 0; i < DataType::num_types; ++i) {
1019 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
1022 for (uint32_t n = 0; n < limit; ++n) {
1023 boost::shared_ptr<Port> p = _master_out->output()->nth (n);
1025 if (outputs[p->type()].size() > n) {
1026 connect_to = outputs[p->type()][n];
1029 if (!connect_to.empty() && p->connected_to (connect_to) == false) {
1030 if (_master_out->output()->connect (p, connect_to, this)) {
1031 error << string_compose (_("cannot connect master output %1 to %2"), n, connect_to)
1040 Session::remove_monitor_section ()
1042 if (!_monitor_out || Profile->get_trx()) {
1046 /* force reversion to Solo-In-Place */
1047 Config->set_solo_control_is_listen_control (false);
1049 /* if we are auditioning, cancel it ... this is a workaround
1050 to a problem (auditioning does not execute the process graph,
1051 which is needed to remove routes when using >1 core for processing)
1056 /* Hold process lock while doing this so that we don't hear bits and
1057 * pieces of audio as we work on each route.
1060 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1062 /* Connect tracks to monitor section. Note that in an
1063 existing session, the internal sends will already exist, but we want the
1064 routes to notice that they connect to the control out specifically.
1068 boost::shared_ptr<RouteList> r = routes.reader ();
1069 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
1071 for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
1073 if ((*x)->is_monitor()) {
1075 } else if ((*x)->is_master()) {
1078 (*x)->remove_aux_or_listen (_monitor_out);
1083 remove_route (_monitor_out);
1084 if (_state_of_the_state & Deletion) {
1088 auto_connect_master_bus ();
1091 auditioner->connect ();
1094 Config->ParameterChanged ("use-monitor-bus");
1098 Session::add_monitor_section ()
1102 if (_monitor_out || !_master_out || Profile->get_trx()) {
1106 boost::shared_ptr<Route> r (new Route (*this, _("Monitor"), Route::MonitorOut, DataType::AUDIO));
1112 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
1113 // boost_debug_shared_ptr_mark_interesting (r.get(), "Route");
1116 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1117 r->input()->ensure_io (_master_out->output()->n_ports(), false, this);
1118 r->output()->ensure_io (_master_out->output()->n_ports(), false, this);
1120 error << _("Cannot create monitor section. 'Monitor' Port name is not unique.") << endmsg;
1125 add_routes (rl, false, false, false);
1127 assert (_monitor_out);
1129 /* AUDIO ONLY as of june 29th 2009, because listen semantics for anything else
1130 are undefined, at best.
1133 uint32_t limit = _monitor_out->n_inputs().n_audio();
1137 /* connect the inputs to the master bus outputs. this
1138 * represents a separate data feed from the internal sends from
1139 * each route. as of jan 2011, it allows the monitor section to
1140 * conditionally ignore either the internal sends or the normal
1141 * input feed, but we should really find a better way to do
1145 _master_out->output()->disconnect (this);
1147 for (uint32_t n = 0; n < limit; ++n) {
1148 boost::shared_ptr<AudioPort> p = _monitor_out->input()->ports().nth_audio_port (n);
1149 boost::shared_ptr<AudioPort> o = _master_out->output()->ports().nth_audio_port (n);
1152 string connect_to = o->name();
1153 if (_monitor_out->input()->connect (p, connect_to, this)) {
1154 error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
1162 /* if monitor section is not connected, connect it to physical outs
1165 if ((Config->get_auto_connect_standard_busses () || Profile->get_mixbus ()) && !_monitor_out->output()->connected ()) {
1167 if (!Config->get_monitor_bus_preferred_bundle().empty()) {
1169 boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
1172 _monitor_out->output()->connect_ports_to_bundle (b, true, this);
1174 warning << string_compose (_("The preferred I/O for the monitor bus (%1) cannot be found"),
1175 Config->get_monitor_bus_preferred_bundle())
1181 /* Monitor bus is audio only */
1183 vector<string> outputs[DataType::num_types];
1185 for (uint32_t i = 0; i < DataType::num_types; ++i) {
1186 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
1189 uint32_t mod = outputs[DataType::AUDIO].size();
1190 uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
1194 for (uint32_t n = 0; n < limit; ++n) {
1196 boost::shared_ptr<Port> p = _monitor_out->output()->ports().port(DataType::AUDIO, n);
1198 if (outputs[DataType::AUDIO].size() > (n % mod)) {
1199 connect_to = outputs[DataType::AUDIO][n % mod];
1202 if (!connect_to.empty()) {
1203 if (_monitor_out->output()->connect (p, connect_to, this)) {
1204 error << string_compose (
1205 _("cannot connect control output %1 to %2"),
1216 /* Hold process lock while doing this so that we don't hear bits and
1217 * pieces of audio as we work on each route.
1220 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1222 /* Connect tracks to monitor section. Note that in an
1223 existing session, the internal sends will already exist, but we want the
1224 routes to notice that they connect to the control out specifically.
1228 boost::shared_ptr<RouteList> rls = routes.reader ();
1230 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
1232 for (RouteList::iterator x = rls->begin(); x != rls->end(); ++x) {
1234 if ((*x)->is_monitor()) {
1236 } else if ((*x)->is_master()) {
1239 (*x)->enable_monitor_send ();
1244 auditioner->connect ();
1246 Config->ParameterChanged ("use-monitor-bus");
1250 Session::reset_monitor_section ()
1252 /* Process lock should be held by the caller.*/
1254 if (!_monitor_out || Profile->get_trx()) {
1258 uint32_t limit = _master_out->n_outputs().n_audio();
1260 /* connect the inputs to the master bus outputs. this
1261 * represents a separate data feed from the internal sends from
1262 * each route. as of jan 2011, it allows the monitor section to
1263 * conditionally ignore either the internal sends or the normal
1264 * input feed, but we should really find a better way to do
1268 _master_out->output()->disconnect (this);
1269 _monitor_out->output()->disconnect (this);
1271 _monitor_out->input()->ensure_io (_master_out->output()->n_ports(), false, this);
1272 _monitor_out->output()->ensure_io (_master_out->output()->n_ports(), false, this);
1274 for (uint32_t n = 0; n < limit; ++n) {
1275 boost::shared_ptr<AudioPort> p = _monitor_out->input()->ports().nth_audio_port (n);
1276 boost::shared_ptr<AudioPort> o = _master_out->output()->ports().nth_audio_port (n);
1279 string connect_to = o->name();
1280 if (_monitor_out->input()->connect (p, connect_to, this)) {
1281 error << string_compose (_("cannot connect control input %1 to %2"), n, connect_to)
1288 /* connect monitor section to physical outs
1291 if (Config->get_auto_connect_standard_busses()) {
1293 if (!Config->get_monitor_bus_preferred_bundle().empty()) {
1295 boost::shared_ptr<Bundle> b = bundle_by_name (Config->get_monitor_bus_preferred_bundle());
1298 _monitor_out->output()->connect_ports_to_bundle (b, true, this);
1300 warning << string_compose (_("The preferred I/O for the monitor bus (%1) cannot be found"),
1301 Config->get_monitor_bus_preferred_bundle())
1307 /* Monitor bus is audio only */
1309 vector<string> outputs[DataType::num_types];
1311 for (uint32_t i = 0; i < DataType::num_types; ++i) {
1312 _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
1315 uint32_t mod = outputs[DataType::AUDIO].size();
1316 uint32_t limit = _monitor_out->n_outputs().get (DataType::AUDIO);
1320 for (uint32_t n = 0; n < limit; ++n) {
1322 boost::shared_ptr<Port> p = _monitor_out->output()->ports().port(DataType::AUDIO, n);
1324 if (outputs[DataType::AUDIO].size() > (n % mod)) {
1325 connect_to = outputs[DataType::AUDIO][n % mod];
1328 if (!connect_to.empty()) {
1329 if (_monitor_out->output()->connect (p, connect_to, this)) {
1330 error << string_compose (
1331 _("cannot connect control output %1 to %2"),
1342 /* Connect tracks to monitor section. Note that in an
1343 existing session, the internal sends will already exist, but we want the
1344 routes to notice that they connect to the control out specifically.
1348 boost::shared_ptr<RouteList> rls = routes.reader ();
1350 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
1352 for (RouteList::iterator x = rls->begin(); x != rls->end(); ++x) {
1354 if ((*x)->is_monitor()) {
1356 } else if ((*x)->is_master()) {
1359 (*x)->enable_monitor_send ();
1365 Session::hookup_io ()
1367 /* stop graph reordering notifications from
1368 causing resorts, etc.
1371 _state_of_the_state = StateOfTheState (_state_of_the_state | InitialConnecting);
1375 /* we delay creating the auditioner till now because
1376 it makes its own connections to ports.
1380 boost::shared_ptr<Auditioner> a (new Auditioner (*this));
1382 throw failed_constructor ();
1384 a->use_new_diskstream ();
1388 catch (failed_constructor& err) {
1389 warning << _("cannot create Auditioner: no auditioning of regions possible") << endmsg;
1393 /* load bundles, which we may have postponed earlier on */
1394 if (_bundle_xml_node) {
1395 load_bundles (*_bundle_xml_node);
1396 delete _bundle_xml_node;
1399 /* Tell all IO objects to connect themselves together */
1401 IO::enable_connecting ();
1403 /* Now tell all "floating" ports to connect to whatever
1404 they should be connected to.
1407 AudioEngine::instance()->reconnect_ports ();
1409 /* Anyone who cares about input state, wake up and do something */
1411 IOConnectionsComplete (); /* EMIT SIGNAL */
1413 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InitialConnecting);
1415 /* now handle the whole enchilada as if it was one
1416 graph reorder event.
1421 /* update the full solo state, which can't be
1422 correctly determined on a per-route basis, but
1423 needs the global overview that only the session
1427 update_route_solo_state ();
1431 Session::track_playlist_changed (boost::weak_ptr<Track> wp)
1433 boost::shared_ptr<Track> track = wp.lock ();
1438 boost::shared_ptr<Playlist> playlist;
1440 if ((playlist = track->playlist()) != 0) {
1441 playlist->RegionAdded.connect_same_thread (*this, boost::bind (&Session::playlist_region_added, this, _1));
1442 playlist->RangesMoved.connect_same_thread (*this, boost::bind (&Session::playlist_ranges_moved, this, _1));
1443 playlist->RegionsExtended.connect_same_thread (*this, boost::bind (&Session::playlist_regions_extended, this, _1));
1448 Session::record_enabling_legal () const
1450 /* this used to be in here, but survey says.... we don't need to restrict it */
1451 // if (record_status() == Recording) {
1455 if (Config->get_all_safe()) {
1462 Session::set_track_monitor_input_status (bool yn)
1464 boost::shared_ptr<RouteList> rl = routes.reader ();
1465 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1466 boost::shared_ptr<AudioTrack> tr = boost::dynamic_pointer_cast<AudioTrack> (*i);
1467 if (tr && tr->record_enabled ()) {
1468 //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
1469 tr->request_input_monitoring (yn);
1475 Session::auto_punch_start_changed (Location* location)
1477 replace_event (SessionEvent::PunchIn, location->start());
1479 if (get_record_enabled() && config.get_punch_in()) {
1480 /* capture start has been changed, so save new pending state */
1481 save_state ("", true);
1486 Session::auto_punch_end_changed (Location* location)
1488 framepos_t when_to_stop = location->end();
1489 // when_to_stop += _worst_output_latency + _worst_input_latency;
1490 replace_event (SessionEvent::PunchOut, when_to_stop);
1494 Session::auto_punch_changed (Location* location)
1496 framepos_t when_to_stop = location->end();
1498 replace_event (SessionEvent::PunchIn, location->start());
1499 //when_to_stop += _worst_output_latency + _worst_input_latency;
1500 replace_event (SessionEvent::PunchOut, when_to_stop);
1503 /** @param loc A loop location.
1504 * @param pos Filled in with the start time of the required fade-out (in session frames).
1505 * @param length Filled in with the length of the required fade-out.
1508 Session::auto_loop_declick_range (Location* loc, framepos_t & pos, framepos_t & length)
1510 pos = max (loc->start(), loc->end() - 64);
1511 length = loc->end() - pos;
1515 Session::auto_loop_changed (Location* location)
1517 replace_event (SessionEvent::AutoLoop, location->end(), location->start());
1520 auto_loop_declick_range (location, dcp, dcl);
1522 if (transport_rolling() && play_loop) {
1524 replace_event (SessionEvent::AutoLoopDeclick, dcp, dcl);
1526 // if (_transport_frame > location->end()) {
1528 if (_transport_frame < location->start() || _transport_frame > location->end()) {
1529 // relocate to beginning of loop
1530 clear_events (SessionEvent::LocateRoll);
1532 request_locate (location->start(), true);
1535 else if (Config->get_seamless_loop() && !loop_changing) {
1537 // schedule a locate-roll to refill the diskstreams at the
1538 // previous loop end
1539 loop_changing = true;
1541 if (location->end() > last_loopend) {
1542 clear_events (SessionEvent::LocateRoll);
1543 SessionEvent *ev = new SessionEvent (SessionEvent::LocateRoll, SessionEvent::Add, last_loopend, last_loopend, 0, true);
1549 clear_events (SessionEvent::AutoLoopDeclick);
1550 clear_events (SessionEvent::AutoLoop);
1553 /* possibly move playhead if not rolling; if we are rolling we'll move
1554 to the loop start on stop if that is appropriate.
1559 if (!transport_rolling() && select_playhead_priority_target (pos)) {
1560 if (pos == location->start()) {
1561 request_locate (pos);
1566 last_loopend = location->end();
1571 Session::set_auto_punch_location (Location* location)
1575 if ((existing = _locations->auto_punch_location()) != 0 && existing != location) {
1576 punch_connections.drop_connections();
1577 existing->set_auto_punch (false, this);
1578 remove_event (existing->start(), SessionEvent::PunchIn);
1579 clear_events (SessionEvent::PunchOut);
1580 auto_punch_location_changed (0);
1585 if (location == 0) {
1589 if (location->end() <= location->start()) {
1590 error << _("Session: you can't use that location for auto punch (start <= end)") << endmsg;
1594 punch_connections.drop_connections ();
1596 location->StartChanged.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_start_changed, this, location));
1597 location->EndChanged.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_end_changed, this, location));
1598 location->Changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_changed, this, location));
1600 location->set_auto_punch (true, this);
1602 auto_punch_changed (location);
1604 auto_punch_location_changed (location);
1608 Session::set_session_extents (framepos_t start, framepos_t end)
1611 if ((existing = _locations->session_range_location()) == 0) {
1612 //if there is no existing session, we need to make a new session location (should never happen)
1613 existing = new Location (*this, 0, 0, _("session"), Location::IsSessionRange);
1617 error << _("Session: you can't use that location for session start/end)") << endmsg;
1621 existing->set( start, end );
1627 Session::set_auto_loop_location (Location* location)
1631 if ((existing = _locations->auto_loop_location()) != 0 && existing != location) {
1632 loop_connections.drop_connections ();
1633 existing->set_auto_loop (false, this);
1634 remove_event (existing->end(), SessionEvent::AutoLoop);
1637 auto_loop_declick_range (existing, dcp, dcl);
1638 remove_event (dcp, SessionEvent::AutoLoopDeclick);
1639 auto_loop_location_changed (0);
1644 if (location == 0) {
1648 if (location->end() <= location->start()) {
1649 error << _("You cannot use this location for auto-loop because it has zero or negative length") << endmsg;
1653 last_loopend = location->end();
1655 loop_connections.drop_connections ();
1657 location->StartChanged.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1658 location->EndChanged.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1659 location->Changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1660 location->FlagsChanged.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
1662 location->set_auto_loop (true, this);
1664 if (Config->get_loop_is_mode() && play_loop && Config->get_seamless_loop()) {
1665 // set all tracks to use internal looping
1666 boost::shared_ptr<RouteList> rl = routes.reader ();
1667 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1668 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1669 if (tr && !tr->hidden()) {
1670 tr->set_loop (location);
1675 /* take care of our stuff first */
1677 auto_loop_changed (location);
1679 /* now tell everyone else */
1681 auto_loop_location_changed (location);
1685 Session::update_marks (Location*)
1691 Session::update_skips (Location* loc, bool consolidate)
1693 if (_ignore_skips_updates) {
1697 Locations::LocationList skips;
1700 PBD::Unwinder<bool> uw (_ignore_skips_updates, true);
1701 consolidate_skips (loc);
1704 sync_locations_to_skips ();
1710 Session::consolidate_skips (Location* loc)
1712 Locations::LocationList all_locations = _locations->list ();
1714 for (Locations::LocationList::iterator l = all_locations.begin(); l != all_locations.end(); ) {
1716 if (!(*l)->is_skip ()) {
1721 /* don't test against self */
1728 switch (Evoral::coverage ((*l)->start(), (*l)->end(), loc->start(), loc->end())) {
1729 case Evoral::OverlapInternal:
1730 case Evoral::OverlapExternal:
1731 case Evoral::OverlapStart:
1732 case Evoral::OverlapEnd:
1733 /* adjust new location to cover existing one */
1734 loc->set_start (min (loc->start(), (*l)->start()));
1735 loc->set_end (max (loc->end(), (*l)->end()));
1736 /* we don't need this one any more */
1737 _locations->remove (*l);
1738 /* the location has been deleted, so remove reference to it in our local list */
1739 l = all_locations.erase (l);
1742 case Evoral::OverlapNone:
1750 Session::sync_locations_to_skips ()
1752 /* This happens asynchronously (in the audioengine thread). After the clear is done, we will call
1753 * Session::_sync_locations_to_skips() from the audioengine thread.
1755 clear_events (SessionEvent::Skip, boost::bind (&Session::_sync_locations_to_skips, this));
1759 Session::_sync_locations_to_skips ()
1761 /* called as a callback after existing Skip events have been cleared from a realtime audioengine thread */
1763 Locations::LocationList const & locs (_locations->list());
1765 for (Locations::LocationList::const_iterator i = locs.begin(); i != locs.end(); ++i) {
1767 Location* location = *i;
1769 if (location->is_skip() && location->is_skipping()) {
1770 SessionEvent* ev = new SessionEvent (SessionEvent::Skip, SessionEvent::Add, location->start(), location->end(), 1.0);
1778 Session::location_added (Location *location)
1780 if (location->is_auto_punch()) {
1781 set_auto_punch_location (location);
1784 if (location->is_auto_loop()) {
1785 set_auto_loop_location (location);
1788 if (location->is_session_range()) {
1789 /* no need for any signal handling or event setting with the session range,
1790 because we keep a direct reference to it and use its start/end directly.
1792 _session_range_location = location;
1795 if (location->is_mark()) {
1796 /* listen for per-location signals that require us to do any * global updates for marks */
1798 location->StartChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1799 location->EndChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1800 location->Changed.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1801 location->FlagsChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_marks, this, location));
1804 if (location->is_skip()) {
1805 /* listen for per-location signals that require us to update skip-locate events */
1807 location->StartChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, true));
1808 location->EndChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, true));
1809 location->Changed.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, true));
1810 location->FlagsChanged.connect_same_thread (skip_update_connections, boost::bind (&Session::update_skips, this, location, false));
1812 update_skips (location, true);
1819 Session::location_removed (Location *location)
1821 if (location->is_auto_loop()) {
1822 set_auto_loop_location (0);
1823 set_track_loop (false);
1826 if (location->is_auto_punch()) {
1827 set_auto_punch_location (0);
1830 if (location->is_session_range()) {
1831 /* this is never supposed to happen */
1832 error << _("programming error: session range removed!") << endl;
1835 if (location->is_skip()) {
1837 update_skips (location, false);
1844 Session::locations_changed ()
1846 _locations->apply (*this, &Session::_locations_changed);
1850 Session::_locations_changed (const Locations::LocationList& locations)
1852 /* There was some mass-change in the Locations object.
1854 We might be re-adding a location here but it doesn't actually matter
1855 for all the locations that the Session takes an interest in.
1859 PBD::Unwinder<bool> protect_ignore_skip_updates (_ignore_skips_updates, true);
1860 for (Locations::LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
1861 location_added (*i);
1865 update_skips (NULL, false);
1869 Session::enable_record ()
1871 if (_transport_speed != 0.0 && _transport_speed != 1.0) {
1872 /* no recording at anything except normal speed */
1877 RecordState rs = (RecordState) g_atomic_int_get (&_record_status);
1879 if (rs == Recording) {
1883 if (g_atomic_int_compare_and_exchange (&_record_status, rs, Recording)) {
1885 _last_record_location = _transport_frame;
1886 send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordStrobe));
1888 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1889 set_track_monitor_input_status (true);
1892 RecordStateChanged ();
1899 Session::set_all_tracks_record_enabled (bool enable )
1901 boost::shared_ptr<RouteList> rl = routes.reader();
1902 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
1903 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
1905 tr->set_record_enabled (enable, Controllable::NoGroup);
1912 Session::disable_record (bool rt_context, bool force)
1916 if ((rs = (RecordState) g_atomic_int_get (&_record_status)) != Disabled) {
1918 if (!Config->get_latched_record_enable () || force) {
1919 g_atomic_int_set (&_record_status, Disabled);
1920 send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordExit));
1922 if (rs == Recording) {
1923 g_atomic_int_set (&_record_status, Enabled);
1927 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1928 set_track_monitor_input_status (false);
1931 RecordStateChanged (); /* emit signal */
1934 remove_pending_capture_state ();
1940 Session::step_back_from_record ()
1942 if (g_atomic_int_compare_and_exchange (&_record_status, Recording, Enabled)) {
1944 if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
1945 set_track_monitor_input_status (false);
1948 RecordStateChanged (); /* emit signal */
1953 Session::maybe_enable_record ()
1955 if (_step_editors > 0) {
1959 g_atomic_int_set (&_record_status, Enabled);
1961 /* This function is currently called from somewhere other than an RT thread.
1962 This save_state() call therefore doesn't impact anything. Doing it here
1963 means that we save pending state of which sources the next record will use,
1964 which gives us some chance of recovering from a crash during the record.
1967 save_state ("", true);
1969 if (_transport_speed) {
1970 if (!config.get_punch_in()) {
1974 send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdRecordPause));
1975 RecordStateChanged (); /* EMIT SIGNAL */
1982 Session::audible_frame () const
1988 offset = worst_playback_latency ();
1990 if (synced_to_engine()) {
1991 /* Note: this is basically just sync-to-JACK */
1992 tf = _engine.transport_frame();
1994 tf = _transport_frame;
1999 if (!non_realtime_work_pending()) {
2003 /* Check to see if we have passed the first guaranteed
2004 audible frame past our last start position. if not,
2005 return that last start point because in terms
2006 of audible frames, we have not moved yet.
2008 `Start position' in this context means the time we last
2009 either started, located, or changed transport direction.
2012 if (_transport_speed > 0.0f) {
2014 if (!play_loop || !have_looped) {
2015 if (tf < _last_roll_or_reversal_location + offset) {
2016 return _last_roll_or_reversal_location;
2024 } else if (_transport_speed < 0.0f) {
2026 /* XXX wot? no backward looping? */
2028 if (tf > _last_roll_or_reversal_location - offset) {
2029 return _last_roll_or_reversal_location;
2041 Session::set_frame_rate (framecnt_t frames_per_second)
2043 /** \fn void Session::set_frame_size(framecnt_t)
2044 the AudioEngine object that calls this guarantees
2045 that it will not be called while we are also in
2046 ::process(). Its fine to do things that block
2050 if (_base_frame_rate == 0) {
2051 _base_frame_rate = frames_per_second;
2053 else if (_base_frame_rate != frames_per_second && frames_per_second != _nominal_frame_rate) {
2054 NotifyAboutSampleRateMismatch (_base_frame_rate, frames_per_second);
2056 _nominal_frame_rate = frames_per_second;
2061 reset_write_sources (false);
2063 // XXX we need some equivalent to this, somehow
2064 // SndFileSource::setup_standard_crossfades (frames_per_second);
2068 /* XXX need to reset/reinstantiate all LADSPA plugins */
2072 Session::set_block_size (pframes_t nframes)
2074 /* the AudioEngine guarantees
2075 that it will not be called while we are also in
2076 ::process(). It is therefore fine to do things that block
2081 current_block_size = nframes;
2085 boost::shared_ptr<RouteList> r = routes.reader ();
2087 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2088 (*i)->set_block_size (nframes);
2091 boost::shared_ptr<RouteList> rl = routes.reader ();
2092 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2093 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2095 tr->set_block_size (nframes);
2099 set_worst_io_latencies ();
2105 trace_terminal (boost::shared_ptr<Route> r1, boost::shared_ptr<Route> rbase)
2107 boost::shared_ptr<Route> r2;
2109 if (r1->feeds (rbase) && rbase->feeds (r1)) {
2110 info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
2114 /* make a copy of the existing list of routes that feed r1 */
2116 Route::FedBy existing (r1->fed_by());
2118 /* for each route that feeds r1, recurse, marking it as feeding
2122 for (Route::FedBy::iterator i = existing.begin(); i != existing.end(); ++i) {
2123 if (!(r2 = i->r.lock ())) {
2124 /* (*i) went away, ignore it */
2128 /* r2 is a route that feeds r1 which somehow feeds base. mark
2129 base as being fed by r2
2132 rbase->add_fed_by (r2, i->sends_only);
2136 /* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
2140 if (r1->feeds (r2) && r2->feeds (r1)) {
2144 /* now recurse, so that we can mark base as being fed by
2145 all routes that feed r2
2148 trace_terminal (r2, rbase);
2155 Session::resort_routes ()
2157 /* don't do anything here with signals emitted
2158 by Routes during initial setup or while we
2159 are being destroyed.
2162 if (_state_of_the_state & (InitialConnecting | Deletion)) {
2166 if (_route_deletion_in_progress) {
2171 RCUWriter<RouteList> writer (routes);
2172 boost::shared_ptr<RouteList> r = writer.get_copy ();
2173 resort_routes_using (r);
2174 /* writer goes out of scope and forces update */
2178 if (DEBUG_ENABLED(DEBUG::Graph)) {
2179 boost::shared_ptr<RouteList> rl = routes.reader ();
2180 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
2181 DEBUG_TRACE (DEBUG::Graph, string_compose ("%1 fed by ...\n", (*i)->name()));
2183 const Route::FedBy& fb ((*i)->fed_by());
2185 for (Route::FedBy::const_iterator f = fb.begin(); f != fb.end(); ++f) {
2186 boost::shared_ptr<Route> sf = f->r.lock();
2188 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 (sends only ? %2)\n", sf->name(), f->sends_only));
2197 /** This is called whenever we need to rebuild the graph of how we will process
2199 * @param r List of routes, in any order.
2203 Session::resort_routes_using (boost::shared_ptr<RouteList> r)
2205 /* We are going to build a directed graph of our routes;
2206 this is where the edges of that graph are put.
2211 /* Go through all routes doing two things:
2213 * 1. Collect the edges of the route graph. Each of these edges
2214 * is a pair of routes, one of which directly feeds the other
2215 * either by a JACK connection or by an internal send.
2217 * 2. Begin the process of making routes aware of which other
2218 * routes directly or indirectly feed them. This information
2219 * is used by the solo code.
2222 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2224 /* Clear out the route's list of direct or indirect feeds */
2225 (*i)->clear_fed_by ();
2227 for (RouteList::iterator j = r->begin(); j != r->end(); ++j) {
2229 bool via_sends_only;
2231 /* See if this *j feeds *i according to the current state of the JACK
2232 connections and internal sends.
2234 if ((*j)->direct_feeds_according_to_reality (*i, &via_sends_only)) {
2235 /* add the edge to the graph (part #1) */
2236 edges.add (*j, *i, via_sends_only);
2237 /* tell the route (for part #2) */
2238 (*i)->add_fed_by (*j, via_sends_only);
2243 /* Attempt a topological sort of the route graph */
2244 boost::shared_ptr<RouteList> sorted_routes = topological_sort (r, edges);
2246 if (sorted_routes) {
2247 /* We got a satisfactory topological sort, so there is no feedback;
2250 Note: the process graph rechain does not require a
2251 topologically-sorted list, but hey ho.
2253 if (_process_graph) {
2254 _process_graph->rechain (sorted_routes, edges);
2257 _current_route_graph = edges;
2259 /* Complete the building of the routes' lists of what directly
2260 or indirectly feeds them.
2262 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2263 trace_terminal (*i, *i);
2266 *r = *sorted_routes;
2269 DEBUG_TRACE (DEBUG::Graph, "Routes resorted, order follows:\n");
2270 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2271 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 signal order %2\n",
2272 (*i)->name(), (*i)->order_key ()));
2276 SuccessfulGraphSort (); /* EMIT SIGNAL */
2279 /* The topological sort failed, so we have a problem. Tell everyone
2280 and stick to the old graph; this will continue to be processed, so
2281 until the feedback is fixed, what is played back will not quite
2282 reflect what is actually connected. Note also that we do not
2283 do trace_terminal here, as it would fail due to an endless recursion,
2284 so the solo code will think that everything is still connected
2288 FeedbackDetected (); /* EMIT SIGNAL */
2293 /** Find a route name starting with \a base, maybe followed by the
2294 * lowest \a id. \a id will always be added if \a definitely_add_number
2295 * is true on entry; otherwise it will only be added if required
2296 * to make the name unique.
2298 * Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
2299 * The available route name with the lowest ID will be used, and \a id
2300 * will be set to the ID.
2302 * \return false if a route name could not be found, and \a track_name
2303 * and \a id do not reflect a free route name.
2306 Session::find_route_name (string const & base, uint32_t& id, string& name, bool definitely_add_number)
2308 /* the base may conflict with ports that do not belong to existing
2309 routes, but hidden objects like the click track. So check port names
2310 before anything else.
2313 for (vector<string>::const_iterator reserved = reserved_io_names.begin(); reserved != reserved_io_names.end(); ++reserved) {
2314 if (base == *reserved) {
2315 /* Check if this reserved name already exists, and if
2316 so, disallow it without a numeric suffix.
2318 if (route_by_name (*reserved)) {
2319 definitely_add_number = true;
2328 if (!definitely_add_number && route_by_name (base) == 0) {
2329 /* juse use the base */
2335 name = string_compose ("%1 %2", base, id);
2337 if (route_by_name (name) == 0) {
2343 } while (id < (UINT_MAX-1));
2348 /** Count the total ins and outs of all non-hidden tracks in the session and return them in in and out */
2350 Session::count_existing_track_channels (ChanCount& in, ChanCount& out)
2352 in = ChanCount::ZERO;
2353 out = ChanCount::ZERO;
2355 boost::shared_ptr<RouteList> r = routes.reader ();
2357 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
2358 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
2359 if (tr && !tr->is_auditioner()) {
2360 in += tr->n_inputs();
2361 out += tr->n_outputs();
2367 Session::default_track_name_pattern (DataType t)
2370 case DataType::AUDIO:
2371 if (Profile->get_trx()) {
2378 case DataType::MIDI:
2385 /** Caller must not hold process lock
2386 * @param name_template string to use for the start of the name, or "" to use "MIDI".
2387 * @param instrument plugin info for the instrument to insert pre-fader, if any
2389 list<boost::shared_ptr<MidiTrack> >
2390 Session::new_midi_track (const ChanCount& input, const ChanCount& output, boost::shared_ptr<PluginInfo> instrument,
2391 TrackMode mode, RouteGroup* route_group, uint32_t how_many, string name_template)
2394 uint32_t track_id = 0;
2396 RouteList new_routes;
2397 list<boost::shared_ptr<MidiTrack> > ret;
2399 const string name_pattern = default_track_name_pattern (DataType::MIDI);
2400 bool const use_number = (how_many != 1) || name_template.empty () || (name_template == name_pattern);
2403 if (!find_route_name (name_template.empty() ? _("MIDI") : name_template, ++track_id, track_name, use_number)) {
2404 error << "cannot find name for new midi track" << endmsg;
2408 boost::shared_ptr<MidiTrack> track;
2411 track.reset (new MidiTrack (*this, track_name, Route::Flag (0), mode));
2413 if (track->init ()) {
2417 if (Profile->get_mixbus ()) {
2418 track->set_strict_io (true);
2421 track->use_new_diskstream();
2423 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2424 // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
2427 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2428 if (track->input()->ensure_io (input, false, this)) {
2429 error << "cannot configure " << input << " out configuration for new midi track" << endmsg;
2433 if (track->output()->ensure_io (output, false, this)) {
2434 error << "cannot configure " << output << " out configuration for new midi track" << endmsg;
2439 track->non_realtime_input_change();
2442 route_group->add (track);
2445 track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
2447 if (Config->get_remote_model() == UserOrdered) {
2448 track->set_remote_control_id (next_control_id());
2451 new_routes.push_back (track);
2452 ret.push_back (track);
2454 RouteAddedOrRemoved (true); /* EMIT SIGNAL */
2457 catch (failed_constructor &err) {
2458 error << _("Session: could not create new midi track.") << endmsg;
2462 catch (AudioEngine::PortRegistrationFailure& pfe) {
2464 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;
2472 if (!new_routes.empty()) {
2473 StateProtector sp (this);
2474 if (Profile->get_trx()) {
2475 add_routes (new_routes, false, false, false);
2477 add_routes (new_routes, true, true, false);
2481 for (RouteList::iterator r = new_routes.begin(); r != new_routes.end(); ++r) {
2482 PluginPtr plugin = instrument->load (*this);
2483 boost::shared_ptr<Processor> p (new PluginInsert (*this, plugin));
2484 (*r)->add_processor (p, PreFader);
2494 Session::new_midi_route (RouteGroup* route_group, uint32_t how_many, string name_template, boost::shared_ptr<PluginInfo> instrument)
2497 uint32_t bus_id = 0;
2501 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Midi Bus");
2504 if (!find_route_name (name_template.empty () ? _("Midi Bus") : name_template, ++bus_id, bus_name, use_number)) {
2505 error << "cannot find name for new midi bus" << endmsg;
2510 boost::shared_ptr<Route> bus (new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO)); // XXX Editor::add_routes is not ready for ARDOUR::DataType::MIDI
2516 if (Profile->get_mixbus ()) {
2517 bus->set_strict_io (true);
2520 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2521 // boost_debug_shared_ptr_mark_interesting (bus.get(), "Route");
2524 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2526 if (bus->input()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
2527 error << _("cannot configure new midi bus input") << endmsg;
2532 if (bus->output()->ensure_io (ChanCount(DataType::MIDI, 1), false, this)) {
2533 error << _("cannot configure new midi bus output") << endmsg;
2539 route_group->add (bus);
2541 if (Config->get_remote_model() == UserOrdered) {
2542 bus->set_remote_control_id (next_control_id());
2545 ret.push_back (bus);
2546 RouteAddedOrRemoved (true); /* EMIT SIGNAL */
2550 catch (failed_constructor &err) {
2551 error << _("Session: could not create new audio route.") << endmsg;
2555 catch (AudioEngine::PortRegistrationFailure& pfe) {
2556 error << pfe.what() << endmsg;
2566 StateProtector sp (this);
2567 add_routes (ret, false, false, false);
2570 for (RouteList::iterator r = ret.begin(); r != ret.end(); ++r) {
2571 PluginPtr plugin = instrument->load (*this);
2572 boost::shared_ptr<Processor> p (new PluginInsert (*this, plugin));
2573 (*r)->add_processor (p, PreFader);
2584 Session::midi_output_change_handler (IOChange change, void * /*src*/, boost::weak_ptr<Route> wmt)
2586 boost::shared_ptr<Route> midi_track (wmt.lock());
2592 if ((change.type & IOChange::ConfigurationChanged) && Config->get_output_auto_connect() != ManualConnect) {
2594 if (change.after.n_audio() <= change.before.n_audio()) {
2598 /* new audio ports: make sure the audio goes somewhere useful,
2599 * unless the user has no-auto-connect selected.
2601 * The existing ChanCounts don't matter for this call as they are only
2602 * to do with matching input and output indices, and we are only changing
2605 auto_connect_route (midi_track, false, ChanCount(), change.before);
2609 #ifdef USE_TRACKS_CODE_FEATURES
2612 compare_routes_by_remote_id (const boost::shared_ptr<Route>& route1, const boost::shared_ptr<Route>& route2)
2614 return route1->remote_control_id() < route2->remote_control_id();
2618 Session::reconnect_existing_routes (bool withLock, bool reconnect_master, bool reconnect_inputs, bool reconnect_outputs)
2620 // it is not allowed to perform connection
2621 if (!IO::connecting_legal) {
2625 // if we are deleting routes we will call this once at the end
2626 if (_route_deletion_in_progress) {
2630 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
2636 // We need to disconnect the route's inputs and outputs first
2637 // basing on autoconnect configuration
2638 bool reconnectIputs = !(Config->get_input_auto_connect() & ManualConnect) && reconnect_inputs;
2639 bool reconnectOutputs = !(Config->get_output_auto_connect() & ManualConnect) && reconnect_outputs;
2641 ChanCount existing_inputs;
2642 ChanCount existing_outputs;
2643 count_existing_track_channels (existing_inputs, existing_outputs);
2645 //ChanCount inputs = ChanCount::ZERO;
2646 //ChanCount outputs = ChanCount::ZERO;
2648 RouteList existing_routes = *routes.reader ();
2649 existing_routes.sort (compare_routes_by_remote_id);
2652 PBD::Unwinder<bool> protect_ignore_changes (_reconnecting_routes_in_progress, true);
2654 vector<string> physinputs;
2655 vector<string> physoutputs;
2657 EngineStateController::instance()->get_physical_audio_outputs(physoutputs);
2658 EngineStateController::instance()->get_physical_audio_inputs(physinputs);
2660 uint32_t input_n = 0;
2661 uint32_t output_n = 0;
2662 RouteList::iterator rIter = existing_routes.begin();
2663 const AutoConnectOption current_input_auto_connection (Config->get_input_auto_connect());
2664 const AutoConnectOption current_output_auto_connection (Config->get_output_auto_connect());
2665 for (; rIter != existing_routes.end(); ++rIter) {
2666 if (*rIter == _master_out || *rIter == _monitor_out ) {
2670 if (current_output_auto_connection == AutoConnectPhysical) {
2671 (*rIter)->amp()->deactivate();
2672 } else if (current_output_auto_connection == AutoConnectMaster) {
2673 (*rIter)->amp()->activate();
2676 if (reconnectIputs) {
2677 (*rIter)->input()->disconnect (this); //GZ: check this; could be heavy
2679 for (uint32_t route_input_n = 0; route_input_n < (*rIter)->n_inputs().get(DataType::AUDIO); ++route_input_n) {
2681 if (current_input_auto_connection & AutoConnectPhysical) {
2683 if ( input_n == physinputs.size() ) {
2687 string port = physinputs[input_n];
2689 if (port.empty() ) {
2690 error << "Physical Input number "<< input_n << " is unavailable and cannot be connected" << endmsg;
2693 //GZ: check this; could be heavy
2694 (*rIter)->input()->connect ((*rIter)->input()->ports().port(DataType::AUDIO, route_input_n), port, this);
2700 if (reconnectOutputs) {
2702 //normalize route ouptuts: reduce the amount outputs to be equal to the amount of inputs
2703 if (current_output_auto_connection & AutoConnectPhysical) {
2705 //GZ: check this; could be heavy
2706 (*rIter)->output()->disconnect (this);
2707 size_t route_inputs_count = (*rIter)->n_inputs().get(DataType::AUDIO);
2709 //GZ: check this; could be heavy
2710 (*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, route_inputs_count), false, this );
2712 } else if (current_output_auto_connection & AutoConnectMaster){
2714 if (!reconnect_master) {
2718 //GZ: check this; could be heavy
2719 (*rIter)->output()->disconnect (this);
2722 uint32_t master_inputs_count = _master_out->n_inputs().get(DataType::AUDIO);
2723 (*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, master_inputs_count), false, this );
2725 error << error << "Master bus is not available" << endmsg;
2730 for (uint32_t route_output_n = 0; route_output_n < (*rIter)->n_outputs().get(DataType::AUDIO); ++route_output_n) {
2731 if (current_output_auto_connection & AutoConnectPhysical) {
2733 if ( output_n == physoutputs.size() ) {
2737 string port = physoutputs[output_n];
2739 if (port.empty() ) {
2740 error << "Physical Output number "<< output_n << " is unavailable and cannot be connected" << endmsg;
2743 //GZ: check this; could be heavy
2744 (*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
2747 } else if (current_output_auto_connection & AutoConnectMaster) {
2749 if ( route_output_n == _master_out->n_inputs().get(DataType::AUDIO) ) {
2753 // connect to master bus
2754 string port = _master_out->input()->ports().port(DataType::AUDIO, route_output_n)->name();
2756 if (port.empty() ) {
2757 error << "MasterBus Input number "<< route_output_n << " is unavailable and cannot be connected" << endmsg;
2761 //GZ: check this; could be heavy
2762 (*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
2769 _master_out->output()->disconnect (this);
2770 auto_connect_master_bus ();
2775 session_routes_reconnected (); /* EMIT SIGNAL */
2779 Session::reconnect_midi_scene_ports(bool inputs)
2783 boost::shared_ptr<MidiPort> scene_in_ptr = scene_in();
2785 scene_in_ptr->disconnect_all ();
2787 std::vector<EngineStateController::MidiPortState> midi_port_states;
2788 EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
2790 std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2792 for (; state_iter != midi_port_states.end(); ++state_iter) {
2793 if (state_iter->active && state_iter->available && state_iter->scene_connected) {
2794 scene_in_ptr->connect (state_iter->name);
2801 boost::shared_ptr<MidiPort> scene_out_ptr = scene_out();
2803 if (scene_out_ptr ) {
2804 scene_out_ptr->disconnect_all ();
2806 std::vector<EngineStateController::MidiPortState> midi_port_states;
2807 EngineStateController::instance()->get_physical_midi_output_states (midi_port_states);
2809 std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2811 for (; state_iter != midi_port_states.end(); ++state_iter) {
2812 if (state_iter->active && state_iter->available && state_iter->scene_connected) {
2813 scene_out_ptr->connect (state_iter->name);
2821 Session::reconnect_mtc_ports ()
2823 boost::shared_ptr<MidiPort> mtc_in_ptr = _midi_ports->mtc_input_port();
2829 mtc_in_ptr->disconnect_all ();
2831 std::vector<EngineStateController::MidiPortState> midi_port_states;
2832 EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
2834 std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
2836 for (; state_iter != midi_port_states.end(); ++state_iter) {
2837 if (state_iter->available && state_iter->mtc_in) {
2838 mtc_in_ptr->connect (state_iter->name);
2842 if (!_midi_ports->mtc_input_port ()->connected () &&
2843 config.get_external_sync () &&
2844 (Config->get_sync_source () == MTC) ) {
2845 config.set_external_sync (false);
2848 if ( ARDOUR::Profile->get_trx () ) {
2849 // Tracks need this signal to update timecode_source_dropdown
2850 MtcOrLtcInputPortChanged (); //emit signal
2855 Session::reconnect_mmc_ports(bool inputs)
2857 if (inputs ) { // get all enabled midi input ports
2859 boost::shared_ptr<MidiPort> mmc_in_ptr = _midi_ports->mmc_in();
2861 mmc_in_ptr->disconnect_all ();
2862 std::vector<std::string> enabled_midi_inputs;
2863 EngineStateController::instance()->get_physical_midi_inputs (enabled_midi_inputs);
2865 std::vector<std::string>::iterator port_iter = enabled_midi_inputs.begin();
2867 for (; port_iter != enabled_midi_inputs.end(); ++port_iter) {
2868 mmc_in_ptr->connect (*port_iter);
2872 } else { // get all enabled midi output ports
2874 boost::shared_ptr<MidiPort> mmc_out_ptr = _midi_ports->mmc_out();
2876 mmc_out_ptr->disconnect_all ();
2877 std::vector<std::string> enabled_midi_outputs;
2878 EngineStateController::instance()->get_physical_midi_outputs (enabled_midi_outputs);
2880 std::vector<std::string>::iterator port_iter = enabled_midi_outputs.begin();
2882 for (; port_iter != enabled_midi_outputs.end(); ++port_iter) {
2883 mmc_out_ptr->connect (*port_iter);
2891 /** Caller must not hold process lock
2892 * @param name_template string to use for the start of the name, or "" to use "Audio".
2894 list< boost::shared_ptr<AudioTrack> >
2895 Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group,
2896 uint32_t how_many, string name_template)
2899 uint32_t track_id = 0;
2901 RouteList new_routes;
2902 list<boost::shared_ptr<AudioTrack> > ret;
2904 const string name_pattern = default_track_name_pattern (DataType::AUDIO);
2905 bool const use_number = (how_many != 1) || name_template.empty () || (name_template == name_pattern);
2909 if (!find_route_name (name_template.empty() ? _(name_pattern.c_str()) : name_template, ++track_id, track_name, use_number)) {
2910 error << "cannot find name for new audio track" << endmsg;
2914 boost::shared_ptr<AudioTrack> track;
2917 track.reset (new AudioTrack (*this, track_name, Route::Flag (0), mode));
2919 if (track->init ()) {
2923 if (Profile->get_mixbus ()) {
2924 track->set_strict_io (true);
2928 if (ARDOUR::Profile->get_trx ()) {
2929 // TRACKS considers it's not a USE CASE, it's
2930 // a piece of behavior of the session model:
2932 // Gain for a newly created route depends on
2933 // the current output_auto_connect mode:
2935 // 0 for Stereo Out mode
2937 if (Config->get_output_auto_connect() & AutoConnectMaster) {
2938 track->set_gain (dB_to_coefficient (0), Controllable::NoGroup);
2942 track->use_new_diskstream();
2944 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
2945 // boost_debug_shared_ptr_mark_interesting (track.get(), "Track");
2948 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2950 if (track->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
2951 error << string_compose (
2952 _("cannot configure %1 in/%2 out configuration for new audio track"),
2953 input_channels, output_channels)
2958 if (track->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
2959 error << string_compose (
2960 _("cannot configure %1 in/%2 out configuration for new audio track"),
2961 input_channels, output_channels)
2968 route_group->add (track);
2971 track->non_realtime_input_change();
2973 track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
2974 if (Config->get_remote_model() == UserOrdered) {
2975 track->set_remote_control_id (next_control_id());
2978 new_routes.push_back (track);
2979 ret.push_back (track);
2981 RouteAddedOrRemoved (true); /* EMIT SIGNAL */
2984 catch (failed_constructor &err) {
2985 error << _("Session: could not create new audio track.") << endmsg;
2989 catch (AudioEngine::PortRegistrationFailure& pfe) {
2991 error << pfe.what() << endmsg;
2999 if (!new_routes.empty()) {
3000 StateProtector sp (this);
3001 if (Profile->get_trx()) {
3002 add_routes (new_routes, false, false, false);
3004 add_routes (new_routes, true, true, false);
3011 /** Caller must not hold process lock.
3012 * @param name_template string to use for the start of the name, or "" to use "Bus".
3015 Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, string name_template)
3018 uint32_t bus_id = 0;
3022 bool const use_number = (how_many != 1) || name_template.empty () || name_template == _("Bus");
3025 if (!find_route_name (name_template.empty () ? _("Bus") : name_template, ++bus_id, bus_name, use_number)) {
3026 error << "cannot find name for new audio bus" << endmsg;
3031 boost::shared_ptr<Route> bus (new Route (*this, bus_name, Route::Flag(0), DataType::AUDIO));
3037 if (Profile->get_mixbus ()) {
3038 bus->set_strict_io (true);
3041 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
3042 // boost_debug_shared_ptr_mark_interesting (bus.get(), "Route");
3045 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3047 if (bus->input()->ensure_io (ChanCount(DataType::AUDIO, input_channels), false, this)) {
3048 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
3049 input_channels, output_channels)
3055 if (bus->output()->ensure_io (ChanCount(DataType::AUDIO, output_channels), false, this)) {
3056 error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
3057 input_channels, output_channels)
3064 route_group->add (bus);
3066 if (Config->get_remote_model() == UserOrdered) {
3067 bus->set_remote_control_id (next_control_id());
3070 bus->add_internal_return ();
3072 ret.push_back (bus);
3074 RouteAddedOrRemoved (true); /* EMIT SIGNAL */
3080 catch (failed_constructor &err) {
3081 error << _("Session: could not create new audio route.") << endmsg;
3085 catch (AudioEngine::PortRegistrationFailure& pfe) {
3086 error << pfe.what() << endmsg;
3096 StateProtector sp (this);
3097 if (Profile->get_trx()) {
3098 add_routes (ret, false, false, false);
3100 add_routes (ret, false, true, true); // autoconnect // outputs only
3109 Session::new_route_from_template (uint32_t how_many, const std::string& template_path, const std::string& name_base, PlaylistDisposition pd)
3113 if (!tree.read (template_path.c_str())) {
3117 return new_route_from_template (how_many, *tree.root(), name_base, pd);
3121 Session::new_route_from_template (uint32_t how_many, XMLNode& node, const std::string& name_base, PlaylistDisposition pd)
3124 uint32_t control_id;
3125 uint32_t number = 0;
3126 const uint32_t being_added = how_many;
3127 /* This will prevent the use of any existing XML-provided PBD::ID
3130 Stateful::ForceIDRegeneration force_ids;
3131 IO::disable_connecting ();
3133 control_id = next_control_id ();
3137 /* We're going to modify the node contents a bit so take a
3138 * copy. The node may be re-used when duplicating more than once.
3141 XMLNode node_copy (node);
3146 if (!name_base.empty()) {
3148 /* if we're adding more than one routes, force
3149 * all the names of the new routes to be
3150 * numbered, via the final parameter.
3153 if (!find_route_name (name_base.c_str(), ++number, name, (being_added > 1))) {
3154 fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
3160 string const route_name = node_copy.property(X_("name"))->value ();
3162 /* generate a new name by adding a number to the end of the template name */
3163 if (!find_route_name (route_name.c_str(), ++number, name, true)) {
3164 fatal << _("Session: UINT_MAX routes? impossible!") << endmsg;
3165 abort(); /*NOTREACHED*/
3169 /* set this name in the XML description that we are about to use */
3171 bool rename_playlist;
3174 rename_playlist = true;
3178 rename_playlist = false;
3181 Route::set_name_in_state (node_copy, name, rename_playlist);
3183 /* trim bitslots from listen sends so that new ones are used */
3184 XMLNodeList children = node_copy.children ();
3185 for (XMLNodeList::iterator i = children.begin(); i != children.end(); ++i) {
3186 if ((*i)->name() == X_("Processor")) {
3187 /* ForceIDRegeneration does not catch the following */
3188 XMLProperty* role = (*i)->property (X_("role"));
3189 XMLProperty* type = (*i)->property (X_("type"));
3190 if (role && role->value() == X_("Aux")) {
3191 /* check if the target bus exists.
3192 * we should not save aux-sends in templates.
3194 XMLProperty* target = (*i)->property (X_("target"));
3196 (*i)->add_property ("type", "dangling-aux-send");
3199 boost::shared_ptr<Route> r = route_by_id (target->value());
3200 if (!r || boost::dynamic_pointer_cast<Track>(r)) {
3201 (*i)->add_property ("type", "dangling-aux-send");
3205 if (role && role->value() == X_("Listen")) {
3206 (*i)->remove_property (X_("bitslot"));
3208 else if (role && (role->value() == X_("Send") || role->value() == X_("Aux"))) {
3210 Delivery::Role xrole;
3211 uint32_t bitslot = 0;
3212 xrole = Delivery::Role (string_2_enum (role->value(), xrole));
3213 std::string name = Send::name_and_id_new_send(*this, xrole, bitslot, false);
3214 snprintf (buf, sizeof (buf), "%" PRIu32, bitslot);
3215 (*i)->remove_property (X_("bitslot"));
3216 (*i)->remove_property (X_("name"));
3217 (*i)->add_property ("bitslot", buf);
3218 (*i)->add_property ("name", name);
3220 else if (type && type->value() == X_("return")) {
3221 // Return::set_state() generates a new one
3222 (*i)->remove_property (X_("bitslot"));
3224 else if (type && type->value() == X_("port")) {
3225 // PortInsert::set_state() handles the bitslot
3226 (*i)->remove_property (X_("bitslot"));
3227 (*i)->add_property ("ignore-name", "1");
3232 boost::shared_ptr<Route> route (XMLRouteFactory (node_copy, 3000));
3235 error << _("Session: cannot create track/bus from template description") << endmsg;
3239 if (boost::dynamic_pointer_cast<Track>(route)) {
3240 /* force input/output change signals so that the new diskstream
3241 picks up the configuration of the route. During session
3242 loading this normally happens in a different way.
3245 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3247 IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
3248 change.after = route->input()->n_ports();
3249 route->input()->changed (change, this);
3250 change.after = route->output()->n_ports();
3251 route->output()->changed (change, this);
3254 route->set_remote_control_id (control_id);
3257 boost::shared_ptr<Track> track;
3259 if ((track = boost::dynamic_pointer_cast<Track> (route))) {
3262 track->use_new_playlist ();
3265 track->use_copy_playlist ();
3272 ret.push_back (route);
3274 RouteAddedOrRemoved (true); /* EMIT SIGNAL */
3277 catch (failed_constructor &err) {
3278 error << _("Session: could not create new route from template") << endmsg;
3282 catch (AudioEngine::PortRegistrationFailure& pfe) {
3283 error << pfe.what() << endmsg;
3292 StateProtector sp (this);
3293 if (Profile->get_trx()) {
3294 add_routes (ret, false, false, false);
3296 add_routes (ret, true, true, false);
3298 IO::enable_connecting ();
3305 Session::add_routes (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect, bool save)
3308 PBD::Unwinder<bool> aip (_adding_routes_in_progress, true);
3309 add_routes_inner (new_routes, input_auto_connect, output_auto_connect);
3312 error << _("Adding new tracks/busses failed") << endmsg;
3317 update_latency (true);
3318 update_latency (false);
3323 save_state (_current_snapshot_name);
3326 reassign_track_numbers();
3328 update_route_record_state ();
3330 RouteAdded (new_routes); /* EMIT SIGNAL */
3334 Session::add_routes_inner (RouteList& new_routes, bool input_auto_connect, bool output_auto_connect)
3336 ChanCount existing_inputs;
3337 ChanCount existing_outputs;
3338 uint32_t order = next_control_id();
3341 if (_order_hint > -1) {
3342 order = _order_hint;
3346 count_existing_track_channels (existing_inputs, existing_outputs);
3349 RCUWriter<RouteList> writer (routes);
3350 boost::shared_ptr<RouteList> r = writer.get_copy ();
3351 r->insert (r->end(), new_routes.begin(), new_routes.end());
3353 /* if there is no control out and we're not in the middle of loading,
3354 * resort the graph here. if there is a control out, we will resort
3355 * toward the end of this method. if we are in the middle of loading,
3356 * we will resort when done.
3359 if (!_monitor_out && IO::connecting_legal) {
3360 resort_routes_using (r);
3364 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
3366 boost::weak_ptr<Route> wpr (*x);
3367 boost::shared_ptr<Route> r (*x);
3369 r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
3370 r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2, wpr));
3371 r->solo_isolated_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, wpr));
3372 r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this));
3373 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
3374 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
3376 if (r->is_master()) {
3380 if (r->is_monitor()) {
3384 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (r);
3386 tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
3387 track_playlist_changed (boost::weak_ptr<Track> (tr));
3388 tr->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Session::update_route_record_state, this));
3390 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
3392 mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
3393 mt->output()->changed.connect_same_thread (*this, boost::bind (&Session::midi_output_change_handler, this, _1, _2, boost::weak_ptr<Route>(mt)));
3397 if (input_auto_connect || output_auto_connect) {
3398 auto_connect_route (r, input_auto_connect, ChanCount (), ChanCount (), existing_inputs, existing_outputs);
3399 existing_inputs += r->n_inputs();
3400 existing_outputs += r->n_outputs();
3403 /* order keys are a GUI responsibility but we need to set up
3404 reasonable defaults because they also affect the remote control
3405 ID in most situations.
3408 if (!r->has_order_key ()) {
3409 if (r->is_auditioner()) {
3410 /* use an arbitrarily high value */
3411 r->set_order_key (UINT_MAX);
3413 DEBUG_TRACE (DEBUG::OrderKeys, string_compose ("while adding, set %1 to order key %2\n", r->name(), order));
3414 r->set_order_key (order);
3422 if (_monitor_out && IO::connecting_legal) {
3423 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
3425 for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
3426 if ((*x)->is_monitor()) {
3428 } else if ((*x)->is_master()) {
3431 (*x)->enable_monitor_send ();
3438 Session::globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest)
3440 boost::shared_ptr<RouteList> r = routes.reader ();
3441 boost::shared_ptr<Send> s;
3443 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3444 if ((s = (*i)->internal_send_for (dest)) != 0) {
3445 s->amp()->gain_control()->set_value (GAIN_COEFF_ZERO, Controllable::NoGroup);
3451 Session::globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest)
3453 boost::shared_ptr<RouteList> r = routes.reader ();
3454 boost::shared_ptr<Send> s;
3456 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3457 if ((s = (*i)->internal_send_for (dest)) != 0) {
3458 s->amp()->gain_control()->set_value (GAIN_COEFF_UNITY, Controllable::NoGroup);
3464 Session::globally_set_send_gains_from_track(boost::shared_ptr<Route> dest)
3466 boost::shared_ptr<RouteList> r = routes.reader ();
3467 boost::shared_ptr<Send> s;
3469 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3470 if ((s = (*i)->internal_send_for (dest)) != 0) {
3471 s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value(), Controllable::NoGroup);
3476 /** @param include_buses true to add sends to buses and tracks, false for just tracks */
3478 Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
3480 boost::shared_ptr<RouteList> r = routes.reader ();
3481 boost::shared_ptr<RouteList> t (new RouteList);
3483 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3484 /* no MIDI sends because there are no MIDI busses yet */
3485 if (include_buses || boost::dynamic_pointer_cast<AudioTrack>(*i)) {
3490 add_internal_sends (dest, p, t);
3494 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
3496 for (RouteList::iterator i = senders->begin(); i != senders->end(); ++i) {
3497 add_internal_send (dest, (*i)->before_processor_for_placement (p), *i);
3502 Session::add_internal_send (boost::shared_ptr<Route> dest, int index, boost::shared_ptr<Route> sender)
3504 add_internal_send (dest, sender->before_processor_for_index (index), sender);
3508 Session::add_internal_send (boost::shared_ptr<Route> dest, boost::shared_ptr<Processor> before, boost::shared_ptr<Route> sender)
3510 if (sender->is_monitor() || sender->is_master() || sender == dest || dest->is_monitor() || dest->is_master()) {
3514 if (!dest->internal_return()) {
3515 dest->add_internal_return ();
3518 sender->add_aux_send (dest, before);
3525 Session::remove_routes (boost::shared_ptr<RouteList> routes_to_remove)
3527 { // RCU Writer scope
3528 PBD::Unwinder<bool> uw_flag (_route_deletion_in_progress, true);
3529 RCUWriter<RouteList> writer (routes);
3530 boost::shared_ptr<RouteList> rs = writer.get_copy ();
3533 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3535 if (*iter == _master_out) {
3539 (*iter)->set_solo (false, Controllable::NoGroup);
3543 /* deleting the master out seems like a dumb
3544 idea, but its more of a UI policy issue
3548 if (*iter == _master_out) {
3549 _master_out = boost::shared_ptr<Route> ();
3552 if (*iter == _monitor_out) {
3553 _monitor_out.reset ();
3556 // We need to disconnect the route's inputs and outputs
3558 (*iter)->input()->disconnect (0);
3559 (*iter)->output()->disconnect (0);
3561 /* if the route had internal sends sending to it, remove them */
3562 if ((*iter)->internal_return()) {
3564 boost::shared_ptr<RouteList> r = routes.reader ();
3565 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3566 boost::shared_ptr<Send> s = (*i)->internal_send_for (*iter);
3568 (*i)->remove_processor (s);
3573 /* if the monitoring section had a pointer to this route, remove it */
3574 if (_monitor_out && !(*iter)->is_master() && !(*iter)->is_monitor()) {
3575 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3576 PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
3577 (*iter)->remove_aux_or_listen (_monitor_out);
3580 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*iter);
3581 if (mt && mt->step_editing()) {
3582 if (_step_editors > 0) {
3588 /* writer goes out of scope, forces route list update */
3590 } // end of RCU Writer scope
3592 update_route_solo_state ();
3593 RouteAddedOrRemoved (false); /* EMIT SIGNAL */
3594 update_latency_compensation ();
3597 /* Re-sort routes to remove the graph's current references to the one that is
3598 * going away, then flush old references out of the graph.
3599 * Wave Tracks: reconnect routes
3602 #ifdef USE_TRACKS_CODE_FEATURES
3603 reconnect_existing_routes(true, false);
3605 routes.flush (); // maybe unsafe, see below.
3609 if (_process_graph && !(_state_of_the_state & Deletion)) {
3610 _process_graph->clear_other_chain ();
3613 /* get rid of it from the dead wood collection in the route list manager */
3614 /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
3618 /* try to cause everyone to drop their references
3619 * and unregister ports from the backend
3622 for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
3623 (*iter)->drop_references ();
3626 if (_state_of_the_state & Deletion) {
3630 Route::RemoteControlIDChange(); /* EMIT SIGNAL */
3632 /* save the new state of the world */
3634 if (save_state (_current_snapshot_name)) {
3635 save_history (_current_snapshot_name);
3638 reassign_track_numbers();
3639 update_route_record_state ();
3643 Session::remove_route (boost::shared_ptr<Route> route)
3645 boost::shared_ptr<RouteList> rl (new RouteList);
3646 rl->push_back (route);
3651 Session::route_mute_changed ()
3657 Session::route_listen_changed (Controllable::GroupControlDisposition group_override, boost::weak_ptr<Route> wpr)
3659 boost::shared_ptr<Route> route = wpr.lock();
3661 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_listen_changed")) << endmsg;
3665 if (route->listening_via_monitor ()) {
3667 if (Config->get_exclusive_solo()) {
3669 RouteGroup* rg = route->route_group ();
3670 const bool group_already_accounted_for = route->use_group (group_override, &RouteGroup::is_solo);
3672 boost::shared_ptr<RouteList> r = routes.reader ();
3674 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3675 if ((*i) == route) {
3676 /* already changed */
3680 if ((*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3681 /* route does not get solo propagated to it */
3685 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
3686 /* this route is a part of the same solo group as the route
3687 * that was changed. Changing that route did change or will
3688 * change all group members appropriately, so we can ignore it
3693 (*i)->set_listen (false, Controllable::NoGroup);
3699 } else if (_listen_cnt > 0) {
3704 update_route_solo_state ();
3707 Session::route_solo_isolated_changed (boost::weak_ptr<Route> wpr)
3709 boost::shared_ptr<Route> route = wpr.lock ();
3712 /* should not happen */
3713 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_isolated_changed")) << endmsg;
3717 bool send_changed = false;
3719 if (route->solo_isolated()) {
3720 if (_solo_isolated_cnt == 0) {
3721 send_changed = true;
3723 _solo_isolated_cnt++;
3724 } else if (_solo_isolated_cnt > 0) {
3725 _solo_isolated_cnt--;
3726 if (_solo_isolated_cnt == 0) {
3727 send_changed = true;
3732 IsolatedChanged (); /* EMIT SIGNAL */
3737 Session::route_solo_changed (bool self_solo_change, Controllable::GroupControlDisposition group_override, boost::weak_ptr<Route> wpr)
3739 DEBUG_TRACE (DEBUG::Solo, string_compose ("route solo change, self = %1\n", self_solo_change));
3741 if (!self_solo_change) {
3742 // session doesn't care about changes to soloed-by-others
3746 boost::shared_ptr<Route> route = wpr.lock ();
3749 boost::shared_ptr<RouteList> r = routes.reader ();
3752 if (route->self_soloed()) {
3758 /* the route may be a member of a group that has shared-solo
3759 * semantics. If so, then all members of that group should follow the
3760 * solo of the changed route. But ... this is optional, controlled by a
3761 * Controllable::GroupControlDisposition.
3763 * The first argument to the signal that this method is connected to is the
3764 * GroupControlDisposition value that was used to change solo.
3766 * If the solo change was done with group semantics (either InverseGroup
3767 * (force the entire group to change even if the group shared solo is
3768 * disabled) or UseGroup (use the group, which may or may not have the
3769 * shared solo property enabled)) then as we propagate the change to
3770 * the entire session we should IGNORE THE GROUP that the changed route
3774 RouteGroup* rg = route->route_group ();
3775 const bool group_already_accounted_for = (group_override == Controllable::ForGroup);
3777 if (delta == 1 && Config->get_exclusive_solo()) {
3779 /* new solo: disable all other solos, but not the group if its solo-enabled */
3781 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3783 if ((*i) == route) {
3784 /* already changed */
3788 if ((*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3789 /* route does not get solo propagated to it */
3793 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
3794 /* this route is a part of the same solo group as the route
3795 * that was changed. Changing that route did change or will
3796 * change all group members appropriately, so we can ignore it
3802 (*i)->set_solo (false, group_override);
3806 DEBUG_TRACE (DEBUG::Solo, string_compose ("propagate solo change, delta = %1\n", delta));
3808 RouteList uninvolved;
3810 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1\n", route->name()));
3812 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3813 bool via_sends_only;
3814 bool in_signal_flow;
3816 if ((*i) == route) {
3817 /* already changed */
3821 if ((*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3822 /* route does not get solo propagated to it */
3826 if ((group_already_accounted_for && (*i)->route_group() && (*i)->route_group() == rg)) {
3827 /* this route is a part of the same solo group as the route
3828 * that was changed. Changing that route did change or will
3829 * change all group members appropriately, so we can ignore it
3835 in_signal_flow = false;
3837 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed from %1\n", (*i)->name()));
3839 if ((*i)->feeds (route, &via_sends_only)) {
3840 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a feed from %1\n", (*i)->name()));
3841 if (!via_sends_only) {
3842 if (!route->soloed_by_others_upstream()) {
3843 (*i)->mod_solo_by_others_downstream (delta);
3845 DEBUG_TRACE (DEBUG::Solo, "\talready soloed by others upstream\n");
3848 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tthere is a send-only feed from %1\n", (*i)->name()));
3850 in_signal_flow = true;
3852 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tno feed from %1\n", (*i)->name()));
3855 DEBUG_TRACE (DEBUG::Solo, string_compose ("check feed to %1\n", (*i)->name()));
3857 if (route->feeds (*i, &via_sends_only)) {
3858 /* propagate solo upstream only if routing other than
3859 sends is involved, but do consider the other route
3860 (*i) to be part of the signal flow even if only
3863 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 feeds %2 via sends only %3 sboD %4 sboU %5\n",
3867 route->soloed_by_others_downstream(),
3868 route->soloed_by_others_upstream()));
3869 if (!via_sends_only) {
3870 //NB. Triggers Invert Push, which handles soloed by downstream
3871 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tmod %1 by %2\n", (*i)->name(), delta));
3872 (*i)->mod_solo_by_others_upstream (delta);
3874 DEBUG_TRACE (DEBUG::Solo, string_compose ("\tfeed to %1 ignored, sends-only\n", (*i)->name()));
3876 in_signal_flow = true;
3878 DEBUG_TRACE (DEBUG::Solo, "\tno feed to\n");
3881 if (!in_signal_flow) {
3882 uninvolved.push_back (*i);
3886 DEBUG_TRACE (DEBUG::Solo, "propagation complete\n");
3888 update_route_solo_state (r);
3890 /* now notify that the mute state of the routes not involved in the signal
3891 pathway of the just-solo-changed route may have altered.
3894 for (RouteList::iterator i = uninvolved.begin(); i != uninvolved.end(); ++i) {
3895 DEBUG_TRACE (DEBUG::Solo, string_compose ("mute change for %1, which neither feeds or is fed by %2\n", (*i)->name(), route->name()));
3896 (*i)->act_on_mute ();
3897 (*i)->mute_changed ();
3900 SoloChanged (); /* EMIT SIGNAL */
3905 Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
3907 /* now figure out if anything that matters is soloed (or is "listening")*/
3909 bool something_soloed = false;
3910 bool something_listening = false;
3911 uint32_t listeners = 0;
3912 uint32_t isolated = 0;
3915 r = routes.reader();
3918 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3919 if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner() && (*i)->self_soloed()) {
3920 something_soloed = true;
3923 if (!(*i)->is_auditioner() && (*i)->listening_via_monitor()) {
3924 if (Config->get_solo_control_is_listen_control()) {
3926 something_listening = true;
3928 (*i)->set_listen (false, Controllable::NoGroup);
3932 if ((*i)->solo_isolated()) {
3937 if (something_soloed != _non_soloed_outs_muted) {
3938 _non_soloed_outs_muted = something_soloed;
3939 SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */
3942 if (something_listening != _listening) {
3943 _listening = something_listening;
3944 SoloActive (_listening);
3947 _listen_cnt = listeners;
3949 if (isolated != _solo_isolated_cnt) {
3950 _solo_isolated_cnt = isolated;
3951 IsolatedChanged (); /* EMIT SIGNAL */
3954 DEBUG_TRACE (DEBUG::Solo, string_compose ("solo state updated by session, soloed? %1 listeners %2 isolated %3\n",
3955 something_soloed, listeners, isolated));
3958 boost::shared_ptr<RouteList>
3959 Session::get_routes_with_internal_returns() const
3961 boost::shared_ptr<RouteList> r = routes.reader ();
3962 boost::shared_ptr<RouteList> rl (new RouteList);
3964 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3965 if ((*i)->internal_return ()) {
3973 Session::io_name_is_legal (const std::string& name)
3975 boost::shared_ptr<RouteList> r = routes.reader ();
3977 for (vector<string>::const_iterator reserved = reserved_io_names.begin(); reserved != reserved_io_names.end(); ++reserved) {
3978 if (name == *reserved) {
3979 if (!route_by_name (*reserved)) {
3980 /* first instance of a reserved name is allowed */
3983 /* all other instances of a reserved name are not allowed */
3988 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
3989 if ((*i)->name() == name) {
3993 if ((*i)->has_io_processor_named (name)) {
4002 Session::set_exclusive_input_active (boost::shared_ptr<RouteList> rl, bool onoff, bool flip_others)
4005 vector<string> connections;
4007 /* if we are passed only a single route and we're not told to turn
4008 * others off, then just do the simple thing.
4011 if (flip_others == false && rl->size() == 1) {
4012 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (rl->front());
4014 mt->set_input_active (onoff);
4019 for (RouteList::iterator rt = rl->begin(); rt != rl->end(); ++rt) {
4021 PortSet& ps ((*rt)->input()->ports());
4023 for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
4024 p->get_connections (connections);
4027 for (vector<string>::iterator s = connections.begin(); s != connections.end(); ++s) {
4028 routes_using_input_from (*s, rl2);
4031 /* scan all relevant routes to see if others are on or off */
4033 bool others_are_already_on = false;
4035 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
4037 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
4043 if ((*r) != (*rt)) {
4044 if (mt->input_active()) {
4045 others_are_already_on = true;
4048 /* this one needs changing */
4049 mt->set_input_active (onoff);
4055 /* globally reverse other routes */
4057 for (RouteList::iterator r = rl2.begin(); r != rl2.end(); ++r) {
4058 if ((*r) != (*rt)) {
4059 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*r);
4061 mt->set_input_active (!others_are_already_on);
4070 Session::routes_using_input_from (const string& str, RouteList& rl)
4072 boost::shared_ptr<RouteList> r = routes.reader();
4074 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4075 if ((*i)->input()->connected_to (str)) {
4081 boost::shared_ptr<Route>
4082 Session::route_by_name (string name)
4084 boost::shared_ptr<RouteList> r = routes.reader ();
4086 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4087 if ((*i)->name() == name) {
4092 return boost::shared_ptr<Route> ((Route*) 0);
4095 boost::shared_ptr<Route>
4096 Session::route_by_id (PBD::ID id)
4098 boost::shared_ptr<RouteList> r = routes.reader ();
4100 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4101 if ((*i)->id() == id) {
4106 return boost::shared_ptr<Route> ((Route*) 0);
4109 boost::shared_ptr<Processor>
4110 Session::processor_by_id (PBD::ID id) const
4112 boost::shared_ptr<RouteList> r = routes.reader ();
4114 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4115 boost::shared_ptr<Processor> p = (*i)->Route::processor_by_id (id);
4121 return boost::shared_ptr<Processor> ();
4124 boost::shared_ptr<Track>
4125 Session::track_by_diskstream_id (PBD::ID id)
4127 boost::shared_ptr<RouteList> r = routes.reader ();
4129 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4130 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
4131 if (t && t->using_diskstream_id (id)) {
4136 return boost::shared_ptr<Track> ();
4139 boost::shared_ptr<Route>
4140 Session::route_by_remote_id (uint32_t id)
4142 boost::shared_ptr<RouteList> r = routes.reader ();
4144 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4145 if ((*i)->remote_control_id() == id) {
4150 return boost::shared_ptr<Route> ((Route*) 0);
4154 boost::shared_ptr<Route>
4155 Session::route_by_selected_count (uint32_t id)
4157 boost::shared_ptr<RouteList> r = routes.reader ();
4159 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
4160 /* NOT IMPLEMENTED */
4163 return boost::shared_ptr<Route> ((Route*) 0);
4168 Session::reassign_track_numbers ()
4172 RouteList r (*(routes.reader ()));
4173 SignalOrderRouteSorter sorter;
4176 StateProtector sp (this);
4178 for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4179 if (boost::dynamic_pointer_cast<Track> (*i)) {
4180 (*i)->set_track_number(++tn);
4182 else if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_auditioner()) {
4183 (*i)->set_track_number(--bn);
4186 const uint32_t decimals = ceilf (log10f (tn + 1));
4187 const bool decimals_changed = _track_number_decimals != decimals;
4188 _track_number_decimals = decimals;
4190 if (decimals_changed && config.get_track_name_number ()) {
4191 for (RouteList::iterator i = r.begin(); i != r.end(); ++i) {
4192 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
4194 t->resync_track_name();
4197 // trigger GUI re-layout
4198 config.ParameterChanged("track-name-number");
4203 Session::playlist_region_added (boost::weak_ptr<Region> w)
4205 boost::shared_ptr<Region> r = w.lock ();
4210 /* These are the operations that are currently in progress... */
4211 list<GQuark> curr = _current_trans_quarks;
4214 /* ...and these are the operations during which we want to update
4215 the session range location markers.
4218 ops.push_back (Operations::capture);
4219 ops.push_back (Operations::paste);
4220 ops.push_back (Operations::duplicate_region);
4221 ops.push_back (Operations::insert_file);
4222 ops.push_back (Operations::insert_region);
4223 ops.push_back (Operations::drag_region_brush);
4224 ops.push_back (Operations::region_drag);
4225 ops.push_back (Operations::selection_grab);
4226 ops.push_back (Operations::region_fill);
4227 ops.push_back (Operations::fill_selection);
4228 ops.push_back (Operations::create_region);
4229 ops.push_back (Operations::region_copy);
4230 ops.push_back (Operations::fixed_time_region_copy);
4233 /* See if any of the current operations match the ones that we want */
4235 set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
4237 /* If so, update the session range markers */
4239 maybe_update_session_range (r->position (), r->last_frame ());
4243 /** Update the session range markers if a is before the current start or
4244 * b is after the current end.
4247 Session::maybe_update_session_range (framepos_t a, framepos_t b)
4249 if (_state_of_the_state & Loading) {
4253 framepos_t session_end_marker_shift_samples = session_end_shift * _nominal_frame_rate;
4255 if (_session_range_location == 0) {
4257 set_session_range_location (a, b + session_end_marker_shift_samples);
4261 if (a < _session_range_location->start()) {
4262 _session_range_location->set_start (a);
4265 if (b > _session_range_location->end()) {
4266 _session_range_location->set_end (b);
4272 Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
4274 for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4275 maybe_update_session_range (i->to, i->to + i->length);
4280 Session::playlist_regions_extended (list<Evoral::Range<framepos_t> > const & ranges)
4282 for (list<Evoral::Range<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
4283 maybe_update_session_range (i->from, i->to);
4287 /* Region management */
4289 boost::shared_ptr<Region>
4290 Session::find_whole_file_parent (boost::shared_ptr<Region const> child) const
4292 const RegionFactory::RegionMap& regions (RegionFactory::regions());
4293 RegionFactory::RegionMap::const_iterator i;
4294 boost::shared_ptr<Region> region;
4296 Glib::Threads::Mutex::Lock lm (region_lock);
4298 for (i = regions.begin(); i != regions.end(); ++i) {
4302 if (region->whole_file()) {
4304 if (child->source_equivalent (region)) {
4310 return boost::shared_ptr<Region> ();
4314 Session::destroy_sources (list<boost::shared_ptr<Source> > srcs)
4316 set<boost::shared_ptr<Region> > relevant_regions;
4318 for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ++s) {
4319 RegionFactory::get_regions_using_source (*s, relevant_regions);
4322 for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
4323 set<boost::shared_ptr<Region> >::iterator tmp;
4328 playlists->destroy_region (*r);
4329 RegionFactory::map_remove (*r);
4331 (*r)->drop_sources ();
4332 (*r)->drop_references ();
4334 relevant_regions.erase (r);
4339 for (list<boost::shared_ptr<Source> >::iterator s = srcs.begin(); s != srcs.end(); ) {
4342 Glib::Threads::Mutex::Lock ls (source_lock);
4343 /* remove from the main source list */
4344 sources.erase ((*s)->id());
4347 (*s)->mark_for_remove ();
4348 (*s)->drop_references ();
4357 Session::remove_last_capture ()
4359 list<boost::shared_ptr<Source> > srcs;
4361 boost::shared_ptr<RouteList> rl = routes.reader ();
4362 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
4363 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
4368 list<boost::shared_ptr<Source> >& l = tr->last_capture_sources();
4371 srcs.insert (srcs.end(), l.begin(), l.end());
4376 destroy_sources (srcs);
4378 save_state (_current_snapshot_name);
4383 /* Source Management */
4386 Session::add_source (boost::shared_ptr<Source> source)
4388 pair<SourceMap::key_type, SourceMap::mapped_type> entry;
4389 pair<SourceMap::iterator,bool> result;
4391 entry.first = source->id();
4392 entry.second = source;
4395 Glib::Threads::Mutex::Lock lm (source_lock);
4396 result = sources.insert (entry);
4399 if (result.second) {
4401 /* yay, new source */
4403 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
4406 if (!fs->within_session()) {
4407 ensure_search_path_includes (Glib::path_get_dirname (fs->path()), fs->type());
4413 boost::shared_ptr<AudioFileSource> afs;
4415 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
4416 if (Config->get_auto_analyse_audio()) {
4417 Analyser::queue_source_for_analysis (source, false);
4421 source->DropReferences.connect_same_thread (*this, boost::bind (&Session::remove_source, this, boost::weak_ptr<Source> (source)));
4426 Session::remove_source (boost::weak_ptr<Source> src)
4428 if (_state_of_the_state & Deletion) {
4432 SourceMap::iterator i;
4433 boost::shared_ptr<Source> source = src.lock();
4440 Glib::Threads::Mutex::Lock lm (source_lock);
4442 if ((i = sources.find (source->id())) != sources.end()) {
4447 if (!(_state_of_the_state & StateOfTheState (InCleanup|Loading))) {
4449 /* save state so we don't end up with a session file
4450 referring to non-existent sources.
4453 save_state (_current_snapshot_name);
4457 boost::shared_ptr<Source>
4458 Session::source_by_id (const PBD::ID& id)
4460 Glib::Threads::Mutex::Lock lm (source_lock);
4461 SourceMap::iterator i;
4462 boost::shared_ptr<Source> source;
4464 if ((i = sources.find (id)) != sources.end()) {
4471 boost::shared_ptr<AudioFileSource>
4472 Session::audio_source_by_path_and_channel (const string& path, uint16_t chn) const
4474 /* Restricted to audio files because only audio sources have channel
4478 Glib::Threads::Mutex::Lock lm (source_lock);
4480 for (SourceMap::const_iterator i = sources.begin(); i != sources.end(); ++i) {
4481 boost::shared_ptr<AudioFileSource> afs
4482 = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
4484 if (afs && afs->path() == path && chn == afs->channel()) {
4489 return boost::shared_ptr<AudioFileSource>();
4492 boost::shared_ptr<MidiSource>
4493 Session::midi_source_by_path (const std::string& path) const
4495 /* Restricted to MIDI files because audio sources require a channel
4496 for unique identification, in addition to a path.
4499 Glib::Threads::Mutex::Lock lm (source_lock);
4501 for (SourceMap::const_iterator s = sources.begin(); s != sources.end(); ++s) {
4502 boost::shared_ptr<MidiSource> ms
4503 = boost::dynamic_pointer_cast<MidiSource>(s->second);
4504 boost::shared_ptr<FileSource> fs
4505 = boost::dynamic_pointer_cast<FileSource>(s->second);
4507 if (ms && fs && fs->path() == path) {
4512 return boost::shared_ptr<MidiSource>();
4516 Session::count_sources_by_origin (const string& path)
4519 Glib::Threads::Mutex::Lock lm (source_lock);
4521 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
4522 boost::shared_ptr<FileSource> fs
4523 = boost::dynamic_pointer_cast<FileSource>(i->second);
4525 if (fs && fs->origin() == path) {
4534 peak_file_helper (const string& peak_path, const string& file_path, const string& file_base, bool hash) {
4536 std::string checksum = Glib::Checksum::compute_checksum(Glib::Checksum::CHECKSUM_SHA1, file_path + G_DIR_SEPARATOR + file_base);
4537 return Glib::build_filename (peak_path, checksum + peakfile_suffix);
4539 return Glib::build_filename (peak_path, file_base + peakfile_suffix);
4544 Session::construct_peak_filepath (const string& filepath, const bool in_session, const bool old_peak_name) const
4546 string interchange_dir_string = string (interchange_dir_name) + G_DIR_SEPARATOR;
4548 if (Glib::path_is_absolute (filepath)) {
4550 /* rip the session dir from the audiofile source */
4552 string session_path;
4553 bool in_another_session = true;
4555 if (filepath.find (interchange_dir_string) != string::npos) {
4557 session_path = Glib::path_get_dirname (filepath); /* now ends in audiofiles */
4558 session_path = Glib::path_get_dirname (session_path); /* now ends in session name */
4559 session_path = Glib::path_get_dirname (session_path); /* now ends in interchange */
4560 session_path = Glib::path_get_dirname (session_path); /* now has session path */
4562 /* see if it is within our session */
4564 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
4565 if (i->path == session_path) {
4566 in_another_session = false;
4571 in_another_session = false;
4575 if (in_another_session) {
4576 SessionDirectory sd (session_path);
4577 return peak_file_helper (sd.peak_path(), "", Glib::path_get_basename (filepath), !old_peak_name);
4581 /* 1) if file belongs to this session
4582 * it may be a relative path (interchange/...)
4583 * or just basename (session_state, remove source)
4584 * -> just use the basename
4586 std::string filename = Glib::path_get_basename (filepath);
4589 /* 2) if the file is outside our session dir:
4590 * (imported but not copied) add the path for check-summming */
4592 path = Glib::path_get_dirname (filepath);
4595 return peak_file_helper (_session_dir->peak_path(), path, Glib::path_get_basename (filepath), !old_peak_name);
4599 Session::new_audio_source_path_for_embedded (const std::string& path)
4603 * we know that the filename is already unique because it exists
4604 * out in the filesystem.
4606 * However, when we bring it into the session, we could get a
4609 * Eg. two embedded files:
4614 * When merged into session, these collide.
4616 * There will not be a conflict with in-memory sources
4617 * because when the source was created we already picked
4618 * a unique name for it.
4620 * This collision is not likely to be common, but we have to guard
4621 * against it. So, if there is a collision, take the md5 hash of the
4622 * the path, and use that as the filename instead.
4625 SessionDirectory sdir (get_best_session_directory_for_new_audio());
4626 string base = Glib::path_get_basename (path);
4627 string newpath = Glib::build_filename (sdir.sound_path(), base);
4629 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
4633 md5.digestString (path.c_str());
4634 md5.writeToString ();
4635 base = md5.digestChars;
4637 string ext = get_suffix (path);
4644 newpath = Glib::build_filename (sdir.sound_path(), base);
4646 /* if this collides, we're screwed */
4648 if (Glib::file_test (newpath, Glib::FILE_TEST_EXISTS)) {
4649 error << string_compose (_("Merging embedded file %1: name collision AND md5 hash collision!"), path) << endmsg;
4658 /** Return true if there are no audio file sources that use @param name as
4659 * the filename component of their path.
4661 * Return false otherwise.
4663 * This method MUST ONLY be used to check in-session, mono files since it
4664 * hard-codes the channel of the audio file source we are looking for as zero.
4666 * If/when Ardour supports native files in non-mono formats, the logic here
4667 * will need to be revisited.
4670 Session::audio_source_name_is_unique (const string& name)
4672 std::vector<string> sdirs = source_search_path (DataType::AUDIO);
4673 vector<space_and_path>::iterator i;
4674 uint32_t existing = 0;
4676 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
4678 /* note that we search *without* the extension so that
4679 we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
4680 in the event that this new name is required for
4681 a file format change.
4684 const string spath = *i;
4686 if (matching_unsuffixed_filename_exists_in (spath, name)) {
4691 /* it is possible that we have the path already
4692 * assigned to a source that has not yet been written
4693 * (ie. the write source for a diskstream). we have to
4694 * check this in order to make sure that our candidate
4695 * path isn't used again, because that can lead to
4696 * two Sources point to the same file with different
4697 * notions of their removability.
4701 string possible_path = Glib::build_filename (spath, name);
4703 if (audio_source_by_path_and_channel (possible_path, 0)) {
4709 return (existing == 0);
4713 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)
4716 const string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
4718 if (Profile->get_trx() && destructive) {
4720 sstr << setfill ('0') << setw (4) << cnt;
4721 sstr << legalized_base;
4723 sstr << legalized_base;
4725 if (take_required || related_exists) {
4737 } else if (nchan > 2) {
4742 /* XXX what? more than 26 channels! */
4753 /** Return a unique name based on \a base for a new internal audio source */
4755 Session::new_audio_source_path (const string& base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required)
4758 string possible_name;
4759 const uint32_t limit = 9999; // arbitrary limit on number of files with the same basic name
4761 bool some_related_source_name_exists = false;
4763 legalized = legalize_for_path (base);
4765 // Find a "version" of the base name that doesn't exist in any of the possible directories.
4767 for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
4769 possible_name = format_audio_source_name (legalized, nchan, chan, destructive, take_required, cnt, some_related_source_name_exists);
4771 if (audio_source_name_is_unique (possible_name)) {
4775 some_related_source_name_exists = true;
4778 error << string_compose(
4779 _("There are already %1 recordings for %2, which I consider too many."),
4780 limit, base) << endmsg;
4782 throw failed_constructor();
4786 /* We've established that the new name does not exist in any session
4787 * directory, so now find out which one we should use for this new
4791 SessionDirectory sdir (get_best_session_directory_for_new_audio());
4793 std::string s = Glib::build_filename (sdir.sound_path(), possible_name);
4798 /** Return a unique name based on `base` for a new internal MIDI source */
4800 Session::new_midi_source_path (const string& base)
4803 char buf[PATH_MAX+1];
4804 const uint32_t limit = 10000;
4806 string possible_path;
4807 string possible_name;
4810 legalized = legalize_for_path (base);
4812 // Find a "version" of the file name that doesn't exist in any of the possible directories.
4813 std::vector<string> sdirs = source_search_path(DataType::MIDI);
4815 /* - the main session folder is the first in the vector.
4816 * - after checking all locations for file-name uniqueness,
4817 * we keep the one from the last iteration as new file name
4818 * - midi files are small and should just be kept in the main session-folder
4820 * -> reverse the array, check main session folder last and use that as location
4823 std::reverse(sdirs.begin(), sdirs.end());
4825 for (cnt = 1; cnt <= limit; ++cnt) {
4827 vector<space_and_path>::iterator i;
4828 uint32_t existing = 0;
4830 for (vector<string>::const_iterator i = sdirs.begin(); i != sdirs.end(); ++i) {
4832 snprintf (buf, sizeof(buf), "%s-%u.mid", legalized.c_str(), cnt);
4833 possible_name = buf;
4835 possible_path = Glib::build_filename (*i, possible_name);
4837 if (Glib::file_test (possible_path, Glib::FILE_TEST_EXISTS)) {
4841 if (midi_source_by_path (possible_path)) {
4846 if (existing == 0) {
4851 error << string_compose(
4852 _("There are already %1 recordings for %2, which I consider too many."),
4853 limit, base) << endmsg;
4859 /* No need to "find best location" for software/app-based RAID, because
4860 MIDI is so small that we always put it in the same place.
4863 return possible_path;
4867 /** Create a new within-session audio source */
4868 boost::shared_ptr<AudioFileSource>
4869 Session::create_audio_source_for_session (size_t n_chans, string const & base, uint32_t chan, bool destructive)
4871 const string path = new_audio_source_path (base, n_chans, chan, destructive, true);
4873 if (!path.empty()) {
4874 return boost::dynamic_pointer_cast<AudioFileSource> (
4875 SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate(), true, true));
4877 throw failed_constructor ();
4881 /** Create a new within-session MIDI source */
4882 boost::shared_ptr<MidiSource>
4883 Session::create_midi_source_for_session (string const & basic_name)
4885 const string path = new_midi_source_path (basic_name);
4887 if (!path.empty()) {
4888 return boost::dynamic_pointer_cast<SMFSource> (
4889 SourceFactory::createWritable (
4890 DataType::MIDI, *this, path, false, frame_rate()));
4892 throw failed_constructor ();
4896 /** Create a new within-session MIDI source */
4897 boost::shared_ptr<MidiSource>
4898 Session::create_midi_source_by_stealing_name (boost::shared_ptr<Track> track)
4900 /* the caller passes in the track the source will be used in,
4901 so that we can keep the numbering sane.
4903 Rationale: a track with the name "Foo" that has had N
4904 captures carried out so far will ALREADY have a write source
4905 named "Foo-N+1.mid" waiting to be used for the next capture.
4907 If we call new_midi_source_name() we will get "Foo-N+2". But
4908 there is no region corresponding to "Foo-N+1", so when
4909 "Foo-N+2" appears in the track, the gap presents the user
4910 with odd behaviour - why did it skip past Foo-N+1?
4912 We could explain this to the user in some odd way, but
4913 instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
4916 If that attempted rename fails, we get "Foo-N+2.mid" anyway.
4919 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (track);
4921 std::string name = track->steal_write_source_name ();
4924 return boost::shared_ptr<MidiSource>();
4927 /* MIDI files are small, just put them in the first location of the
4928 session source search path.
4931 const string path = Glib::build_filename (source_search_path (DataType::MIDI).front(), name);
4933 return boost::dynamic_pointer_cast<SMFSource> (
4934 SourceFactory::createWritable (
4935 DataType::MIDI, *this, path, false, frame_rate()));
4940 Session::add_playlist (boost::shared_ptr<Playlist> playlist, bool unused)
4942 if (playlist->hidden()) {
4946 playlists->add (playlist);
4949 playlist->release();
4956 Session::remove_playlist (boost::weak_ptr<Playlist> weak_playlist)
4958 if (_state_of_the_state & Deletion) {
4962 boost::shared_ptr<Playlist> playlist (weak_playlist.lock());
4968 playlists->remove (playlist);
4974 Session::set_audition (boost::shared_ptr<Region> r)
4976 pending_audition_region = r;
4977 add_post_transport_work (PostTransportAudition);
4978 _butler->schedule_transport_work ();
4982 Session::audition_playlist ()
4984 SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
4985 ev->region.reset ();
4991 Session::register_lua_function (
4992 const std::string& name,
4993 const std::string& script,
4994 const LuaScriptParamList& args
4997 Glib::Threads::Mutex::Lock lm (lua_lock);
4999 lua_State* L = lua.getState();
5001 const std::string& bytecode = LuaScripting::get_factory_bytecode (script);
5002 luabridge::LuaRef tbl_arg (luabridge::newTable(L));
5003 for (LuaScriptParamList::const_iterator i = args.begin(); i != args.end(); ++i) {
5004 if ((*i)->optional && !(*i)->is_set) { continue; }
5005 tbl_arg[(*i)->name] = (*i)->value;
5007 (*_lua_add)(name, bytecode, tbl_arg); // throws luabridge::LuaException
5012 Session::unregister_lua_function (const std::string& name)
5014 Glib::Threads::Mutex::Lock lm (lua_lock);
5015 (*_lua_del)(name); // throws luabridge::LuaException
5016 lua.collect_garbage ();
5020 std::vector<std::string>
5021 Session::registered_lua_functions ()
5023 Glib::Threads::Mutex::Lock lm (lua_lock);
5024 std::vector<std::string> rv;
5027 luabridge::LuaRef list ((*_lua_list)());
5028 for (luabridge::Iterator i (list); !i.isNil (); ++i) {
5029 if (!i.key ().isString ()) { assert(0); continue; }
5030 rv.push_back (i.key ().cast<std::string> ());
5032 } catch (luabridge::LuaException const& e) { }
5037 static void _lua_print (std::string s) {
5038 std::cout << "SessionLua: " << s << "\n";
5043 Session::try_run_lua (pframes_t nframes)
5045 if (_n_lua_scripts == 0) return;
5046 Glib::Threads::Mutex::Lock tm (lua_lock, Glib::Threads::TRY_LOCK);
5048 try { (*_lua_run)(nframes); } catch (luabridge::LuaException const& e) { }
5053 Session::setup_lua ()
5056 lua.Print.connect (&_lua_print);
5059 "function ArdourSession ()"
5060 " local self = { scripts = {}, instances = {} }"
5062 " local remove = function (n)"
5063 " self.scripts[n] = nil"
5064 " self.instances[n] = nil"
5065 " Session:scripts_changed()" // call back
5068 " local addinternal = function (n, f, a)"
5069 " assert(type(n) == 'string', 'function-name must be string')"
5070 " assert(type(f) == 'function', 'Given script is a not a function')"
5071 " assert(type(a) == 'table' or type(a) == 'nil', 'Given argument is invalid')"
5072 " assert(self.scripts[n] == nil, 'Callback \"'.. n ..'\" already exists.')"
5073 " self.scripts[n] = { ['f'] = f, ['a'] = a }"
5074 " local env = _ENV; env.f = nil env.io = nil env.os = nil env.loadfile = nil env.require = nil env.dofile = nil env.package = nil env.debug = nil"
5075 " local env = { print = print, Session = Session, tostring = tostring, assert = assert, ipairs = ipairs, error = error, select = select, string = string, type = type, tonumber = tonumber, collectgarbage = collectgarbage, pairs = pairs, math = math, table = table, pcall = pcall }"
5076 " self.instances[n] = load (string.dump(f, true), nil, nil, env)(a)"
5077 " Session:scripts_changed()" // call back
5080 " local add = function (n, b, a)"
5081 " assert(type(b) == 'string', 'ByteCode must be string')"
5082 " load (b)()" // assigns f
5083 " assert(type(f) == 'string', 'Assigned ByteCode must be string')"
5084 " addinternal (n, load(f), a)"
5087 " local run = function (...)"
5088 " for n, s in pairs (self.instances) do"
5089 " local status, err = pcall (s, ...)"
5090 " if not status then"
5091 " print ('fn \"'.. n .. '\": ', err)"
5098 " local cleanup = function ()"
5099 " self.scripts = nil"
5100 " self.instances = nil"
5103 " local list = function ()"
5105 " for n, _ in pairs (self.scripts) do"
5111 " local function basic_serialize (o)"
5112 " if type(o) == \"number\" then"
5113 " return tostring(o)"
5115 " return string.format(\"%q\", o)"
5119 " local function serialize (name, value)"
5120 " local rv = name .. ' = '"
5122 " if type(value) == \"number\" or type(value) == \"string\" or type(value) == \"nil\" then"
5123 " return rv .. basic_serialize(value) .. ' '"
5124 " elseif type(value) == \"table\" then"
5126 " for k,v in pairs(value) do"
5127 " local fieldname = string.format(\"%s[%s]\", name, basic_serialize(k))"
5128 " rv = rv .. serialize(fieldname, v) .. ' '"
5129 " collectgarbage()" // string concatenation allocates a new string :(
5132 " elseif type(value) == \"function\" then"
5133 " return rv .. string.format(\"%q\", string.dump(value, true))"
5135 " error('cannot save a ' .. type(value))"
5140 " local save = function ()"
5141 " return (serialize('scripts', self.scripts))"
5144 " local restore = function (state)"
5145 " self.scripts = {}"
5147 " for n, s in pairs (scripts) do"
5148 " addinternal (n, load(s['f']), s['a'])"
5152 " return { run = run, add = add, remove = remove,"
5153 " list = list, restore = restore, save = save, cleanup = cleanup}"
5156 " sess = ArdourSession ()"
5157 " ArdourSession = nil"
5159 "function ardour () end"
5162 lua_State* L = lua.getState();
5165 luabridge::LuaRef lua_sess = luabridge::getGlobal (L, "sess");
5166 lua.do_command ("sess = nil"); // hide it.
5167 lua.do_command ("collectgarbage()");
5169 _lua_run = new luabridge::LuaRef(lua_sess["run"]);
5170 _lua_add = new luabridge::LuaRef(lua_sess["add"]);
5171 _lua_del = new luabridge::LuaRef(lua_sess["remove"]);
5172 _lua_list = new luabridge::LuaRef(lua_sess["list"]);
5173 _lua_save = new luabridge::LuaRef(lua_sess["save"]);
5174 _lua_load = new luabridge::LuaRef(lua_sess["restore"]);
5175 _lua_cleanup = new luabridge::LuaRef(lua_sess["cleanup"]);
5176 } catch (luabridge::LuaException const& e) {
5177 fatal << string_compose (_("programming error: %1"),
5178 X_("Failed to setup Lua interpreter"))
5180 abort(); /*NOTREACHED*/
5183 LuaBindings::stddef (L);
5184 LuaBindings::common (L);
5185 LuaBindings::dsp (L);
5186 luabridge::push <Session *> (L, this);
5187 lua_setglobal (L, "Session");
5191 Session::scripts_changed ()
5193 assert (!lua_lock.trylock()); // must hold lua_lock
5196 luabridge::LuaRef list ((*_lua_list)());
5198 for (luabridge::Iterator i (list); !i.isNil (); ++i) {
5199 if (!i.key ().isString ()) { assert(0); continue; }
5202 _n_lua_scripts = cnt;
5203 } catch (luabridge::LuaException const& e) {
5204 fatal << string_compose (_("programming error: %1"),
5205 X_("Indexing Lua Session Scripts failed."))
5207 abort(); /*NOTREACHED*/
5212 Session::non_realtime_set_audition ()
5214 assert (pending_audition_region);
5215 auditioner->audition_region (pending_audition_region);
5216 pending_audition_region.reset ();
5217 AuditionActive (true); /* EMIT SIGNAL */
5221 Session::audition_region (boost::shared_ptr<Region> r)
5223 SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
5229 Session::cancel_audition ()
5234 if (auditioner->auditioning()) {
5235 auditioner->cancel_audition ();
5236 AuditionActive (false); /* EMIT SIGNAL */
5241 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
5243 if (a->is_monitor()) {
5246 if (b->is_monitor()) {
5249 return a->order_key () < b->order_key ();
5253 Session::is_auditioning () const
5255 /* can be called before we have an auditioner object */
5257 return auditioner->auditioning();
5264 Session::graph_reordered ()
5266 /* don't do this stuff if we are setting up connections
5267 from a set_state() call or creating new tracks. Ditto for deletion.
5270 if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress || _reconnecting_routes_in_progress || _route_deletion_in_progress) {
5274 /* every track/bus asked for this to be handled but it was deferred because
5275 we were connecting. do it now.
5278 request_input_change_handling ();
5282 /* force all diskstreams to update their capture offset values to
5283 reflect any changes in latencies within the graph.
5286 boost::shared_ptr<RouteList> rl = routes.reader ();
5287 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5288 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5290 tr->set_capture_offset ();
5295 /** @return Number of frames that there is disk space available to write,
5298 boost::optional<framecnt_t>
5299 Session::available_capture_duration ()
5301 Glib::Threads::Mutex::Lock lm (space_lock);
5303 if (_total_free_4k_blocks_uncertain) {
5304 return boost::optional<framecnt_t> ();
5307 float sample_bytes_on_disk = 4.0; // keep gcc happy
5309 switch (config.get_native_file_data_format()) {
5311 sample_bytes_on_disk = 4.0;
5315 sample_bytes_on_disk = 3.0;
5319 sample_bytes_on_disk = 2.0;
5323 /* impossible, but keep some gcc versions happy */
5324 fatal << string_compose (_("programming error: %1"),
5325 X_("illegal native file data format"))
5327 abort(); /*NOTREACHED*/
5330 double scale = 4096.0 / sample_bytes_on_disk;
5332 if (_total_free_4k_blocks * scale > (double) max_framecnt) {
5333 return max_framecnt;
5336 return (framecnt_t) floor (_total_free_4k_blocks * scale);
5340 Session::add_bundle (boost::shared_ptr<Bundle> bundle, bool emit_signal)
5343 RCUWriter<BundleList> writer (_bundles);
5344 boost::shared_ptr<BundleList> b = writer.get_copy ();
5345 b->push_back (bundle);
5349 BundleAddedOrRemoved (); /* EMIT SIGNAL */
5356 Session::remove_bundle (boost::shared_ptr<Bundle> bundle)
5358 bool removed = false;
5361 RCUWriter<BundleList> writer (_bundles);
5362 boost::shared_ptr<BundleList> b = writer.get_copy ();
5363 BundleList::iterator i = find (b->begin(), b->end(), bundle);
5365 if (i != b->end()) {
5372 BundleAddedOrRemoved (); /* EMIT SIGNAL */
5378 boost::shared_ptr<Bundle>
5379 Session::bundle_by_name (string name) const
5381 boost::shared_ptr<BundleList> b = _bundles.reader ();
5383 for (BundleList::const_iterator i = b->begin(); i != b->end(); ++i) {
5384 if ((*i)->name() == name) {
5389 return boost::shared_ptr<Bundle> ();
5393 Session::tempo_map_changed (const PropertyChange&)
5397 playlists->update_after_tempo_map_change ();
5399 _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
5405 Session::update_locations_after_tempo_map_change (const Locations::LocationList& loc)
5407 for (Locations::LocationList::const_iterator i = loc.begin(); i != loc.end(); ++i) {
5408 (*i)->recompute_frames_from_bbt ();
5412 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
5413 * the given count with the current block size.
5416 Session::ensure_buffers (ChanCount howmany)
5418 BufferManager::ensure_buffers (howmany, bounce_processing() ? bounce_chunk_size : 0);
5422 Session::ensure_buffer_set(BufferSet& buffers, const ChanCount& count)
5424 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
5425 buffers.ensure_buffers(*t, count.get(*t), _engine.raw_buffer_size(*t));
5430 Session::next_insert_id ()
5432 /* this doesn't really loop forever. just think about it */
5435 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < insert_bitset.size(); ++n) {
5436 if (!insert_bitset[n]) {
5437 insert_bitset[n] = true;
5443 /* none available, so resize and try again */
5445 insert_bitset.resize (insert_bitset.size() + 16, false);
5450 Session::next_send_id ()
5452 /* this doesn't really loop forever. just think about it */
5455 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < send_bitset.size(); ++n) {
5456 if (!send_bitset[n]) {
5457 send_bitset[n] = true;
5463 /* none available, so resize and try again */
5465 send_bitset.resize (send_bitset.size() + 16, false);
5470 Session::next_aux_send_id ()
5472 /* this doesn't really loop forever. just think about it */
5475 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < aux_send_bitset.size(); ++n) {
5476 if (!aux_send_bitset[n]) {
5477 aux_send_bitset[n] = true;
5483 /* none available, so resize and try again */
5485 aux_send_bitset.resize (aux_send_bitset.size() + 16, false);
5490 Session::next_return_id ()
5492 /* this doesn't really loop forever. just think about it */
5495 for (boost::dynamic_bitset<uint32_t>::size_type n = 1; n < return_bitset.size(); ++n) {
5496 if (!return_bitset[n]) {
5497 return_bitset[n] = true;
5503 /* none available, so resize and try again */
5505 return_bitset.resize (return_bitset.size() + 16, false);
5510 Session::mark_send_id (uint32_t id)
5512 if (id >= send_bitset.size()) {
5513 send_bitset.resize (id+16, false);
5515 if (send_bitset[id]) {
5516 warning << string_compose (_("send ID %1 appears to be in use already"), id) << endmsg;
5518 send_bitset[id] = true;
5522 Session::mark_aux_send_id (uint32_t id)
5524 if (id >= aux_send_bitset.size()) {
5525 aux_send_bitset.resize (id+16, false);
5527 if (aux_send_bitset[id]) {
5528 warning << string_compose (_("aux send ID %1 appears to be in use already"), id) << endmsg;
5530 aux_send_bitset[id] = true;
5534 Session::mark_return_id (uint32_t id)
5536 if (id >= return_bitset.size()) {
5537 return_bitset.resize (id+16, false);
5539 if (return_bitset[id]) {
5540 warning << string_compose (_("return ID %1 appears to be in use already"), id) << endmsg;
5542 return_bitset[id] = true;
5546 Session::mark_insert_id (uint32_t id)
5548 if (id >= insert_bitset.size()) {
5549 insert_bitset.resize (id+16, false);
5551 if (insert_bitset[id]) {
5552 warning << string_compose (_("insert ID %1 appears to be in use already"), id) << endmsg;
5554 insert_bitset[id] = true;
5558 Session::unmark_send_id (uint32_t id)
5560 if (id < send_bitset.size()) {
5561 send_bitset[id] = false;
5566 Session::unmark_aux_send_id (uint32_t id)
5568 if (id < aux_send_bitset.size()) {
5569 aux_send_bitset[id] = false;
5574 Session::unmark_return_id (uint32_t id)
5576 if (_state_of_the_state & Deletion) { return; }
5577 if (id < return_bitset.size()) {
5578 return_bitset[id] = false;
5583 Session::unmark_insert_id (uint32_t id)
5585 if (id < insert_bitset.size()) {
5586 insert_bitset[id] = false;
5591 Session::reset_native_file_format ()
5593 boost::shared_ptr<RouteList> rl = routes.reader ();
5595 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
5596 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
5598 /* don't save state as we do this, there's no point
5600 _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
5601 tr->reset_write_sources (false);
5602 _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
5608 Session::route_name_unique (string n) const
5610 boost::shared_ptr<RouteList> r = routes.reader ();
5612 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5613 if ((*i)->name() == n) {
5622 Session::route_name_internal (string n) const
5624 if (auditioner && auditioner->name() == n) {
5628 if (_click_io && _click_io->name() == n) {
5636 Session::freeze_all (InterThreadInfo& itt)
5638 boost::shared_ptr<RouteList> r = routes.reader ();
5640 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
5642 boost::shared_ptr<Track> t;
5644 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
5645 /* XXX this is wrong because itt.progress will keep returning to zero at the start
5655 boost::shared_ptr<Region>
5656 Session::write_one_track (Track& track, framepos_t start, framepos_t end,
5657 bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
5658 InterThreadInfo& itt,
5659 boost::shared_ptr<Processor> endpoint, bool include_endpoint,
5660 bool for_export, bool for_freeze)
5662 boost::shared_ptr<Region> result;
5663 boost::shared_ptr<Playlist> playlist;
5664 boost::shared_ptr<Source> source;
5665 ChanCount diskstream_channels (track.n_channels());
5666 framepos_t position;
5667 framecnt_t this_chunk;
5669 framepos_t latency_skip;
5671 framepos_t len = end - start;
5672 bool need_block_size_reset = false;
5673 ChanCount const max_proc = track.max_processor_streams ();
5674 string legal_playlist_name;
5675 string possible_path;
5678 error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
5679 end, start) << endmsg;
5683 diskstream_channels = track.bounce_get_output_streams (diskstream_channels, endpoint,
5684 include_endpoint, for_export, for_freeze);
5686 if (diskstream_channels.n(track.data_type()) < 1) {
5687 error << _("Cannot write a range with no data.") << endmsg;
5691 // block all process callback handling
5693 block_processing ();
5696 // synchronize with AudioEngine::process_callback()
5697 // make sure processing is not currently running
5698 // and processing_blocked() is honored before
5699 // acquiring thread buffers
5700 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
5703 _bounce_processing_active = true;
5705 /* call tree *MUST* hold route_lock */
5707 if ((playlist = track.playlist()) == 0) {
5711 legal_playlist_name = legalize_for_path (playlist->name());
5713 for (uint32_t chan_n = 0; chan_n < diskstream_channels.n(track.data_type()); ++chan_n) {
5715 string base_name = string_compose ("%1-%2-bounce", playlist->name(), chan_n);
5716 string path = ((track.data_type() == DataType::AUDIO)
5717 ? new_audio_source_path (legal_playlist_name, diskstream_channels.n_audio(), chan_n, false, true)
5718 : new_midi_source_path (legal_playlist_name));
5725 source = SourceFactory::createWritable (track.data_type(), *this, path, false, frame_rate());
5728 catch (failed_constructor& err) {
5729 error << string_compose (_("cannot create new file \"%1\" for %2"), path, track.name()) << endmsg;
5733 srcs.push_back (source);
5736 /* tell redirects that care that we are about to use a much larger
5737 * blocksize. this will flush all plugins too, so that they are ready
5738 * to be used for this process.
5741 need_block_size_reset = true;
5742 track.set_block_size (bounce_chunk_size);
5743 _engine.main_thread()->get_buffers ();
5747 latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
5749 /* create a set of reasonably-sized buffers */
5750 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
5751 buffers.ensure_buffers(*t, max_proc.get(*t), bounce_chunk_size);
5753 buffers.set_count (max_proc);
5755 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5756 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5757 boost::shared_ptr<MidiSource> ms;
5759 afs->prepare_for_peakfile_writes ();
5760 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5761 Source::Lock lock(ms->mutex());
5762 ms->mark_streaming_write_started(lock);
5766 while (to_do && !itt.cancel) {
5768 this_chunk = min (to_do, bounce_chunk_size);
5770 if (track.export_stuff (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze)) {
5774 start += this_chunk;
5775 to_do -= this_chunk;
5776 itt.progress = (float) (1.0 - ((double) to_do / len));
5778 if (latency_skip >= bounce_chunk_size) {
5779 latency_skip -= bounce_chunk_size;
5783 const framecnt_t current_chunk = this_chunk - latency_skip;
5786 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
5787 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5788 boost::shared_ptr<MidiSource> ms;
5791 if (afs->write (buffers.get_audio(n).data(latency_skip), current_chunk) != current_chunk) {
5794 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5795 Source::Lock lock(ms->mutex());
5797 const MidiBuffer& buf = buffers.get_midi(0);
5798 for (MidiBuffer::const_iterator i = buf.begin(); i != buf.end(); ++i) {
5799 Evoral::Event<framepos_t> ev = *i;
5800 ev.set_time(ev.time() - position);
5801 ms->append_event_frames(lock, ev, ms->timeline_position());
5808 /* post-roll, pick up delayed processor output */
5809 latency_skip = track.bounce_get_latency (endpoint, include_endpoint, for_export, for_freeze);
5811 while (latency_skip && !itt.cancel) {
5812 this_chunk = min (latency_skip, bounce_chunk_size);
5813 latency_skip -= this_chunk;
5815 buffers.silence (this_chunk, 0);
5816 track.bounce_process (buffers, start, this_chunk, endpoint, include_endpoint, for_export, for_freeze);
5819 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
5820 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5823 if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
5835 xnow = localtime (&now);
5837 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
5838 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5839 boost::shared_ptr<MidiSource> ms;
5842 afs->update_header (position, *xnow, now);
5843 afs->flush_header ();
5844 } else if ((ms = boost::dynamic_pointer_cast<MidiSource>(*src))) {
5845 Source::Lock lock(ms->mutex());
5846 ms->mark_streaming_write_completed(lock);
5850 /* construct a region to represent the bounced material */
5854 plist.add (Properties::start, 0);
5855 plist.add (Properties::length, srcs.front()->length(srcs.front()->timeline_position()));
5856 plist.add (Properties::name, region_name_from_path (srcs.front()->name(), true));
5858 result = RegionFactory::create (srcs, plist);
5864 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5865 (*src)->mark_for_remove ();
5866 (*src)->drop_references ();
5870 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
5871 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
5874 afs->done_with_peakfile_writes ();
5878 _bounce_processing_active = false;
5880 if (need_block_size_reset) {
5881 _engine.main_thread()->drop_buffers ();
5882 track.set_block_size (get_block_size());
5885 unblock_processing ();
5892 Session::gain_automation_buffer() const
5894 return ProcessThread::gain_automation_buffer ();
5898 Session::trim_automation_buffer() const
5900 return ProcessThread::trim_automation_buffer ();
5904 Session::send_gain_automation_buffer() const
5906 return ProcessThread::send_gain_automation_buffer ();
5910 Session::pan_automation_buffer() const
5912 return ProcessThread::pan_automation_buffer ();
5916 Session::get_silent_buffers (ChanCount count)
5918 return ProcessThread::get_silent_buffers (count);
5922 Session::get_scratch_buffers (ChanCount count, bool silence)
5924 return ProcessThread::get_scratch_buffers (count, silence);
5928 Session::get_noinplace_buffers (ChanCount count)
5930 return ProcessThread::get_noinplace_buffers (count);
5934 Session::get_route_buffers (ChanCount count, bool silence)
5936 return ProcessThread::get_route_buffers (count, silence);
5941 Session::get_mix_buffers (ChanCount count)
5943 return ProcessThread::get_mix_buffers (count);
5947 Session::ntracks () const
5950 boost::shared_ptr<RouteList> r = routes.reader ();
5952 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5953 if (boost::dynamic_pointer_cast<Track> (*i)) {
5962 Session::nbusses () const
5965 boost::shared_ptr<RouteList> r = routes.reader ();
5967 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
5968 if (boost::dynamic_pointer_cast<Track>(*i) == 0) {
5977 Session::add_automation_list(AutomationList *al)
5979 automation_lists[al->id()] = al;
5982 /** @return true if there is at least one record-enabled track, otherwise false */
5984 Session::have_rec_enabled_track () const
5986 return g_atomic_int_get (const_cast<gint*>(&_have_rec_enabled_track)) == 1;
5990 Session::have_rec_disabled_track () const
5992 return g_atomic_int_get (const_cast<gint*>(&_have_rec_disabled_track)) == 1;
5995 /** Update the state of our rec-enabled tracks flag */
5997 Session::update_route_record_state ()
5999 boost::shared_ptr<RouteList> rl = routes.reader ();
6000 RouteList::iterator i = rl->begin();
6001 while (i != rl->end ()) {
6003 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6004 if (tr && tr->record_enabled ()) {
6011 int const old = g_atomic_int_get (&_have_rec_enabled_track);
6013 g_atomic_int_set (&_have_rec_enabled_track, i != rl->end () ? 1 : 0);
6015 if (g_atomic_int_get (&_have_rec_enabled_track) != old) {
6016 RecordStateChanged (); /* EMIT SIGNAL */
6019 for (i = rl->begin(); i != rl->end (); ++i) {
6020 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6021 if (tr && !tr->record_enabled ()) {
6026 g_atomic_int_set (&_have_rec_disabled_track, i != rl->end () ? 1 : 0);
6028 bool record_arm_state_changed = (old != g_atomic_int_get (&_have_rec_enabled_track) );
6030 if (record_status() == Recording && record_arm_state_changed ) {
6031 RecordArmStateChanged ();
6037 Session::listen_position_changed ()
6039 boost::shared_ptr<RouteList> r = routes.reader ();
6041 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6042 (*i)->listen_position_changed ();
6047 Session::solo_control_mode_changed ()
6049 /* cancel all solo or all listen when solo control mode changes */
6052 set_solo (get_routes(), false);
6053 } else if (listening()) {
6054 set_listen (get_routes(), false);
6058 /** Called when a property of one of our route groups changes */
6060 Session::route_group_property_changed (RouteGroup* rg)
6062 RouteGroupPropertyChanged (rg); /* EMIT SIGNAL */
6065 /** Called when a route is added to one of our route groups */
6067 Session::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
6069 RouteAddedToRouteGroup (rg, r);
6072 /** Called when a route is removed from one of our route groups */
6074 Session::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> r)
6076 update_route_record_state ();
6077 RouteRemovedFromRouteGroup (rg, r); /* EMIT SIGNAL */
6080 boost::shared_ptr<RouteList>
6081 Session::get_tracks () const
6083 boost::shared_ptr<RouteList> rl = routes.reader ();
6084 boost::shared_ptr<RouteList> tl (new RouteList);
6086 for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
6087 if (boost::dynamic_pointer_cast<Track> (*r)) {
6088 if (!(*r)->is_auditioner()) {
6096 boost::shared_ptr<RouteList>
6097 Session::get_routes_with_regions_at (framepos_t const p) const
6099 boost::shared_ptr<RouteList> r = routes.reader ();
6100 boost::shared_ptr<RouteList> rl (new RouteList);
6102 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6103 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6108 boost::shared_ptr<Playlist> pl = tr->playlist ();
6113 if (pl->has_region_at (p)) {
6122 Session::goto_end ()
6124 if (_session_range_location) {
6125 request_locate (_session_range_location->end(), false);
6127 request_locate (0, false);
6132 Session::goto_start ()
6134 if (_session_range_location) {
6135 request_locate (_session_range_location->start(), false);
6137 request_locate (0, false);
6142 Session::current_start_frame () const
6144 return _session_range_location ? _session_range_location->start() : 0;
6148 Session::current_end_frame () const
6150 return _session_range_location ? _session_range_location->end() : 0;
6154 Session::set_session_range_location (framepos_t start, framepos_t end)
6156 _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
6157 _locations->add (_session_range_location);
6161 Session::step_edit_status_change (bool yn)
6167 send = (_step_editors == 0);
6172 send = (_step_editors == 1);
6175 if (_step_editors > 0) {
6181 StepEditStatusChange (val);
6187 Session::start_time_changed (framepos_t old)
6189 /* Update the auto loop range to match the session range
6190 (unless the auto loop range has been changed by the user)
6193 Location* s = _locations->session_range_location ();
6198 Location* l = _locations->auto_loop_location ();
6200 if (l && l->start() == old) {
6201 l->set_start (s->start(), true);
6206 Session::end_time_changed (framepos_t old)
6208 /* Update the auto loop range to match the session range
6209 (unless the auto loop range has been changed by the user)
6212 Location* s = _locations->session_range_location ();
6217 Location* l = _locations->auto_loop_location ();
6219 if (l && l->end() == old) {
6220 l->set_end (s->end(), true);
6224 std::vector<std::string>
6225 Session::source_search_path (DataType type) const
6229 if (session_dirs.size() == 1) {
6231 case DataType::AUDIO:
6232 sp.push_back (_session_dir->sound_path());
6234 case DataType::MIDI:
6235 sp.push_back (_session_dir->midi_path());
6239 for (vector<space_and_path>::const_iterator i = session_dirs.begin(); i != session_dirs.end(); ++i) {
6240 SessionDirectory sdir (i->path);
6242 case DataType::AUDIO:
6243 sp.push_back (sdir.sound_path());
6245 case DataType::MIDI:
6246 sp.push_back (sdir.midi_path());
6252 if (type == DataType::AUDIO) {
6253 const string sound_path_2X = _session_dir->sound_path_2X();
6254 if (Glib::file_test (sound_path_2X, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_DIR)) {
6255 if (find (sp.begin(), sp.end(), sound_path_2X) == sp.end()) {
6256 sp.push_back (sound_path_2X);
6261 // now check the explicit (possibly user-specified) search path
6264 case DataType::AUDIO:
6265 sp += Searchpath(config.get_audio_search_path ());
6267 case DataType::MIDI:
6268 sp += Searchpath(config.get_midi_search_path ());
6276 Session::ensure_search_path_includes (const string& path, DataType type)
6285 case DataType::AUDIO:
6286 sp += Searchpath(config.get_audio_search_path ());
6288 case DataType::MIDI:
6289 sp += Searchpath (config.get_midi_search_path ());
6293 for (vector<std::string>::iterator i = sp.begin(); i != sp.end(); ++i) {
6294 /* No need to add this new directory if it has the same inode as
6295 an existing one; checking inode rather than name prevents duplicated
6296 directories when we are using symlinks.
6298 On Windows, I think we could just do if (*i == path) here.
6300 if (PBD::equivalent_paths (*i, path)) {
6308 case DataType::AUDIO:
6309 config.set_audio_search_path (sp.to_string());
6311 case DataType::MIDI:
6312 config.set_midi_search_path (sp.to_string());
6318 Session::remove_dir_from_search_path (const string& dir, DataType type)
6323 case DataType::AUDIO:
6324 sp = Searchpath(config.get_audio_search_path ());
6326 case DataType::MIDI:
6327 sp = Searchpath (config.get_midi_search_path ());
6334 case DataType::AUDIO:
6335 config.set_audio_search_path (sp.to_string());
6337 case DataType::MIDI:
6338 config.set_midi_search_path (sp.to_string());
6344 boost::shared_ptr<Speakers>
6345 Session::get_speakers()
6351 Session::unknown_processors () const
6355 boost::shared_ptr<RouteList> r = routes.reader ();
6356 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6357 list<string> t = (*i)->unknown_processors ();
6358 copy (t.begin(), t.end(), back_inserter (p));
6368 Session::update_latency (bool playback)
6370 DEBUG_TRACE (DEBUG::Latency, string_compose ("JACK latency callback: %1\n", (playback ? "PLAYBACK" : "CAPTURE")));
6372 if ((_state_of_the_state & (InitialConnecting|Deletion)) || _adding_routes_in_progress) {
6376 boost::shared_ptr<RouteList> r = routes.reader ();
6377 framecnt_t max_latency = 0;
6380 /* reverse the list so that we work backwards from the last route to run to the first */
6381 RouteList* rl = routes.reader().get();
6382 r.reset (new RouteList (*rl));
6383 reverse (r->begin(), r->end());
6386 /* compute actual latency values for the given direction and store them all in per-port
6387 structures. this will also publish the same values (to JACK) so that computation of latency
6388 for routes can consistently use public latency values.
6391 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6392 max_latency = max (max_latency, (*i)->set_private_port_latencies (playback));
6395 /* because we latency compensate playback, our published playback latencies should
6396 be the same for all output ports - all material played back by ardour has
6397 the same latency, whether its caused by plugins or by latency compensation. since
6398 these may differ from the values computed above, reset all playback port latencies
6402 DEBUG_TRACE (DEBUG::Latency, string_compose ("Set public port latencies to %1\n", max_latency));
6404 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6405 (*i)->set_public_port_latencies (max_latency, playback);
6410 post_playback_latency ();
6414 post_capture_latency ();
6417 DEBUG_TRACE (DEBUG::Latency, "JACK latency callback: DONE\n");
6421 Session::post_playback_latency ()
6423 set_worst_playback_latency ();
6425 boost::shared_ptr<RouteList> r = routes.reader ();
6427 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6428 if (!(*i)->is_auditioner() && ((*i)->active())) {
6429 _worst_track_latency = max (_worst_track_latency, (*i)->update_signal_latency ());
6433 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6434 (*i)->set_latency_compensation (_worst_track_latency);
6439 Session::post_capture_latency ()
6441 set_worst_capture_latency ();
6443 /* reflect any changes in capture latencies into capture offsets
6446 boost::shared_ptr<RouteList> rl = routes.reader();
6447 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
6448 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6450 tr->set_capture_offset ();
6456 Session::initialize_latencies ()
6459 Glib::Threads::Mutex::Lock lm (_engine.process_lock());
6460 update_latency (false);
6461 update_latency (true);
6464 set_worst_io_latencies ();
6468 Session::set_worst_io_latencies ()
6470 set_worst_playback_latency ();
6471 set_worst_capture_latency ();
6475 Session::set_worst_playback_latency ()
6477 if (_state_of_the_state & (InitialConnecting|Deletion)) {
6481 _worst_output_latency = 0;
6483 if (!_engine.connected()) {
6487 boost::shared_ptr<RouteList> r = routes.reader ();
6489 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6490 _worst_output_latency = max (_worst_output_latency, (*i)->output()->latency());
6493 DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst output latency: %1\n", _worst_output_latency));
6497 Session::set_worst_capture_latency ()
6499 if (_state_of_the_state & (InitialConnecting|Deletion)) {
6503 _worst_input_latency = 0;
6505 if (!_engine.connected()) {
6509 boost::shared_ptr<RouteList> r = routes.reader ();
6511 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6512 _worst_input_latency = max (_worst_input_latency, (*i)->input()->latency());
6515 DEBUG_TRACE (DEBUG::Latency, string_compose ("Worst input latency: %1\n", _worst_input_latency));
6519 Session::update_latency_compensation (bool force_whole_graph)
6521 bool some_track_latency_changed = false;
6523 if (_state_of_the_state & (InitialConnecting|Deletion)) {
6527 DEBUG_TRACE(DEBUG::Latency, "---------------------------- update latency compensation\n\n");
6529 _worst_track_latency = 0;
6531 boost::shared_ptr<RouteList> r = routes.reader ();
6533 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6534 if (!(*i)->is_auditioner() && ((*i)->active())) {
6536 if ((*i)->signal_latency () != (tl = (*i)->update_signal_latency ())) {
6537 some_track_latency_changed = true;
6539 _worst_track_latency = max (tl, _worst_track_latency);
6543 DEBUG_TRACE (DEBUG::Latency, string_compose ("worst signal processing latency: %1 (changed ? %2)\n", _worst_track_latency,
6544 (some_track_latency_changed ? "yes" : "no")));
6546 DEBUG_TRACE(DEBUG::Latency, "---------------------------- DONE update latency compensation\n\n");
6548 if (some_track_latency_changed || force_whole_graph) {
6549 _engine.update_latencies ();
6553 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
6554 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
6558 tr->set_capture_offset ();
6563 Session::session_name_is_legal (const string& path)
6565 char illegal_chars[] = { '/', '\\', ':', ';', '\0' };
6567 for (int i = 0; illegal_chars[i]; ++i) {
6568 if (path.find (illegal_chars[i]) != string::npos) {
6569 return illegal_chars[i];
6577 Session::next_control_id () const
6581 /* the monitor bus remote ID is in a different
6582 * "namespace" than regular routes. its existence doesn't
6583 * affect normal (low) numbered routes.
6590 /* the same about masterbus in Waves Tracks */
6592 if (Profile->get_trx() && _master_out) {
6596 return nroutes() - subtract;
6600 Session::notify_remote_id_change ()
6602 if (deletion_in_progress()) {
6606 switch (Config->get_remote_model()) {
6608 Route::RemoteControlIDChange (); /* EMIT SIGNAL */
6614 #ifdef USE_TRACKS_CODE_FEATURES
6615 /* Waves Tracks: for Waves Tracks session it's required to reconnect their IOs
6616 * if track order has been changed by user
6618 reconnect_existing_routes(true, true);
6624 Session::sync_order_keys ()
6626 if (deletion_in_progress()) {
6630 /* tell everyone that something has happened to the sort keys
6631 and let them sync up with the change(s)
6632 this will give objects that manage the sort order keys the
6633 opportunity to keep them in sync if they wish to.
6636 DEBUG_TRACE (DEBUG::OrderKeys, "Sync Order Keys.\n");
6638 reassign_track_numbers();
6640 Route::SyncOrderKeys (); /* EMIT SIGNAL */
6642 DEBUG_TRACE (DEBUG::OrderKeys, "\tsync done\n");
6646 Session::operation_in_progress (GQuark op) const
6648 return (find (_current_trans_quarks.begin(), _current_trans_quarks.end(), op) != _current_trans_quarks.end());
6651 boost::shared_ptr<Port>
6652 Session::ltc_input_port () const
6654 return _ltc_input->nth (0);
6657 boost::shared_ptr<Port>
6658 Session::ltc_output_port () const
6660 return _ltc_output->nth (0);
6664 Session::reconnect_ltc_input ()
6668 string src = Config->get_ltc_source_port();
6670 _ltc_input->disconnect (this);
6672 if (src != _("None") && !src.empty()) {
6673 _ltc_input->nth (0)->connect (src);
6676 if ( ARDOUR::Profile->get_trx () ) {
6677 // Tracks need this signal to update timecode_source_dropdown
6678 MtcOrLtcInputPortChanged (); //emit signal
6684 Session::reconnect_ltc_output ()
6688 string src = Config->get_ltc_output_port();
6690 _ltc_output->disconnect (this);
6692 if (src != _("None") && !src.empty()) {
6693 _ltc_output->nth (0)->connect (src);
6699 Session::set_range_selection (framepos_t start, framepos_t end)
6701 _range_selection = Evoral::Range<framepos_t> (start, end);
6702 #ifdef USE_TRACKS_CODE_FEATURES
6703 follow_playhead_priority ();
6708 Session::set_object_selection (framepos_t start, framepos_t end)
6710 _object_selection = Evoral::Range<framepos_t> (start, end);
6711 #ifdef USE_TRACKS_CODE_FEATURES
6712 follow_playhead_priority ();
6717 Session::clear_range_selection ()
6719 _range_selection = Evoral::Range<framepos_t> (-1,-1);
6720 #ifdef USE_TRACKS_CODE_FEATURES
6721 follow_playhead_priority ();
6726 Session::clear_object_selection ()
6728 _object_selection = Evoral::Range<framepos_t> (-1,-1);
6729 #ifdef USE_TRACKS_CODE_FEATURES
6730 follow_playhead_priority ();
6735 Session::auto_connect_route (boost::shared_ptr<Route> route, bool connect_inputs,
6736 const ChanCount& input_start,
6737 const ChanCount& output_start,
6738 const ChanCount& input_offset,
6739 const ChanCount& output_offset)
6741 Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
6742 _auto_connect_queue.push (AutoConnectRequest (route, connect_inputs,
6743 input_start, output_start,
6744 input_offset, output_offset));
6746 if (pthread_mutex_trylock (&_auto_connect_mutex) == 0) {
6747 pthread_cond_signal (&_auto_connect_cond);
6748 pthread_mutex_unlock (&_auto_connect_mutex);
6753 Session::auto_connect (const AutoConnectRequest& ar)
6755 boost::shared_ptr<Route> route = ar.route.lock();
6757 if (!route) { return; }
6759 if (!IO::connecting_legal) {
6763 /* If both inputs and outputs are auto-connected to physical ports,
6764 * use the max of input and output offsets to ensure auto-connected
6765 * port numbers always match up (e.g. the first audio input and the
6766 * first audio output of the route will have the same physical
6767 * port number). Otherwise just use the lowest input or output
6771 const bool in_out_physical =
6772 (Config->get_input_auto_connect() & AutoConnectPhysical)
6773 && (Config->get_output_auto_connect() & AutoConnectPhysical)
6774 && ar.connect_inputs;
6776 const ChanCount in_offset = in_out_physical
6777 ? ChanCount::max(ar.input_offset, ar.output_offset)
6780 const ChanCount out_offset = in_out_physical
6781 ? ChanCount::max(ar.input_offset, ar.output_offset)
6784 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
6785 vector<string> physinputs;
6786 vector<string> physoutputs;
6788 _engine.get_physical_outputs (*t, physoutputs);
6789 _engine.get_physical_inputs (*t, physinputs);
6791 if (!physinputs.empty() && ar.connect_inputs) {
6792 uint32_t nphysical_in = physinputs.size();
6794 for (uint32_t i = ar.input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
6797 if (Config->get_input_auto_connect() & AutoConnectPhysical) {
6798 port = physinputs[(in_offset.get(*t) + i) % nphysical_in];
6801 if (!port.empty() && route->input()->connect (route->input()->ports().port(*t, i), port, this)) {
6807 if (!physoutputs.empty()) {
6808 uint32_t nphysical_out = physoutputs.size();
6809 for (uint32_t i = ar.output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
6813 * do not create new connections if we reached the limit of physical outputs
6816 if (!(Config->get_output_auto_connect() & AutoConnectMaster) &&
6817 ARDOUR::Profile->get_trx () &&
6818 ar.output_offset.get(*t) == nphysical_out ) {
6822 if ((*t) == DataType::MIDI && (Config->get_output_auto_connect() & AutoConnectPhysical)) {
6823 port = physoutputs[(out_offset.get(*t) + i) % nphysical_out];
6824 } else if ((*t) == DataType::AUDIO && (Config->get_output_auto_connect() & AutoConnectMaster)) {
6825 /* master bus is audio only */
6826 if (_master_out && _master_out->n_inputs().get(*t) > 0) {
6827 port = _master_out->input()->ports().port(*t,
6828 i % _master_out->input()->n_ports().get(*t))->name();
6832 if (!port.empty() && route->output()->connect (route->output()->ports().port(*t, i), port, this)) {
6841 Session::auto_connect_thread_start ()
6843 if (_ac_thread_active) {
6847 while (!_auto_connect_queue.empty ()) {
6848 _auto_connect_queue.pop ();
6851 _ac_thread_active = true;
6852 if (pthread_create (&_auto_connect_thread, NULL, auto_connect_thread, this)) {
6853 _ac_thread_active = false;
6858 Session::auto_connect_thread_terminate ()
6860 if (!_ac_thread_active) {
6863 _ac_thread_active = false;
6866 Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
6867 while (!_auto_connect_queue.empty ()) {
6868 _auto_connect_queue.pop ();
6872 if (pthread_mutex_lock (&_auto_connect_mutex) == 0) {
6873 pthread_cond_signal (&_auto_connect_cond);
6874 pthread_mutex_unlock (&_auto_connect_mutex);
6878 pthread_join (_auto_connect_thread, &status);
6882 Session::auto_connect_thread (void *arg)
6884 Session *s = static_cast<Session *>(arg);
6885 s->auto_connect_thread_run ();
6891 Session::auto_connect_thread_run ()
6893 pthread_set_name (X_("autoconnect"));
6894 SessionEvent::create_per_thread_pool (X_("autoconnect"), 1024);
6895 PBD::notify_event_loops_about_thread_creation (pthread_self(), X_("autoconnect"), 1024);
6896 pthread_mutex_lock (&_auto_connect_mutex);
6897 while (_ac_thread_active) {
6899 if (!_auto_connect_queue.empty ()) {
6900 // Why would we need the process lock ??
6901 // A: if ports are added while we're connecting, the backend's iterator may be invalidated:
6902 // graph_order_callback() -> resort_routes() -> direct_feeds_according_to_reality () -> backend::connected_to()
6903 // All ardour-internal backends use a std::vector xxxAudioBackend::find_port()
6904 // We have control over those, but what does jack do?
6905 Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
6907 Glib::Threads::Mutex::Lock lx (_auto_connect_queue_lock);
6908 while (!_auto_connect_queue.empty ()) {
6909 const AutoConnectRequest ar (_auto_connect_queue.front());
6910 _auto_connect_queue.pop ();
6917 pthread_cond_wait (&_auto_connect_cond, &_auto_connect_mutex);
6919 pthread_mutex_unlock (&_auto_connect_mutex);